diff --git a/Makefile.libretro b/Makefile.libretro new file mode 100755 index 0000000..e711bb0 --- /dev/null +++ b/Makefile.libretro @@ -0,0 +1,103 @@ + +DEBUG = 0 + +ifeq ($(platform),) +platform = unix +ifeq ($(shell uname -a),) + platform = win +else ifneq ($(findstring Darwin,$(shell uname -a)),) + platform = osx +else ifneq ($(findstring MINGW,$(shell uname -a)),) + platform = win +endif +endif + +TARGET_NAME := px68k + +ifeq ($(platform), unix) + CC = gcc + CXX = g++ + CFLAGS = -g -O2 + CXXFLAGS = -g -O2 -fno-merge-constants + TARGET := $(TARGET_NAME)_libretro.so + fpic := -fPIC + SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T + ENDIANNESS_DEFINES := -DLSB_FIRST + FLAGS += -D__LINUX__ +# android arm +else ifneq (,$(findstring android,$(platform))) + TARGET := $(TARGET_NAME)_libretro_android.so + fpic = -fPIC + SHARED := -lstdc++ -llog -lz -shared -Wl,--version-script=link.T -Wl,--no-undefined + CFLAGS += -g -O2 + CC = arm-linux-androideabi-gcc + CXX = arm-linux-androideabi-g++ +# cross Windows +else ifeq ($(platform), wincross64) + TARGET := $(TARGET_NAME)_libretro.dll + AR = x86_64-w64-mingw32-ar + CC = x86_64-w64-mingw32-gcc + CXX = x86_64-w64-mingw32-g++ + SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T + LDFLAGS += -static-libgcc -static-libstdc++ + ENDIANNESS_DEFINES := -DLSB_FIRST + FLAGS += + EXTRA_LDF := -lwinmm -Wl,--export-all-symbols +else + TARGET := $(TARGET_NAME)_retro.dll + CC = gcc + CXX = g++ + SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T + LDFLAGS += -static-libgcc -static-libstdc++ + ENDIANNESS_DEFINES := -DLSB_FIRST + FLAGS += + EXTRA_LDF = -lwinmm -Wl,--export-all-symbols +endif + +CDEBUGFLAGS+= -DNO_MERCURY +CDEBUGFLAGS+=-DPX68K_VERSION=0.15 +EXTRA_INCLUDES= -I./libretro -I./x68k -I./fmgen -I./win32api +FLAGS += $(CDEBUGFLAGS) + +CPUOBJS= x68k/d68k.o m68000/m68000.o +C68KOBJS= m68000/c68k/c68k.o m68000/c68k/c68kexec.o + +X68KOBJS= x68k/adpcm.o x68k/bg.o x68k/crtc.o x68k/dmac.o x68k/fdc.o x68k/fdd.o x68k/disk_d88.o x68k/disk_dim.o x68k/disk_xdf.o x68k/gvram.o x68k/ioc.o x68k/irqh.o x68k/mem_wrap.o x68k/mercury.o x68k/mfp.o x68k/palette.o x68k/midi.o x68k/pia.o x68k/rtc.o x68k/sasi.o x68k/scc.o x68k/scsi.o x68k/sram.o x68k/sysport.o x68k/tvram.o +FMGENOBJS= fmgen/fmgen.o fmgen/fmg_wrap.o fmgen/file.o fmgen/fmtimer.o fmgen/opm.o fmgen/opna.o fmgen/psg.o +X11OBJS= libretro/joystick.o libretro/juliet.o libretro/keyboard.o libretro/mouse.o libretro/prop.o libretro/status.o libretro/timer.o libretro/dswin.o libretro/windraw.o libretro/winui.o libretro/about.o libretro/common.o +X11CXXOBJS= libretro/winx68k.o +WIN32APIOBJS= win32api/dosio.o win32api/fake.o win32api/peace.o + +OBJECTS := $(X68KOBJS) $(X11OBJS) $(WIN32APIOBJS) $(CPUOBJS) $(C68KOBJS) $(FMGENOBJS) $(X11CXXOBJS) libretro.o + +all: $(TARGET) + +ifeq ($(DEBUG), 0) + FLAGS += -O3 -ffast-math -fomit-frame-pointer +else + FLAGS += -O0 -g +endif + +LDFLAGS += $(fpic) $(SHARED) $(EXTRA_LDF) +FLAGS += -I. -I.. $(EXTRA_INCLUDES) + +WARNINGS := + +FLAGS += -D__LIBRETRO__ $(ENDIANNESS_DEFINES) $(WARNINGS) $(fpic) + +CXXFLAGS += $(FLAGS) -fpermissive +CFLAGS += $(FLAGS) -std=gnu99 + +$(TARGET): $(OBJECTS) + $(CXX) -o $@ $^ $(LDFLAGS) + +%.o: %.cpp + $(CXX) -c -o $@ $< $(CXXFLAGS) + +%.o: %.c + $(CC) -c -o $@ $< $(CFLAGS) + +clean: + rm -f $(TARGET) $(OBJECTS) + +.PHONY: clean diff --git a/libretro.c b/libretro.c new file mode 100755 index 0000000..65f7e9c --- /dev/null +++ b/libretro.c @@ -0,0 +1,482 @@ + +#include +#include +#include + +#include "libretro.h" + +#ifdef _WIN32 + char slash = '\\'; +#else + char slash = '/'; +#endif + +#define LOGI printf +#define RENDER16B 1 + +char RPATH[512]; +char RETRO_DIR[512]; +const char *retro_save_directory; +const char *retro_system_directory; +const char *retro_content_directory; +char retro_system_conf[512]; + +char Core_Key_Sate[512]; +char Core_old_Key_Sate[512]; + +bool opt_analog; + +int retrow=800; +int retroh=600; +int CHANGEAV=0; + +int pauseg=0; + +signed short soundbuf[1024*2]; + +uint16_t *videoBuffer; + +static retro_video_refresh_t video_cb; +static retro_environment_t environ_cb; + +static retro_input_poll_t input_poll_cb; + +retro_input_state_t input_state_cb; +retro_audio_sample_t audio_cb; +retro_audio_sample_batch_t audio_batch_cb; + +void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; } +void retro_set_audio_sample(retro_audio_sample_t cb) { audio_cb =cb; } +void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) { audio_batch_cb = cb; } +void retro_set_input_poll(retro_input_poll_t cb) { input_poll_cb = cb; } +void retro_set_input_state(retro_input_state_t cb) { input_state_cb = cb; } + +#define LOGI printf + +//Args for experimental_cmdline +static char ARGUV[64][1024]; +static unsigned char ARGUC=0; + +// Args for Core +static char XARGV[64][1024]; +static const char* xargv_cmd[64]; +int PARAMCOUNT=0; + +extern int cmain(int argc, char *argv[]); + +void parse_cmdline( const char *argv ); + +void Add_Option(const char* option) +{ + static int first=0; + + if(first==0) + { + PARAMCOUNT=0; + first++; + } + + sprintf(XARGV[PARAMCOUNT++],"%s\0",option); +} + +int pre_main(const char *argv) +{ + int i; + int Only1Arg; + + parse_cmdline(argv); + + Only1Arg = (strcmp(ARGUV[0],"px68k") == 0) ? 0 : 1; + + for (i = 0; i<64; i++) + xargv_cmd[i] = NULL; + + + if(Only1Arg) + { + int cfgload=0; + + Add_Option("px68k"); + + if (strlen(RPATH) >= strlen("hdf")){ + if(!strcasecmp(&RPATH[strlen(RPATH)-strlen("hdf")], "hdf")){ + Add_Option("-h"); + cfgload=1; + } + } + + if(cfgload==0) { + //Add_Option("-verbose"); + //Add_Option(retro_system_tos); + //Add_Option("-8"); + } + + Add_Option(RPATH); + } + else + { // Pass all cmdline args + for(i = 0; i < ARGUC; i++) + Add_Option(ARGUV[i]); + } + + for (i = 0; i < PARAMCOUNT; i++) + { + xargv_cmd[i] = (char*)(XARGV[i]); + LOGI("%2d %s\n",i,XARGV[i]); + } + + pmain(PARAMCOUNT,( char **)xargv_cmd); + + xargv_cmd[PARAMCOUNT - 2] = NULL; + + return 0; +} + +void parse_cmdline(const char *argv) +{ + char *p,*p2,*start_of_word; + int c,c2; + static char buffer[512*4]; + enum states { DULL, IN_WORD, IN_STRING } state = DULL; + + strcpy(buffer,argv); + strcat(buffer," \0"); + + for (p = buffer; *p != '\0'; p++) + { + c = (unsigned char) *p; /* convert to unsigned char for is* functions */ + switch (state) + { + case DULL: /* not in a word, not in a double quoted string */ + if (isspace(c)) /* still not in a word, so ignore this char */ + continue; + /* not a space -- if it's a double quote we go to IN_STRING, else to IN_WORD */ + if (c == '"') + { + state = IN_STRING; + start_of_word = p + 1; /* word starts at *next* char, not this one */ + continue; + } + state = IN_WORD; + start_of_word = p; /* word starts here */ + continue; + case IN_STRING: + /* we're in a double quoted string, so keep going until we hit a close " */ + if (c == '"') + { + /* word goes from start_of_word to p-1 */ + //... do something with the word ... + for (c2 = 0,p2 = start_of_word; p2 < p; p2++, c2++) + ARGUV[ARGUC][c2] = (unsigned char) *p2; + ARGUC++; + + state = DULL; /* back to "not in word, not in string" state */ + } + continue; /* either still IN_STRING or we handled the end above */ + case IN_WORD: + /* we're in a word, so keep going until we get to a space */ + if (isspace(c)) + { + /* word goes from start_of_word to p-1 */ + //... do something with the word ... + for (c2 = 0,p2 = start_of_word; p2 library_name = "px68k"; + info->library_version = "0.15+"; + info->need_fullpath = true; + info->valid_extensions = "dim|zip|img|d88|88d|hdm|dup|2hd|xdf|hdf"; +} + + +void retro_get_system_av_info(struct retro_system_av_info *info) +{ +//FIXME handle vice PAL/NTSC + struct retro_game_geometry geom = { retrow, retroh,800, 600 ,4.0 / 3.0 }; + struct retro_system_timing timing = { 60.0, 44100.0 }; + + info->geometry = geom; + info->timing = timing; +} + +void update_geometry() +{ + struct retro_system_av_info system_av_info; + system_av_info.geometry.base_width = retrow; + system_av_info.geometry.base_height = retroh; + system_av_info.geometry.aspect_ratio = (float)4/3;// retro_aspect; + environ_cb(RETRO_ENVIRONMENT_SET_GEOMETRY, &system_av_info); +} + + +void retro_set_controller_port_device(unsigned port, unsigned device) +{ + (void)port; + (void)device; +} + +size_t retro_serialize_size(void) +{ + return 0; +} + +bool retro_serialize(void *data, size_t size) +{ + return false; +} + +bool retro_unserialize(const void *data, size_t size) +{ + return false; +} + +void retro_cheat_reset(void) +{} + +void retro_cheat_set(unsigned index, bool enabled, const char *code) +{ + (void)index; + (void)enabled; + (void)code; +} + +bool retro_load_game(const struct retro_game_info *info) +{ + + const char *full_path; + + full_path = info->path; + + strcpy(RPATH,full_path); + + printf("LOAD EMU\n"); + + return true; +} + +bool retro_load_game_special(unsigned game_type, const struct retro_game_info *info, size_t num_info) +{ + (void)game_type; + (void)info; + (void)num_info; + return false; +} + +void retro_unload_game(void) +{ + pauseg=0; +} + +unsigned retro_get_region(void) +{ + return RETRO_REGION_NTSC; +} + +unsigned retro_api_version(void) +{ + return RETRO_API_VERSION; +} + +void *retro_get_memory_data(unsigned id) +{ + return NULL; +} + +size_t retro_get_memory_size(unsigned id) +{ + return 0; +} + +void retro_init(void) +{ + const char *system_dir = NULL; + + if (environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &system_dir) && system_dir) + { + // if defined, use the system directory + retro_system_directory=system_dir; + } + + const char *content_dir = NULL; + + if (environ_cb(RETRO_ENVIRONMENT_GET_CONTENT_DIRECTORY, &content_dir) && content_dir) + { + // if defined, use the system directory + retro_content_directory=content_dir; + } + + const char *save_dir = NULL; + + if (environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &save_dir) && save_dir) + { + // If save directory is defined use it, otherwise use system directory + retro_save_directory = *save_dir ? save_dir : retro_system_directory; + } + else + { + // make retro_save_directory the same in case RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY is not implemented by the frontend + retro_save_directory=retro_system_directory; + } + + if(retro_system_directory==NULL)sprintf(RETRO_DIR, "%s\0","."); + else sprintf(RETRO_DIR, "%s\0", retro_system_directory); + + sprintf(retro_system_conf, "%s%ckeropi\0",RETRO_DIR,slash); + + LOGI("Retro SYSTEM_DIRECTORY %s\n",retro_system_directory); + LOGI("Retro SAVE_DIRECTORY %s\n",retro_save_directory); + LOGI("Retro CONTENT_DIRECTORY %s\n",retro_content_directory); + + enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_RGB565; + if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) + { + fprintf(stderr, "RGB565 is not supported.\n"); + exit(0); + } + + struct retro_input_descriptor inputDescriptors[] = { + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "A" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B, "B" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X, "X" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y, "Y" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START, "Start" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "Up" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "Down" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R, "R" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L, "L" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2, "R2" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2, "L2" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3, "R3" }, + { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3, "L3" } + }; + environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, &inputDescriptors); + +/* + struct retro_keyboard_callback cbk = { keyboard_cb }; + environ_cb(RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK, &cbk); +*/ + update_variables(); + + memset(Core_Key_Sate,0,512); + memset(Core_old_Key_Sate ,0, sizeof(Core_old_Key_Sate)); +} + +void retro_deinit(void) +{ + end_loop_retro(); + printf("Retro DeInit\n"); +} + +void retro_reset(void) +{ +} + +static int firstcall=1; + +void retro_run(void) +{ + + if(firstcall){ + pre_main(RPATH); + firstcall=0; + printf("INIT done\n"); + return; + } + + if (CHANGEAV == 1){ + update_geometry(); + printf("w:%d h:%d a:%f\n",retrow,retroh,(float)(4/3)); + CHANGEAV=0; + } + + + update_input(); + + if(pauseg!=-1){ + + } + + exec_app_retro(); + + raudio_callback(NULL, NULL,735*4); + + video_cb(videoBuffer, retrow, retroh, /*retrow*/ 800 << 1/*2*/); + +} + diff --git a/libretro.h b/libretro.h new file mode 100644 index 0000000..16c274a --- /dev/null +++ b/libretro.h @@ -0,0 +1,1926 @@ +/* Copyright (C) 2010-2014 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this libretro API header (libretro.h). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef LIBRETRO_H__ +#define LIBRETRO_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef __cplusplus +#if defined(_MSC_VER) && !defined(SN_TARGET_PS3) +/* Hack applied for MSVC when compiling in C89 mode + * as it isn't C99-compliant. */ +#define bool unsigned char +#define true 1 +#define false 0 +#else +#include +#endif +#endif + +/* Used for checking API/ABI mismatches that can break libretro + * implementations. + * It is not incremented for compatible changes to the API. + */ +#define RETRO_API_VERSION 1 + +/* + * Libretro's fundamental device abstractions. + * + * Libretro's input system consists of some standardized device types, + * such as a joypad (with/without analog), mouse, keyboard, lightgun + * and a pointer. + * + * The functionality of these devices are fixed, and individual cores + * map their own concept of a controller to libretro's abstractions. + * This makes it possible for frontends to map the abstract types to a + * real input device, and not having to worry about binding input + * correctly to arbitrary controller layouts. + */ + +#define RETRO_DEVICE_TYPE_SHIFT 8 +#define RETRO_DEVICE_MASK ((1 << RETRO_DEVICE_TYPE_SHIFT) - 1) +#define RETRO_DEVICE_SUBCLASS(base, id) (((id + 1) << RETRO_DEVICE_TYPE_SHIFT) | base) + +/* Input disabled. */ +#define RETRO_DEVICE_NONE 0 + +/* The JOYPAD is called RetroPad. It is essentially a Super Nintendo + * controller, but with additional L2/R2/L3/R3 buttons, similar to a + * PS1 DualShock. */ +#define RETRO_DEVICE_JOYPAD 1 + +/* The mouse is a simple mouse, similar to Super Nintendo's mouse. + * X and Y coordinates are reported relatively to last poll (poll callback). + * It is up to the libretro implementation to keep track of where the mouse + * pointer is supposed to be on the screen. + * The frontend must make sure not to interfere with its own hardware + * mouse pointer. + */ +#define RETRO_DEVICE_MOUSE 2 + +/* KEYBOARD device lets one poll for raw key pressed. + * It is poll based, so input callback will return with the current + * pressed state. + * For event/text based keyboard input, see + * RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK. + */ +#define RETRO_DEVICE_KEYBOARD 3 + +/* Lightgun X/Y coordinates are reported relatively to last poll, + * similar to mouse. */ +#define RETRO_DEVICE_LIGHTGUN 4 + +/* The ANALOG device is an extension to JOYPAD (RetroPad). + * Similar to DualShock it adds two analog sticks. + * This is treated as a separate device type as it returns values in the + * full analog range of [-0x8000, 0x7fff]. Positive X axis is right. + * Positive Y axis is down. + * Only use ANALOG type when polling for analog values of the axes. + */ +#define RETRO_DEVICE_ANALOG 5 + +/* Abstracts the concept of a pointing mechanism, e.g. touch. + * This allows libretro to query in absolute coordinates where on the + * screen a mouse (or something similar) is being placed. + * For a touch centric device, coordinates reported are the coordinates + * of the press. + * + * Coordinates in X and Y are reported as: + * [-0x7fff, 0x7fff]: -0x7fff corresponds to the far left/top of the screen, + * and 0x7fff corresponds to the far right/bottom of the screen. + * The "screen" is here defined as area that is passed to the frontend and + * later displayed on the monitor. + * + * The frontend is free to scale/resize this screen as it sees fit, however, + * (X, Y) = (-0x7fff, -0x7fff) will correspond to the top-left pixel of the + * game image, etc. + * + * To check if the pointer coordinates are valid (e.g. a touch display + * actually being touched), PRESSED returns 1 or 0. + * + * If using a mouse on a desktop, PRESSED will usually correspond to the + * left mouse button, but this is a frontend decision. + * PRESSED will only return 1 if the pointer is inside the game screen. + * + * For multi-touch, the index variable can be used to successively query + * more presses. + * If index = 0 returns true for _PRESSED, coordinates can be extracted + * with _X, _Y for index = 0. One can then query _PRESSED, _X, _Y with + * index = 1, and so on. + * Eventually _PRESSED will return false for an index. No further presses + * are registered at this point. */ +#define RETRO_DEVICE_POINTER 6 + +/* Buttons for the RetroPad (JOYPAD). + * The placement of these is equivalent to placements on the + * Super Nintendo controller. + * L2/R2/L3/R3 buttons correspond to the PS1 DualShock. */ +#define RETRO_DEVICE_ID_JOYPAD_B 0 +#define RETRO_DEVICE_ID_JOYPAD_Y 1 +#define RETRO_DEVICE_ID_JOYPAD_SELECT 2 +#define RETRO_DEVICE_ID_JOYPAD_START 3 +#define RETRO_DEVICE_ID_JOYPAD_UP 4 +#define RETRO_DEVICE_ID_JOYPAD_DOWN 5 +#define RETRO_DEVICE_ID_JOYPAD_LEFT 6 +#define RETRO_DEVICE_ID_JOYPAD_RIGHT 7 +#define RETRO_DEVICE_ID_JOYPAD_A 8 +#define RETRO_DEVICE_ID_JOYPAD_X 9 +#define RETRO_DEVICE_ID_JOYPAD_L 10 +#define RETRO_DEVICE_ID_JOYPAD_R 11 +#define RETRO_DEVICE_ID_JOYPAD_L2 12 +#define RETRO_DEVICE_ID_JOYPAD_R2 13 +#define RETRO_DEVICE_ID_JOYPAD_L3 14 +#define RETRO_DEVICE_ID_JOYPAD_R3 15 + +/* Index / Id values for ANALOG device. */ +#define RETRO_DEVICE_INDEX_ANALOG_LEFT 0 +#define RETRO_DEVICE_INDEX_ANALOG_RIGHT 1 +#define RETRO_DEVICE_ID_ANALOG_X 0 +#define RETRO_DEVICE_ID_ANALOG_Y 1 + +/* Id values for MOUSE. */ +#define RETRO_DEVICE_ID_MOUSE_X 0 +#define RETRO_DEVICE_ID_MOUSE_Y 1 +#define RETRO_DEVICE_ID_MOUSE_LEFT 2 +#define RETRO_DEVICE_ID_MOUSE_RIGHT 3 +#define RETRO_DEVICE_ID_MOUSE_WHEELUP 4 +#define RETRO_DEVICE_ID_MOUSE_WHEELDOWN 5 +#define RETRO_DEVICE_ID_MOUSE_MIDDLE 6 + +/* Id values for LIGHTGUN types. */ +#define RETRO_DEVICE_ID_LIGHTGUN_X 0 +#define RETRO_DEVICE_ID_LIGHTGUN_Y 1 +#define RETRO_DEVICE_ID_LIGHTGUN_TRIGGER 2 +#define RETRO_DEVICE_ID_LIGHTGUN_CURSOR 3 +#define RETRO_DEVICE_ID_LIGHTGUN_TURBO 4 +#define RETRO_DEVICE_ID_LIGHTGUN_PAUSE 5 +#define RETRO_DEVICE_ID_LIGHTGUN_START 6 + +/* Id values for POINTER. */ +#define RETRO_DEVICE_ID_POINTER_X 0 +#define RETRO_DEVICE_ID_POINTER_Y 1 +#define RETRO_DEVICE_ID_POINTER_PRESSED 2 + +/* Returned from retro_get_region(). */ +#define RETRO_REGION_NTSC 0 +#define RETRO_REGION_PAL 1 + +/* Id values for LANGUAGE */ +enum retro_language +{ + RETRO_LANGUAGE_ENGLISH = 0, + RETRO_LANGUAGE_JAPANESE = 1, + RETRO_LANGUAGE_FRENCH = 2, + RETRO_LANGUAGE_SPANISH = 3, + RETRO_LANGUAGE_GERMAN = 4, + RETRO_LANGUAGE_ITALIAN = 5, + RETRO_LANGUAGE_DUTCH = 6, + RETRO_LANGUAGE_PORTUGUESE = 7, + RETRO_LANGUAGE_RUSSIAN = 8, + RETRO_LANGUAGE_KOREAN = 9, + RETRO_LANGUAGE_CHINESE_TRADITIONAL = 10, + RETRO_LANGUAGE_CHINESE_SIMPLIFIED = 11, + RETRO_LANGUAGE_LAST, + + /* Ensure sizeof(enum) == sizeof(int) */ + RETRO_LANGUAGE_DUMMY = INT_MAX +}; + +/* Passed to retro_get_memory_data/size(). + * If the memory type doesn't apply to the + * implementation NULL/0 can be returned. + */ +#define RETRO_MEMORY_MASK 0xff + +/* Regular save RAM. This RAM is usually found on a game cartridge, + * backed up by a battery. + * If save game data is too complex for a single memory buffer, + * the SAVE_DIRECTORY (preferably) or SYSTEM_DIRECTORY environment + * callback can be used. */ +#define RETRO_MEMORY_SAVE_RAM 0 + +/* Some games have a built-in clock to keep track of time. + * This memory is usually just a couple of bytes to keep track of time. + */ +#define RETRO_MEMORY_RTC 1 + +/* System ram lets a frontend peek into a game systems main RAM. */ +#define RETRO_MEMORY_SYSTEM_RAM 2 + +/* Video ram lets a frontend peek into a game systems video RAM (VRAM). */ +#define RETRO_MEMORY_VIDEO_RAM 3 + +/* Keysyms used for ID in input state callback when polling RETRO_KEYBOARD. */ +enum retro_key +{ + RETROK_UNKNOWN = 0, + RETROK_FIRST = 0, + RETROK_BACKSPACE = 8, + RETROK_TAB = 9, + RETROK_CLEAR = 12, + RETROK_RETURN = 13, + RETROK_PAUSE = 19, + RETROK_ESCAPE = 27, + RETROK_SPACE = 32, + RETROK_EXCLAIM = 33, + RETROK_QUOTEDBL = 34, + RETROK_HASH = 35, + RETROK_DOLLAR = 36, + RETROK_AMPERSAND = 38, + RETROK_QUOTE = 39, + RETROK_LEFTPAREN = 40, + RETROK_RIGHTPAREN = 41, + RETROK_ASTERISK = 42, + RETROK_PLUS = 43, + RETROK_COMMA = 44, + RETROK_MINUS = 45, + RETROK_PERIOD = 46, + RETROK_SLASH = 47, + RETROK_0 = 48, + RETROK_1 = 49, + RETROK_2 = 50, + RETROK_3 = 51, + RETROK_4 = 52, + RETROK_5 = 53, + RETROK_6 = 54, + RETROK_7 = 55, + RETROK_8 = 56, + RETROK_9 = 57, + RETROK_COLON = 58, + RETROK_SEMICOLON = 59, + RETROK_LESS = 60, + RETROK_EQUALS = 61, + RETROK_GREATER = 62, + RETROK_QUESTION = 63, + RETROK_AT = 64, + RETROK_LEFTBRACKET = 91, + RETROK_BACKSLASH = 92, + RETROK_RIGHTBRACKET = 93, + RETROK_CARET = 94, + RETROK_UNDERSCORE = 95, + RETROK_BACKQUOTE = 96, + RETROK_a = 97, + RETROK_b = 98, + RETROK_c = 99, + RETROK_d = 100, + RETROK_e = 101, + RETROK_f = 102, + RETROK_g = 103, + RETROK_h = 104, + RETROK_i = 105, + RETROK_j = 106, + RETROK_k = 107, + RETROK_l = 108, + RETROK_m = 109, + RETROK_n = 110, + RETROK_o = 111, + RETROK_p = 112, + RETROK_q = 113, + RETROK_r = 114, + RETROK_s = 115, + RETROK_t = 116, + RETROK_u = 117, + RETROK_v = 118, + RETROK_w = 119, + RETROK_x = 120, + RETROK_y = 121, + RETROK_z = 122, + RETROK_DELETE = 127, + + RETROK_KP0 = 256, + RETROK_KP1 = 257, + RETROK_KP2 = 258, + RETROK_KP3 = 259, + RETROK_KP4 = 260, + RETROK_KP5 = 261, + RETROK_KP6 = 262, + RETROK_KP7 = 263, + RETROK_KP8 = 264, + RETROK_KP9 = 265, + RETROK_KP_PERIOD = 266, + RETROK_KP_DIVIDE = 267, + RETROK_KP_MULTIPLY = 268, + RETROK_KP_MINUS = 269, + RETROK_KP_PLUS = 270, + RETROK_KP_ENTER = 271, + RETROK_KP_EQUALS = 272, + + RETROK_UP = 273, + RETROK_DOWN = 274, + RETROK_RIGHT = 275, + RETROK_LEFT = 276, + RETROK_INSERT = 277, + RETROK_HOME = 278, + RETROK_END = 279, + RETROK_PAGEUP = 280, + RETROK_PAGEDOWN = 281, + + RETROK_F1 = 282, + RETROK_F2 = 283, + RETROK_F3 = 284, + RETROK_F4 = 285, + RETROK_F5 = 286, + RETROK_F6 = 287, + RETROK_F7 = 288, + RETROK_F8 = 289, + RETROK_F9 = 290, + RETROK_F10 = 291, + RETROK_F11 = 292, + RETROK_F12 = 293, + RETROK_F13 = 294, + RETROK_F14 = 295, + RETROK_F15 = 296, + + RETROK_NUMLOCK = 300, + RETROK_CAPSLOCK = 301, + RETROK_SCROLLOCK = 302, + RETROK_RSHIFT = 303, + RETROK_LSHIFT = 304, + RETROK_RCTRL = 305, + RETROK_LCTRL = 306, + RETROK_RALT = 307, + RETROK_LALT = 308, + RETROK_RMETA = 309, + RETROK_LMETA = 310, + RETROK_LSUPER = 311, + RETROK_RSUPER = 312, + RETROK_MODE = 313, + RETROK_COMPOSE = 314, + + RETROK_HELP = 315, + RETROK_PRINT = 316, + RETROK_SYSREQ = 317, + RETROK_BREAK = 318, + RETROK_MENU = 319, + RETROK_POWER = 320, + RETROK_EURO = 321, + RETROK_UNDO = 322, + + RETROK_LAST, + + RETROK_DUMMY = INT_MAX /* Ensure sizeof(enum) == sizeof(int) */ +}; + +enum retro_mod +{ + RETROKMOD_NONE = 0x0000, + + RETROKMOD_SHIFT = 0x01, + RETROKMOD_CTRL = 0x02, + RETROKMOD_ALT = 0x04, + RETROKMOD_META = 0x08, + + RETROKMOD_NUMLOCK = 0x10, + RETROKMOD_CAPSLOCK = 0x20, + RETROKMOD_SCROLLOCK = 0x40, + + RETROKMOD_DUMMY = INT_MAX /* Ensure sizeof(enum) == sizeof(int) */ +}; + +/* If set, this call is not part of the public libretro API yet. It can + * change or be removed at any time. */ +#define RETRO_ENVIRONMENT_EXPERIMENTAL 0x10000 +/* Environment callback to be used internally in frontend. */ +#define RETRO_ENVIRONMENT_PRIVATE 0x20000 + +/* Environment commands. */ +#define RETRO_ENVIRONMENT_SET_ROTATION 1 /* const unsigned * -- + * Sets screen rotation of graphics. + * Is only implemented if rotation can be accelerated by hardware. + * Valid values are 0, 1, 2, 3, which rotates screen by 0, 90, 180, + * 270 degrees counter-clockwise respectively. + */ +#define RETRO_ENVIRONMENT_GET_OVERSCAN 2 /* bool * -- + * Boolean value whether or not the implementation should use overscan, + * or crop away overscan. + */ +#define RETRO_ENVIRONMENT_GET_CAN_DUPE 3 /* bool * -- + * Boolean value whether or not frontend supports frame duping, + * passing NULL to video frame callback. + */ + + /* Environ 4, 5 are no longer supported (GET_VARIABLE / SET_VARIABLES), + * and reserved to avoid possible ABI clash. + */ + +#define RETRO_ENVIRONMENT_SET_MESSAGE 6 /* const struct retro_message * -- + * Sets a message to be displayed in implementation-specific manner + * for a certain amount of 'frames'. + * Should not be used for trivial messages, which should simply be + * logged via RETRO_ENVIRONMENT_GET_LOG_INTERFACE (or as a + * fallback, stderr). + */ +#define RETRO_ENVIRONMENT_SHUTDOWN 7 /* N/A (NULL) -- + * Requests the frontend to shutdown. + * Should only be used if game has a specific + * way to shutdown the game from a menu item or similar. + */ +#define RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL 8 + /* const unsigned * -- + * Gives a hint to the frontend how demanding this implementation + * is on a system. E.g. reporting a level of 2 means + * this implementation should run decently on all frontends + * of level 2 and up. + * + * It can be used by the frontend to potentially warn + * about too demanding implementations. + * + * The levels are "floating". + * + * This function can be called on a per-game basis, + * as certain games an implementation can play might be + * particularly demanding. + * If called, it should be called in retro_load_game(). + */ +#define RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY 9 + /* const char ** -- + * Returns the "system" directory of the frontend. + * This directory can be used to store system specific + * content such as BIOSes, configuration data, etc. + * The returned value can be NULL. + * If so, no such directory is defined, + * and it's up to the implementation to find a suitable directory. + * + * NOTE: Some cores used this folder also for "save" data such as + * memory cards, etc, for lack of a better place to put it. + * This is now discouraged, and if possible, cores should try to + * use the new GET_SAVE_DIRECTORY. + */ +#define RETRO_ENVIRONMENT_SET_PIXEL_FORMAT 10 + /* const enum retro_pixel_format * -- + * Sets the internal pixel format used by the implementation. + * The default pixel format is RETRO_PIXEL_FORMAT_0RGB1555. + * This pixel format however, is deprecated (see enum retro_pixel_format). + * If the call returns false, the frontend does not support this pixel + * format. + * + * This function should be called inside retro_load_game() or + * retro_get_system_av_info(). + */ +#define RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS 11 + /* const struct retro_input_descriptor * -- + * Sets an array of retro_input_descriptors. + * It is up to the frontend to present this in a usable way. + * The array is terminated by retro_input_descriptor::description + * being set to NULL. + * This function can be called at any time, but it is recommended + * to call it as early as possible. + */ +#define RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK 12 + /* const struct retro_keyboard_callback * -- + * Sets a callback function used to notify core about keyboard events. + */ +#define RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE 13 + /* const struct retro_disk_control_callback * -- + * Sets an interface which frontend can use to eject and insert + * disk images. + * This is used for games which consist of multiple images and + * must be manually swapped out by the user (e.g. PSX). + */ +#define RETRO_ENVIRONMENT_SET_HW_RENDER 14 + /* struct retro_hw_render_callback * -- + * Sets an interface to let a libretro core render with + * hardware acceleration. + * Should be called in retro_load_game(). + * If successful, libretro cores will be able to render to a + * frontend-provided framebuffer. + * The size of this framebuffer will be at least as large as + * max_width/max_height provided in get_av_info(). + * If HW rendering is used, pass only RETRO_HW_FRAME_BUFFER_VALID or + * NULL to retro_video_refresh_t. + */ +#define RETRO_ENVIRONMENT_GET_VARIABLE 15 + /* struct retro_variable * -- + * Interface to acquire user-defined information from environment + * that cannot feasibly be supported in a multi-system way. + * 'key' should be set to a key which has already been set by + * SET_VARIABLES. + * 'data' will be set to a value or NULL. + */ +#define RETRO_ENVIRONMENT_SET_VARIABLES 16 + /* const struct retro_variable * -- + * Allows an implementation to signal the environment + * which variables it might want to check for later using + * GET_VARIABLE. + * This allows the frontend to present these variables to + * a user dynamically. + * This should be called as early as possible (ideally in + * retro_set_environment). + * + * 'data' points to an array of retro_variable structs + * terminated by a { NULL, NULL } element. + * retro_variable::key should be namespaced to not collide + * with other implementations' keys. E.g. A core called + * 'foo' should use keys named as 'foo_option'. + * retro_variable::value should contain a human readable + * description of the key as well as a '|' delimited list + * of expected values. + * + * The number of possible options should be very limited, + * i.e. it should be feasible to cycle through options + * without a keyboard. + * + * First entry should be treated as a default. + * + * Example entry: + * { "foo_option", "Speed hack coprocessor X; false|true" } + * + * Text before first ';' is description. This ';' must be + * followed by a space, and followed by a list of possible + * values split up with '|'. + * + * Only strings are operated on. The possible values will + * generally be displayed and stored as-is by the frontend. + */ +#define RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE 17 + /* bool * -- + * Result is set to true if some variables are updated by + * frontend since last call to RETRO_ENVIRONMENT_GET_VARIABLE. + * Variables should be queried with GET_VARIABLE. + */ +#define RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME 18 + /* const bool * -- + * If true, the libretro implementation supports calls to + * retro_load_game() with NULL as argument. + * Used by cores which can run without particular game data. + * This should be called within retro_set_environment() only. + */ +#define RETRO_ENVIRONMENT_GET_LIBRETRO_PATH 19 + /* const char ** -- + * Retrieves the absolute path from where this libretro + * implementation was loaded. + * NULL is returned if the libretro was loaded statically + * (i.e. linked statically to frontend), or if the path cannot be + * determined. + * Mostly useful in cooperation with SET_SUPPORT_NO_GAME as assets can + * be loaded without ugly hacks. + */ + + /* Environment 20 was an obsolete version of SET_AUDIO_CALLBACK. + * It was not used by any known core at the time, + * and was removed from the API. */ +#define RETRO_ENVIRONMENT_SET_AUDIO_CALLBACK 22 + /* const struct retro_audio_callback * -- + * Sets an interface which is used to notify a libretro core about audio + * being available for writing. + * The callback can be called from any thread, so a core using this must + * have a thread safe audio implementation. + * It is intended for games where audio and video are completely + * asynchronous and audio can be generated on the fly. + * This interface is not recommended for use with emulators which have + * highly synchronous audio. + * + * The callback only notifies about writability; the libretro core still + * has to call the normal audio callbacks + * to write audio. The audio callbacks must be called from within the + * notification callback. + * The amount of audio data to write is up to the implementation. + * Generally, the audio callback will be called continously in a loop. + * + * Due to thread safety guarantees and lack of sync between audio and + * video, a frontend can selectively disallow this interface based on + * internal configuration. A core using this interface must also + * implement the "normal" audio interface. + * + * A libretro core using SET_AUDIO_CALLBACK should also make use of + * SET_FRAME_TIME_CALLBACK. + */ +#define RETRO_ENVIRONMENT_SET_FRAME_TIME_CALLBACK 21 + /* const struct retro_frame_time_callback * -- + * Lets the core know how much time has passed since last + * invocation of retro_run(). + * The frontend can tamper with the timing to fake fast-forward, + * slow-motion, frame stepping, etc. + * In this case the delta time will use the reference value + * in frame_time_callback.. + */ +#define RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE 23 + /* struct retro_rumble_interface * -- + * Gets an interface which is used by a libretro core to set + * state of rumble motors in controllers. + * A strong and weak motor is supported, and they can be + * controlled indepedently. + */ +#define RETRO_ENVIRONMENT_GET_INPUT_DEVICE_CAPABILITIES 24 + /* uint64_t * -- + * Gets a bitmask telling which device type are expected to be + * handled properly in a call to retro_input_state_t. + * Devices which are not handled or recognized always return + * 0 in retro_input_state_t. + * Example bitmask: caps = (1 << RETRO_DEVICE_JOYPAD) | (1 << RETRO_DEVICE_ANALOG). + * Should only be called in retro_run(). + */ +#define RETRO_ENVIRONMENT_GET_SENSOR_INTERFACE (25 | RETRO_ENVIRONMENT_EXPERIMENTAL) + /* struct retro_sensor_interface * -- + * Gets access to the sensor interface. + * The purpose of this interface is to allow + * setting state related to sensors such as polling rate, + * enabling/disable it entirely, etc. + * Reading sensor state is done via the normal + * input_state_callback API. + */ +#define RETRO_ENVIRONMENT_GET_CAMERA_INTERFACE (26 | RETRO_ENVIRONMENT_EXPERIMENTAL) + /* struct retro_camera_callback * -- + * Gets an interface to a video camera driver. + * A libretro core can use this interface to get access to a + * video camera. + * New video frames are delivered in a callback in same + * thread as retro_run(). + * + * GET_CAMERA_INTERFACE should be called in retro_load_game(). + * + * Depending on the camera implementation used, camera frames + * will be delivered as a raw framebuffer, + * or as an OpenGL texture directly. + * + * The core has to tell the frontend here which types of + * buffers can be handled properly. + * An OpenGL texture can only be handled when using a + * libretro GL core (SET_HW_RENDER). + * It is recommended to use a libretro GL core when + * using camera interface. + * + * The camera is not started automatically. The retrieved start/stop + * functions must be used to explicitly + * start and stop the camera driver. + */ +#define RETRO_ENVIRONMENT_GET_LOG_INTERFACE 27 + /* struct retro_log_callback * -- + * Gets an interface for logging. This is useful for + * logging in a cross-platform way + * as certain platforms cannot use use stderr for logging. + * It also allows the frontend to + * show logging information in a more suitable way. + * If this interface is not used, libretro cores should + * log to stderr as desired. + */ +#define RETRO_ENVIRONMENT_GET_PERF_INTERFACE 28 + /* struct retro_perf_callback * -- + * Gets an interface for performance counters. This is useful + * for performance logging in a cross-platform way and for detecting + * architecture-specific features, such as SIMD support. + */ +#define RETRO_ENVIRONMENT_GET_LOCATION_INTERFACE 29 + /* struct retro_location_callback * -- + * Gets access to the location interface. + * The purpose of this interface is to be able to retrieve + * location-based information from the host device, + * such as current latitude / longitude. + */ +#define RETRO_ENVIRONMENT_GET_CONTENT_DIRECTORY 30 + /* const char ** -- + * Returns the "content" directory of the frontend. + * This directory can be used to store specific assets that the + * core relies upon, such as art assets, + * input data, etc etc. + * The returned value can be NULL. + * If so, no such directory is defined, + * and it's up to the implementation to find a suitable directory. + */ +#define RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY 31 + /* const char ** -- + * Returns the "save" directory of the frontend. + * This directory can be used to store SRAM, memory cards, + * high scores, etc, if the libretro core + * cannot use the regular memory interface (retro_get_memory_data()). + * + * NOTE: libretro cores used to check GET_SYSTEM_DIRECTORY for + * similar things before. + * They should still check GET_SYSTEM_DIRECTORY if they want to + * be backwards compatible. + * The path here can be NULL. It should only be non-NULL if the + * frontend user has set a specific save path. + */ +#define RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO 32 + /* const struct retro_system_av_info * -- + * Sets a new av_info structure. This can only be called from + * within retro_run(). + * This should *only* be used if the core is completely altering the + * internal resolutions, aspect ratios, timings, sampling rate, etc. + * Calling this can require a full reinitialization of video/audio + * drivers in the frontend, + * + * so it is important to call it very sparingly, and usually only with + * the users explicit consent. + * An eventual driver reinitialize will happen so that video and + * audio callbacks + * happening after this call within the same retro_run() call will + * target the newly initialized driver. + * + * This callback makes it possible to support configurable resolutions + * in games, which can be useful to + * avoid setting the "worst case" in max_width/max_height. + * + * ***HIGHLY RECOMMENDED*** Do not call this callback every time + * resolution changes in an emulator core if it's + * expected to be a temporary change, for the reasons of possible + * driver reinitialization. + * This call is not a free pass for not trying to provide + * correct values in retro_get_system_av_info(). If you need to change + * things like aspect ratio or nominal width/height, + * use RETRO_ENVIRONMENT_SET_GEOMETRY, which is a softer variant + * of SET_SYSTEM_AV_INFO. + * + * If this returns false, the frontend does not acknowledge a + * changed av_info struct. + */ +#define RETRO_ENVIRONMENT_SET_PROC_ADDRESS_CALLBACK 33 + /* const struct retro_get_proc_address_interface * -- + * Allows a libretro core to announce support for the + * get_proc_address() interface. + * This interface allows for a standard way to extend libretro where + * use of environment calls are too indirect, + * e.g. for cases where the frontend wants to call directly into the core. + * + * If a core wants to expose this interface, SET_PROC_ADDRESS_CALLBACK + * **MUST** be called from within retro_set_environment(). + */ +#define RETRO_ENVIRONMENT_SET_SUBSYSTEM_INFO 34 + /* const struct retro_subsystem_info * -- + * This environment call introduces the concept of libretro "subsystems". + * A subsystem is a variant of a libretro core which supports + * different kinds of games. + * The purpose of this is to support e.g. emulators which might + * have special needs, e.g. Super Nintendo's Super GameBoy, Sufami Turbo. + * It can also be used to pick among subsystems in an explicit way + * if the libretro implementation is a multi-system emulator itself. + * + * Loading a game via a subsystem is done with retro_load_game_special(), + * and this environment call allows a libretro core to expose which + * subsystems are supported for use with retro_load_game_special(). + * A core passes an array of retro_game_special_info which is terminated + * with a zeroed out retro_game_special_info struct. + * + * If a core wants to use this functionality, SET_SUBSYSTEM_INFO + * **MUST** be called from within retro_set_environment(). + */ +#define RETRO_ENVIRONMENT_SET_CONTROLLER_INFO 35 + /* const struct retro_controller_info * -- + * This environment call lets a libretro core tell the frontend + * which controller types are recognized in calls to + * retro_set_controller_port_device(). + * + * Some emulators such as Super Nintendo + * support multiple lightgun types which must be specifically + * selected from. + * It is therefore sometimes necessary for a frontend to be able + * to tell the core about a special kind of input device which is + * not covered by the libretro input API. + * + * In order for a frontend to understand the workings of an input device, + * it must be a specialized type + * of the generic device types already defined in the libretro API. + * + * Which devices are supported can vary per input port. + * The core must pass an array of const struct retro_controller_info which + * is terminated with a blanked out struct. Each element of the struct + * corresponds to an ascending port index to + * retro_set_controller_port_device(). + * Even if special device types are set in the libretro core, + * libretro should only poll input based on the base input device types. + */ +#define RETRO_ENVIRONMENT_SET_MEMORY_MAPS (36 | RETRO_ENVIRONMENT_EXPERIMENTAL) + /* const struct retro_memory_map * -- + * This environment call lets a libretro core tell the frontend + * about the memory maps this core emulates. + * This can be used to implement, for example, cheats in a core-agnostic way. + * + * Should only be used by emulators; it doesn't make much sense for + * anything else. + * It is recommended to expose all relevant pointers through + * retro_get_memory_* as well. + * + * Can be called from retro_init and retro_load_game. + */ +#define RETRO_ENVIRONMENT_SET_GEOMETRY 37 + /* const struct retro_game_geometry * -- + * This environment call is similar to SET_SYSTEM_AV_INFO for changing + * video parameters, but provides a guarantee that drivers will not be + * reinitialized. + * This can only be called from within retro_run(). + * + * The purpose of this call is to allow a core to alter nominal + * width/heights as well as aspect ratios on-the-fly, which can be + * useful for some emulators to change in run-time. + * + * max_width/max_height arguments are ignored and cannot be changed + * with this call as this could potentially require a reinitialization or a + * non-constant time operation. + * If max_width/max_height are to be changed, SET_SYSTEM_AV_INFO is required. + * + * A frontend must guarantee that this environment call completes in + * constant time. + */ +#define RETRO_ENVIRONMENT_GET_USERNAME 38 + /* const char ** + * Returns the specified username of the frontend, if specified by the user. + * This username can be used as a nickname for a core that has online facilities + * or any other mode where personalization of the user is desirable. + * The returned value can be NULL. + * If this environ callback is used by a core that requires a valid username, + * a default username should be specified by the core. + */ +#define RETRO_ENVIRONMENT_GET_LANGUAGE 39 + /* unsigned * -- + * Returns the specified language of the frontend, if specified by the user. + * It can be used by the core for localization purposes. + */ + +#define RETRO_MEMDESC_CONST (1 << 0) /* The frontend will never change this memory area once retro_load_game has returned. */ +#define RETRO_MEMDESC_BIGENDIAN (1 << 1) /* The memory area contains big endian data. Default is little endian. */ +#define RETRO_MEMDESC_ALIGN_2 (1 << 16) /* All memory access in this area is aligned to their own size, or 2, whichever is smaller. */ +#define RETRO_MEMDESC_ALIGN_4 (2 << 16) +#define RETRO_MEMDESC_ALIGN_8 (3 << 16) +#define RETRO_MEMDESC_MINSIZE_2 (1 << 24) /* All memory in this region is accessed at least 2 bytes at the time. */ +#define RETRO_MEMDESC_MINSIZE_4 (2 << 24) +#define RETRO_MEMDESC_MINSIZE_8 (3 << 24) +struct retro_memory_descriptor +{ + uint64_t flags; + + /* Pointer to the start of the relevant ROM or RAM chip. + * It's strongly recommended to use 'offset' if possible, rather than + * doing math on the pointer. + * + * If the same byte is mapped my multiple descriptors, their descriptors + * must have the same pointer. + * If 'start' does not point to the first byte in the pointer, put the + * difference in 'offset' instead. + * + * May be NULL if there's nothing usable here (e.g. hardware registers and + * open bus). No flags should be set if the pointer is NULL. + * It's recommended to minimize the number of descriptors if possible, + * but not mandatory. */ + void *ptr; + size_t offset; + + /* This is the location in the emulated address space + * where the mapping starts. */ + size_t start; + + /* Which bits must be same as in 'start' for this mapping to apply. + * The first memory descriptor to claim a certain byte is the one + * that applies. + * A bit which is set in 'start' must also be set in this. + * Can be zero, in which case each byte is assumed mapped exactly once. + * In this case, 'len' must be a power of two. */ + size_t select; + + /* If this is nonzero, the set bits are assumed not connected to the + * memory chip's address pins. */ + size_t disconnect; + + /* This one tells the size of the current memory area. + * If, after start+disconnect are applied, the address is higher than + * this, the highest bit of the address is cleared. + * + * If the address is still too high, the next highest bit is cleared. + * Can be zero, in which case it's assumed to be infinite (as limited + * by 'select' and 'disconnect'). */ + size_t len; + + /* To go from emulated address to physical address, the following + * order applies: + * Subtract 'start', pick off 'disconnect', apply 'len', add 'offset'. + * + * The address space name must consist of only a-zA-Z0-9_-, + * should be as short as feasible (maximum length is 8 plus the NUL), + * and may not be any other address space plus one or more 0-9A-F + * at the end. + * However, multiple memory descriptors for the same address space is + * allowed, and the address space name can be empty. NULL is treated + * as empty. + * + * Address space names are case sensitive, but avoid lowercase if possible. + * The same pointer may exist in multiple address spaces. + * + * Examples: + * blank+blank - valid (multiple things may be mapped in the same namespace) + * 'Sp'+'Sp' - valid (multiple things may be mapped in the same namespace) + * 'A'+'B' - valid (neither is a prefix of each other) + * 'S'+blank - valid ('S' is not in 0-9A-F) + * 'a'+blank - valid ('a' is not in 0-9A-F) + * 'a'+'A' - valid (neither is a prefix of each other) + * 'AR'+blank - valid ('R' is not in 0-9A-F) + * 'ARB'+blank - valid (the B can't be part of the address either, because + * there is no namespace 'AR') + * blank+'B' - not valid, because it's ambigous which address space B1234 + * would refer to. + * The length can't be used for that purpose; the frontend may want + * to append arbitrary data to an address, without a separator. */ + const char *addrspace; +}; + +/* The frontend may use the largest value of 'start'+'select' in a + * certain namespace to infer the size of the address space. + * + * If the address space is larger than that, a mapping with .ptr=NULL + * should be at the end of the array, with .select set to all ones for + * as long as the address space is big. + * + * Sample descriptors (minus .ptr, and RETRO_MEMFLAG_ on the flags): + * SNES WRAM: + * .start=0x7E0000, .len=0x20000 + * (Note that this must be mapped before the ROM in most cases; some of the + * ROM mappers + * try to claim $7E0000, or at least $7E8000.) + * SNES SPC700 RAM: + * .addrspace="S", .len=0x10000 + * SNES WRAM mirrors: + * .flags=MIRROR, .start=0x000000, .select=0xC0E000, .len=0x2000 + * .flags=MIRROR, .start=0x800000, .select=0xC0E000, .len=0x2000 + * SNES WRAM mirrors, alternate equivalent descriptor: + * .flags=MIRROR, .select=0x40E000, .disconnect=~0x1FFF + * (Various similar constructions can be created by combining parts of + * the above two.) + * SNES LoROM (512KB, mirrored a couple of times): + * .flags=CONST, .start=0x008000, .select=0x408000, .disconnect=0x8000, .len=512*1024 + * .flags=CONST, .start=0x400000, .select=0x400000, .disconnect=0x8000, .len=512*1024 + * SNES HiROM (4MB): + * .flags=CONST, .start=0x400000, .select=0x400000, .len=4*1024*1024 + * .flags=CONST, .offset=0x8000, .start=0x008000, .select=0x408000, .len=4*1024*1024 + * SNES ExHiROM (8MB): + * .flags=CONST, .offset=0, .start=0xC00000, .select=0xC00000, .len=4*1024*1024 + * .flags=CONST, .offset=4*1024*1024, .start=0x400000, .select=0xC00000, .len=4*1024*1024 + * .flags=CONST, .offset=0x8000, .start=0x808000, .select=0xC08000, .len=4*1024*1024 + * .flags=CONST, .offset=4*1024*1024+0x8000, .start=0x008000, .select=0xC08000, .len=4*1024*1024 + * Clarify the size of the address space: + * .ptr=NULL, .select=0xFFFFFF + * .len can be implied by .select in many of them, but was included for clarity. + */ + +struct retro_memory_map +{ + const struct retro_memory_descriptor *descriptors; + unsigned num_descriptors; +}; + +struct retro_controller_description +{ + /* Human-readable description of the controller. Even if using a generic + * input device type, this can be set to the particular device type the + * core uses. */ + const char *desc; + + /* Device type passed to retro_set_controller_port_device(). If the device + * type is a sub-class of a generic input device type, use the + * RETRO_DEVICE_SUBCLASS macro to create an ID. + * + * E.g. RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 1). */ + unsigned id; +}; + +struct retro_controller_info +{ + const struct retro_controller_description *types; + unsigned num_types; +}; + +struct retro_subsystem_memory_info +{ + /* The extension associated with a memory type, e.g. "psram". */ + const char *extension; + + /* The memory type for retro_get_memory(). This should be at + * least 0x100 to avoid conflict with standardized + * libretro memory types. */ + unsigned type; +}; + +struct retro_subsystem_rom_info +{ + /* Describes what the content is (SGB BIOS, GB ROM, etc). */ + const char *desc; + + /* Same definition as retro_get_system_info(). */ + const char *valid_extensions; + + /* Same definition as retro_get_system_info(). */ + bool need_fullpath; + + /* Same definition as retro_get_system_info(). */ + bool block_extract; + + /* This is set if the content is required to load a game. + * If this is set to false, a zeroed-out retro_game_info can be passed. */ + bool required; + + /* Content can have multiple associated persistent + * memory types (retro_get_memory()). */ + const struct retro_subsystem_memory_info *memory; + unsigned num_memory; +}; + +struct retro_subsystem_info +{ + /* Human-readable string of the subsystem type, e.g. "Super GameBoy" */ + const char *desc; + + /* A computer friendly short string identifier for the subsystem type. + * This name must be [a-z]. + * E.g. if desc is "Super GameBoy", this can be "sgb". + * This identifier can be used for command-line interfaces, etc. + */ + const char *ident; + + /* Infos for each content file. The first entry is assumed to be the + * "most significant" content for frontend purposes. + * E.g. with Super GameBoy, the first content should be the GameBoy ROM, + * as it is the most "significant" content to a user. + * If a frontend creates new file paths based on the content used + * (e.g. savestates), it should use the path for the first ROM to do so. */ + const struct retro_subsystem_rom_info *roms; + + /* Number of content files associated with a subsystem. */ + unsigned num_roms; + + /* The type passed to retro_load_game_special(). */ + unsigned id; +}; + +typedef void (*retro_proc_address_t)(void); + +/* libretro API extension functions: + * (None here so far). + * + * Get a symbol from a libretro core. + * Cores should only return symbols which are actual + * extensions to the libretro API. + * + * Frontends should not use this to obtain symbols to standard + * libretro entry points (static linking or dlsym). + * + * The symbol name must be equal to the function name, + * e.g. if void retro_foo(void); exists, the symbol must be called "retro_foo". + * The returned function pointer must be cast to the corresponding type. + */ +typedef retro_proc_address_t (*retro_get_proc_address_t)(const char *sym); + +struct retro_get_proc_address_interface +{ + retro_get_proc_address_t get_proc_address; +}; + +enum retro_log_level +{ + RETRO_LOG_DEBUG = 0, + RETRO_LOG_INFO, + RETRO_LOG_WARN, + RETRO_LOG_ERROR, + + RETRO_LOG_DUMMY = INT_MAX +}; + +/* Logging function. Takes log level argument as well. */ +typedef void (*retro_log_printf_t)(enum retro_log_level level, + const char *fmt, ...); + +struct retro_log_callback +{ + retro_log_printf_t log; +}; + +/* Performance related functions */ + +/* ID values for SIMD CPU features */ +#define RETRO_SIMD_SSE (1 << 0) +#define RETRO_SIMD_SSE2 (1 << 1) +#define RETRO_SIMD_VMX (1 << 2) +#define RETRO_SIMD_VMX128 (1 << 3) +#define RETRO_SIMD_AVX (1 << 4) +#define RETRO_SIMD_NEON (1 << 5) +#define RETRO_SIMD_SSE3 (1 << 6) +#define RETRO_SIMD_SSSE3 (1 << 7) +#define RETRO_SIMD_MMX (1 << 8) +#define RETRO_SIMD_MMXEXT (1 << 9) +#define RETRO_SIMD_SSE4 (1 << 10) +#define RETRO_SIMD_SSE42 (1 << 11) +#define RETRO_SIMD_AVX2 (1 << 12) +#define RETRO_SIMD_VFPU (1 << 13) +#define RETRO_SIMD_PS (1 << 14) +#define RETRO_SIMD_AES (1 << 15) + +typedef uint64_t retro_perf_tick_t; +typedef int64_t retro_time_t; + +struct retro_perf_counter +{ + const char *ident; + retro_perf_tick_t start; + retro_perf_tick_t total; + retro_perf_tick_t call_cnt; + + bool registered; +}; + +/* Returns current time in microseconds. + * Tries to use the most accurate timer available. + */ +typedef retro_time_t (*retro_perf_get_time_usec_t)(void); + +/* A simple counter. Usually nanoseconds, but can also be CPU cycles. + * Can be used directly if desired (when creating a more sophisticated + * performance counter system). + * */ +typedef retro_perf_tick_t (*retro_perf_get_counter_t)(void); + +/* Returns a bit-mask of detected CPU features (RETRO_SIMD_*). */ +typedef uint64_t (*retro_get_cpu_features_t)(void); + +/* Asks frontend to log and/or display the state of performance counters. + * Performance counters can always be poked into manually as well. + */ +typedef void (*retro_perf_log_t)(void); + +/* Register a performance counter. + * ident field must be set with a discrete value and other values in + * retro_perf_counter must be 0. + * Registering can be called multiple times. To avoid calling to + * frontend redundantly, you can check registered field first. */ +typedef void (*retro_perf_register_t)(struct retro_perf_counter *counter); + +/* Starts a registered counter. */ +typedef void (*retro_perf_start_t)(struct retro_perf_counter *counter); + +/* Stops a registered counter. */ +typedef void (*retro_perf_stop_t)(struct retro_perf_counter *counter); + +/* For convenience it can be useful to wrap register, start and stop in macros. + * E.g.: + * #ifdef LOG_PERFORMANCE + * #define RETRO_PERFORMANCE_INIT(perf_cb, name) static struct retro_perf_counter name = {#name}; if (!name.registered) perf_cb.perf_register(&(name)) + * #define RETRO_PERFORMANCE_START(perf_cb, name) perf_cb.perf_start(&(name)) + * #define RETRO_PERFORMANCE_STOP(perf_cb, name) perf_cb.perf_stop(&(name)) + * #else + * ... Blank macros ... + * #endif + * + * These can then be used mid-functions around code snippets. + * + * extern struct retro_perf_callback perf_cb; * Somewhere in the core. + * + * void do_some_heavy_work(void) + * { + * RETRO_PERFORMANCE_INIT(cb, work_1; + * RETRO_PERFORMANCE_START(cb, work_1); + * heavy_work_1(); + * RETRO_PERFORMANCE_STOP(cb, work_1); + * + * RETRO_PERFORMANCE_INIT(cb, work_2); + * RETRO_PERFORMANCE_START(cb, work_2); + * heavy_work_2(); + * RETRO_PERFORMANCE_STOP(cb, work_2); + * } + * + * void retro_deinit(void) + * { + * perf_cb.perf_log(); * Log all perf counters here for example. + * } + */ + +struct retro_perf_callback +{ + retro_perf_get_time_usec_t get_time_usec; + retro_get_cpu_features_t get_cpu_features; + + retro_perf_get_counter_t get_perf_counter; + retro_perf_register_t perf_register; + retro_perf_start_t perf_start; + retro_perf_stop_t perf_stop; + retro_perf_log_t perf_log; +}; + +/* FIXME: Document the sensor API and work out behavior. + * It will be marked as experimental until then. + */ +enum retro_sensor_action +{ + RETRO_SENSOR_ACCELEROMETER_ENABLE = 0, + RETRO_SENSOR_ACCELEROMETER_DISABLE, + + RETRO_SENSOR_DUMMY = INT_MAX +}; + +/* Id values for SENSOR types. */ +#define RETRO_SENSOR_ACCELEROMETER_X 0 +#define RETRO_SENSOR_ACCELEROMETER_Y 1 +#define RETRO_SENSOR_ACCELEROMETER_Z 2 + +typedef bool (*retro_set_sensor_state_t)(unsigned port, + enum retro_sensor_action action, unsigned rate); + +typedef float (*retro_sensor_get_input_t)(unsigned port, unsigned id); + +struct retro_sensor_interface +{ + retro_set_sensor_state_t set_sensor_state; + retro_sensor_get_input_t get_sensor_input; +}; + +enum retro_camera_buffer +{ + RETRO_CAMERA_BUFFER_OPENGL_TEXTURE = 0, + RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER, + + RETRO_CAMERA_BUFFER_DUMMY = INT_MAX +}; + +/* Starts the camera driver. Can only be called in retro_run(). */ +typedef bool (*retro_camera_start_t)(void); + +/* Stops the camera driver. Can only be called in retro_run(). */ +typedef void (*retro_camera_stop_t)(void); + +/* Callback which signals when the camera driver is initialized + * and/or deinitialized. + * retro_camera_start_t can be called in initialized callback. + */ +typedef void (*retro_camera_lifetime_status_t)(void); + +/* A callback for raw framebuffer data. buffer points to an XRGB8888 buffer. + * Width, height and pitch are similar to retro_video_refresh_t. + * First pixel is top-left origin. + */ +typedef void (*retro_camera_frame_raw_framebuffer_t)(const uint32_t *buffer, + unsigned width, unsigned height, size_t pitch); + +/* A callback for when OpenGL textures are used. + * + * texture_id is a texture owned by camera driver. + * Its state or content should be considered immutable, except for things like + * texture filtering and clamping. + * + * texture_target is the texture target for the GL texture. + * These can include e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE, and possibly + * more depending on extensions. + * + * affine points to a packed 3x3 column-major matrix used to apply an affine + * transform to texture coordinates. (affine_matrix * vec3(coord_x, coord_y, 1.0)) + * After transform, normalized texture coord (0, 0) should be bottom-left + * and (1, 1) should be top-right (or (width, height) for RECTANGLE). + * + * GL-specific typedefs are avoided here to avoid relying on gl.h in + * the API definition. + */ +typedef void (*retro_camera_frame_opengl_texture_t)(unsigned texture_id, + unsigned texture_target, const float *affine); + +struct retro_camera_callback +{ + /* Set by libretro core. + * Example bitmask: caps = (1 << RETRO_CAMERA_BUFFER_OPENGL_TEXTURE) | (1 << RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER). + */ + uint64_t caps; + + unsigned width; /* Desired resolution for camera. Is only used as a hint. */ + unsigned height; + retro_camera_start_t start; /* Set by frontend. */ + retro_camera_stop_t stop; /* Set by frontend. */ + + /* Set by libretro core if raw framebuffer callbacks will be used. */ + retro_camera_frame_raw_framebuffer_t frame_raw_framebuffer; + /* Set by libretro core if OpenGL texture callbacks will be used. */ + retro_camera_frame_opengl_texture_t frame_opengl_texture; + + /* Set by libretro core. Called after camera driver is initialized and + * ready to be started. + * Can be NULL, in which this callback is not called. + */ + retro_camera_lifetime_status_t initialized; + + /* Set by libretro core. Called right before camera driver is + * deinitialized. + * Can be NULL, in which this callback is not called. + */ + retro_camera_lifetime_status_t deinitialized; +}; + +/* Sets the interval of time and/or distance at which to update/poll + * location-based data. + * + * To ensure compatibility with all location-based implementations, + * values for both interval_ms and interval_distance should be provided. + * + * interval_ms is the interval expressed in milliseconds. + * interval_distance is the distance interval expressed in meters. + */ +typedef void (*retro_location_set_interval_t)(unsigned interval_ms, + unsigned interval_distance); + +/* Start location services. The device will start listening for changes to the + * current location at regular intervals (which are defined with + * retro_location_set_interval_t). */ +typedef bool (*retro_location_start_t)(void); + +/* Stop location services. The device will stop listening for changes + * to the current location. */ +typedef void (*retro_location_stop_t)(void); + +/* Get the position of the current location. Will set parameters to + * 0 if no new location update has happened since the last time. */ +typedef bool (*retro_location_get_position_t)(double *lat, double *lon, + double *horiz_accuracy, double *vert_accuracy); + +/* Callback which signals when the location driver is initialized + * and/or deinitialized. + * retro_location_start_t can be called in initialized callback. + */ +typedef void (*retro_location_lifetime_status_t)(void); + +struct retro_location_callback +{ + retro_location_start_t start; + retro_location_stop_t stop; + retro_location_get_position_t get_position; + retro_location_set_interval_t set_interval; + + retro_location_lifetime_status_t initialized; + retro_location_lifetime_status_t deinitialized; +}; + +enum retro_rumble_effect +{ + RETRO_RUMBLE_STRONG = 0, + RETRO_RUMBLE_WEAK = 1, + + RETRO_RUMBLE_DUMMY = INT_MAX +}; + +/* Sets rumble state for joypad plugged in port 'port'. + * Rumble effects are controlled independently, + * and setting e.g. strong rumble does not override weak rumble. + * Strength has a range of [0, 0xffff]. + * + * Returns true if rumble state request was honored. + * Calling this before first retro_run() is likely to return false. */ +typedef bool (*retro_set_rumble_state_t)(unsigned port, + enum retro_rumble_effect effect, uint16_t strength); + +struct retro_rumble_interface +{ + retro_set_rumble_state_t set_rumble_state; +}; + +/* Notifies libretro that audio data should be written. */ +typedef void (*retro_audio_callback_t)(void); + +/* True: Audio driver in frontend is active, and callback is + * expected to be called regularily. + * False: Audio driver in frontend is paused or inactive. + * Audio callback will not be called until set_state has been + * called with true. + * Initial state is false (inactive). + */ +typedef void (*retro_audio_set_state_callback_t)(bool enabled); + +struct retro_audio_callback +{ + retro_audio_callback_t callback; + retro_audio_set_state_callback_t set_state; +}; + +/* Notifies a libretro core of time spent since last invocation + * of retro_run() in microseconds. + * + * It will be called right before retro_run() every frame. + * The frontend can tamper with timing to support cases like + * fast-forward, slow-motion and framestepping. + * + * In those scenarios the reference frame time value will be used. */ +typedef int64_t retro_usec_t; +typedef void (*retro_frame_time_callback_t)(retro_usec_t usec); +struct retro_frame_time_callback +{ + retro_frame_time_callback_t callback; + /* Represents the time of one frame. It is computed as + * 1000000 / fps, but the implementation will resolve the + * rounding to ensure that framestepping, etc is exact. */ + retro_usec_t reference; +}; + +/* Pass this to retro_video_refresh_t if rendering to hardware. + * Passing NULL to retro_video_refresh_t is still a frame dupe as normal. + * */ +#define RETRO_HW_FRAME_BUFFER_VALID ((void*)-1) + +/* Invalidates the current HW context. + * Any GL state is lost, and must not be deinitialized explicitly. + * If explicit deinitialization is desired by the libretro core, + * it should implement context_destroy callback. + * If called, all GPU resources must be reinitialized. + * Usually called when frontend reinits video driver. + * Also called first time video driver is initialized, + * allowing libretro core to initialize resources. + */ +typedef void (*retro_hw_context_reset_t)(void); + +/* Gets current framebuffer which is to be rendered to. + * Could change every frame potentially. + */ +typedef uintptr_t (*retro_hw_get_current_framebuffer_t)(void); + +/* Get a symbol from HW context. */ +typedef retro_proc_address_t (*retro_hw_get_proc_address_t)(const char *sym); + +enum retro_hw_context_type +{ + RETRO_HW_CONTEXT_NONE = 0, + /* OpenGL 2.x. Driver can choose to use latest compatibility context. */ + RETRO_HW_CONTEXT_OPENGL = 1, + /* OpenGL ES 2.0. */ + RETRO_HW_CONTEXT_OPENGLES2 = 2, + /* Modern desktop core GL context. Use version_major/ + * version_minor fields to set GL version. */ + RETRO_HW_CONTEXT_OPENGL_CORE = 3, + /* OpenGL ES 3.0 */ + RETRO_HW_CONTEXT_OPENGLES3 = 4, + /* OpenGL ES 3.1+. Set version_major/version_minor. For GLES2 and GLES3, + * use the corresponding enums directly. */ + RETRO_HW_CONTEXT_OPENGLES_VERSION = 5, + + RETRO_HW_CONTEXT_DUMMY = INT_MAX +}; + +struct retro_hw_render_callback +{ + /* Which API to use. Set by libretro core. */ + enum retro_hw_context_type context_type; + + /* Called when a context has been created or when it has been reset. + * An OpenGL context is only valid after context_reset() has been called. + * + * When context_reset is called, OpenGL resources in the libretro + * implementation are guaranteed to be invalid. + * + * It is possible that context_reset is called multiple times during an + * application lifecycle. + * If context_reset is called without any notification (context_destroy), + * the OpenGL context was lost and resources should just be recreated + * without any attempt to "free" old resources. + */ + retro_hw_context_reset_t context_reset; + + /* Set by frontend. */ + retro_hw_get_current_framebuffer_t get_current_framebuffer; + + /* Set by frontend. */ + retro_hw_get_proc_address_t get_proc_address; + + /* Set if render buffers should have depth component attached. */ + bool depth; + + /* Set if stencil buffers should be attached. */ + bool stencil; + + /* If depth and stencil are true, a packed 24/8 buffer will be added. + * Only attaching stencil is invalid and will be ignored. */ + + /* Use conventional bottom-left origin convention. If false, + * standard libretro top-left origin semantics are used. */ + bool bottom_left_origin; + + /* Major version number for core GL context or GLES 3.1+. */ + unsigned version_major; + + /* Minor version number for core GL context or GLES 3.1+. */ + unsigned version_minor; + + /* If this is true, the frontend will go very far to avoid + * resetting context in scenarios like toggling fullscreen, etc. + */ + bool cache_context; + + /* The reset callback might still be called in extreme situations + * such as if the context is lost beyond recovery. + * + * For optimal stability, set this to false, and allow context to be + * reset at any time. + */ + + /* A callback to be called before the context is destroyed in a + * controlled way by the frontend. */ + retro_hw_context_reset_t context_destroy; + + /* OpenGL resources can be deinitialized cleanly at this step. + * context_destroy can be set to NULL, in which resources will + * just be destroyed without any notification. + * + * Even when context_destroy is non-NULL, it is possible that + * context_reset is called without any destroy notification. + * This happens if context is lost by external factors (such as + * notified by GL_ARB_robustness). + * + * In this case, the context is assumed to be already dead, + * and the libretro implementation must not try to free any OpenGL + * resources in the subsequent context_reset. + */ + + /* Creates a debug context. */ + bool debug_context; +}; + +/* Callback type passed in RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK. + * Called by the frontend in response to keyboard events. + * down is set if the key is being pressed, or false if it is being released. + * keycode is the RETROK value of the char. + * character is the text character of the pressed key. (UTF-32). + * key_modifiers is a set of RETROKMOD values or'ed together. + * + * The pressed/keycode state can be indepedent of the character. + * It is also possible that multiple characters are generated from a + * single keypress. + * Keycode events should be treated separately from character events. + * However, when possible, the frontend should try to synchronize these. + * If only a character is posted, keycode should be RETROK_UNKNOWN. + * + * Similarily if only a keycode event is generated with no corresponding + * character, character should be 0. + */ +typedef void (*retro_keyboard_event_t)(bool down, unsigned keycode, + uint32_t character, uint16_t key_modifiers); + +struct retro_keyboard_callback +{ + retro_keyboard_event_t callback; +}; + +/* Callbacks for RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE. + * Should be set for implementations which can swap out multiple disk + * images in runtime. + * + * If the implementation can do this automatically, it should strive to do so. + * However, there are cases where the user must manually do so. + * + * Overview: To swap a disk image, eject the disk image with + * set_eject_state(true). + * Set the disk index with set_image_index(index). Insert the disk again + * with set_eject_state(false). + */ + +/* If ejected is true, "ejects" the virtual disk tray. + * When ejected, the disk image index can be set. + */ +typedef bool (*retro_set_eject_state_t)(bool ejected); + +/* Gets current eject state. The initial state is 'not ejected'. */ +typedef bool (*retro_get_eject_state_t)(void); + +/* Gets current disk index. First disk is index 0. + * If return value is >= get_num_images(), no disk is currently inserted. + */ +typedef unsigned (*retro_get_image_index_t)(void); + +/* Sets image index. Can only be called when disk is ejected. + * The implementation supports setting "no disk" by using an + * index >= get_num_images(). + */ +typedef bool (*retro_set_image_index_t)(unsigned index); + +/* Gets total number of images which are available to use. */ +typedef unsigned (*retro_get_num_images_t)(void); + +struct retro_game_info; + +/* Replaces the disk image associated with index. + * Arguments to pass in info have same requirements as retro_load_game(). + * Virtual disk tray must be ejected when calling this. + * + * Replacing a disk image with info = NULL will remove the disk image + * from the internal list. + * As a result, calls to get_image_index() can change. + * + * E.g. replace_image_index(1, NULL), and previous get_image_index() + * returned 4 before. + * Index 1 will be removed, and the new index is 3. + */ +typedef bool (*retro_replace_image_index_t)(unsigned index, + const struct retro_game_info *info); + +/* Adds a new valid index (get_num_images()) to the internal disk list. + * This will increment subsequent return values from get_num_images() by 1. + * This image index cannot be used until a disk image has been set + * with replace_image_index. */ +typedef bool (*retro_add_image_index_t)(void); + +struct retro_disk_control_callback +{ + retro_set_eject_state_t set_eject_state; + retro_get_eject_state_t get_eject_state; + + retro_get_image_index_t get_image_index; + retro_set_image_index_t set_image_index; + retro_get_num_images_t get_num_images; + + retro_replace_image_index_t replace_image_index; + retro_add_image_index_t add_image_index; +}; + +enum retro_pixel_format +{ + /* 0RGB1555, native endian. + * 0 bit must be set to 0. + * This pixel format is default for compatibility concerns only. + * If a 15/16-bit pixel format is desired, consider using RGB565. */ + RETRO_PIXEL_FORMAT_0RGB1555 = 0, + + /* XRGB8888, native endian. + * X bits are ignored. */ + RETRO_PIXEL_FORMAT_XRGB8888 = 1, + + /* RGB565, native endian. + * This pixel format is the recommended format to use if a 15/16-bit + * format is desired as it is the pixel format that is typically + * available on a wide range of low-power devices. + * + * It is also natively supported in APIs like OpenGL ES. */ + RETRO_PIXEL_FORMAT_RGB565 = 2, + + /* Ensure sizeof() == sizeof(int). */ + RETRO_PIXEL_FORMAT_UNKNOWN = INT_MAX +}; + +struct retro_message +{ + const char *msg; /* Message to be displayed. */ + unsigned frames; /* Duration in frames of message. */ +}; + +/* Describes how the libretro implementation maps a libretro input bind + * to its internal input system through a human readable string. + * This string can be used to better let a user configure input. */ +struct retro_input_descriptor +{ + /* Associates given parameters with a description. */ + unsigned port; + unsigned device; + unsigned index; + unsigned id; + + /* Human readable description for parameters. + * The pointer must remain valid until + * retro_unload_game() is called. */ + const char *description; +}; + +struct retro_system_info +{ + /* All pointers are owned by libretro implementation, and pointers must + * remain valid until retro_deinit() is called. */ + + const char *library_name; /* Descriptive name of library. Should not + * contain any version numbers, etc. */ + const char *library_version; /* Descriptive version of core. */ + + const char *valid_extensions; /* A string listing probably content + * extensions the core will be able to + * load, separated with pipe. + * I.e. "bin|rom|iso". + * Typically used for a GUI to filter + * out extensions. */ + + /* If true, retro_load_game() is guaranteed to provide a valid pathname + * in retro_game_info::path. + * ::data and ::size are both invalid. + * + * If false, ::data and ::size are guaranteed to be valid, but ::path + * might not be valid. + * + * This is typically set to true for libretro implementations that must + * load from file. + * Implementations should strive for setting this to false, as it allows + * the frontend to perform patching, etc. */ + bool need_fullpath; + + /* If true, the frontend is not allowed to extract any archives before + * loading the real content. + * Necessary for certain libretro implementations that load games + * from zipped archives. */ + bool block_extract; +}; + +struct retro_game_geometry +{ + unsigned base_width; /* Nominal video width of game. */ + unsigned base_height; /* Nominal video height of game. */ + unsigned max_width; /* Maximum possible width of game. */ + unsigned max_height; /* Maximum possible height of game. */ + + float aspect_ratio; /* Nominal aspect ratio of game. If + * aspect_ratio is <= 0.0, an aspect ratio + * of base_width / base_height is assumed. + * A frontend could override this setting, + * if desired. */ +}; + +struct retro_system_timing +{ + double fps; /* FPS of video content. */ + double sample_rate; /* Sampling rate of audio. */ +}; + +struct retro_system_av_info +{ + struct retro_game_geometry geometry; + struct retro_system_timing timing; +}; + +struct retro_variable +{ + /* Variable to query in RETRO_ENVIRONMENT_GET_VARIABLE. + * If NULL, obtains the complete environment string if more + * complex parsing is necessary. + * The environment string is formatted as key-value pairs + * delimited by semicolons as so: + * "key1=value1;key2=value2;..." + */ + const char *key; + + /* Value to be obtained. If key does not exist, it is set to NULL. */ + const char *value; +}; + +struct retro_game_info +{ + const char *path; /* Path to game, UTF-8 encoded. + * Usually used as a reference. + * May be NULL if rom was loaded from stdin + * or similar. + * retro_system_info::need_fullpath guaranteed + * that this path is valid. */ + const void *data; /* Memory buffer of loaded game. Will be NULL + * if need_fullpath was set. */ + size_t size; /* Size of memory buffer. */ + const char *meta; /* String of implementation specific meta-data. */ +}; + +/* Callbacks */ + +/* Environment callback. Gives implementations a way of performing + * uncommon tasks. Extensible. */ +typedef bool (*retro_environment_t)(unsigned cmd, void *data); + +/* Render a frame. Pixel format is 15-bit 0RGB1555 native endian + * unless changed (see RETRO_ENVIRONMENT_SET_PIXEL_FORMAT). + * + * Width and height specify dimensions of buffer. + * Pitch specifices length in bytes between two lines in buffer. + * + * For performance reasons, it is highly recommended to have a frame + * that is packed in memory, i.e. pitch == width * byte_per_pixel. + * Certain graphic APIs, such as OpenGL ES, do not like textures + * that are not packed in memory. + */ +typedef void (*retro_video_refresh_t)(const void *data, unsigned width, + unsigned height, size_t pitch); + +/* Renders a single audio frame. Should only be used if implementation + * generates a single sample at a time. + * Format is signed 16-bit native endian. + */ +typedef void (*retro_audio_sample_t)(int16_t left, int16_t right); + +/* Renders multiple audio frames in one go. + * + * One frame is defined as a sample of left and right channels, interleaved. + * I.e. int16_t buf[4] = { l, r, l, r }; would be 2 frames. + * Only one of the audio callbacks must ever be used. + */ +typedef size_t (*retro_audio_sample_batch_t)(const int16_t *data, + size_t frames); + +/* Polls input. */ +typedef void (*retro_input_poll_t)(void); + +/* Queries for input for player 'port'. device will be masked with + * RETRO_DEVICE_MASK. + * + * Specialization of devices such as RETRO_DEVICE_JOYPAD_MULTITAP that + * have been set with retro_set_controller_port_device() + * will still use the higher level RETRO_DEVICE_JOYPAD to request input. + */ +typedef int16_t (*retro_input_state_t)(unsigned port, unsigned device, + unsigned index, unsigned id); + +/* Sets callbacks. retro_set_environment() is guaranteed to be called + * before retro_init(). + * + * The rest of the set_* functions are guaranteed to have been called + * before the first call to retro_run() is made. */ +void retro_set_environment(retro_environment_t); +void retro_set_video_refresh(retro_video_refresh_t); +void retro_set_audio_sample(retro_audio_sample_t); +void retro_set_audio_sample_batch(retro_audio_sample_batch_t); +void retro_set_input_poll(retro_input_poll_t); +void retro_set_input_state(retro_input_state_t); + +/* Library global initialization/deinitialization. */ +void retro_init(void); +void retro_deinit(void); + +/* Must return RETRO_API_VERSION. Used to validate ABI compatibility + * when the API is revised. */ +unsigned retro_api_version(void); + +/* Gets statically known system info. Pointers provided in *info + * must be statically allocated. + * Can be called at any time, even before retro_init(). */ +void retro_get_system_info(struct retro_system_info *info); + +/* Gets information about system audio/video timings and geometry. + * Can be called only after retro_load_game() has successfully completed. + * NOTE: The implementation of this function might not initialize every + * variable if needed. + * E.g. geom.aspect_ratio might not be initialized if core doesn't + * desire a particular aspect ratio. */ +void retro_get_system_av_info(struct retro_system_av_info *info); + +/* Sets device to be used for player 'port'. + * By default, RETRO_DEVICE_JOYPAD is assumed to be plugged into all + * available ports. + * Setting a particular device type is not a guarantee that libretro cores + * will only poll input based on that particular device type. It is only a + * hint to the libretro core when a core cannot automatically detect the + * appropriate input device type on its own. It is also relevant when a + * core can change its behavior depending on device type. */ +void retro_set_controller_port_device(unsigned port, unsigned device); + +/* Resets the current game. */ +void retro_reset(void); + +/* Runs the game for one video frame. + * During retro_run(), input_poll callback must be called at least once. + * + * If a frame is not rendered for reasons where a game "dropped" a frame, + * this still counts as a frame, and retro_run() should explicitly dupe + * a frame if GET_CAN_DUPE returns true. + * In this case, the video callback can take a NULL argument for data. + */ +void retro_run(void); + +/* Returns the amount of data the implementation requires to serialize + * internal state (save states). + * Between calls to retro_load_game() and retro_unload_game(), the + * returned size is never allowed to be larger than a previous returned + * value, to ensure that the frontend can allocate a save state buffer once. + */ +size_t retro_serialize_size(void); + +/* Serializes internal state. If failed, or size is lower than + * retro_serialize_size(), it should return false, true otherwise. */ +bool retro_serialize(void *data, size_t size); +bool retro_unserialize(const void *data, size_t size); + +void retro_cheat_reset(void); +void retro_cheat_set(unsigned index, bool enabled, const char *code); + +/* Loads a game. */ +bool retro_load_game(const struct retro_game_info *game); + +/* Loads a "special" kind of game. Should not be used, + * except in extreme cases. */ +bool retro_load_game_special( + unsigned game_type, + const struct retro_game_info *info, size_t num_info +); + +/* Unloads a currently loaded game. */ +void retro_unload_game(void); + +/* Gets region of game. */ +unsigned retro_get_region(void); + +/* Gets region of memory. */ +void *retro_get_memory_data(unsigned id); +size_t retro_get_memory_size(unsigned id); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libretro/about.c b/libretro/about.c new file mode 100644 index 0000000..e69de29 diff --git a/libretro/about.h b/libretro/about.h new file mode 100644 index 0000000..e69de29 diff --git a/libretro/cdaspi.h b/libretro/cdaspi.h new file mode 100644 index 0000000..954ce54 --- /dev/null +++ b/libretro/cdaspi.h @@ -0,0 +1,24 @@ +#ifndef CDASPI_H_ +#define CDASPI_H_ + +int CDASPI_Open(void); +void CDASPI_Close(void); +int CDASPI_Wait(void); +int CDASPI_ReadTOC(void* buf); +int CDASPI_Read(long block, BYTE* buf); +int CDASPI_ExecCmd(BYTE *cdb, int cdb_size, BYTE *out_buff, int out_size); +int CDASPI_IsOpen(void); + +void CDASPI_EnumCD(void); + +void CDASPI_Init(void); +void CDASPI_Cleanup(void); + +extern BYTE CDASPI_CDName[8][4]; +extern int CDASPI_CDNum; + +extern HINSTANCE ASPIDLL; +DWORD (*pSendASPI32Command)(LPSRB); +DWORD (*pGetASPI32SupportInfo)(VOID); + +#endif // CDASPI_H_ diff --git a/libretro/cdctrl.h b/libretro/cdctrl.h new file mode 100644 index 0000000..8b86e94 --- /dev/null +++ b/libretro/cdctrl.h @@ -0,0 +1,11 @@ +#ifndef CDCTRL_H_ +#define CDCTRL_H_ + +int CDCTRL_Open(void); +void CDCTRL_Close(void); +int CDCTRL_Wait(void); +int CDCTRL_ReadTOC(void* buf); +int CDCTRL_Read(long block, BYTE* buf); +int CDCTRL_IsOpen(void); + +#endif // CDCTRL_H_ diff --git a/libretro/cdrom.h b/libretro/cdrom.h new file mode 100644 index 0000000..da5db52 --- /dev/null +++ b/libretro/cdrom.h @@ -0,0 +1,29 @@ +#ifndef _winx68k_cdrom +#define _winx68k_cdrom + +#include "common.h" + +typedef struct { + unsigned char reserved; + unsigned char adr; + unsigned char trackno; + unsigned char reserved1; + unsigned char addr[4]; +} TOCENTRY; + +typedef struct { + unsigned char size[2]; + unsigned char first; + unsigned char last; + TOCENTRY track[100]; +} TOC; + +void CDROM_Init(void); +void CDROM_Cleanup(void); +BYTE FASTCALL CDROM_Read(DWORD adr); +void FASTCALL CDROM_Write(DWORD adr, BYTE data); + +extern BYTE CDROM_ASPIChecked; + +#endif + diff --git a/libretro/cmdline.h b/libretro/cmdline.h new file mode 100644 index 0000000..98afa28 --- /dev/null +++ b/libretro/cmdline.h @@ -0,0 +1,9 @@ +#ifndef keropi_cmdline_h +#define keropi_cmdline_h + +extern char macrofile[MAX_PATH]; + +void CheckCmdLine(LPSTR s); +void SetCmdLineFD(void); + +#endif //keropi_cmdline_h diff --git a/libretro/common.c b/libretro/common.c new file mode 100644 index 0000000..a1e7d6f --- /dev/null +++ b/libretro/common.c @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------------------------- +// COMMON - 標準ヘッダ群（COMMON.H）とエラーダイアログ表示とか +// --------------------------------------------------------------------------------------- +//#include +#include +#include +#ifdef ANDROID +#include +#endif + +//#include "sstp.h" + +//extern HWND hWndMain; +extern const char PrgTitle[]; + +// P6L: PX68K_LOG +// ~ ~ ~ +#define P6L_LEN 256 +char p6l_buf[P6L_LEN]; + +void Error(const char* s) +{ + printf("%s Error: %s\n", PrgTitle, s); + +// SSTP_SendMes(SSTPMES_ERROR); + +// MessageBox(hWndMain, s, title, MB_ICONERROR | MB_OK); +} + +// log for debug +void p6logd(const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + vsnprintf(p6l_buf, P6L_LEN, fmt, args); + va_end(args); + +#if defined(ANDROID) + __android_log_write(ANDROID_LOG_DEBUG, "Tag", p6l_buf); +#elif defined(PSP) + printf("%s", p6l_buf); +#else + printf("%s", p6l_buf); +#endif +} diff --git a/libretro/common.h b/libretro/common.h new file mode 100644 index 0000000..6ac60b7 --- /dev/null +++ b/libretro/common.h @@ -0,0 +1,55 @@ +#ifndef winx68k_common_h +#define winx68k_common_h + +#include "windows.h" +#include +#include + +#ifdef __APPLE__ +#include "TargetConditionals.h" +#endif + +#define TRUE 1 +#define FALSE 0 +#define SUCCESS 0 +#define FAILURE 1 + +#define FASTCALL +#define STDCALL +#define LABEL +#define __stdcall + +#ifdef PSP +#ifdef MAX_PATH +#undef MAX_PATH +#endif +#define MAX_PATH 256 +#endif + +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned int UINT32; +typedef signed char INT8; +typedef signed short INT16; +typedef signed int INT32; + +typedef union { + struct { + BYTE l; + BYTE h; + } b; + WORD w; +} PAIR; + +#ifdef __cplusplus +extern "C" { +#endif + +void Error(const char* s); +void p6logd(const char *fmt, ...); + +#ifdef __cplusplus +} +#endif + +#endif //winx68k_common_h diff --git a/libretro/dswin.c b/libretro/dswin.c new file mode 100755 index 0000000..24d7fe2 --- /dev/null +++ b/libretro/dswin.c @@ -0,0 +1,268 @@ +/* + * Copyright (c) 2003 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "windows.h" +#include "common.h" +#include "dswin.h" +#include "prop.h" +#include "adpcm.h" +#include "mercury.h" +#include "fmg_wrap.h" + +#include "libretro.h" +extern retro_audio_sample_batch_t audio_batch_cb; +extern signed short soundbuf[1024*2]; + +short playing = FALSE; + +#define PCMBUF_SIZE 2*2*48000 +BYTE pcmbuffer[PCMBUF_SIZE]; +BYTE *pcmbufp = pcmbuffer; +BYTE *pbsp = pcmbuffer; +BYTE *pbrp = pcmbuffer, *pbwp = pcmbuffer; +BYTE *pbep = &pcmbuffer[PCMBUF_SIZE]; +DWORD ratebase = 22050; +long DSound_PreCounter = 0; +BYTE rsndbuf[PCMBUF_SIZE]; + +int audio_fd = 1; + + void raudio_callback(void *userdata, unsigned char *stream, int len); + +#ifndef NOSOUND + + +int +DSound_Init(unsigned long rate, unsigned long buflen) +{ + DWORD samples; + + if (playing) { + return FALSE; + } + + if (rate == 0) { + audio_fd = -1; + return TRUE; + } + + ratebase = rate; + + samples = 2048; + + playing = TRUE; + return TRUE; +} + +void +DSound_Play(void) +{ +// if (audio_fd >= 0); + +} + +void +DSound_Stop(void) +{ +// if (audio_fd >= 0); + +} + +int +DSound_Cleanup(void) +{ + playing = FALSE; + if (audio_fd >= 0) { + + audio_fd = -1; + } + return TRUE; +} + +static void sound_send(int length) +{ + int rate; + + rate = 0; + + ADPCM_Update((short *)pbwp, length, rate, pbsp, pbep); + OPM_Update((short *)pbwp, length, rate, pbsp, pbep); +#ifndef NO_MERCURY + //Mcry_Update((short *)pcmbufp, length); +#endif + + pbwp += length * sizeof(WORD) * 2; + if (pbwp >= pbep) { + pbwp = pbsp + (pbwp - pbep); + } + +} + +void FASTCALL DSound_Send0(long clock) +{ + int length = 0; + int rate; + + if (audio_fd < 0) { + return; + } + + DSound_PreCounter += (ratebase * clock); + while (DSound_PreCounter >= 10000000L) { + length++; + DSound_PreCounter -= 10000000L; + } + if (length == 0) { + return; + } + sound_send(length); +} + +static void FASTCALL DSound_Send(int length) +{ + int rate; + + if (audio_fd < 0) { + return; + } + sound_send(length); +} + +void +raudio_callback(void *userdata, unsigned char *stream, int len) +{ + int lena, lenb, datalen, rate; + BYTE *buf; + static DWORD bef; + DWORD now; + + now = timeGetTime(); + + //p6logd("tdiff %4d : len %d ", now - bef, len); + +//printf("tdiff %4d : len %d \n", now - bef, len); +cb_start: + if (pbrp <= pbwp) { + // pcmbuffer + // +---------+-------------+----------+ + // | |/////////////| | + // +---------+-------------+----------+ + // A A<--datalen-->A A + // | | | | + // pbsp pbrp pbwp pbep + + datalen = pbwp - pbrp; + if (datalen < len) { + // needs more data + + DSound_Send((len - datalen) / 4); + + } +#if 0 + datalen = pbwp - pbrp; + if (datalen < len) { + printf("xxxxx not enough sound data xxxxx\n"); + } +#endif + if (pbrp > pbwp) { + // chage to TYPEC or TYPED + goto cb_start; + } + + buf = pbrp; + pbrp += len; + //printf("TYPEA: "); + + } else { + // pcmbuffer + // +---------+-------------+----------+ + // |/////////| |//////////| + // +------+--+-------------+----------+ + // <-lenb-> A <---lena---> + // A | A A + // | | | | + // pbsp pbwp pbrp pbep + + lena = pbep - pbrp; + if (lena >= len) { + buf = pbrp; + pbrp += len; + //printf("TYPEC: "); + } else { + lenb = len - lena; + if (pbwp - pbsp < lenb) { + + DSound_Send((lenb - (pbwp - pbsp)) / 4); + + } +#if 0 + if (pbwp - pbsp < lenb) { + printf("xxxxx not enough sound data xxxxx\n"); + } +#endif + memcpy(rsndbuf, pbrp, lena); + memcpy(&rsndbuf[lena], pbsp, lenb); + buf = rsndbuf; + pbrp = pbsp + lenb; + //printf("TYPED: "); + } + } + +//printf("%d %d \n",len,lena+lenb); +// _MixAudio(stream, buf, len, _MIX_MAXVOLUME); + signed short int *ptr=(signed short int *)buf; +memcpy(&soundbuf[0],buf,735*4); + audio_batch_cb(soundbuf,735); + bef = now; +} + +#else /* NOSOUND */ +int +DSound_Init(unsigned long rate, unsigned long buflen) +{ + return FALSE; +} + +void +DSound_Play(void) +{ +} + +void +DSound_Stop(void) +{ +} + +int +DSound_Cleanup(void) +{ + return TRUE; +} + +void FASTCALL +DSound_Send0(long clock) +{ +} +#endif /* !NOSOUND */ diff --git a/libretro/dswin.h b/libretro/dswin.h new file mode 100644 index 0000000..bd51b48 --- /dev/null +++ b/libretro/dswin.h @@ -0,0 +1,17 @@ +#ifndef dswin_h__ +#define dswin_h__ + +#include "common.h" + +int DSound_Init(unsigned long rate, unsigned long length); +int DSound_Cleanup(void); + +void DSound_Play(void); +void DSound_Stop(void); +void FASTCALL DSound_Send0(long clock); + +void DS_SetVolumeOPM(long vol); +void DS_SetVolumeADPCM(long vol); +void DS_SetVolumeMercury(long vol); + +#endif /* dswin_h__ */ diff --git a/libretro/fileio.h b/libretro/fileio.h new file mode 100644 index 0000000..ea91f37 --- /dev/null +++ b/libretro/fileio.h @@ -0,0 +1,40 @@ +#ifndef winx68k_fileio_h +#define winx68k_fileio_h + +#include "common.h" +#include "dosio.h" + +#define FILEH HANDLE + +#define FSEEK_SET 0 +#define FSEEK_CUR 1 +#define FSEEK_END 2 + +LPSTR getFileName(LPSTR filename); +//#define getFileName GetFileName + +FILEH File_Open(BYTE *filename); +FILEH File_Create(BYTE *filename); +DWORD File_Seek(FILEH handle, long pointer, short mode); +DWORD File_Read(FILEH handle, void *data, DWORD length); +DWORD File_Write(FILEH handle, void *data, DWORD length); +short File_Close(FILEH handle); +short File_Attr(BYTE *filename); +#define File_Open file_open +#define File_Create file_create +#define File_Seek file_seek +#define File_Read file_lread +#define File_Write file_lwrite +#define File_Close file_close +#define File_Attr file_attr + +void File_SetCurDir(BYTE *exename); +FILEH File_OpenCurDir(BYTE *filename); +FILEH File_CreateCurDir(BYTE *filename); +short File_AttrCurDir(BYTE *filename); +#define File_SetCurDir file_setcd +#define File_OpenCurDir file_open_c +#define File_CreateCurDir file_create_c +#define File_AttrCurDir file_attr_c + +#endif diff --git a/libretro/joystick.c b/libretro/joystick.c new file mode 100644 index 0000000..b532eab --- /dev/null +++ b/libretro/joystick.c @@ -0,0 +1,141 @@ +// JOYSTICK.C - joystick support for WinX68k + +#include "common.h" +#include "prop.h" +#include "joystick.h" +#include "winui.h" +#include "keyboard.h" + +#include "libretro.h" +extern retro_input_state_t input_state_cb; + +#ifndef MAX_BUTTON +#define MAX_BUTTON 32 +#endif + +char joyname[2][MAX_PATH]; +char joybtnname[2][MAX_BUTTON][MAX_PATH]; +BYTE joybtnnum[2] = {0, 0}; + +BYTE joy[2]; +BYTE JoyKeyState; +BYTE JoyKeyState0; +BYTE JoyKeyState1; +BYTE JoyState0[2]; +BYTE JoyState1[2]; + +// This stores whether the buttons were down. This avoids key repeats. +BYTE JoyDownState0; +BYTE MouseDownState0; + +// This stores whether the buttons were up. This avoids key repeats. +BYTE JoyUpState0; +BYTE MouseUpState0; + +BYTE JoyPortData[2]; + +int *r_joy; + +void Joystick_Init(void) +{ + joy[0] = 1; // active only one + joy[1] = 0; + JoyKeyState = 0; + JoyKeyState0 = 0; + JoyKeyState1 = 0; + JoyState0[0] = 0xff; + JoyState0[1] = 0xff; + JoyState1[0] = 0xff; + JoyState1[1] = 0xff; + JoyPortData[0] = 0; + JoyPortData[1] = 0; +} + +void Joystick_Cleanup(void) +{ + +} + +BYTE FASTCALL Joystick_Read(BYTE num) +{ + BYTE joynum = num; + BYTE ret0 = 0xff, ret1 = 0xff, ret; + + if (Config.JoySwap) joynum ^= 1; + if (joy[num]) { + ret0 = JoyState0[num]; + ret1 = JoyState1[num]; + } + + if (Config.JoyKey) + { + if ((Config.JoyKeyJoy2)&&(num==1)) + ret0 ^= JoyKeyState; + else if ((!Config.JoyKeyJoy2)&&(num==0)) + ret0 ^= JoyKeyState; + } + + ret = ((~JoyPortData[num])&ret0)|(JoyPortData[num]&ret1); + + return ret; +} + + +void FASTCALL Joystick_Write(BYTE num, BYTE data) +{ + if ( (num==0)||(num==1) ) JoyPortData[num] = data; +} + +void FASTCALL Joystick_Update(int is_menu, int key) +{ + BYTE ret0 = 0xff, ret1 = 0xff; + BYTE mret0 = 0xff, mret1 = 0xff; + int num = 0; //xxx only joy1 + static BYTE pre_ret0 = 0xff, pre_mret0 = 0xff; + + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT))ret0 ^= JOY_RIGHT; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT))ret0 ^= JOY_LEFT; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP) )ret0 ^= JOY_UP; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN))ret0 ^= JOY_DOWN; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A) )ret0 ^= JOY_TRG1; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B) )ret0 ^= JOY_TRG2; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT))ret0 ^= JOY_TRG3; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START) )ret0 ^= JOY_TRG4; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X) )ret0 ^= JOY_TRG5; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y) )ret0 ^= JOY_TRG6; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L))ret0 ^= JOY_TRG7; + if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R) )ret0 ^= JOY_TRG8; + + JoyDownState0 = ~(ret0 ^ pre_ret0) | ret0; + JoyUpState0 = (ret0 ^ pre_ret0) & ret0; + pre_ret0 = ret0; + + MouseDownState0 = ~(mret0 ^ pre_mret0) | mret0; + MouseUpState0 = (mret0 ^ pre_mret0) & mret0; + pre_mret0 = mret0; + + // disable Joystick when software keyboard is active + if (!is_menu && !Keyboard_IsSwKeyboard()) { + JoyState0[num] = ret0; + JoyState1[num] = ret1; + } +} + +BYTE get_joy_downstate(void) +{ + return JoyDownState0; +} +void reset_joy_downstate(void) +{ + JoyDownState0 = 0xff; +} +BYTE get_joy_upstate(void) +{ + return JoyUpState0; +} +void reset_joy_upstate(void) +{ + JoyUpState0 = 0x00; +} + + diff --git a/libretro/joystick.h b/libretro/joystick.h new file mode 100644 index 0000000..1a132f0 --- /dev/null +++ b/libretro/joystick.h @@ -0,0 +1,45 @@ +#ifndef winx68k_joy_h +#define winx68k_joy_h + +#include "common.h" + +#define JOY_UP 0x01 +#define JOY_DOWN 0x02 +#define JOY_LEFT 0x04 +#define JOY_RIGHT 0x08 +#define JOY_TRG2 0x20 +#define JOY_TRG1 0x40 + +#define JOY_TRG5 0x01 +#define JOY_TRG4 0x02 +#define JOY_TRG3 0x04 +#define JOY_TRG7 0x08 +#define JOY_TRG8 0x20 +#define JOY_TRG6 0x40 + +#ifndef PSP +#define JOYAXISPLAY 2048 +#endif + +#define need_Vpad() (is_menu || Keyboard_IsSwKeyboard() || (!Config.JoyOrMouse && !r_joy)) + +void Joystick_Init(void); +void Joystick_Cleanup(void); +BYTE FASTCALL Joystick_Read(BYTE num); +void FASTCALL Joystick_Write(BYTE num, BYTE data); + +typedef signed int R_Keycode; +void FASTCALL Joystick_Update(int is_menu, R_Keycode key); + + +BYTE get_joy_downstate(void); +void reset_joy_downstate(void); +BYTE get_joy_upstate(void); +void reset_joy_upstate(void); + + +extern BYTE JoyKeyState; + +extern int *r_joy; + +#endif diff --git a/libretro/juliet.c b/libretro/juliet.c new file mode 100644 index 0000000..bb9c600 --- /dev/null +++ b/libretro/juliet.c @@ -0,0 +1,101 @@ +/* $Id: juliet.c,v 1.2 2003/12/05 18:07:16 nonaka Exp $ */ + +#include "common.h" +#include "juliet.h" + +#if 0 +/* + * Juliet ダミー + */ + +BOOL +juliet_load(void) +{ + + return FAILURE; +} + +void +juliet_unload(void) +{ +} + +BOOL +juliet_prepare(void) +{ + + return FAILURE; +} + + +// ---- YM2151部 +// リセットと同時に、OPMチップの有無も確認 +void +juliet_YM2151Reset(void) +{ +} + +int +juliet_YM2151IsEnable(void) +{ + + return FALSE; +} + +int +juliet_YM2151IsBusy(void) +{ + + return FALSE; +} + + +void +juliet_YM2151W(BYTE reg, BYTE data) +{ +} + +// ---- YMF288部 + +void +juliet_YMF288Reset(void) +{ +} + +int +juliet_YM288IsEnable(void) +{ + + return TRUE; +} + +int +juliet_YM288IsBusy(void) +{ + + return 0; +} + +void +juliet_YMF288A(BYTE addr, BYTE data) +{ +} + +void +juliet_YMF288B(BYTE addr, BYTE data) +{ +} + +void +juliet_YMF288W(BYTE addr, BYTE data) +{ +} + +BYTE +juliet_YMF288R(BYTE addr) +{ + + return 0xff; +} + +#endif diff --git a/libretro/juliet.h b/libretro/juliet.h new file mode 100644 index 0000000..1df8558 --- /dev/null +++ b/libretro/juliet.h @@ -0,0 +1,41 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#if 1 + +#define juliet_load() +#define juliet_unload() + +#define juliet_prepare() + +#define juliet_YM2151Reset() +#define juliet_YM2151IsEnable() FALSE + +#define juliet_YM2151W(r,d) + +#else + +BOOL juliet_load(void); +void juliet_unload(void); + +BOOL juliet_prepare(void); + +void juliet_YM2151Reset(void); +int juliet_YM2151IsEnable(void); +int juliet_YM2151IsBusy(void); +void juliet_YM2151W(BYTE reg, BYTE data); + +void juliet_YMF288Reset(void); +int juliet_YMF288Enable(void); +int juliet_YMF288IsBusy(void); +void juliet_YMF288A(BYTE addr, BYTE data); +void juliet_YMF288B(BYTE addr, BYTE data); +void juliet_YMF288W(BYTE addr, BYTE data); +BYTE juliet_YMF288R(BYTE addr); + +#endif + +#ifdef __cplusplus +} +#endif diff --git a/libretro/keyboard.c b/libretro/keyboard.c new file mode 100644 index 0000000..11ccaf9 --- /dev/null +++ b/libretro/keyboard.c @@ -0,0 +1,641 @@ +/* + * Copyright (c) 2003,2008 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "common.h" +#include "joystick.h" +#include "prop.h" +#include "keyboard.h" +#include "mfp.h" +#include "windraw.h" + +#include "libretro.h" + +BYTE KeyBufWP; +BYTE KeyBufRP; +BYTE KeyBuf[KeyBufSize]; +BYTE KeyEnable = 1; +BYTE KeyIntFlag = 0; + +struct keyboard_key kbd_key[] = { +#include "keytbl.inc" +}; + +extern BYTE traceflag; + +void +Keyboard_Init(void) +{ + + KeyBufWP = 0; + KeyBufRP = 0; + ZeroMemory(KeyBuf, KeyBufSize); + KeyEnable = 1; + KeyIntFlag = 0; + +} + +// ---------------------------------- +// てーぶる類 +// ---------------------------------- + +#define NC 0 +#define KEYTABLE_MAX 512 + + +BYTE KeyTable[KEYTABLE_MAX] = { + // , , , , , , , ; 0x00 + NC, NC, NC, NC, NC, NC, NC, NC, + // BS, TAB, , , , RET, , ; 0x08 + 0x0f,0x10, NC, NC, NC,0x1d, NC, NC, + // , , , , , , , ; 0x10 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , ESC, , , , ; 0x18 + NC, NC, NC,0x01, NC, NC, NC, NC, + // SPC, ! , " , # , $ , % , & , ' ; 0x20 + 0x35,0x02,0x03,0x04,0x05,0x06,0x07,0x08, + // ( , ) , * , + , , , - , . , / ; 0x28 + 0x09,0x0a,0x28,0x27,0x31,0x0c,0x32,0x33, + // 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ; 0x30 + 0x0b,0x02,0x03,0x04,0x05,0x06,0x07,0x08, + // 8 , 9 , ; , : , < , = , > , ? ; 0x38 + 0x09,0x0a,0x28,0x27,0x31,0x0c,0x32,0x33, + // @ , A , B , C , D , E , F , G ; 0x40 + 0x1b,0x1e,0x2e,0x2c,0x20,0x13,0x21,0x22, + // H , I , J , K , L , M , N , O ; 0x48 + 0x23,0x18,0x24,0x25,0x26,0x30,0x2f,0x10, + // P , Q , R , S , T , U , V , W ; 0x50 + 0x1a,0x11,0x14,0x1f,0x15,0x17,0x2d,0x12, + // X , Y , Z , [ , \ , ] , ^ , _ ; 0x58 + 0x2b,0x16,0x2a,0x1c,0x0e,0x29,0x0d,0x34, + // ` , a , b , c , d , e , f , g ; 0x60 + 0x1b,0x1e,0x2e,0x2c,0x20,0x13,0x21,0x22, + // h , i , j , k , l , m , n , o ; 0x68 + 0x23,0x18,0x24,0x25,0x26,0x30,0x2f,0x19, + // p , q , r , s , t , u , v , w ; 0x70 + 0x1a,0x11,0x14,0x1f,0x15,0x17,0x2d,0x12, + // x , y , z , { , | , } , ~ , ; 0x78 + 0x2b,0x16,0x2a,0x1c,0x0e,0x29,0x0d, NC, + // , , , , , , , ; 0x80 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x88 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x90 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x98 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xa0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xa8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xb0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xb8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xc0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xc8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xe0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xe8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xf0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xf8 + NC, NC, NC, NC, NC, NC, NC, NC, + + // ;0x100 + + // , , , , , , , ; 0x00 + NC, NC, NC, NC, NC, NC, NC, NC, + // BS, TAB, LF, CLR, , RET, , ; 0x08 + 0x0f,0x10,0x1d, NC, NC,0x1d, NC, NC, + // , ↑, ↓, →, ←,SYSQ, , ; 0x10 + NC,0x3c,0x3e,0x3d,0x3b, NC, NC, NC, + // , , , ESC, , , , ; 0x18 + NC, NC,0x63,0x01, NC, NC, NC, NC, + // ,KANJ,MUHE,HENM,HENK,RONM,HIRA,KATA ; 0x20 + NC, NC,0x56, NC, NC, NC, NC, NC, + // HIKA,ZENK,HANK,ZNHN, ,KANA, , ; 0x28 + NC, NC, NC, NC, NC, NC, NC, NC, + // SFTL, , , , , , , ; 0x30 + 0x70, NC, NC, NC, NC, NC, NC, NC, + // , , , , ,ZKOU,MKOU, ; 0x38 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x40 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x48 + NC, NC, NC, NC, NC, NC, NC, NC, + // HOME, ←, ↑, →, ↓,RLDN,RLUP, END ; 0x50 + 0x36,0x3b,0x3c,0x3d,0x3e,0x39,0x38,0x3a, + // , , , , , , , ; 0x58 + NC, NC, NC, NC, NC, NC, NC, NC, + // ,PRNT, INS, , , , , ; 0x60 + NC, NC,0x5e, NC, NC, NC, NC, NC, + // , , ,BREA, , , , ; 0x68 + NC, NC, NC,0x61, NC, NC, NC, NC, + // , , , , , , , ; 0x70 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x78 + NC, NC, NC, NC, NC, NC, NC, NC, + // ,<↑> ; 0x90 + NC, NC, NC, NC, NC,0x36,0x3b,0x3c, + // <→>,<↓>,, <+>, <,>, <->, <.>, ; 0xa8 + NC, NC,0x41,0x46, NC,0x42,0x51,0x40, + // <0>, <1>, <2>, <3>, <4>, <5>, <6>, <7> ; 0xb0 + 0x4f,0x4b,0x4c,0x4d,0x47,0x48,0x49,0x43, + // <8>, <9>, , , , , f.1, f.2 ; 0xb8 + 0x44,0x45, NC, NC, NC, NC,0x63,0x64, + // f.3, f.4, f.5, f.6, f.7, f.8, f.9,f.10 ; 0xc0 + 0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c, + // f.11,f.12,f.13,f.14,f.15, , , ; 0xc8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd8 + NC, NC, NC, NC, NC, NC, NC, NC, + // ,SFTL,SFTR,CTLL,CTLR,CAPS, ,METL ; 0xe0 + NC,0x70,0x70,0x71,0x71,0x5d, NC,0x55, + // METR,ALTL,ALTR, , , , , ; 0xe8 + 0x55,0x55,0x55, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xf0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , DEL ; 0xf8 + NC, NC, NC, NC, NC, NC, NC,0x37 +}; + +BYTE KeyTableMaster[KEYTABLE_MAX] = { + // , , , , , , , ; 0x00 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x08 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x10 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x18 + NC, NC, NC, NC, NC, NC, NC, NC, + // SPC, ! , " , # , $ , % , & , ' ; 0x20 + 0x35,0x02,0x03,0x04,0x05,0x06,0x07,0x08, + // ( , ) , * , + , , , - , . , / ; 0x28 + 0x09,0x0a,0x28,0x27,0x31,0x0c,0x32,0x33, + // 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ; 0x30 + 0x0b,0x02,0x03,0x04,0x05,0x06,0x07,0x08, + // 8 , 9 , ; , : , < , = , > , ? ; 0x38 + 0x09,0x0a,0x28,0x27,0x31,0x0c,0x32,0x33, + // @ , A , B , C , D , E , F , G ; 0x40 + 0x1b,0x1e,0x2e,0x2c,0x20,0x13,0x21,0x22, + // H , I , J , K , L , M , N , O ; 0x48 + 0x23,0x18,0x24,0x25,0x26,0x30,0x2f,0x10, + // P , Q , R , S , T , U , V , W ; 0x50 + 0x1a,0x11,0x14,0x1f,0x15,0x17,0x2d,0x12, + // X , Y , Z , [ , \ , ] , ^ , _ ; 0x58 + 0x2b,0x16,0x2a,0x1c,0x0e,0x29,0x0d,0x34, + // ` , a , b , c , d , e , f , g ; 0x60 + 0x1b,0x1e,0x2e,0x2c,0x20,0x13,0x21,0x22, + // h , i , j , k , l , m , n , o ; 0x68 + 0x23,0x18,0x24,0x25,0x26,0x30,0x2f,0x19, + // p , q , r , s , t , u , v , w ; 0x70 + 0x1a,0x11,0x14,0x1f,0x15,0x17,0x2d,0x12, + // x , y , z , { , | , } , ~ , ; 0x78 + 0x2b,0x16,0x2a,0x1c,0x0e,0x29,0x0d, NC, + // , , , , , , , ; 0x80 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x88 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x90 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x98 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xa0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xa8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xb0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xb8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xc0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xc8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xe0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xe8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xf0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xf8 + NC, NC, NC, NC, NC, NC, NC, NC, + + // ;0x100 + + // , , , , , , , ; 0x00 + NC, NC, NC, NC, NC, NC, NC, NC, + // BS, TAB, LF, CLR, , RET, , ; 0x08 + 0x0f,0x10,0x1d, NC, NC,0x1d, NC, NC, + // , , ,PAUS,SCRL,SYSQ, , ; 0x10 + NC, NC, NC,0x61, NC, NC, NC, NC, + // , , , ESC, , , , ; 0x18 + NC, NC,0x63,0x01, NC, NC, NC, NC, + // ,KANJ,MUHE,HENM,HENK,RONM,HIRA,KATA ; 0x20 + NC, NC,0x56, NC, NC, NC, NC, NC, + // HIKA,ZENK,HANK,ZNHN, ,KANA, , ; 0x28 + NC, NC, NC, NC, NC, NC, NC, NC, + // ALNU, , , , , , , ; 0x30 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , ,ZKOU,MKOU, ; 0x38 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x40 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x48 + NC, NC, NC, NC, NC, NC, NC, NC, + // HOME, ←, ↑, →, ↓,RLDN,RLUP, END ; 0x50 + 0x36, NC, NC, NC, NC,0x39,0x38,0x3a, + // , , , , , , , ; 0x58 + NC, NC, NC, NC, NC, NC, NC, NC, + // ,PRNT, INS, , , , , ; 0x60 + NC, NC,0x5e, NC, NC, NC, NC, NC, + // , , ,BREA, , , , ; 0x68 + NC, NC, NC,0x61, NC, NC, NC, NC, + // , , , , , , , ; 0x70 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0x78 + NC, NC, NC, NC, NC, NC, NC, NC, + // ,<↑> ; 0x90 + NC, NC, NC, NC, NC,0x36, NC, NC, + // <→>,<↓>,, <+>, <,>, <->, <.>, ; 0xa8 + NC, NC,0x41,0x46, NC,0x42, NC,0x40, + // <0>, <1>, <2>, <3>, <4>, <5>, <6>, <7> ; 0xb0 + 0x4f,0x4b,0x4c,0x4d,0x47,0x48,0x49,0x43, + // <8>, <9>, , , , , f.1, f.2 ; 0xb8 + 0x44,0x45, NC, NC, NC, NC,0x63,0x64, + // f.3, f.4, f.5, f.6, f.7, f.8, f.9,f.10 ; 0xc0 + 0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c, + // f.11,f.12,f.13,f.14,f.15, , , ; 0xc8 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xd8 + NC, NC, NC, NC, NC, NC, NC, NC, + // ,SFTL,SFTR,CTLL,CTLR,CAPS, ,METL ; 0xe0 + NC,0x70,0x70,0x71,0x71,0x5d, NC,0x55, + // METR,ALTL,ALTR, , , , , ; 0xe8 + 0x55,0x55,0x55, NC, NC, NC, NC, NC, + // , , , , , , , ; 0xf0 + NC, NC, NC, NC, NC, NC, NC, NC, + // , , , , , , , DEL ; 0xf8 + NC, NC, NC, NC, NC, NC, NC,0x37 +}; + +// P6K: PX68K_KEYBOARD +// ~ ~ ~ +#define P6K_UP 1 +#define P6K_DOWN 2 + +void send_keycode(BYTE code, int flag) +{ + BYTE newwp; + + if (code != NC) { + newwp = ((KeyBufWP + 1) & (KeyBufSize - 1)); + if (newwp != KeyBufRP) { + KeyBuf[KeyBufWP] = code | ((flag == P6K_UP)? 0x80 : 0); + p6logd("KeyBuf: %x\n", KeyBuf[KeyBufWP]); + KeyBufWP = newwp; + p6logd("KeyBufWP: %d\n", KeyBufWP); + } + } +} + +static BYTE get_x68k_keycode(DWORD wp) +{ + if (wp < KEYTABLE_MAX) { + return KeyTable[wp]; + } + + switch (wp) { + case RETROK_UP: + return 0x3c; + case RETROK_DOWN: + return 0x3e; + case RETROK_LEFT: + return 0x3b; + case RETROK_RIGHT: + return 0x3d; + +#define RETROK_KP_0 RETROK_KP0 +#define RETROK_KP_1 RETROK_KP1 +#define RETROK_KP_2 RETROK_KP2 +#define RETROK_KP_3 RETROK_KP3 +#define RETROK_KP_4 RETROK_KP4 +#define RETROK_KP_5 RETROK_KP5 +#define RETROK_KP_6 RETROK_KP6 +#define RETROK_KP_7 RETROK_KP7 +#define RETROK_KP_8 RETROK_KP8 +#define RETROK_KP_9 RETROK_KP9 +#define RETROK_NUMLOCKCLEAR RETROK_NUMLOCK + + case RETROK_KP_0: + return 0x4f; + case RETROK_KP_1: + return 0x4b; + case RETROK_KP_2: + return 0x4c; + case RETROK_KP_3: + return 0x4d; + case RETROK_KP_4: + return 0x47; + case RETROK_KP_5: + return 0x48; + case RETROK_KP_6: + return 0x49; + case RETROK_KP_7: + return 0x43; + case RETROK_KP_8: + return 0x44; + case RETROK_KP_9: + return 0x45; + case RETROK_NUMLOCKCLEAR: + return 0x3f; + + case RETROK_F1: + return 0x63; + case RETROK_F2: + return 0x64; + case RETROK_F3: + return 0x65; + case RETROK_F4: + return 0x66; + case RETROK_F5: + return 0x67; + case RETROK_F6: + return 0x68; + case RETROK_F7: + return 0x69; + case RETROK_F8: + return 0x6a; + case RETROK_F9: + return 0x6b; + case RETROK_F10: + return 0x6c; + case RETROK_LSHIFT: + case RETROK_RSHIFT: + return 0x70; + case RETROK_LCTRL: + case RETROK_RCTRL: + return 0x71; + case RETROK_KP_DIVIDE: + return 0x40; + case RETROK_KP_MULTIPLY: + return 0x41; + case RETROK_KP_MINUS: + return 0x42; + case RETROK_KP_PLUS: + return 0x46; + case RETROK_KP_ENTER: + return 0x4e; + case RETROK_INSERT: + return 0x5e; + case RETROK_HOME: + return 0x36; + case RETROK_END: + return 0x3a; + case RETROK_PAGEUP: + return 0x38; + case RETROK_PAGEDOWN: + return 0x39; + default: + return -1; + } +} + +// ---------------------------------- +// WM_KEYDOWN〜 +// ---------------------------------- +void +Keyboard_KeyDown(DWORD wp) +{ + + BYTE code; + BYTE newwp; +#if 0 + if (wp & ~0xff) { + if (wp == GDK_VoidSymbol) + code = NC; + else if ((wp & 0xff00) == 0xff00) + code = KeyTable[(wp & 0xff) | 0x100]; + else + code = NC; + } else + code = KeyTable[wp & 0xff]; +#endif + code = get_x68k_keycode(wp); + if (code < 0) { + return; + } + + printf("Keyboard_KeyDown: "); + printf("wp=0x%x, code=0x%x\n", wp, code); + printf("RETROK_UP: 0x%x", RETROK_UP); + +#if 0 + if (code != NC) { + newwp = ((KeyBufWP + 1) & (KeyBufSize - 1)); + if (newwp != KeyBufRP) { + KeyBuf[KeyBufWP] = code; + KeyBufWP = newwp; + printf("KeyBufWP: %d\n", KeyBufWP); + } + } +#else + send_keycode(code, P6K_DOWN); +#endif + + printf("JoyKeyState: 0x%x\n", JoyKeyState); + + switch (wp) { + case RETROK_UP: + puts("key up"); + if (!(JoyKeyState&JOY_DOWN)) + JoyKeyState |= JOY_UP; + break; + + case RETROK_DOWN: + if (!(JoyKeyState&JOY_UP)) + JoyKeyState |= JOY_DOWN; + break; + + case RETROK_LEFT: + if (!(JoyKeyState&JOY_RIGHT)) + JoyKeyState |= JOY_LEFT; + break; + + case RETROK_RIGHT: + if (!(JoyKeyState&JOY_LEFT)) + JoyKeyState |= JOY_RIGHT; + break; + + case RETROK_z: + puts("key z"); + if (Config.JoyKeyReverse) + JoyKeyState |= JOY_TRG2; + else + JoyKeyState |= JOY_TRG1; + break; + + case RETROK_x: + puts("key x"); + if (Config.JoyKeyReverse) + JoyKeyState |= JOY_TRG1; + else + JoyKeyState |= JOY_TRG2; + break; + } +} + +// ---------------------------------- +// WM_KEYUP +// ---------------------------------- +void +Keyboard_KeyUp(DWORD wp) +{ + BYTE code; + BYTE newwp; +#if 0 + if (wp & ~0xff) { + if (wp == GDK_VoidSymbol) + code = NC; + else if ((wp & 0xff00) == 0xff00) + code = KeyTable[(wp & 0xff) | 0x100]; + else + code = NC; + } else + code = KeyTable[wp & 0xff]; +#endif + code = get_x68k_keycode(wp); + if (code < 0) { + return; + } +#if 0 + if (code != NC) { + newwp = ((KeyBufWP + 1) & (KeyBufSize - 1)); + if (newwp != KeyBufRP) { + KeyBuf[KeyBufWP] = code | 0x80; + KeyBufWP = newwp; + } + } +#else + send_keycode(code, P6K_UP); +#endif + + printf("JoyKeyState: 0x%x\n", JoyKeyState); + + switch(wp) { + case RETROK_UP: + JoyKeyState &= ~JOY_UP; + break; + + case RETROK_DOWN: + JoyKeyState &= ~JOY_DOWN; + break; + + case RETROK_LEFT: + JoyKeyState &= ~JOY_LEFT; + break; + + case RETROK_RIGHT: + JoyKeyState &= ~JOY_RIGHT; + break; + + case RETROK_z: + if (Config.JoyKeyReverse) + JoyKeyState &= ~JOY_TRG2; + else + JoyKeyState &= ~JOY_TRG1; + break; + + case RETROK_x: + if (Config.JoyKeyReverse) + JoyKeyState &= ~JOY_TRG1; + else + JoyKeyState &= ~JOY_TRG2; + break; + } + +} + +// ---------------------------------- +// Key Check +// 1フレーム中に4回（2400bps/10bit/60fpsとすれば、だが）呼ばれて、MFPにデータを送る +// ---------------------------------- + +void +Keyboard_Int(void) +{ + if (KeyBufRP != KeyBufWP) { + printf("KeyBufRP:%d, KeyBufWP:%d\n", KeyBufRP, KeyBufWP); + if (!KeyIntFlag) { + LastKey = KeyBuf[KeyBufRP]; + KeyBufRP = ((KeyBufRP+1)&(KeyBufSize-1)); + KeyIntFlag = 1; + MFP_Int(3); + } + } else if (!KeyIntFlag) { + LastKey = 0; + } +} + +/********** ソフトウェアキーボード **********/ + + +int Keyboard_IsSwKeyboard(void) +{ + + return FALSE; + +} diff --git a/libretro/keyboard.h b/libretro/keyboard.h new file mode 100644 index 0000000..15dc1cb --- /dev/null +++ b/libretro/keyboard.h @@ -0,0 +1,39 @@ +#ifndef _winx68k_keyboard +#define _winx68k_keyboard + +#include "common.h" + +#define KeyBufSize 128 + +extern BYTE KeyBuf[KeyBufSize]; +extern BYTE KeyBufWP; +extern BYTE KeyBufRP; +extern BYTE KeyTable[512]; +extern BYTE KeyTableMaster[512]; +extern BYTE KeyEnable; +extern BYTE KeyIntFlag; + +struct keyboard_key { + int x; + int y; + int w; + int h; + char *s; + unsigned char c; +}; + +extern struct keyboard_key kbd_key[]; +extern int kbd_kx, kbd_ky; +extern int kbd_x, kbd_y, kbd_w, kbd_h; + +void Keyboard_Init(void); +void Keyboard_KeyDown(DWORD vkcode); +void Keyboard_KeyUp(DWORD vkcode); +void Keyboard_Int(void); +void send_keycode(BYTE code, int flag); +int Keyboard_get_key_ptr(int x, int y); +void Keyboard_skbd(void); +int Keyboard_IsSwKeyboard(void); +void Keyboard_ToggleSkbd(void); + +#endif //_winx68k_keyboard diff --git a/libretro/keyconf.c b/libretro/keyconf.c new file mode 100644 index 0000000..bde024f --- /dev/null +++ b/libretro/keyconf.c @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------------------------- +// KEYCONF.C - KeyConfig 入力待ちダイアログ +// --------------------------------------------------------------------------------------- +#include "common.h" +#include "resource.h" +#include "keyconf.h" +#include "winx68k.h" + +HWND hWndKeyConf = NULL; +WORD KeyConf_CodeW = 0; +DWORD KeyConf_CodeL = 0; +char KeyConfMessage[255]; +int KeyConfFlag = 0; + + +LRESULT CALLBACK KeyConfProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp) +{ + switch (msg) + { + case WM_INITDIALOG: +// if (!KeyConfFlag) SetFocus(hWndKeyConf); + KeyConfFlag = 1; + KeyConf_CodeW = 0; + KeyConf_CodeL = 0; +// SetDlgItemText(hdlg, IDC_KEYCONF_DLG, KeyConfMessage); +//ShowWindow(hdlg, SW_HIDE); + return 0; + + case WM_COMMAND: + if (IDCANCEL == LOWORD(wp)) + { + EndDialog(hdlg, TRUE); + break; + } + return TRUE; + + case WM_SYSCOMMAND: + return TRUE; + + case WM_ACTIVATE: + SetFocus(hWndKeyConf); + break; + +// case WM_CLOSE: +// EndDialog(hdlg, FALSE); +// return TRUE; + + case WM_KEYDOWN: + case WM_SYSKEYDOWN: + case WM_KEYUP: + case WM_SYSKEYUP: + if (wp==VK_F12) + { + EndDialog(hdlg, TRUE); + return TRUE; + } +// Error("Key Pressed."); + KeyConf_CodeW = wp; + KeyConf_CodeL = lp; + EndDialog(hdlg, TRUE); + return TRUE; + + default: +// SetFocus(hWndKeyConf); + return FALSE; + } + return FALSE; +} diff --git a/libretro/keyconf.h b/libretro/keyconf.h new file mode 100644 index 0000000..587b91e --- /dev/null +++ b/libretro/keyconf.h @@ -0,0 +1,10 @@ +#ifndef _x68_keyconf +#define _x68_keyconf + +extern HWND hWndKeyConf; +extern WORD KeyConf_CodeW; +extern DWORD KeyConf_CodeL; +extern char KeyConfMessage[255]; +LRESULT CALLBACK KeyConfProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp); + +#endif // _x68_keyconf diff --git a/libretro/keytbl.inc b/libretro/keytbl.inc new file mode 100644 index 0000000..650fc2c --- /dev/null +++ b/libretro/keytbl.inc @@ -0,0 +1,115 @@ +{ 2, 2, 32, 32, "BRK", 0x61}, +{ 40, 2, 32, 32, "CPY", 0x62}, +{ 86, 16, 40, 18, "F 1", 0x63}, +{128, 16, 40, 18, "F 2", 0x64}, +{170, 16, 40, 18, "F 3", 0x65}, +{212, 16, 40, 18, "F 4", 0x66}, +{254, 16, 40, 18, "F 5", 0x67}, +{302, 16, 40, 18, "F 6", 0x68}, +{344, 16, 40, 18, "F 7", 0x69}, +{386, 16, 40, 18, "F 8", 0x6a}, +{428, 16, 40, 18, "F 9", 0x6b}, +{470, 16, 40, 18, "F10", 0x6c}, +{520, 2, 32, 32, "KAN", 0x5a}, +{554, 2, 32, 32, "ROM", 0x5b}, +{588, 2, 32, 32, "COD", 0x5c}, +{630, 2, 32, 32, "CAP", 0x5d}, +{664, 2, 32, 32, "KIG", 0x52}, +{698, 2, 32, 32, "TOR", 0x53}, +{732, 2, 32, 32, "HLP", 0x54}, +{ 2, 48, 32, 32, "ESC", 0x1}, +{ 36, 48, 32, 32, "1", 0x2}, +{ 70, 48, 32, 32, "2", 0x3}, +{104, 48, 32, 32, "3", 0x4}, +{138, 48, 32, 32, "4", 0x5}, +{172, 48, 32, 32, "5", 0x6}, +{206, 48, 32, 32, "6", 0x7}, +{240, 48, 32, 32, "7", 0x8}, +{274, 48, 32, 32, "8", 0x9}, +{308, 48, 32, 32, "9", 0xa}, +{342, 48, 32, 32, "0", 0xb}, +{376, 48, 32, 32, "-", 0xc}, +{410, 48, 32, 32, "^", 0xd}, +{444, 48, 32, 32, "\\", 0xe}, +{478, 48, 32, 32, "BS", 0xf}, +{520, 48, 32, 32, "HOM", 0x36}, +{554, 48, 32, 32, "INS", 0x5e}, +{588, 48, 32, 32, "DEL", 0x37}, +{630, 48, 32, 32, "CLR", 0x3f}, +{664, 48, 32, 32, "/", 0x40}, +{698, 48, 32, 32, "*", 0x41}, +{732, 48, 32, 32, "-", 0x42}, +{ 2, 82, 44, 32, "TAB", 0x10}, +{ 48, 82, 32, 32, "Q", 0x11}, +{ 82, 82, 32, 32, "W", 0x12}, +{116, 82, 32, 32, "E", 0x13}, +{150, 82, 32, 32, "R", 0x14}, +{184, 82, 32, 32, "T", 0x15}, +{218, 82, 32, 32, "Y", 0x16}, +{252, 82, 32, 32, "U", 0x17}, +{286, 82, 32, 32, "I", 0x18}, +{320, 82, 32, 32, "O", 0x19}, +{354, 82, 32, 32, "P", 0x1a}, +{388, 82, 32, 32, "@", 0x1b}, +{422, 82, 32, 32, "[", 0x1c}, +{456, 82, 32, 32, "", 0x0}, +{468, 82, 42, 66, "RET", 0x1d}, +{520, 82, 32, 32, "RUP", 0x38}, +{554, 82, 32, 32, "RDN", 0x39}, +{588, 82, 32, 32, "UND", 0x3a}, +{630, 82, 32, 32, "7", 0x43}, +{664, 82, 32, 32, "8", 0x44}, +{698, 82, 32, 32, "9", 0x45}, +{732, 82, 32, 32, "+", 0x46}, +{ 2, 116, 56, 32, "CTRL", 0x71}, +{ 60, 116, 32, 32, "A", 0x1e}, +{ 94, 116, 32, 32, "S", 0x1f}, +{128, 116, 32, 32, "D", 0x20}, +{162, 116, 32, 32, "F", 0x21}, +{196, 116, 32, 32, "G", 0x22}, +{230, 116, 32, 32, "H", 0x23}, +{264, 116, 32, 32, "J", 0x24}, +{298, 116, 32, 32, "K", 0x25}, +{332, 116, 32, 32, "L", 0x26}, +{366, 116, 32, 32, ";", 0x27}, +{400, 116, 32, 32, ":", 0x28}, +{434, 116, 32, 32, "]", 0x29}, +{554, 116, 32, 32, "up", 0x3c}, +{630, 116, 32, 32, "4", 0x47}, +{664, 116, 32, 32, "5", 0x48}, +{698, 116, 32, 32, "6", 0x49}, +{732, 116, 32, 32, "=", 0x4a}, +{ 2, 150, 68, 32, "SHIFT", 0x70}, +{ 72, 150, 32, 32, "Z", 0x2a}, +{106, 150, 32, 32, "X", 0x2b}, +{140, 150, 32, 32, "C", 0x2c}, +{174, 150, 32, 32, "V", 0x2d}, +{208, 150, 32, 32, "B", 0x2e}, +{242, 150, 32, 32, "N", 0x2f}, +{276, 150, 32, 32, "M", 0x30}, +{310, 150, 32, 32, ",", 0x31}, +{344, 150, 32, 32, ".", 0x32}, +{378, 150, 32, 32, "/", 0x33}, +{412, 150, 32, 32, " ", 0x34}, +{446, 150, 64, 32, "SHIFT", 0x70}, +{520, 132, 32, 32, "left", 0x3b}, +{554, 150, 32, 32, "down", 0x3e}, +{588, 132, 32, 32, "rigt", 0x3d}, +{630, 150, 32, 32, "1", 0x4b}, +{664, 150, 32, 32, "2", 0x4c}, +{698, 150, 32, 32, "3", 0x4d}, +{732, 150, 32, 66, "ENT", 0x4e}, +{ 60, 184, 32, 32, "HIR", 0x5f}, +{ 94, 184, 38, 32, "XF1", 0x55}, +{134, 184, 38, 32, "XF2", 0x56}, +{174, 184, 128, 32, "", 0x35}, +{304, 184, 38, 32, "XF3", 0x57}, +{344, 184, 42, 32, "XF4", 0x58}, +{388, 184, 42, 32, "XF5", 0x59}, +{432, 184, 32, 32, "ZEN", 0x60}, +{520, 184, 48, 32, "OPT1", 0x72}, +{572, 184, 48, 32, "OPT2", 0x73}, +{630, 184, 32, 32, "0", 0x4f}, +{664, 184, 32, 32, ",", 0x50}, +{698, 184, 32, 32, ".", 0x51}, +{-1, -1, -1, -1, NULL} diff --git a/libretro/menu_str_sjis.txt b/libretro/menu_str_sjis.txt new file mode 100644 index 0000000..b91b598 --- /dev/null +++ b/libretro/menu_str_sjis.txt @@ -0,0 +1,32 @@ +char twaku_str[] = ""; +char twaku2_str[] = " "; +char twaku3_str[] = ""; + +char title_str[] = "rvhsbg owUWj Version "; + +char pc98_title1_str[] = "rvhsbgR}h Ver. "; +char pc98_title2_str[] = " Copyright (C) hissorii 2013"; +char pc98_title3_str[] = " (l)"; + + +char waku_val_str[][10] = {"薫椣爪", "l"}; + +char waku_str[] = ""; +char waku2_str[] = " "; +char waku3_str[] = ""; + +char swaku_str[] = ""; +char swaku2_str[] = " "; +char swaku3_str[] = ""; + +char item_cap[][60] = {"VXe[Zbg/NMIZbg/I]", "[zpbh/z}EX]I", "tbs[O[/CWFNg]", "tbs[P[/CWFNg]", "n[hfBXNO[/CWFNg]", "n[hfBXNP[/CWFNg]", "t[XLbv", "TEhog(NL)", "zpbhAz{^", "z{^u", "Pad", "No Wait Mode", "JoyKey"}; + +#if defined (PSP) +#define CAP_BTN_STR "[]{^" +#elif defined (ANDROID) +#define CAP_BTN_STR "[TRG1]{^" +#else +#define CAP_BTN_STR "[^[]L[" +#endif + +char item_cap2[][50] = {"IA"CAP_BTN_STR"ﾀs", "IA"CAP_BTN_STR"ﾀs", "IA"CAP_BTN_STR"ﾀs", "IA"CAP_BTN_STR"ﾀs", "IA"CAP_BTN_STR"ﾀs", "IA"CAP_BTN_STR"ﾀs", "I", "IB", "I", "I", "IApbh", "I", "I"}; diff --git a/libretro/mk_kbdtbl.c b/libretro/mk_kbdtbl.c new file mode 100644 index 0000000..605af86 --- /dev/null +++ b/libretro/mk_kbdtbl.c @@ -0,0 +1,200 @@ +/* + x11/keytbl.inc 若違 + */ + +#include +#include + +// 0xff: 腟腴, 0xfe, 紜膵違菴, 0x0: 若(帥若潟若茖蕋丞) +unsigned char code_tbl[] = { + 0xfe, 0x61, 12, 0xfe, 0x5a, 4, 0xfe, 0x52, 3, + 0xfe, 0x01, 15, 0x36, 0x5e, 0x37, 0x3f, 0xfe, 0x40, 3, + 0xfe, 0x10, 13, 0x0, 0x1d, 0xfe, 0x38, 3, 0xfe, 0x43, 4, + 0x71, 0xfe, 0x1e, 12, 0x3c, 0xfe, 0x47, 4, + 0x70, 0xfe, 0x2a, 11, 0x70, 0x3b, 0x3e, 0x3d, 0xfe, 0x4b, 4, + 0x5f, 0x55, 0x56, 0x35, 0xfe, 0x57, 3, 0x60, 0x72, 0x73, 0xfe, 0x4f, 3 +}; + +int ct_ptr = 0; +unsigned char get_code(void) +{ + static int cnt = 0; + static unsigned char cc; + unsigned char c; + + if (cnt > 0) { + cnt--; + return cc++; + } + + c = code_tbl[ct_ptr++]; + + if (c == 0xfe) { + cc = code_tbl[ct_ptr++]; + cnt = code_tbl[ct_ptr++]; + return get_code(); + } + + return c; +} + +void prt_tbl(int x, int y, int w, int h, char *s) +{ + printf("{%3d, %3d, %3d, %3d, \"%s\", 0x%x},\n", + x, y, w, h, s, get_code()); +} +void prt_tblc(int x, int y, int w, int h, char c) +{ + printf("{%3d, %3d, %3d, %3d, \"%c\", 0x%x},\n", + x, y, w, h, c, get_code()); +} + +main() +{ + int x, y, w, h, i; + char s[256]; + char str[][10] = {"KAN", "ROM", "COD", "CAP", "KIG", "TOR", "HLP", //0 + "HOM", "INS", "DEL", "CLR", "/", "*", "-", // 7 + "RUP", "RDN", "UND", "7", "8", "9", "+", // 14 + "4", "5", "6", "=", // 21 + "1", "2", "3", // 25 + "0", ",", ".", // 28 + }; + + char c[] = "1234567890-^QWERTYUIOP@[ASDFGHJKL;:]ZXCVBNM,./ "; + + char *p[10]; + + // 1 + + w = 32; + h = 32; + strcpy(s, "BRK"); + prt_tbl(2, 2, w, h, s); + + strcpy(s, "CPY"); + prt_tbl(40, 2, w, h, s); + + // function keys + y = 16; + w = 40; + h = 18; + for (i = 0; i < 5; i++) { + sprintf(s, "F%2d", i + 1); + prt_tbl(86 + (w + 2) * i, y, w, h, s); + } + + for (i = 0; i < 5; i++) { + sprintf(s, "F%2d", i + 6); + prt_tbl(302 + (w + 2) * i, y, w, h, s); + } + + y = 2; + w = 32; + h = 32; + for (i = 0; i < 3; i++) { + prt_tbl(520 + (w + 2) * i, y, w, h, str[i]); + } + for (i = 0; i < 4; i++) { + prt_tbl(630 + (w + 2) * i, y, w, h, str[i + 3]); + } + + // 2 + + y = 48; + + prt_tbl(2, y, w, h, "ESC"); + for (i = 0; i < 12; i++) { + prt_tblc(36 + (w + 2) * i, y, w, h, c[i]); + } + prt_tbl(444, y, w, h, "\\\\"); + prt_tbl(478, y, w, h, "BS"); + + for (i = 0; i < 3; i++) { + prt_tbl(520 + (w + 2) * i, y, w, h, str[i + 7]); + } + for (i = 0; i < 4; i++) { + prt_tbl(630 + (w + 2) * i, y, w, h, str[i + 10]); + } + + // 3 + + y = 82; + + prt_tbl(2, y, 44, 32, "TAB"); + + for (i = 0; i < 12; i++) { + prt_tblc(48 + (w + 2) * i, y, w, h, c[i + 12]); + } + prt_tbl(456, y, w, h, ""); + prt_tbl(468, y, 42, 66, "RET"); + + for (i = 0; i < 3; i++) { + prt_tbl(520 + (w + 2) * i, y, w, h, str[i + 14]); + } + for (i = 0; i < 4; i++) { + prt_tbl(630 + (w + 2) * i, y, w, h, str[i + 17]); + } + + + // 4 + + y = 116; + + prt_tbl(2, y, 56, 32, "CTRL"); + + for (i = 0; i < 12; i++) { + prt_tblc(60 + (w + 2) * i, y, w, h, c[i + 24]); + } + + prt_tbl(554, y, 32, 32, "up"); + + for (i = 0; i < 4; i++) { + prt_tbl(630 + (w + 2) * i, y, w, h, str[i + 21]); + } + + // 5 + + y = 150; + + prt_tbl(2, y, 68, 32, "SHIFT"); + + for (i = 0; i < 11; i++) { + prt_tblc(72 + (w + 2) * i, y, w, h, c[i + 36]); + } + + prt_tbl(446, y, 64, 32, "SHIFT"); + + prt_tbl(520, 132, 32, 32, "left"); // left cursor + prt_tbl(554, y, 32, 32, "down"); // down cursor + prt_tbl(588, 132, 32, 32, "rigt"); // right cursor + + for (i = 0; i < 3; i++) { + prt_tbl(630 + (w + 2) * i, y, w, h, str[i + 25]); + } + + prt_tbl(732, y, 32, 66, "ENT"); + + // 6 + + y = 184; + + prt_tbl(60, y, 32, 32, "HIR"); + prt_tbl(94, y, 38, 32, "XF1"); + prt_tbl(134, y, 38, 32, "XF2"); + prt_tbl(174, y, 128, 32, ""); + prt_tbl(304, y, 38, 32, "XF3"); + prt_tbl(344, y, 42, 32, "XF4"); + prt_tbl(388, y, 42, 32, "XF5"); + prt_tbl(432, y, 32, 32, "ZEN"); + + prt_tbl(520, y, 48, 32, "OPT1"); + prt_tbl(572, y, 48, 32, "OPT2"); + + for (i = 0; i < 3; i++) { + prt_tbl(630 + (w + 2) * i, y, w, h, str[i + 28]); + } + + // 腟腴 + printf("{-1, -1, -1, -1, NULL}\n"); +} diff --git a/libretro/mkcgrom.c b/libretro/mkcgrom.c new file mode 100644 index 0000000..6e8a60e --- /dev/null +++ b/libretro/mkcgrom.c @@ -0,0 +1,1102 @@ +// ----------------------------------------------------------------------- +// CGROM作成〜 ゆいさんに作ってもらったお +// ----------------------------------------------------------------------- +#include + +static char *str_x68k[14] = { + "　！”＃＄％＆’（）＊＋，−．／", + "０１２３４５６７８９；：＜＝＞？", + "＠ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯ", + "ＰＱＲＳＴＵＶＷＸＹＺ［￥］＾＿", + "‘ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏ", + "ｐｑｒｓｔｕｖｗｘｙｚ｛｜｝￣　", + "　　　　　　をぁぃぅぇぉゃゅょっ", + "　あいうえおかきくけこさしすせそ", + "　。「」、・ヲァィゥェォャュョッ", + "ーアイウエオカキクケコサシスセソ", + "タチツテトナニヌネノハヒフヘホマ", + "ミムメモヤユヨラリルレロワン゛゜", + "たちつてとなにぬねのはひふへほま", + "みむめもやゆよらりるれろわん　　"}; + +static int deltable[] = { + // del del del del del + 0x0f, 0x1a, 0x22, 0x2a, 0x31, 0x3c, 0x4b, 0x52, 0x5a, 0x5e, 0, + 0x01, 0x10, 0x1a, 0x21, 0x3b, 0x41, 0x5b, 0x5f, 0, + 0x54, 0x5f, 0, + 0x57, 0x5f, 0, + 0x19, 0x21, 0x39, 0x5f, 0, + 0x22, 0x31, 0x52, 0x5f, 0}; + +static BYTE x68c8[] = { + 0x60,0x80,0x60,0x12,0xF2,0x1E,0x12,0x12, + 0x60,0x80,0x60,0x12,0xF2,0x0C,0x12,0x12, + 0xF0,0x80,0xE0,0x92,0xF2,0x0C,0x12,0x12, + 0xF0,0x80,0xE0,0x8E,0xF4,0x04,0x04,0x04, + 0xF0,0x80,0xE0,0x8C,0xF2,0x12,0x16,0x0E, + 0x60,0x90,0x90,0xF2,0x94,0x18,0x14,0x12, + 0xE0,0x90,0xE0,0x90,0xF0,0x10,0x10,0x1E, + 0xE0,0x90,0xE0,0x9C,0xF0,0x0C,0x02,0x1C, + 0x90,0x90,0xF0,0x9E,0x94,0x04,0x04,0x04, + 0x80,0x80,0x80,0x9E,0xF0,0x1C,0x10,0x10, + 0x90,0x90,0x90,0x9E,0x64,0x04,0x04,0x04, + 0xF0,0x80,0xE0,0x9E,0x90,0x1C,0x10,0x10, + 0x70,0x80,0x80,0x9C,0x72,0x1E,0x14,0x12, + 0x60,0x80,0x60,0x1C,0xF2,0x12,0x12,0x0C, + 0x60,0x80,0x60,0x1E,0xE4,0x04,0x04,0x0E, + 0xE0,0x90,0x90,0x9E,0xF0,0x1C,0x10,0x1E, + 0xE0,0x90,0x90,0x92,0xE6,0x02,0x02,0x02, + 0xE0,0x90,0x90,0x94,0xEA,0x02,0x04,0x0E, + 0xE0,0x90,0x90,0x9E,0xE4,0x02,0x12,0x0C, + 0xE0,0x90,0x90,0x94,0xE4,0x14,0x1E,0x04, + 0x90,0xD0,0xB0,0x92,0x94,0x18,0x14,0x12, + 0x60,0x80,0x60,0x12,0xFA,0x16,0x12,0x12, + 0xF0,0x80,0xE0,0x9C,0xF2,0x1C,0x12,0x1C, + 0x70,0x80,0x80,0x92,0x7A,0x16,0x12,0x12, + 0xF0,0x80,0xE0,0x92,0xFE,0x12,0x12,0x12, + 0xF0,0x80,0xE0,0x8E,0xF0,0x10,0x10,0x0E, + 0x70,0x40,0x70,0x40,0x7E,0x10,0x10,0x0E, + 0x00,0x08,0x04,0x7E,0x04,0x08,0x00,0x00, + 0x00,0x10,0x20,0x7E,0x20,0x10,0x00,0x00, + 0x00,0x10,0x38,0x54,0x10,0x10,0x10,0x00, + 0x00,0x10,0x10,0x10,0x54,0x38,0x10,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x08,0x08,0x08,0x08,0x08,0x00,0x08,0x00, + 0x14,0x14,0x00,0x00,0x00,0x00,0x00,0x00, + 0x24,0x24,0x7E,0x24,0x24,0x7E,0x24,0x00, + 0x08,0x1C,0x28,0x1C,0x0A,0x1C,0x08,0x00, + 0x00,0x62,0x64,0x08,0x10,0x26,0x46,0x00, + 0x30,0x48,0x48,0x30,0x4A,0x44,0x3A,0x00, + 0x18,0x08,0x10,0x00,0x00,0x00,0x00,0x00, + 0x04,0x08,0x10,0x10,0x10,0x08,0x04,0x00, + 0x20,0x10,0x08,0x08,0x08,0x10,0x20,0x00, + 0x00,0x14,0x08,0x3E,0x08,0x14,0x00,0x00, + 0x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x18,0x08,0x10, + 0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00, + 0x00,0x02,0x04,0x08,0x10,0x20,0x40,0x00, + 0x3C,0x42,0x46,0x5A,0x62,0x42,0x3C,0x00, + 0x08,0x18,0x08,0x08,0x08,0x08,0x1C,0x00, + 0x3C,0x42,0x02,0x0C,0x30,0x40,0x7E,0x00, + 0x7E,0x04,0x08,0x1C,0x02,0x42,0x3C,0x00, + 0x0C,0x14,0x24,0x44,0x7E,0x04,0x04,0x00, + 0x7E,0x40,0x7C,0x02,0x02,0x42,0x3C,0x00, + 0x20,0x20,0x20,0x3C,0x42,0x42,0x3C,0x00, + 0x7E,0x42,0x04,0x04,0x08,0x08,0x10,0x00, + 0x3C,0x42,0x42,0x3C,0x42,0x42,0x3C,0x00, + 0x3C,0x42,0x42,0x3C,0x04,0x04,0x04,0x00, + 0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00, + 0x00,0x00,0x18,0x18,0x00,0x18,0x08,0x10, + 0x04,0x08,0x10,0x20,0x10,0x08,0x04,0x00, + 0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00, + 0x20,0x10,0x08,0x04,0x08,0x10,0x20,0x00, + 0x3C,0x66,0x06,0x0C,0x10,0x00,0x10,0x00, + 0x1C,0x22,0x4A,0x56,0x4C,0x20,0x1E,0x00, + 0x18,0x24,0x24,0x42,0x7E,0x42,0x42,0x00, + 0x7C,0x42,0x42,0x7C,0x42,0x42,0x7C,0x00, + 0x1C,0x22,0x40,0x40,0x40,0x22,0x1C,0x00, + 0x78,0x44,0x42,0x42,0x42,0x44,0x78,0x00, + 0x7E,0x40,0x40,0x78,0x40,0x40,0x7E,0x00, + 0x7E,0x40,0x40,0x78,0x40,0x40,0x40,0x00, + 0x1C,0x22,0x40,0x4E,0x42,0x22,0x1E,0x00, + 0x42,0x42,0x42,0x7E,0x42,0x42,0x42,0x00, + 0x1C,0x08,0x08,0x08,0x08,0x08,0x1C,0x00, + 0x0E,0x04,0x04,0x04,0x04,0x44,0x38,0x00, + 0x42,0x44,0x48,0x70,0x48,0x44,0x42,0x00, + 0x40,0x40,0x40,0x40,0x40,0x40,0x7E,0x00, + 0x42,0x66,0x5A,0x5A,0x42,0x42,0x42,0x00, + 0x42,0x62,0x52,0x4A,0x46,0x42,0x42,0x00, + 0x3C,0x42,0x42,0x42,0x42,0x42,0x3C,0x00, + 0x7C,0x42,0x42,0x7C,0x40,0x40,0x40,0x00, + 0x3C,0x42,0x42,0x42,0x4A,0x44,0x3A,0x00, + 0x7C,0x42,0x42,0x7C,0x44,0x42,0x42,0x00, + 0x3C,0x42,0x20,0x18,0x04,0x42,0x3C,0x00, + 0x3E,0x08,0x08,0x08,0x08,0x08,0x08,0x00, + 0x42,0x42,0x42,0x42,0x42,0x42,0x3C,0x00, + 0x42,0x42,0x42,0x24,0x24,0x18,0x18,0x00, + 0x42,0x42,0x42,0x5A,0x5A,0x66,0x42,0x00, + 0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x00, + 0x22,0x22,0x22,0x1C,0x08,0x08,0x08,0x00, + 0x7E,0x02,0x04,0x18,0x20,0x40,0x7E,0x00, + 0x1C,0x10,0x10,0x10,0x10,0x10,0x1C,0x00, + 0x22,0x22,0x14,0x3E,0x08,0x3E,0x08,0x00, + 0x38,0x08,0x08,0x08,0x08,0x08,0x38,0x00, + 0x08,0x14,0x22,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x7E,0x00, + 0x06,0x04,0x02,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x3C,0x02,0x3E,0x42,0x3E,0x00, + 0x40,0x40,0x5C,0x62,0x42,0x62,0x5C,0x00, + 0x00,0x00,0x3C,0x42,0x40,0x42,0x3C,0x00, + 0x02,0x02,0x3A,0x46,0x42,0x46,0x3A,0x00, + 0x00,0x00,0x3C,0x42,0x7E,0x40,0x3C,0x00, + 0x0E,0x10,0x10,0x7C,0x10,0x10,0x10,0x00, + 0x00,0x00,0x3A,0x46,0x46,0x3A,0x02,0x3C, + 0x40,0x40,0x5C,0x62,0x42,0x42,0x42,0x00, + 0x08,0x00,0x18,0x08,0x08,0x08,0x1C,0x00, + 0x04,0x00,0x0C,0x04,0x04,0x04,0x24,0x18, + 0x40,0x40,0x44,0x48,0x50,0x68,0x44,0x00, + 0x18,0x08,0x08,0x08,0x08,0x08,0x1C,0x00, + 0x00,0x00,0x76,0x49,0x49,0x49,0x49,0x00, + 0x00,0x00,0x5C,0x62,0x42,0x42,0x42,0x00, + 0x00,0x00,0x3C,0x42,0x42,0x42,0x3C,0x00, + 0x00,0x00,0x5C,0x62,0x62,0x5C,0x40,0x40, + 0x00,0x00,0x3A,0x46,0x46,0x3A,0x02,0x02, + 0x00,0x00,0x5C,0x62,0x40,0x40,0x40,0x00, + 0x00,0x00,0x3C,0x40,0x3C,0x02,0x7C,0x00, + 0x10,0x10,0x7C,0x10,0x10,0x10,0x0C,0x00, + 0x00,0x00,0x42,0x42,0x42,0x46,0x3A,0x00, + 0x00,0x00,0x42,0x42,0x42,0x24,0x18,0x00, + 0x00,0x00,0x41,0x49,0x49,0x49,0x36,0x00, + 0x00,0x00,0x42,0x24,0x18,0x24,0x42,0x00, + 0x00,0x00,0x42,0x42,0x42,0x3E,0x02,0x3C, + 0x00,0x00,0x7E,0x04,0x18,0x20,0x7E,0x00, + 0x0C,0x10,0x10,0x20,0x10,0x10,0x0C,0x00, + 0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x00, + 0x30,0x08,0x08,0x04,0x08,0x08,0x30,0x00, + 0x7E,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x00, + 0x60,0xDA,0x0C,0x00,0x00,0x00,0x00,0x00, + 0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x10,0x7C,0x10,0x1C,0x28,0x20,0x1E,0x00, + 0x00,0x00,0x10,0x38,0x14,0x7E,0x34,0x00, + 0x00,0x00,0x00,0x44,0x42,0x52,0x20,0x00, + 0x00,0x00,0x18,0x00,0x3C,0x04,0x18,0x00, + 0x00,0x00,0x18,0x00,0x3C,0x08,0x34,0x00, + 0x00,0x00,0x12,0x7A,0x10,0x7C,0x74,0x00, + 0x00,0x00,0x04,0x28,0x7C,0x22,0x24,0x00, + 0x00,0x00,0x48,0x7C,0x4A,0x5C,0x08,0x00, + 0x00,0x00,0x08,0x0C,0x08,0x3C,0x3A,0x00, + 0x00,0x00,0x00,0x3C,0x02,0x02,0x0C,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x10,0x3C,0x10,0x3E,0x55,0x59,0x32,0x00, + 0x00,0x20,0x44,0x42,0x42,0x50,0x20,0x00, + 0x18,0x00,0x3C,0x02,0x02,0x04,0x18,0x00, + 0x18,0x00,0x3C,0x08,0x10,0x28,0x46,0x00, + 0x10,0x3A,0x12,0x3C,0x52,0x52,0x24,0x00, + 0x24,0x24,0x7A,0x26,0x24,0x24,0x4C,0x00, + 0x10,0x3C,0x10,0x7E,0x08,0x40,0x3C,0x00, + 0x0C,0x10,0x20,0x20,0x10,0x08,0x0C,0x00, + 0x04,0x5E,0x44,0x44,0x44,0x24,0x08,0x00, + 0x00,0x38,0x04,0x00,0x00,0x40,0x3C,0x00, + 0x10,0x3C,0x10,0x08,0x00,0x40,0x3C,0x00, + 0x20,0x20,0x20,0x20,0x20,0x24,0x18,0x00, + 0x04,0x7E,0x0C,0x14,0x1C,0x04,0x18,0x00, + 0x04,0x24,0x7E,0x24,0x2C,0x20,0x1C,0x00, + 0x48,0x10,0x26,0x78,0x20,0x20,0x1C,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x38,0x28,0x38,0x00, + 0x1C,0x10,0x10,0x10,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x08,0x08,0x08,0x38,0x00, + 0x00,0x00,0x00,0x00,0x20,0x10,0x08,0x00, + 0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00, + 0x00,0x3E,0x02,0x3E,0x02,0x04,0x18,0x00, + 0x00,0x00,0x3E,0x02,0x0C,0x08,0x10,0x00, + 0x00,0x00,0x04,0x08,0x18,0x28,0x08,0x00, + 0x00,0x00,0x08,0x3E,0x22,0x02,0x0C,0x00, + 0x00,0x00,0x00,0x3E,0x08,0x08,0x3E,0x00, + 0x00,0x00,0x04,0x3E,0x0C,0x14,0x24,0x00, + 0x00,0x00,0x10,0x3E,0x12,0x14,0x10,0x00, + 0x00,0x00,0x00,0x1C,0x04,0x04,0x3E,0x00, + 0x00,0x00,0x3C,0x04,0x3C,0x04,0x3C,0x00, + 0x00,0x00,0x00,0x2A,0x2A,0x02,0x0C,0x00, + 0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x00, + 0x00,0x7E,0x02,0x14,0x18,0x10,0x20,0x00, + 0x02,0x04,0x08,0x18,0x28,0x08,0x08,0x00, + 0x00,0x08,0x7E,0x42,0x02,0x04,0x18,0x00, + 0x00,0x3E,0x08,0x08,0x08,0x08,0x3E,0x00, + 0x00,0x08,0x7E,0x08,0x18,0x28,0x48,0x00, + 0x00,0x10,0x7E,0x12,0x12,0x22,0x24,0x00, + 0x00,0x08,0x3E,0x08,0x3E,0x08,0x08,0x00, + 0x00,0x1E,0x22,0x42,0x04,0x08,0x30,0x00, + 0x00,0x20,0x3E,0x48,0x08,0x08,0x10,0x00, + 0x00,0x7E,0x02,0x02,0x02,0x02,0x7E,0x00, + 0x00,0x24,0x7E,0x24,0x04,0x04,0x18,0x00, + 0x00,0x70,0x00,0x72,0x02,0x04,0x78,0x00, + 0x00,0x7E,0x02,0x04,0x08,0x14,0x62,0x00, + 0x00,0x20,0x7E,0x22,0x24,0x20,0x1E,0x00, + 0x00,0x22,0x22,0x12,0x02,0x04,0x18,0x00, + 0x00,0x1E,0x12,0x2A,0x06,0x04,0x18,0x00, + 0x00,0x3C,0x08,0x7E,0x08,0x08,0x10,0x00, + 0x00,0x52,0x52,0x52,0x02,0x04,0x18,0x00, + 0x00,0x3C,0x00,0x7E,0x08,0x08,0x10,0x00, + 0x00,0x10,0x10,0x18,0x14,0x10,0x10,0x00, + 0x00,0x08,0x7E,0x08,0x08,0x10,0x20,0x00, + 0x00,0x3C,0x00,0x00,0x00,0x00,0x7E,0x00, + 0x00,0x3E,0x02,0x14,0x08,0x14,0x20,0x00, + 0x00,0x08,0x3E,0x04,0x1C,0x2A,0x08,0x00, + 0x00,0x02,0x02,0x04,0x04,0x08,0x30,0x00, + 0x00,0x08,0x24,0x22,0x42,0x42,0x42,0x00, + 0x00,0x40,0x7E,0x40,0x40,0x40,0x3E,0x00, + 0x00,0x7E,0x02,0x02,0x04,0x08,0x30,0x00, + 0x00,0x00,0x10,0x28,0x44,0x02,0x00,0x00, + 0x00,0x08,0x3E,0x08,0x2A,0x2A,0x08,0x00, + 0x00,0x7E,0x02,0x04,0x28,0x10,0x08,0x00, + 0x00,0x3C,0x00,0x3C,0x00,0x7C,0x02,0x00, + 0x00,0x10,0x20,0x40,0x44,0x7C,0x02,0x00, + 0x00,0x02,0x02,0x14,0x08,0x14,0x20,0x00, + 0x00,0x7E,0x10,0x7E,0x10,0x10,0x1E,0x00, + 0x20,0x20,0x7E,0x22,0x24,0x20,0x20,0x00, + 0x00,0x38,0x08,0x08,0x08,0x08,0x7E,0x00, + 0x00,0x7E,0x02,0x7E,0x02,0x02,0x7E,0x00, + 0x00,0x3C,0x00,0x7E,0x02,0x04,0x38,0x00, + 0x00,0x22,0x22,0x22,0x02,0x04,0x18,0x00, + 0x00,0x28,0x28,0x28,0x2A,0x2A,0x4C,0x00, + 0x00,0x20,0x20,0x22,0x24,0x28,0x30,0x00, + 0x00,0x3E,0x22,0x22,0x22,0x22,0x3E,0x00, + 0x00,0x7E,0x42,0x42,0x02,0x04,0x18,0x00, + 0x00,0x70,0x02,0x02,0x04,0x08,0x70,0x00, + 0x10,0x48,0x20,0x00,0x00,0x00,0x00,0x00, + 0x70,0x50,0x70,0x00,0x00,0x00,0x00,0x00, + 0x20,0x7E,0x20,0x2E,0x20,0x48,0x46,0x00, + 0x10,0x3C,0x10,0x3C,0x42,0x02,0x1C,0x00, + 0x00,0x7C,0x02,0x02,0x02,0x04,0x18,0x00, + 0x00,0x7E,0x04,0x08,0x10,0x10,0x0E,0x00, + 0x10,0x10,0x16,0x38,0x40,0x40,0x3E,0x00, + 0x10,0x7A,0x22,0x48,0x08,0x3C,0x3A,0x00, + 0x20,0x4E,0x40,0x40,0x40,0x50,0x4E,0x00, + 0x04,0x04,0x5C,0x2A,0x52,0x56,0x26,0x00, + 0x20,0x20,0x6C,0x32,0x22,0x66,0x66,0x00, + 0x00,0x1C,0x2A,0x4A,0x52,0x52,0x24,0x00, + 0x04,0x5E,0x44,0x44,0x44,0x5E,0x5C,0x00, + 0x00,0x76,0x22,0x44,0x44,0x44,0x38,0x00, + 0x00,0x10,0x20,0x10,0x4A,0x4A,0x10,0x00, + 0x00,0x10,0x28,0x44,0x06,0x02,0x00,0x00, + 0x00,0x44,0x5E,0x44,0x44,0x5E,0x5C,0x00, + 0x08,0x7E,0x08,0x3E,0x08,0x7E,0x7A,0x00, + 0x70,0x14,0x14,0x3E,0x54,0x54,0x20,0x00, + 0x20,0x72,0x22,0x60,0x60,0x22,0x1C,0x00, + 0x04,0x04,0x5C,0x2A,0x52,0x52,0x24,0x00, + 0x08,0x78,0x10,0x78,0x20,0x22,0x1C,0x00, + 0x28,0x28,0x7C,0x22,0x22,0x26,0x20,0x00, + 0x08,0x5C,0x6A,0x4A,0x4A,0x5C,0x08,0x00, + 0x08,0x0E,0x08,0x08,0x3C,0x4A,0x30,0x00, + 0x10,0x08,0x20,0x3C,0x02,0x02,0x0C,0x00, + 0x04,0x22,0x22,0x22,0x12,0x04,0x08,0x00, + 0x3C,0x08,0x10,0x3C,0x42,0x12,0x1E,0x00, + 0x20,0x24,0x6C,0x34,0x24,0x64,0x26,0x00, + 0x3C,0x08,0x10,0x3C,0x42,0x02,0x1C,0x00, + 0x20,0x20,0x6C,0x32,0x22,0x62,0x24,0x00, + 0x10,0x10,0x20,0x20,0x30,0x4A,0x4C,0x00}; + +static WORD x68c16[] = { + 0x4038,0x1830,0x7008,0x0020,0x1212,0x1E12,0x1216,0x0002, // 1 + 0x4038,0x1830,0x7008,0x0020,0x1A02,0x0C0C,0x121E,0x0002, // 2 + 0x6038,0x7040,0x7840,0x0020,0x1A02,0x0C0C,0x121E,0x0002, // 3 + 0x6038,0x7040,0x7840,0x0020,0x0C1E,0x0808,0x0808,0x0008, // 4 + 0x6038,0x7040,0x7840,0x0020,0x1A1C,0x1212,0x1E16,0x000A, // 5 + 0x6830,0x4848,0x4878,0x0048,0x1210,0x1C14,0x1418,0x0016, // 6 + 0x4870,0x5850,0x4848,0x0050,0x1018,0x1010,0x1E10,0x0004, // 7 + 0x4870,0x5850,0x4848,0x0050,0x100E,0x060C,0x1C02,0x0008, // 8 + 0x4848,0x7848,0x4858,0x0008,0x0C1E,0x0808,0x0808,0x0008, // 9 + 0x4060,0x4040,0x7840,0x0010,0x180E,0x1C10,0x1018,0x0010, // a + 0x4848,0x4848,0x3050,0x0020,0x0C1E,0x0808,0x0808,0x0008, // b + 0x6038,0x7040,0x4060,0x0040,0x180E,0x1C10,0x1018,0x0010, // c + 0xD060,0x8080,0xF0D0,0x0020,0x121C,0x1412,0x1216,0x0010, // d + 0x4038,0x1830,0x7008,0x0020,0x121C,0x1212,0x1C12,0x0008, // e + 0x4038,0x1830,0x7008,0x0020,0x0C1E,0x080C,0x1E08,0x0008, // f + 0x4870,0x4848,0x4848,0x0050,0x180E,0x1C10,0x1E10,0x0008, //10 + 0x4870,0x4848,0x4848,0x0050,0x0C08,0x040C,0x0404,0x0004, //11 + 0x4870,0x4848,0x4848,0x0050,0x120C,0x0406,0x1A08,0x001C, //12 + 0x4870,0x4848,0x4848,0x0050,0x1A0C,0x0C02,0x0602,0x000C, //13 + 0x4870,0x4848,0x4848,0x0050,0x1008,0x1414,0x040E,0x0008, //14 + 0x4858,0x6848,0x5868,0x0048,0x1210,0x1C14,0x1418,0x0016, //15 + 0x4038,0x1830,0x7008,0x0020,0x1216,0x1A12,0x161A,0x0012, //16 + 0x6038,0x7040,0x7840,0x0020,0x121C,0x1614,0x1212,0x0014, //17 + 0x6830,0x4040,0x7868,0x0010,0x1216,0x1A12,0x161A,0x0012, //18 + 0x6038,0x7040,0x7840,0x0020,0x3602,0x223E,0x2222,0x0022, //19 + 0x4038,0x1830,0x7008,0x0020,0x121C,0x1614,0x1212,0x0014, //1a + 0x6038,0x7040,0x7840,0x0020,0x1A0C,0x1010,0x1E1A,0x0004, //1b + 0x0000,0x0000,0x0808,0xFE04,0x0804,0x0008,0x0000,0x0000, //1c + 0x0000,0x0000,0x2020,0xFE40,0x2040,0x0020,0x0000,0x0000, //1d + 0x0000,0x1010,0x3838,0x1054,0x1010,0x1010,0x0010,0x0000, //1e + 0x0000,0x1010,0x1010,0x5410,0x3854,0x1038,0x0010,0x0000, //1f + 0x8000,0x4080,0x2040,0x1020,0x0810,0x0408,0x0204,0x0002, //80 + 0x6000,0x0CDA,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, //81 + 0x1000,0x1010,0x1010,0x0010,0x1000,0x1010,0x1010,0x0010, //82 + 0x1000,0x3C10,0x2460,0x1C28,0x5232,0x4042,0x3C62,0x0000, //86 + 0x0000,0x0000,0x1000,0x1678,0x2C1C,0x5A4A,0x3052,0x0000, //87 + 0x0000,0x0000,0x0000,0x2224,0x2222,0x4242,0x2840,0x0010, //88 + 0x0000,0x0000,0x3800,0x0004,0x621C,0x0202,0x0402,0x0008, //89 + 0x0000,0x0000,0x1000,0x1E08,0x4222,0x0804,0x1A08,0x0024, //8a + 0x0000,0x0000,0x1200,0x6A1C,0x1C08,0x2A2A,0x2A2A,0x0010, //8b + 0x0000,0x0000,0x0000,0x2E04,0x6632,0x1020,0x1010,0x0008, //8c + 0x0000,0x0000,0x0000,0x5C48,0x6A6A,0x0A4A,0x080C,0x0008, //8d + 0x0000,0x0000,0x0000,0x080E,0x3C08,0x4A4C,0x4A4A,0x0030, //8e + 0x0000,0x0000,0x0000,0x621C,0x0202,0x0202,0x0402,0x0018, //8f + 0x0000,0x7820,0x202E,0x361C,0x5252,0x5A4A,0x0232,0x0000, //91 + 0x0000,0x2420,0x4224,0x4242,0x4042,0x4040,0x2840,0x0010, //92 + 0x0000,0x0438,0x0000,0x423C,0x0202,0x0202,0x0C04,0x0008, //93 + 0x0000,0x0810,0x261C,0x0242,0x0404,0x0808,0x1A10,0x0024, //94 + 0x1000,0x1C16,0x0A6A,0x1C08,0x2A2A,0x4A4A,0x326A,0x0000, //95 + 0x0000,0x1202,0x543A,0x2214,0x2222,0x2222,0x0404,0x0000, //96 + 0x1000,0x3E10,0x0868,0x7C06,0x1C04,0x4020,0x2642,0x0018, //97 + 0x0000,0x0806,0x2010,0x4020,0x4040,0x3060,0x0E18,0x0000, //98 + 0x0000,0x2404,0x4E24,0x4454,0x4444,0x4444,0x284C,0x0000, //99 + 0x0000,0x623C,0x0202,0x0000,0x2000,0x4040,0x3E62,0x0000, //9a + 0x1000,0x1010,0x483E,0x1808,0x4020,0x4040,0x3E62,0x0000, //9b + 0x0000,0x2020,0x2020,0x4040,0x4040,0x4040,0x6440,0x0038, //9c + 0x1000,0x7E10,0x0848,0x2C3C,0x4A4A,0x3252,0x0404,0x0008, //9d + 0x0000,0x2400,0x7E24,0x2425,0x4844,0x4040,0x3220,0x000C, //9e + 0x0000,0x4438,0x3008,0x4C22,0x2030,0x4040,0x2642,0x0018, //9f + 0x1000,0x7810,0x2C20,0x2222,0x4040,0x4040,0x7260,0x005C, //e0 + 0x1000,0x1010,0x207E,0x2C20,0x6232,0x0202,0x0C02,0x0000, //e1 + 0x0000,0x3C00,0x4262,0x0202,0x0202,0x0202,0x0C04,0x0010, //e2 + 0x0000,0x7E00,0x080C,0x2010,0x4040,0x6040,0x1E22,0x0000, //e3 + 0x0000,0x1010,0x121C,0x4020,0x4040,0x4040,0x3E22,0x0000, //e4 + 0x0000,0x1010,0x227C,0x4022,0x5C44,0x2414,0x1C24,0x000A, //e5 + 0x0000,0x1A0E,0x4040,0x4040,0x4040,0x5040,0x3250,0x000C, //e6 + 0x0000,0x0808,0x2C1C,0x6A6A,0x722A,0x5656,0x0A2A,0x0004, //e7 + 0x0000,0x2020,0x6A24,0x2232,0x2424,0x6A6C,0x262A,0x0000, //e8 + 0x0000,0x1C00,0x2A34,0x4A4A,0x4A4A,0x4A4A,0x0432,0x0000, //e9 + 0x0800,0x0408,0x645E,0x4C44,0x5654,0x6466,0x1C64,0x0000, //ea + 0x0000,0x3060,0x2410,0x2626,0x4444,0x4444,0x382C,0x0010, //eb + 0x0000,0x043C,0x0804,0x1008,0x4A12,0x4A4A,0x300A,0x0000, //ec + 0x0000,0x0000,0x3418,0x4424,0x0242,0x0202,0x0002,0x0000, //ed + 0x0400,0x441E,0x4444,0x5E44,0x4C44,0x5654,0x1856,0x0000, //ee + 0x1000,0x3E10,0x0848,0x3C0E,0x1848,0x4A2C,0x2A4A,0x0030, //ef + 0x3000,0x0810,0x0A08,0x4E3A,0x4A4E,0x524B,0x0424,0x0004, //f0 + 0x0400,0x7E04,0x0804,0x2A3A,0x5048,0x7250,0x0E2A,0x0004, //f1 + 0x0000,0x4808,0x2A5C,0x6A2A,0x4A6A,0x5252,0x0472,0x0000, //f2 + 0x0000,0x1008,0x127C,0x1010,0x247C,0x2020,0x2622,0x0018, //f3 + 0x0000,0x4400,0x5C44,0x6222,0x2222,0x1012,0x0810,0x0008, //f4 + 0x0000,0x5C08,0x6A6A,0x4A4A,0x4A4A,0x0C4A,0x0808,0x0000, //f5 + 0x0800,0x0E08,0x0808,0x3C08,0x4A6C,0x4A4A,0x3048,0x0000, //f6 + 0x0000,0x0418,0x2020,0x4440,0x625E,0x0202,0x0202,0x0004, //f7 + 0x0000,0x2200,0x4242,0x4242,0x4242,0x2252,0x0406,0x0000, //f8 + 0x0000,0x4C3C,0x1008,0x362C,0x4242,0x261A,0x2422,0x0018, //f9 + 0x0000,0x2020,0x6A26,0x3272,0x2422,0x6464,0x2224,0x0000, //fa + 0x0000,0x443C,0x1008,0x223C,0x4242,0x0202,0x0402,0x000C, //fb + 0x0000,0x1010,0x7C10,0x1232,0x2232,0x6262,0x2422,0x0000, //fc + 0x0000,0x1010,0x2030,0x2820,0x3434,0x2424,0x4624,0x0044}; //fd + +static WORD x68c12[] = { + 0x0000,0x0038,0x0064,0x0030,0x0008,0x0045, // 1 + 0x203B,0x2002,0xA003,0x2002,0x4002,0x0000, + 0x0000,0x0038,0x0064,0x0030,0x0008,0x2044, // 2 + 0x403B,0x8001,0xC000,0x4001,0x2002,0x0000, + 0x0000,0x007C,0x0020,0x0078,0x0040,0x2044, // 3 + 0x403B,0x8001,0xC000,0x4001,0x2002,0x0000, + 0x0000,0x007C,0x0020,0x0078,0x0040,0xE045, // 4 + 0x803A,0x8000,0x8000,0x8000,0x8000,0x0000, + 0x0000,0x007C,0x0020,0x0078,0x0040,0xC044, // 5 + 0x203B,0x2002,0xA002,0x4002,0xA001,0x0000, + 0x0000,0x0018,0x0028,0x0044,0x007C,0x2045, // 6 + 0x4045,0x8001,0x8001,0x4001,0x2001,0x0000, + 0x0000,0x0038,0x0064,0x0048,0x0044,0x0044, // 7 + 0x005A,0x0002,0x0002,0x2001,0xC001,0x0000, + 0x0000,0x0038,0x0064,0x0048,0x0044,0xC045, // 8 + 0x205B,0x8001,0x4000,0x2002,0xC001,0x0000, + 0x0000,0x0020,0x0064,0x0044,0x0074,0xE045, // 9 + 0x804A,0x8000,0x8000,0x8000,0x8000,0x0000, + 0x0000,0x0040,0x0040,0x0040,0x0040,0xE025, // a + 0x003B,0x0002,0xC003,0x0002,0x0002,0x0000, + 0x0000,0x0040,0x0044,0x0044,0x0064,0xE029, // b + 0x803A,0x8010,0x8000,0x8000,0x8000,0x0000, + 0x0000,0x003C,0x0060,0x0040,0x0078,0xE041, // c + 0x0043,0x0002,0xC003,0x0002,0x0002,0x0000, + 0x0000,0x0038,0x0064,0x0040,0x0040,0xC045, // d + 0x203B,0x2002,0x6002,0xC002,0x2002,0x0000, + 0x0000,0x0038,0x0064,0x0030,0x0008,0xC044, // e + 0x203B,0x2002,0x2002,0x4003,0x8001,0x0000, + 0x0000,0x0038,0x0064,0x0030,0x0008,0xC045, // f + 0x8038,0x8000,0x8000,0x8001,0xC000,0x0000, + 0x0000,0x0038,0x006C,0x0044,0x0044,0xE047, //10 + 0x0059,0xC003,0x0002,0x2002,0xC001,0x0000, + 0x0000,0x0038,0x006C,0x0044,0x0044,0x4044, //11 + 0xC058,0x4000,0xC000,0x8000,0xC001,0x0000, + 0x0000,0x0038,0x006C,0x0044,0x0044,0xC044, //12 + 0x6059,0x4000,0x8000,0x0001,0xC001,0x0000, + 0x0000,0x0038,0x006C,0x0044,0x0044,0xC044, //13 + 0x2059,0x4000,0x2000,0x2000,0xC001,0x0000, + 0x0000,0x0038,0x006C,0x0044,0x0044,0x0045, //14 + 0x4059,0x4002,0x8002,0xC001,0x8000,0x0000, + 0x0000,0x0044,0x0064,0x0074,0x0054,0x205D, //15 + 0x4049,0x8001,0x8001,0x4001,0x2001,0x0000, + 0x0000,0x0038,0x0064,0x0030,0x0008,0x2046, //16 + 0x203B,0xA003,0xA002,0xE002,0x4002,0x0000, + 0x0000,0x007C,0x0020,0x0078,0x0040,0xC045, //17 + 0x203B,0x4002,0x2002,0x2002,0xC002,0x0000, + 0x0000,0x0038,0x0064,0x0040,0x0040,0x2046, //18 + 0x203B,0xA003,0xA002,0xE002,0x4002,0x0000, + 0x0000,0x007C,0x0020,0x0078,0x0040,0x0046, //19 + 0x603B,0xE003,0xA002,0x2002,0x2002,0x0000, + 0x0000,0x0038,0x0064,0x0030,0x0008,0xC045, //1a + 0x203B,0x4002,0x2002,0x2002,0xC002,0x0000, + 0x0000,0x007C,0x0020,0x0078,0x0040,0xC045, //1b + 0x203B,0x0002,0x0002,0x2002,0xC001,0x0000, + 0x0000,0x0000,0x0000,0x8000,0x4000,0x2000, //1c + 0xF07F,0x2000,0x4000,0x8000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0008,0x0010,0x0020, //1d + 0xF07F,0x0020,0x0010,0x0008,0x0000,0x0000, + 0x0000,0x0004,0x000E,0x0015,0x8024,0x0004, //1e + 0x0004,0x0004,0x0004,0x0004,0x0004,0x0000, + 0x0000,0x0004,0x0004,0x0004,0x0004,0x0004, //1f + 0x0004,0x8024,0x0015,0x000E,0x0004,0x0000, + 0x0008,0x000C,0x0004,0x0006,0x0002,0x0003, //80 + 0x0001,0x8001,0x8000,0xC000,0x4000,0x0000, + 0x100E,0x601B,0xC020,0x0000,0x0000,0x0000, //81 + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0002,0x0002,0x0002,0x0002,0x0000, //82 + 0x0000,0x0002,0x0002,0x0002,0x0002,0x0000}; + +static WORD x68c24[] = { + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // 1 + 0x0040,0x0020,0x0018,0x000C,0x0044,0x0038, + 0x0001,0x2003,0x2002,0x2002,0xA003,0x2002, + 0x2002,0x4001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // 2 + 0x0040,0x0020,0x0018,0x000C,0x0044,0x0038, + 0x2002,0x6003,0xC001,0x8000,0xC000,0x4001, + 0x2003,0x2002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x007C,0x0020, // 3 + 0x0020,0x0078,0x0040,0x0040,0x0044,0x0038, + 0x2002,0x6003,0xC001,0x8000,0xC000,0x4001, + 0x2003,0x2002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x007C,0x0020, // 4 + 0x0020,0x0078,0x0040,0x0040,0x0044,0x0038, + 0xE001,0x8002,0x8000,0x8000,0x8000,0x8000, + 0x8000,0x8000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x007C,0x0020, // 5 + 0x0020,0x0078,0x0040,0x0040,0x0044,0x0038, + 0xC000,0x2003,0x2002,0x2002,0xA002,0xE002, + 0x4003,0xA001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0018,0x0028, // 6 + 0x0064,0x0044,0x007C,0x0044,0x0044,0x0044, + 0x2002,0x4002,0x8002,0x8003,0x0003,0x8002, + 0x4002,0x2002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // 7 + 0x0044,0x0048,0x0058,0x0044,0x0044,0x0058, + 0x0002,0x0002,0x0002,0x0002,0x0002,0x0002, + 0x2003,0xC001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // 8 + 0x0044,0x0048,0x0058,0x0044,0x0044,0x0058, + 0xC001,0x2003,0x0002,0x0001,0xC000,0x6000, + 0x2002,0xC001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0020,0x0064, // 9 + 0x0044,0x0044,0x0074,0x0044,0x0044,0x0028, + 0xE001,0x8002,0x8000,0x8000,0x8000,0x8000, + 0x8000,0x8000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0040,0x0040, // a + 0x0040,0x0040,0x0040,0x0040,0x0064,0x0038, + 0xE001,0x0003,0x0002,0x8003,0xC002,0x0002, + 0x0002,0x0002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0040,0x0044, // b + 0x0044,0x0044,0x0064,0x0028,0x0038,0x0010, + 0xE001,0x8002,0x8000,0x8000,0x8000,0x8000, + 0x8000,0x8000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x003C,0x0060, // c + 0x0040,0x0070,0x0058,0x0040,0x0040,0x0040, + 0xE001,0x0003,0x0002,0x8003,0xC002,0x0002, + 0x0002,0x0002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // d + 0x0040,0x0040,0x0040,0x0040,0x0044,0x0038, + 0xC001,0x2003,0x2002,0x2002,0x6002,0xC002, + 0x2002,0x2002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // e + 0x0040,0x0020,0x0018,0x000C,0x0044,0x0038, + 0xC000,0x2003,0x2002,0x2002,0x2002,0x2002, + 0x4003,0x8001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, // f + 0x0040,0x0020,0x0018,0x000C,0x0044,0x0038, + 0xC001,0x8000,0x8000,0x8000,0x8000,0x8000, + 0x8001,0xC000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x006C, //10 + 0x0044,0x0044,0x0044,0x0044,0x0044,0x0058, + 0x0000,0xE003,0x0001,0x0001,0xC003,0x0002, + 0x0002,0x2002,0xC001,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x006C, //11 + 0x0044,0x0044,0x0044,0x0044,0x0044,0x0058, + 0x0000,0x8000,0x8001,0x8000,0x8000,0x0001, + 0x0001,0x8003,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x006C, //12 + 0x0044,0x0044,0x0044,0x0044,0x0044,0x0058, + 0xC000,0x2001,0x2000,0x4000,0x8000,0x8000, + 0x0001,0xC003,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x006C, //13 + 0x0044,0x0044,0x0044,0x0044,0x0044,0x0058, + 0xE001,0x2000,0x4000,0xC000,0x2000,0x2000, + 0x4002,0x8001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x006C, //14 + 0x0044,0x0044,0x0044,0x0044,0x0044,0x0058, + 0x8000,0x0001,0x4001,0x4002,0x4002,0xE001, + 0x8000,0x8000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0044,0x0044, //15 + 0x0044,0x0064,0x0074,0x0054,0x005C,0x0048, + 0x2002,0x4002,0x8002,0x8003,0x0003,0x8002, + 0x4002,0x2002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, //16 + 0x0040,0x0020,0x0018,0x000C,0x0044,0x0038, + 0x2002,0x2002,0x2002,0x2003,0xA003,0xA002, + 0xE002,0x4002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x007C,0x0020, //17 + 0x0020,0x0078,0x0040,0x0040,0x0044,0x0038, + 0xC001,0x2003,0x2002,0x4002,0xC002,0x2002, + 0x2002,0xC002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, //18 + 0x0040,0x0040,0x0040,0x0040,0x0044,0x0038, + 0x2002,0x2002,0x2002,0x2003,0xA003,0xA002, + 0xE002,0x4002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x007C,0x0020, //19 + 0x0020,0x0078,0x0040,0x0040,0x0044,0x0038, + 0x0002,0x6003,0xE003,0xA002,0x2002,0x2002, + 0x2002,0x2002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0038,0x0064, //1a + 0x0040,0x0020,0x0018,0x000C,0x0044,0x0038, + 0xC001,0x2003,0x2002,0x4002,0xC002,0x2002, + 0x2002,0xC002,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x007C,0x0020, //1b + 0x0020,0x0078,0x0040,0x0040,0x0044,0x0038, + 0xC001,0x2003,0x0002,0x0002,0x0002,0x0002, + 0x2002,0xC001,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, //1c + 0x0000,0x0000,0x0000,0x0001,0x8000,0x4000, + 0xE07F,0x4000,0x8000,0x0001,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, //1d + 0x0000,0x0000,0x0000,0x0008,0x0010,0x0020, + 0xE07F,0x0020,0x0010,0x0008,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0004, //1e + 0x000E,0x0015,0x8024,0x0004,0x0004,0x0004, + 0x0004,0x0004,0x0004,0x0004,0x0004,0x0004, + 0x0004,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0004, //1f + 0x0004,0x0004,0x0004,0x0004,0x0004,0x0004, + 0x0004,0x0004,0x0004,0x8024,0x0015,0x000E, + 0x0004,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0030,0x0030,0x0030,0x0018, //80 + 0x0018,0x0018,0x000C,0x000C,0x000C,0x0006, + 0x0006,0x0006,0x0003,0x0003,0x0003,0x8001, + 0x8001,0x8001,0xC000,0xC000,0xC000,0x0000, + 0x0000,0x101C,0x303B,0xE061,0xC040,0x0000, //81 + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0006,0x0006,0x0006,0x0006,0x0006, //82 + 0x0006,0x0006,0x0006,0x0006,0x0000,0x0000, + 0x0000,0x0000,0x0006,0x0006,0x0006,0x0006, + 0x0006,0x0006,0x0006,0x0006,0x0006,0x0000}; + +static WORD x68k16[] = { + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFF01, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x00FF, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x00FF, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFF01, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFF01, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x00FF, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFFFF, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFFFF, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFF01, + 0xFF01,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x80FF, + 0x80FF,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x80FF, + 0x80FF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFF01, + 0xFF01,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFF01, + 0xFF01,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0xFFFF,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x80FF, + 0x80FF,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFFFF, + 0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFFFF, + 0xFFFF,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFF01, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0xFFFF,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x80FF, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFFFF, + 0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFFFF, + 0xFFFF,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0xFF01, + 0xFF01,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001, + 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x00FF, + 0x00FF,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFFFF, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0xFFFF, + 0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001,0x8001}; + +static WORD x68k24[] = { + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0xFF00,0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0xFF1F,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0xFF00,0x00F0,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0xFF00,0x00F0,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0x0000,0xFF1F,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0x0000,0xFF1F,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0xFF00,0xFFFF,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0xFF00,0x00F0,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0xFF00,0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000, + 0xFF00,0xFFFF,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800, + 0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x3F00, + 0x00FF,0xFF3F,0x3F00,0x00FF,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xF8FF, + 0xFF00,0x00F8,0xF8FF,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0xF8FF, + 0xFF00,0x00F8,0xF8FF,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3F00, + 0x00FF,0xFF3F,0x3F00,0x00FF,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3F00, + 0x00FF,0xFF3F,0x3F00,0x00FF,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0xF8FF, + 0xFF00,0x00F8,0xF8FF,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800, + 0x0000,0xFF3F,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800, + 0xFF00,0x00F8,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0xFFFF, + 0xFFFF,0xFFFF,0xFFFF,0x00FF,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1F00, + 0x00FF,0xFF1F,0x1F00,0x00FF,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0xFF00,0xFFFF,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0xF0FF, + 0xFF00,0x00F0,0xF0FF,0x0000,0x0010,0x1000,0x0000,0x0010, + 0x1000,0x0000,0x0010,0x1000,0x0000,0x0010,0x1000,0x0000, + 0x0010,0x1000,0x0000,0x0010, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800, + 0xFF00,0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800, + 0xFF00,0xFFFF,0x3800,0x0000,0x0038,0x3800,0x0000,0x0038, + 0x3800,0x0000,0x0038,0x3800,0x0000,0x0038,0x3800,0x0000, + 0x0038,0x3800,0x0000,0x0038}; + +// --------------------------------------------------------------------------- + +static __declspec(naked) WORD __fastcall jis2sjis(WORD jis) { + + __asm { + mov ax, cx + xor dl, dl + add ah, 21h + test ah, 1 + je short jis2sjis1a + mov dl, 5eh +jis2sjis1a: sar ah, 1 + add al, dl + xor ah, 20h + or ah, 80h + cmp al, 60h + jb short jis2sjis1b + inc al +jis2sjis1b: add al, 1fh + xchg al, ah + ret + } +} + + +static void setmonobmphead(BITMAPINFO *bi, int x, int y) { + + BYTE i; + + ZeroMemory(&bi->bmiHeader, sizeof(BITMAPINFOHEADER)); + bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bi->bmiHeader.biWidth = x; + bi->bmiHeader.biHeight = y; + bi->bmiHeader.biPlanes = 1; + bi->bmiHeader.biBitCount = 1; + bi->bmiHeader.biCompression = BI_RGB; + bi->bmiHeader.biSizeImage = (((x + 31) / 8) & ~3) * y; + bi->bmiHeader.biXPelsPerMeter = 0; + bi->bmiHeader.biYPelsPerMeter = 0; + bi->bmiHeader.biClrUsed = 2; + bi->bmiHeader.biClrImportant = 2; + + for (i=0; i<2; i++) { + bi->bmiColors[i].rgbRed = (i ^ 1) - 1; + bi->bmiColors[i].rgbGreen = (i ^ 1) - 1; + bi->bmiColors[i].rgbBlue = (i ^ 1) - 1; + bi->bmiColors[i].rgbReserved = PC_RESERVED; + } +} + + +static int getfont_sub(BYTE *dest, char *str, char *fontname, + int fntx, int fnty, int bmpx, int bmpy) { + + HDC hdc; + HDC hdcimage; + HBITMAP hBitmap; + HBITMAP hBitmapbak; + BYTE *image; + HFONT hfont; + HFONT hfontbak; + RECT rect; + char bmphead[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 2]; + + SetRect(&rect, 0, 0, bmpx, bmpy); + setmonobmphead((BITMAPINFO *)bmphead, bmpx, bmpy); + hdc = GetDC(NULL); + hBitmap = CreateDIBSection(hdc, (BITMAPINFO *)bmphead, + DIB_RGB_COLORS, (void **)&image, NULL, 0); + hdcimage = CreateCompatibleDC(hdc); + ReleaseDC(NULL, hdc); + hBitmapbak = SelectObject(hdcimage, hBitmap); + SetDIBColorTable(hdcimage, 0, 2, ((BITMAPINFO *)bmphead)->bmiColors); + + hfont = CreateFont(fnty, fntx, FW_DONTCARE, FW_DONTCARE, FW_REGULAR, + FALSE, FALSE, FALSE, SHIFTJIS_CHARSET, + OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, + NONANTIALIASED_QUALITY, FIXED_PITCH, fontname); + hfontbak = SelectObject(hdcimage, hfont); + SetTextColor(hdcimage, RGB(255, 255, 255)); + SetBkColor(hdcimage, RGB(0, 0, 0)); + + FillRect(hdcimage, &rect, GetStockObject(BLACK_BRUSH)); + TextOut(hdcimage, 0, 0, str, strlen(str)); + CopyMemory(dest, image, (((bmpx + 31) / 8) & ~3) * bmpy); + + SelectObject(hdcimage, hBitmapbak); + DeleteObject(hBitmap); + DeleteDC(hdcimage); + + return(TRUE); +} + + +static int getfont(BYTE *dest, char *fontface, int base, int size) { + + int i; + char textbuf[256]; + int *p; + + if (!base) { + for (i=0; i<0x5f; i++) { + textbuf[i] = (BYTE)(i + 0x20); + } + textbuf[0x5f] = ' '; + textbuf[0x60] = ' '; + for (i=0x01; i<0x40; i++) { + textbuf[i+0x60] = (BYTE)(i + 0xa0); + } + textbuf[0xa0] = '\0'; + } + else { + *(WORD *)textbuf = 0x4081; + for (i=1; i<0x5f; i++) { + ((WORD *)textbuf)[i] = jis2sjis((WORD)((base << 8) + i + 0x20)); + } + textbuf[i*2] = '\0'; + switch(base) { + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + p = deltable; + while(base > 0x22) { + while(*p++); + base--; + } + while(*p) { + i = *p++; + while(i < *p) { + ((WORD *)textbuf)[i++] = 0x4081; + } + p++; + } + break; + case 0x4f: + for (i=0x34; i<0x5f; i++) { + ((WORD *)textbuf)[i] = 0x4081; + } + break; + case 0x74: + for (i=0x05; i<0x5f; i++) { + ((WORD *)textbuf)[i] = 0x4081; + } + break; + } + } + return(getfont_sub(dest, textbuf, fontface, + size, size*2, size*256, size*2)); +} + +// --------------------------------------------------------------------------- + +static void cpyank2cgrom(BYTE *dst, BYTE *src, int length) { + + int y; + + while(length--) { + for (y=16; y--;) { + *dst++ = src[y*256]; + } + src++; + } +} + +static void cpy12fnt2cgrom(BYTE *dst, BYTE *src, int bmpx, int bmpy) { + + int i, j; + + bmpx /= 8; + for (i=0; i<8; i++) { + for (j=bmpy; j--;) { + *(WORD *)dst = (*(WORD *)(&src[j*bmpx])) & 0xf0ff; + dst += 2; + } + for (j=bmpy; j--;) { + *dst++ = (src[j*bmpx+1] << 4) | (src[j*bmpx+2] >> 4); + *dst++ = (src[j*bmpx+2] << 4); + } + src += 3; + } +} + +static void cpysmall2cgrom(BYTE *dst, BYTE *src, int line) { + + int i, j; + + dst += 0x5e * 32 * line; + for (i=0; i<0x5e; i++) { + src += 2; + for (j=16; j--;) { + *(WORD *)dst = *(WORD *)(src + j * 256); + dst += 2; + } + } +} + +static void cpybig2cgrom(BYTE *dst, BYTE *src, int line) { + + int i, j; + + dst += 0x5e * 72 * line; + for (i=0; i<0x5e; i++) { + src += 3; + for (j=24; j--;) { + *dst++ = *(src + j * 384 + 0); + *dst++ = *(src + j * 384 + 1); + *dst++ = *(src + j * 384 + 2); + } + } +} + +// --------------------------------------------------------------------------- + +int make_cgromdat(BYTE *buf, int x68030, LPSTR primaryface, LPSTR secondaryface) { + + BYTE fnt[24*256*24/8]; + int i; + + ZeroMemory(buf, 0xc0000); + + // 8x8 + CopyMemory(buf + 0x3a000 + 0x01*8, x68c8, 0xfd*8); + + // 8x16 + getfont(fnt, primaryface, 0, 8); + cpyank2cgrom(buf + 0x3a800 + 0x21*16, fnt + 0x01, 0x5e); // 21-7e + cpyank2cgrom(buf + 0x3a800 + 0xa1*16, fnt + 0x61, 0x3f); // a1-df + CopyMemory(buf + 0x3a800 + 0x01*16, &x68c16[0x00*8], 0x1f*16); + CopyMemory(buf + 0x3a800 + 0x80*16, &x68c16[0x1f*8], 0x03*16); + CopyMemory(buf + 0x3a800 + 0x86*16, &x68c16[0x22*8], 0x0a*16); + CopyMemory(buf + 0x3a800 + 0x91*16, &x68c16[0x2c*8], 0x0f*16); + CopyMemory(buf + 0x3a800 + 0xe0*16, &x68c16[0x3b*8], 0x1e*16); + + // 12x12 + for (i=0; i<0x0e; i++) { + getfont_sub(fnt, str_x68k[i], secondaryface, 6, 12, 256, 12); + cpy12fnt2cgrom(buf + 0x3b800 + (i+2)*24*16, fnt, 256, 12); + } + CopyMemory(buf + 0x3b800 + 0x01*24, &x68c12[0x00*12], 0x1f*24); + CopyMemory(buf + 0x3b800 + 0x80*24, &x68c12[0x1f*12], 0x03*24); + + // 12x24 + getfont(fnt, secondaryface, 0, 12); + // ANK + for (i=0; i<6; i++) { + cpy12fnt2cgrom(buf + 0x3d000 + (i+ 2)*16*2*24, + fnt + (i+0)*8*3, 12*256, 24); + } + // カタカナ + for (i=0; i<4; i++) { + cpy12fnt2cgrom(buf + 0x3d000 + (i+10)*16*2*24, + fnt + (i+6)*8*3, 12*256, 24); + } + // 平仮名 + for (i=0; i<2; i++) { + getfont_sub(fnt, str_x68k[i+6], secondaryface, 6, 24, 256, 24); + cpy12fnt2cgrom(buf + 0x3d000 + (i+ 8)*16*2*24, fnt, 256, 24); + getfont_sub(fnt, str_x68k[i+12], secondaryface, 6, 24, 256, 24); + cpy12fnt2cgrom(buf + 0x3d000 + (i+14)*16*2*24, fnt, 256, 24); + } + CopyMemory(buf + 0x3d000 + 0x01*48, &x68c24[0x00*24], 0x1f*48); + CopyMemory(buf + 0x3d000 + 0x80*48, &x68c24[0x1f*24], 0x03*48); + + // 16x16 + for (i=0; i<7; i++) { + getfont(fnt, secondaryface, i+0x21, 8); + cpysmall2cgrom(buf, fnt, i); + } + for (i=0; i<0x45; i++) { + getfont(fnt, primaryface, i+0x30, 8); + cpysmall2cgrom(buf, fnt, i+8); + } + CopyMemory(buf + 0x5e*7*32, x68k16, 32*32); + + // 24x24 + for (i=0; i<7; i++) { + getfont(fnt, secondaryface, i+0x21, 12); + cpybig2cgrom(buf + 0x40000, fnt, i); + } + for (i=0; i<0x45; i++) { + getfont(fnt, secondaryface, i+0x30, 12); + cpybig2cgrom(buf + 0x40000, fnt, i+8); + } + CopyMemory(buf + 0x40000 + 0x5e*7*72, x68k24, 32*72); + + return(TRUE); +} diff --git a/libretro/mkcgrom.h b/libretro/mkcgrom.h new file mode 100644 index 0000000..b504743 --- /dev/null +++ b/libretro/mkcgrom.h @@ -0,0 +1,11 @@ + +// X68KのCGROMを作る +// buf: 作る領域 (0xc0000バイト分のバッファ) +// x68030: X68030フォントを作るか？ (現在無効) +// primaryface: 書体１ (主に16ドット用) +// secondaryface: 書体２ (主に24ドット用) +// +// 戻り値: FALSE: 失敗, TRUE: 成功 + + +int make_cgromdat(BYTE *buf, int x68030, LPSTR primaryface, LPSTR secondaryface); diff --git a/libretro/mouse.c b/libretro/mouse.c new file mode 100644 index 0000000..d4c7b6e --- /dev/null +++ b/libretro/mouse.c @@ -0,0 +1,204 @@ +/* + * Copyright (c) 2003,2008 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "common.h" +#include "winx68k.h" +#include "prop.h" +#include "scc.h" +#include "crtc.h" +#include "mouse.h" + +float MouseDX = 0; +float MouseDY = 0; +BYTE MouseStat = 0; +BYTE MouseSW = 0; + +POINT CursorPos; +int mousex = 0, mousey = 0; + +#if 0 +static GdkPixmap *cursor_pixmap; +static GdkCursor *cursor; + +static void getmaincenter(GtkWidget *w, POINT *p); +void gdk_window_set_pointer(GdkWindow *window, gint x, gint y); +#endif + +void Mouse_Init(void) +{ + if (Config.JoyOrMouse) { + Mouse_StartCapture(1); + } +} + + +// ---------------------------------- +// Mouse Event Occured +// ---------------------------------- +void Mouse_Event(int param, float dx, float dy) +{ + //printf("ME(): %f %f\n", dx, dy); + + if (MouseSW) { + switch (param) { + case 0: // mouse move + MouseDX += dx; + MouseDY += dy; + break; + case 1: // left button + if (dx != 0) + MouseStat |= 1; + else + MouseStat &= 0xfe; + break; + case 2: // right button + if (dx != 0) + MouseStat |= 2; + else + MouseStat &= 0xfd; + break; + default: + break; + } + } +} + + +// ---------------------------------- +// Mouse Data send to SCC +// ---------------------------------- +void Mouse_SetData(void) +{ + POINT pt; + int x, y; + + if (MouseSW) { + + x = (int)MouseDX; + y = (int)MouseDY; + + MouseDX = MouseDY = 0; + + MouseSt = MouseStat; + + if (x > 127) { + MouseSt |= 0x10; + MouseX = 127; + } else if (x < -128) { + MouseSt |= 0x20; + MouseX = -128; + } else { + MouseX = (signed char)x; + } + + if (y > 127) { + MouseSt |= 0x40; + MouseY = 127; + } else if (y < -128) { + MouseSt |= 0x80; + MouseY = -128; + } else { + MouseY = (signed char)y; + } + + } else { + MouseSt = 0; + MouseX = 0; + MouseY = 0; + } +} + + +// ---------------------------------- +// Start Capture +// ---------------------------------- +void Mouse_StartCapture(int flag) +{ + if (flag && !MouseSW) { + MouseSW = 1; + } else if (!flag && MouseSW) { + MouseSW = 0; + } +} + +void Mouse_ChangePos(void) +{ +#if 0 + if (MouseSW) { + POINT pt; + + getmaincenter(window, &pt); + gdk_window_set_pointer(window->window, pt.x, pt.y); + } +#endif +} + +#if 0 +static void +getmaincenter(GtkWidget *w, POINT *p) +{ + + p->x = w->allocation.x + w->allocation.width / 2; + p->y = w->allocation.y + w->allocation.height / 2; +} + +#if GTK_MAJOR_VERSION == 1 +#include + +void +gdk_window_set_pointer(GdkWindow *window, gint x, gint y) +{ + GdkWindowPrivate *private; + + if (!window) + window = (GdkWindow *)&gdk_root_parent; + + private = (GdkWindowPrivate *)window; + if (private->destroyed) + return; + + XWarpPointer(private->xdisplay, None, private->xwindow, + 0, 0, 0, 0, x, y); +} +#else /* GTK_MAJOR_VERSION != 1 */ +#include + +void +gdk_window_set_pointer(GdkWindow *window, gint x, gint y) +{ + GdkScreen *screen; + + if (window == NULL) { + screen = gdk_screen_get_default(); + window = gdk_screen_get_root_window(screen); + } + if (GDK_WINDOW_DESTROYED(window)) + return; + + XWarpPointer(GDK_WINDOW_XDISPLAY(window), None, GDK_WINDOW_XID(window), + 0, 0, 0, 0, x, y); +} +#endif /* GTK_MAJOR_VERSION == 1 */ +#endif diff --git a/libretro/mouse.h b/libretro/mouse.h new file mode 100644 index 0000000..7282c95 --- /dev/null +++ b/libretro/mouse.h @@ -0,0 +1,17 @@ +#ifndef _winx68k_mouse +#define _winx68k_mouse + +#include "common.h" + +extern int MousePosX; +extern int MousePosY; +extern BYTE MouseStat; +extern BYTE MouseSW; + +void Mouse_Init(void); +void Mouse_Event(int wparam, float dx, float dy); +void Mouse_SetData(void); +void Mouse_StartCapture(int flag); +void Mouse_ChangePos(void); + +#endif //_winx68k_mouse diff --git a/libretro/nasm.h b/libretro/nasm.h new file mode 100644 index 0000000..b4e6451 --- /dev/null +++ b/libretro/nasm.h @@ -0,0 +1,178 @@ + +; Copyright (C) 1999 URURI + +; nasm用マクロ +; 1999/08/21 作成 +; 1999/10/10 幾つか追加 +; 1999/10/27 aout対応 +; 1999/11/07 pushf, popf のNASMのバグ対応 +; 1999/12/02 for BCC ( Thanks to Miquel ) + +; for Windows Visual C++ -> define WIN32 +; Borland or cygwin -> WIN32 and COFF +; for FreeBSD 2.x -> AOUT +; for TownsOS -> __tos__ +; otherwise -> none + +;名前の付け方 + +BITS 32 + +%ifdef WIN32 + %define _NAMING + %define segment_code segment .text align=16 class=CODE use32 + %define segment_data segment .data align=16 class=DATA use32 +%ifdef __BORLANDC__ + %define segment_bss segment .data align=16 class=DATA use32 +%else + %define segment_bss segment .bss align=16 class=DATA use32 +%endif +%elifdef AOUT + %define _NAMING + %define segment_code segment .text + %define segment_data segment .data + %define segment_bss segment .bss +%else + %define segment_code segment .text align=16 class=CODE use32 + %define segment_data segment .data align=16 class=DATA use32 + %define segment_bss segment .bss align=16 class=DATA use32 +%endif + +%ifdef __tos__ +group CGROUP text +group DGROUP data +%endif + +;単精度浮動小数点形式 + +%idefine float dword +%idefine fsize 4 +%idefine fsizen(a) (fsize*(a)) + +;ワード形式 + +%idefine wsize 2 +%idefine wsizen(a) (wsize*(a)) +%idefine dwsize 4 +%idefine dwsizen(a) (dwsize*(a)) + +;REG + +%define r0 eax +%define r1 ebx +%define r2 ecx +%define r3 edx +%define r4 esi +%define r5 edi +%define r6 ebp +%define r7 esp + +;MMX,3DNow!,SSE + +%define pmov movq +%define pmovd movd + +%define pupldq punpckldq +%define puphdq punpckhdq +%define puplwd punpcklwd +%define puphwd punpckhwd + +%define xm0 xmm0 +%define xm1 xmm1 +%define xm2 xmm2 +%define xm3 xmm3 +%define xm4 xmm4 +%define xm5 xmm5 +%define xm6 xmm6 +%define xm7 xmm7 + +;シャッフル用の4進マクロ + +%define R4(a,b,c,d) (a*64+b*16+c*4+d) + +;Cライクな簡易マクロ + +%imacro globaldef 1 + %ifdef _NAMING + %define %1 _%1 + %endif + global %1 +%endmacro + +%imacro externdef 1 + %ifdef _NAMING + %define %1 _%1 + %endif + extern %1 +%endmacro + +%imacro proc 1 + %push proc + %ifdef _NAMING + global _%1 + %else + global %1 + %endif + + align 32 +%1: +_%1: + + %assign %$STACK 0 + %assign %$STACKN 0 + %assign %$ARG 4 +%endmacro + +%imacro endproc 0 + %ifnctx proc + %error expected 'proc' before 'endproc'. + %else + %if %$STACK > 0 + add esp, %$STACK + %endif + + %if %$STACK <> (-%$STACKN) + %error STACKLEVEL mismatch check 'local', 'alloc', 'pushd', 'popd' + %endif + + ret + %pop + %endif +%endmacro + +%idefine sp(a) esp+%$STACK+a + +%imacro arg 1 + %00 equ %$ARG + %assign %$ARG %$ARG+%1 +%endmacro + +%imacro local 1 + %assign %$STACKN %$STACKN-%1 + %00 equ %$STACKN +%endmacro + +%imacro alloc 0 + sub esp, (-%$STACKN)-%$STACK + %assign %$STACK (-%$STACKN) +%endmacro + +%imacro pushd 1-* + %rep %0 + push %1 + %assign %$STACK %$STACK+4 + %rotate 1 + %endrep +%endmacro + +%imacro popd 1-* + %rep %0 + %rotate -1 + pop %1 + %assign %$STACK %$STACK-4 + %endrep +%endmacro + +; bug of NASM-0.98 +%define pushf db 0x66, 0x9C +%define popf db 0x66, 0x9D diff --git a/libretro/prop.c b/libretro/prop.c new file mode 100644 index 0000000..8c624f1 --- /dev/null +++ b/libretro/prop.c @@ -0,0 +1,1374 @@ +/* + * Copyright (c) 2003 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* -------------------------------------------------------------------------- * + * PROP.C - 各種設定用プロパティシートと設定値管理 * + * -------------------------------------------------------------------------- */ + +#include + +#include "common.h" +#include "winx68k.h" +#include "keyboard.h" +#include "fileio.h" +#include "prop.h" + +BYTE LastCode = 0; +BYTE KEYCONFFILE[] = "xkeyconf.dat"; + +int CurrentHDDNo = 0; + +BYTE ini_title[] = "WinX68k"; + +static const char MIDI_TYPE_NAME[4][3] = { + "LA", "GM", "GS", "XG" +}; + +BYTE KeyTableBk[512]; + +Win68Conf Config; +Win68Conf ConfBk; + +#ifndef MAX_BUTTON +#define MAX_BUTTON 32 +#endif + +extern char filepath[MAX_PATH]; +extern char winx68k_ini[MAX_PATH]; +extern int winx, winy; +extern char joyname[2][MAX_PATH]; +extern char joybtnname[2][MAX_BUTTON][MAX_PATH]; +extern BYTE joybtnnum[2]; + +#define CFGLEN MAX_PATH + +#if 0 +static long solveHEX(char *str) { + + long ret; + int i; + char c; + + ret = 0; + for (i=0; i<8; i++) { + c = *str++; + if ((c >= '0') && (c <= '9')) { + c -= '0'; + } + else if ((c >= 'A') && (c <= 'F')) { + c -= '7'; + } + else if ((c >= 'a') && (c <= 'f')) { + c -= 'W'; + } + else { + break; + } + ret <<= 4; + ret += (long) c; + } + return(ret); +} +#endif + +static char *makeBOOL(BYTE value) { + + if (value) { + return("true"); + } + return("false"); +} + +static BYTE Aacmp(char *cmp, char *str) { + + char p; + + while(*str) { + p = *cmp++; + if (!p) { + break; + } + if (p >= 'a' && p <= 'z') { + p -= 0x20; + } + if (p != *str++) { + return(-1); + } + } + return(0); +} + +static BYTE solveBOOL(char *str) { + + if ((!Aacmp(str, "TRUE")) || (!Aacmp(str, "ON")) || + (!Aacmp(str, "+")) || (!Aacmp(str, "1")) || + (!Aacmp(str, "ENABLE"))) { + return(1); + } + return(0); +} + +#ifdef __LIBRETRO__ +extern char retro_system_conf[512]; +extern char slash; + +#endif + +int +set_modulepath(char *path, size_t len) +{ + struct stat sb; + char *homepath; + +#ifdef __LIBRETRO__ + puts("Libretro..."); + sprintf(path,retro_system_conf); + sprintf(winx68k_ini, "%s%cconfig",retro_system_conf,slash); + return 0; +#endif + homepath = getenv("HOME"); + if (homepath == 0) + homepath = "."; + + snprintf(path, len, "%s/%s", homepath, ".keropi"); + if (stat(path, &sb) < 0) { +#ifdef _WIN32 + if (mkdir(path) < 0) { +#else + if (mkdir(path, 0700) < 0) { +#endif + perror(path); + return 1; + } + } else { + if ((sb.st_mode & S_IFDIR) == 0) { + fprintf(stderr, "%s isn't directory.\n", path); + return 1; + } + } + snprintf(winx68k_ini, sizeof(winx68k_ini), "%s/%s", path, "config"); + if (stat(winx68k_ini, &sb) >= 0) { + if (sb.st_mode & S_IFDIR) { + fprintf(stderr, "%s is directory.\n", winx68k_ini); + return 1; + } + } + + return 0; +} + +void LoadConfig(void) +{ + int i, j; + char buf[CFGLEN]; + FILEH fp; + + winx = GetPrivateProfileInt(ini_title, "WinPosX", 0, winx68k_ini); + winy = GetPrivateProfileInt(ini_title, "WinPosY", 0, winx68k_ini); + + Config.FrameRate = (BYTE)GetPrivateProfileInt(ini_title, "FrameRate", 1, winx68k_ini); + + if (!Config.FrameRate) Config.FrameRate = 1; + GetPrivateProfileString(ini_title, "StartDir", "", buf, MAX_PATH, winx68k_ini); + if (buf[0] != 0) + strncpy(filepath, buf, sizeof(filepath)); + else + filepath[0] = 0; + + Config.OPM_VOL = GetPrivateProfileInt(ini_title, "OPM_Volume", 12, winx68k_ini); + Config.PCM_VOL = GetPrivateProfileInt(ini_title, "PCM_Volume", 15, winx68k_ini); + Config.MCR_VOL = GetPrivateProfileInt(ini_title, "MCR_Volume", 13, winx68k_ini); + + Config.SampleRate = GetPrivateProfileInt(ini_title, "SampleRate", 44100, winx68k_ini); + + Config.BufferSize = GetPrivateProfileInt(ini_title, "BufferSize", 50, winx68k_ini); + + Config.MouseSpeed = GetPrivateProfileInt(ini_title, "MouseSpeed", 10, winx68k_ini); + + GetPrivateProfileString(ini_title, "FDDStatWin", "1", buf, CFGLEN, winx68k_ini); + Config.WindowFDDStat = solveBOOL(buf); + GetPrivateProfileString(ini_title, "FDDStatFullScr", "1", buf, CFGLEN, winx68k_ini); + Config.FullScrFDDStat = solveBOOL(buf); + + GetPrivateProfileString(ini_title, "DSAlert", "1", buf, CFGLEN, winx68k_ini); + Config.DSAlert = solveBOOL(buf); + GetPrivateProfileString(ini_title, "SoundLPF", "1", buf, CFGLEN, winx68k_ini); + Config.Sound_LPF = solveBOOL(buf); + GetPrivateProfileString(ini_title, "UseRomeo", "0", buf, CFGLEN, winx68k_ini); + Config.SoundROMEO = solveBOOL(buf); + GetPrivateProfileString(ini_title, "MIDI_SW", "1", buf, CFGLEN, winx68k_ini); + Config.MIDI_SW = solveBOOL(buf); + GetPrivateProfileString(ini_title, "MIDI_Reset", "0", buf, CFGLEN, winx68k_ini); + Config.MIDI_Reset = solveBOOL(buf); + Config.MIDI_Type = GetPrivateProfileInt(ini_title, "MIDI_Type", 1, winx68k_ini); + + GetPrivateProfileString(ini_title, "JoySwap", "0", buf, CFGLEN, winx68k_ini); + Config.JoySwap = solveBOOL(buf); + + GetPrivateProfileString(ini_title, "JoyKey", "0", buf, CFGLEN, winx68k_ini); + Config.JoyKey = solveBOOL(buf); + GetPrivateProfileString(ini_title, "JoyKeyReverse", "0", buf, CFGLEN, winx68k_ini); + Config.JoyKeyReverse = solveBOOL(buf); + GetPrivateProfileString(ini_title, "JoyKeyJoy2", "0", buf, CFGLEN, winx68k_ini); + Config.JoyKeyJoy2 = solveBOOL(buf); + GetPrivateProfileString(ini_title, "SRAMBootWarning", "1", buf, CFGLEN, winx68k_ini); + Config.SRAMWarning = solveBOOL(buf); + + GetPrivateProfileString(ini_title, "WinDrvLFN", "1", buf, CFGLEN, winx68k_ini); + Config.LongFileName = solveBOOL(buf); + GetPrivateProfileString(ini_title, "WinDrvFDD", "1", buf, CFGLEN, winx68k_ini); + Config.WinDrvFD = solveBOOL(buf); + + Config.WinStrech = GetPrivateProfileInt(ini_title, "WinStretch", 1, winx68k_ini); + + GetPrivateProfileString(ini_title, "DSMixing", "0", buf, CFGLEN, winx68k_ini); + Config.DSMixing = solveBOOL(buf); + + Config.XVIMode = (BYTE)GetPrivateProfileInt(ini_title, "XVIMode", 0, winx68k_ini); + + GetPrivateProfileString(ini_title, "CDROM_ASPI", "1", buf, CFGLEN, winx68k_ini); + Config.CDROM_ASPI = solveBOOL(buf); + Config.CDROM_SCSIID = (BYTE)GetPrivateProfileInt(ini_title, "CDROM_SCSIID", 6, winx68k_ini); + Config.CDROM_ASPI_Drive = (BYTE)GetPrivateProfileInt(ini_title, "CDROM_ASPIDrv", 0, winx68k_ini); + Config.CDROM_IOCTRL_Drive = (BYTE)GetPrivateProfileInt(ini_title, "CDROM_CTRLDrv", 16, winx68k_ini); + GetPrivateProfileString(ini_title, "CDROM_Enable", "1", buf, CFGLEN, winx68k_ini); + Config.CDROM_Enable = solveBOOL(buf); + + GetPrivateProfileString(ini_title, "SSTP_Enable", "0", buf, CFGLEN, winx68k_ini); + Config.SSTP_Enable = solveBOOL(buf); + Config.SSTP_Port = GetPrivateProfileInt(ini_title, "SSTP_Port", 11000, winx68k_ini); + + GetPrivateProfileString(ini_title, "ToneMapping", "0", buf, CFGLEN, winx68k_ini); + Config.ToneMap = solveBOOL(buf); + GetPrivateProfileString(ini_title, "ToneMapFile", "", buf, MAX_PATH, winx68k_ini); + if (buf[0] != 0) + strcpy(Config.ToneMapFile, buf); + else + Config.ToneMapFile[0] = 0; + + Config.MIDIDelay = GetPrivateProfileInt(ini_title, "MIDIDelay", Config.BufferSize*5, winx68k_ini); + Config.MIDIAutoDelay = GetPrivateProfileInt(ini_title, "MIDIAutoDelay", 1, winx68k_ini); + + Config.VkeyScale = GetPrivateProfileInt(ini_title, "VkeyScale", 4, winx68k_ini); + + Config.VbtnSwap = GetPrivateProfileInt(ini_title, "VbtnSwap", 0, winx68k_ini); + + Config.JoyOrMouse = GetPrivateProfileInt(ini_title, "JoyOrMouse", 0, winx68k_ini); + + Config.HwJoyAxis[0] = GetPrivateProfileInt(ini_title, "HwJoyAxis0", 0, winx68k_ini); + + Config.HwJoyAxis[1] = GetPrivateProfileInt(ini_title, "HwJoyAxis1", 1, winx68k_ini); + + Config.HwJoyHat = GetPrivateProfileInt(ini_title, "HwJoyHat", 0, winx68k_ini); + + for (i = 0; i < 8; i++) { + sprintf(buf, "HwJoyBtn%d", i); + Config.HwJoyBtn[i] = GetPrivateProfileInt(ini_title, buf, i, winx68k_ini); + } + + Config.NoWaitMode = GetPrivateProfileInt(ini_title, "NoWaitMode", 0, winx68k_ini); + + for (i=0; i<2; i++) + { + for (j=0; j<8; j++) + { + sprintf(buf, "Joy%dButton%d", i+1, j+1); + Config.JOY_BTN[i][j] = GetPrivateProfileInt(ini_title, buf, j, winx68k_ini); + } + } + + for (i = 0; i < 2; i++) { + sprintf(buf, "FDD%d", i); + GetPrivateProfileString(ini_title, buf, "", Config.FDDImage[i], MAX_PATH, winx68k_ini); + } + + for (i=0; i<16; i++) + { + sprintf(buf, "HDD%d", i); + GetPrivateProfileString(ini_title, buf, "", Config.HDImage[i], MAX_PATH, winx68k_ini); + } + +#if 0 + fp = File_OpenCurDir(KEYCONFFILE); + if (fp) + { + File_Read(fp, KeyTable, 512); + File_Close(fp); + } +#endif +} + + +void SaveConfig(void) +{ + int i, j; + char buf[CFGLEN], buf2[CFGLEN]; + FILEH fp; + + wsprintf(buf, "%d", winx); + WritePrivateProfileString(ini_title, "WinPosX", buf, winx68k_ini); + wsprintf(buf, "%d", winy); + WritePrivateProfileString(ini_title, "WinPosY", buf, winx68k_ini); + wsprintf(buf, "%d", Config.FrameRate); + WritePrivateProfileString(ini_title, "FrameRate", buf, winx68k_ini); + WritePrivateProfileString(ini_title, "StartDir", filepath, winx68k_ini); + + wsprintf(buf, "%d", Config.OPM_VOL); + WritePrivateProfileString(ini_title, "OPM_Volume", buf, winx68k_ini); + wsprintf(buf, "%d", Config.PCM_VOL); + WritePrivateProfileString(ini_title, "PCM_Volume", buf, winx68k_ini); + wsprintf(buf, "%d", Config.MCR_VOL); + WritePrivateProfileString(ini_title, "MCR_Volume", buf, winx68k_ini); + wsprintf(buf, "%d", Config.SampleRate); + WritePrivateProfileString(ini_title, "SampleRate", buf, winx68k_ini); + wsprintf(buf, "%d", Config.BufferSize); + WritePrivateProfileString(ini_title, "BufferSize", buf, winx68k_ini); + + wsprintf(buf, "%d", Config.MouseSpeed); + WritePrivateProfileString(ini_title, "MouseSpeed", buf, winx68k_ini); + + WritePrivateProfileString(ini_title, "FDDStatWin", makeBOOL((BYTE)Config.WindowFDDStat), winx68k_ini); + WritePrivateProfileString(ini_title, "FDDStatFullScr", makeBOOL((BYTE)Config.FullScrFDDStat), winx68k_ini); + + WritePrivateProfileString(ini_title, "DSAlert", makeBOOL((BYTE)Config.DSAlert), winx68k_ini); + WritePrivateProfileString(ini_title, "SoundLPF", makeBOOL((BYTE)Config.Sound_LPF), winx68k_ini); + WritePrivateProfileString(ini_title, "UseRomeo", makeBOOL((BYTE)Config.SoundROMEO), winx68k_ini); + WritePrivateProfileString(ini_title, "MIDI_SW", makeBOOL((BYTE)Config.MIDI_SW), winx68k_ini); + WritePrivateProfileString(ini_title, "MIDI_Reset", makeBOOL((BYTE)Config.MIDI_Reset), winx68k_ini); + wsprintf(buf, "%d", Config.MIDI_Type); + WritePrivateProfileString(ini_title, "MIDI_Type", buf, winx68k_ini); + + WritePrivateProfileString(ini_title, "JoySwap", makeBOOL((BYTE)Config.JoySwap), winx68k_ini); + + WritePrivateProfileString(ini_title, "JoyKey", makeBOOL((BYTE)Config.JoyKey), winx68k_ini); + WritePrivateProfileString(ini_title, "JoyKeyReverse", makeBOOL((BYTE)Config.JoyKeyReverse), winx68k_ini); + WritePrivateProfileString(ini_title, "JoyKeyJoy2", makeBOOL((BYTE)Config.JoyKeyJoy2), winx68k_ini); + WritePrivateProfileString(ini_title, "SRAMBootWarning", makeBOOL((BYTE)Config.SRAMWarning), winx68k_ini); + + WritePrivateProfileString(ini_title, "WinDrvLFN", makeBOOL((BYTE)Config.LongFileName), winx68k_ini); + WritePrivateProfileString(ini_title, "WinDrvFDD", makeBOOL((BYTE)Config.WinDrvFD), winx68k_ini); + + wsprintf(buf, "%d", Config.WinStrech); + WritePrivateProfileString(ini_title, "WinStretch", buf, winx68k_ini); + + WritePrivateProfileString(ini_title, "DSMixing", makeBOOL((BYTE)Config.DSMixing), winx68k_ini); + + wsprintf(buf, "%d", Config.XVIMode); + WritePrivateProfileString(ini_title, "XVIMode", buf, winx68k_ini); + + WritePrivateProfileString(ini_title, "CDROM_ASPI", makeBOOL((BYTE)Config.CDROM_ASPI), winx68k_ini); + wsprintf(buf, "%d", Config.CDROM_SCSIID); + WritePrivateProfileString(ini_title, "CDROM_SCSIID", buf, winx68k_ini); + wsprintf(buf, "%d", Config.CDROM_ASPI_Drive); + WritePrivateProfileString(ini_title, "CDROM_ASPIDrv", buf, winx68k_ini); + wsprintf(buf, "%d", Config.CDROM_IOCTRL_Drive); + WritePrivateProfileString(ini_title, "CDROM_CTRLDrv", buf, winx68k_ini); + WritePrivateProfileString(ini_title, "CDROM_Enable", makeBOOL((BYTE)Config.CDROM_Enable), winx68k_ini); + + WritePrivateProfileString(ini_title, "SSTP_Enable", makeBOOL((BYTE)Config.SSTP_Enable), winx68k_ini); + wsprintf(buf, "%d", Config.SSTP_Port); + WritePrivateProfileString(ini_title, "SSTP_Port", buf, winx68k_ini); + + WritePrivateProfileString(ini_title, "ToneMapping", makeBOOL((BYTE)Config.ToneMap), winx68k_ini); + WritePrivateProfileString(ini_title, "ToneMapFile", Config.ToneMapFile, winx68k_ini); + + wsprintf(buf, "%d", Config.MIDIDelay); + WritePrivateProfileString(ini_title, "MIDIDelay", buf, winx68k_ini); + WritePrivateProfileString(ini_title, "MIDIAutoDelay", makeBOOL((BYTE)Config.MIDIAutoDelay), winx68k_ini); + + wsprintf(buf, "%d", Config.VkeyScale); + WritePrivateProfileString(ini_title, "VkeyScale", buf, winx68k_ini); + + wsprintf(buf, "%d", Config.VbtnSwap); + WritePrivateProfileString(ini_title, "VbtnSwap", buf, winx68k_ini); + + wsprintf(buf, "%d", Config.JoyOrMouse); + WritePrivateProfileString(ini_title, "JoyOrMouse", buf, winx68k_ini); + + wsprintf(buf, "%d", Config.HwJoyAxis[0]); + WritePrivateProfileString(ini_title, "HwJoyAxis0", buf, winx68k_ini); + + wsprintf(buf, "%d", Config.HwJoyAxis[1]); + WritePrivateProfileString(ini_title, "HwJoyAxis1", buf, winx68k_ini); + + wsprintf(buf, "%d", Config.HwJoyHat); + WritePrivateProfileString(ini_title, "HwJoyHat", buf, winx68k_ini); + + for (i = 0; i < 8; i++) { + sprintf(buf, "HwJoyBtn%d", i); + sprintf(buf2, "%d", Config.HwJoyBtn[i]); + WritePrivateProfileString(ini_title, buf, buf2, winx68k_ini); + } + + wsprintf(buf, "%d", Config.NoWaitMode); + WritePrivateProfileString(ini_title, "NoWaitMode", buf, winx68k_ini); + + for (i=0; i<2; i++) + { + for (j=0; j<8; j++) + { + sprintf(buf, "Joy%dButton%d", i+1, j+1); + wsprintf(buf2, "%d", Config.JOY_BTN[i][j]); + WritePrivateProfileString(ini_title, buf, buf2, winx68k_ini); + } + } + + for (i = 0; i < 2; i++) + { + printf("i: %d", i); + sprintf(buf, "FDD%d", i); + WritePrivateProfileString(ini_title, buf, Config.FDDImage[i], winx68k_ini); + } + + for (i=0; i<16; i++) + { + sprintf(buf, "HDD%d", i); + WritePrivateProfileString(ini_title, buf, Config.HDImage[i], winx68k_ini); + } + +#if 0 + fp = File_OpenCurDir(KEYCONFFILE); + if (!fp) + fp = File_CreateCurDir(KEYCONFFILE, FTYPE_TEXT); + if (fp) + { + File_Write(fp, KeyTable, 512); + File_Close(fp); + } +#endif +} + + +/* --------------- */ + +#if 0 +typedef struct { + GtkWidget *fs; + int type; + void *arg; +} file_selection_t; + +static void file_selection_ok(GtkWidget *w, GtkFileSelection *gfs); +static void file_selection_destroy(GtkWidget *w, GtkWidget **wp); +static void file_selection(int type, char *title, char *defstr, void *arg); + +static Win68Conf ConfigProp; + +static GtkWidget *create_sound_note(void); +static GtkWidget *create_midi_note(void); +static GtkWidget *create_mouse_note(void); +static GtkWidget *create_others_note(void); + +static void +dialog_destroy(GtkWidget *w, GtkWidget **wp) +{ + + UNUSED(wp); + + gtk_widget_destroy(w); + install_idle_process(); +} + +/* + * Config dialog + */ +static void config_ok_button_clicked(GtkButton *b, gpointer d); +static void config_accept_button_clicked(GtkButton *b, gpointer d); + +void +PropPage_Init(void) +{ + GtkWidget *dialog; + GtkWidget *dialog_table; + GtkWidget *notebook; + GtkWidget *note; + GtkWidget *ok_button; + GtkWidget *cancel_button; + GtkWidget *accept_button; + + uninstall_idle_process(); + + ConfigProp = Config; + + dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(dialog), "Configure Keropi"); + gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); + gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); + gtk_signal_connect(GTK_OBJECT(dialog), "destroy", + GTK_SIGNAL_FUNC(dialog_destroy), NULL); + + dialog_table = gtk_table_new(10, 4, FALSE); + gtk_container_add(GTK_CONTAINER(dialog), dialog_table); + gtk_widget_show(dialog_table); + + /* notebook */ + notebook = gtk_notebook_new(); + gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); + gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); + gtk_table_attach_defaults(GTK_TABLE(dialog_table),notebook, 0, 4, 0, 9); + gtk_widget_show(notebook); + + /* Sound note */ + note = create_sound_note(); + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), note, + gtk_label_new("Sound")); + gtk_widget_show(note); + + /* MIDI note */ + note = create_midi_note(); + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), note, + gtk_label_new("MIDI")); + gtk_widget_show(note); + + /* Keyboard note */ + /* Joystick1 note */ + /* Joystick2 note */ + + /* Mouse note */ + note = create_mouse_note(); + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), note, + gtk_label_new("Mouse")); + gtk_widget_show(note); + + /* SCSI note */ + + /* Others note */ + note = create_others_note(); + gtk_notebook_append_page(GTK_NOTEBOOK(notebook), note, + gtk_label_new("Others")); + gtk_widget_show(note); + + /* ページ下部ボタン */ + ok_button = gtk_button_new_with_label("OK"); + gtk_table_attach_defaults(GTK_TABLE(dialog_table), ok_button, + 1, 2, 9, 10); + gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", + GTK_SIGNAL_FUNC(config_ok_button_clicked), dialog); + GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); + GTK_WIDGET_SET_FLAGS(ok_button, GTK_HAS_DEFAULT); + gtk_widget_grab_default(ok_button); + gtk_widget_show(ok_button); + + cancel_button = gtk_button_new_with_label("Cancel"); + gtk_container_set_border_width(GTK_CONTAINER(cancel_button), 5); + gtk_table_attach_defaults(GTK_TABLE(dialog_table), cancel_button, + 2, 3, 9, 10); + gtk_signal_connect_object(GTK_OBJECT(cancel_button), "clicked", + GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dialog)); + gtk_widget_show(cancel_button); + + accept_button = gtk_button_new_with_label("Accept"); + gtk_container_set_border_width(GTK_CONTAINER(accept_button), 5); + gtk_table_attach_defaults(GTK_TABLE(dialog_table), accept_button, + 3, 4, 9, 10); + gtk_signal_connect(GTK_OBJECT(accept_button), "clicked", + GTK_SIGNAL_FUNC(config_accept_button_clicked), dialog); + gtk_widget_show(accept_button); + + gtk_widget_show(dialog); +} + +static void +config_ok_button_clicked(GtkButton *b, gpointer d) +{ + + (void)b; + + Config = ConfigProp; + gtk_widget_destroy(GTK_WIDGET(d)); +} + +static void +config_accept_button_clicked(GtkButton *b, gpointer d) +{ + + (void)b; + (void)d; + + Config = ConfigProp; +} + +/* + * Sound note + */ +static void sample_rate_button_clicked(GtkButton *b, gpointer d); +static void adpcm_lpf_button_clicked(GtkButton *b, gpointer d); +static void vol_adj_value_changed(GtkAdjustment *adj, gpointer d); + +static const struct { + const char *str; + DWORD rate; +} sample_rate[] = { + { "No Sound", 0 }, + { "11kHz", 11025 }, + { "22kHz", 22050 }, + { "44kHz", 44100 }, + { "48kHz", 48000 }, +}; + +static const struct { + const char *name; + gfloat value; + gfloat min; + gfloat max; + size_t offset; +} sound_right_frame[] = { + { "Buffer size", 500.0, 20.0,1000.0, offsetof(Win68Conf,BufferSize) }, + { "ADPCM volume", 15.0, 0.0, 16.0, offsetof(Win68Conf,PCM_VOL) }, + { "OPM volume", 12.0, 0.0, 16.0, offsetof(Win68Conf,OPM_VOL) }, + { "Mercury volume", 13.0, 0.0, 16.0, offsetof(Win68Conf,MCR_VOL) }, +}; + +static GtkWidget * +create_sound_note(void) +{ + GtkWidget *main_vbox; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *frame; + GtkWidget *button[NELEMENTS(sample_rate)]; + GSList *gslist; + int i; + + main_vbox = gtk_vbox_new(FALSE, 2); + + hbox = gtk_hbox_new(FALSE, 2); + gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 10); + gtk_widget_show(hbox); + + frame = gtk_frame_new("Sample rate"); + gtk_container_set_border_width(GTK_CONTAINER(frame), 5); + gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0); + gtk_widget_show(frame); + + vbox = gtk_vbox_new(FALSE, 5); + gtk_container_add(GTK_CONTAINER(frame), vbox); + gtk_widget_show(vbox); + + /* Sample rate */ + for (gslist = 0, i = 0; i < NELEMENTS(sample_rate); ++i) { + button[i] = gtk_radio_button_new_with_label(gslist, + sample_rate[i].str); + GTK_WIDGET_UNSET_FLAGS(button[i], GTK_CAN_FOCUS); + gslist = gtk_radio_button_group(GTK_RADIO_BUTTON(button[i])); + gtk_box_pack_start(GTK_BOX(vbox), button[i], FALSE, FALSE, 0); + gtk_signal_connect(GTK_OBJECT(button[i]), "clicked", + GTK_SIGNAL_FUNC(sample_rate_button_clicked), + (gpointer)sample_rate[i].rate); + gtk_widget_show(button[i]); + } + for (i = 0; i < NELEMENTS(sample_rate); ++i) { + if (sample_rate[i].rate == Config.SampleRate) + break; + } + if (i == NELEMENTS(sample_rate)) + i = 0; + gtk_signal_emit_by_name(GTK_OBJECT(button[i]), "clicked"); + + vbox = gtk_vbox_new(FALSE, 4); + gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 10); + gtk_widget_show(vbox); + + for (i = 0; i < NELEMENTS(sound_right_frame); ++i) { + GtkObject *adjust; + GtkWidget *hscale; + GtkWidget *align; + + frame = gtk_frame_new(sound_right_frame[i].name); + gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); + gtk_widget_show(frame); + + align = gtk_alignment_new(0.5, 0.5, 0.9, 0.9); + gtk_container_add(GTK_CONTAINER(frame), align); + gtk_widget_show(align); + + adjust = gtk_adjustment_new(sound_right_frame[i].value, + sound_right_frame[i].min, sound_right_frame[i].max, + 1.0, 0.0, 0.0); + hscale = gtk_hscale_new(GTK_ADJUSTMENT(adjust)); + gtk_scale_set_value_pos(GTK_SCALE(hscale), GTK_POS_RIGHT); + gtk_scale_set_digits(GTK_SCALE(hscale), 0); + gtk_container_add(GTK_CONTAINER(align), hscale); + gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", + GTK_SIGNAL_FUNC(vol_adj_value_changed),(gpointer)i); + gtk_widget_show(hscale); + if (i == 0) + gtk_adjustment_set_value(GTK_ADJUSTMENT(adjust), + Config.BufferSize); + else { + int *p = (int *)(((char *)&Config) + sound_right_frame[i].offset); + gtk_adjustment_set_value(GTK_ADJUSTMENT(adjust), *p); + } + } + + button[0] = gtk_check_button_new_with_label("Enable ADPCM LPF"); + gtk_container_set_border_width(GTK_CONTAINER(button[0]), 5); + gtk_box_pack_start(GTK_BOX(main_vbox), button[0], TRUE, TRUE, 0); + gtk_signal_connect(GTK_OBJECT(button[0]), "clicked", + GTK_SIGNAL_FUNC(adpcm_lpf_button_clicked), 0); + gtk_widget_show(button[0]); + if (Config.Sound_LPF) + gtk_signal_emit_by_name(GTK_OBJECT(button[0]), "clicked"); + + return main_vbox; +} + +static void +sample_rate_button_clicked(GtkButton *b, gpointer d) +{ + + UNUSED(b); + + ConfigProp.SampleRate = (DWORD)((long)d); +} + +static void +adpcm_lpf_button_clicked(GtkButton *b, gpointer d) +{ + + UNUSED(d); + + ConfigProp.Sound_LPF = GTK_TOGGLE_BUTTON(b)->active; +} + +static void +vol_adj_value_changed(GtkAdjustment *adj, gpointer d) +{ + int val = (int)(GTK_ADJUSTMENT(adj)->value); + int idx = (int)(long)d; + size_t offset = sound_right_frame[idx].offset; + + if (idx == 0) + ConfigProp.BufferSize = (DWORD)val; + else { + int *p = (int *)(((char *)&ConfigProp) + offset); + *p = val; + } +} + +/* + * Midi note + */ +static void midi_enable_button_clicked(GtkButton *b, gpointer d); +static void midi_send_reset_button_clicked(GtkButton *b, gpointer d); +static void midi_mimpi_browse_button_clicked(GtkButton *b, gpointer d); +static void midi_mimpi_button_clicked(GtkButton *b, gpointer d); +static void midi_init_entry_changed(GtkEditable *e, gpointer d); + +typedef struct { + GtkWidget *init_combo; + GtkWidget *init_label; + GtkWidget *reset_button; + GtkWidget *mimpi_button; + GtkWidget *mimpi_entry; + GtkWidget *mimpi_browse_button; +} midi_init_item_t; + +static GtkWidget * +create_midi_note(void) +{ + GtkWidget *vbox; + GtkWidget *button; + GtkWidget *enable_button; + GtkWidget *mimpi_button; + GtkWidget *label; + GtkWidget *combo; + GtkWidget *entry; + GtkWidget *hbox; + static midi_init_item_t mii; + GList *items; + int i; + + vbox = gtk_vbox_new(FALSE, 4); + + hbox = gtk_hbox_new(FALSE, 3); + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show(hbox); + + enable_button = gtk_check_button_new_with_label( + "Enable MIDI"); + gtk_container_set_border_width(GTK_CONTAINER(enable_button), 5); + gtk_box_pack_start(GTK_BOX(hbox), enable_button, FALSE, FALSE, 0); + gtk_widget_show(enable_button); + + mii.init_combo = combo = gtk_combo_new(); + gtk_container_set_border_width(GTK_CONTAINER(combo), 5); + gtk_combo_set_value_in_list(GTK_COMBO(combo), TRUE, TRUE); + gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE); + for (items = 0, i = 0; i < NELEMENTS(MIDI_TYPE_NAME); ++i) + items = g_list_append(items, (gpointer)MIDI_TYPE_NAME[i]); + gtk_combo_set_popdown_strings(GTK_COMBO(combo), items); + g_list_free(items); + gtk_box_pack_end(GTK_BOX(hbox), combo, FALSE, FALSE, 0); + gtk_widget_show(combo); + + entry = GTK_COMBO(combo)->entry; + gtk_entry_set_editable(GTK_ENTRY(entry), FALSE); + gtk_signal_connect(GTK_OBJECT(entry), "changed", + GTK_SIGNAL_FUNC(midi_init_entry_changed), 0); + gtk_widget_show(entry); + + mii.init_label = label = gtk_label_new( + "- MIDI initialized method:"); + gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 0); + gtk_widget_show(label); + + mii.reset_button = button = gtk_check_button_new_with_label( + "Send initialize command when X68k is reseted"); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(midi_send_reset_button_clicked), 0); + gtk_widget_show(button); + if (Config.MIDI_Reset) + gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked"); + + mii.mimpi_button = mimpi_button = gtk_check_button_new_with_label( + "Use MIMPI tone map"); + gtk_container_set_border_width(GTK_CONTAINER(mimpi_button), 5); + gtk_box_pack_start(GTK_BOX(vbox), mimpi_button, FALSE, FALSE, 0); + gtk_widget_show(mimpi_button); + + hbox = gtk_hbox_new(FALSE, 5); + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show(hbox); + + mii.mimpi_entry = entry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_PATH - 1); + gtk_entry_set_editable(GTK_ENTRY(entry), FALSE); + gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 10); + gtk_widget_show(entry); + + mii.mimpi_browse_button = button = gtk_button_new_with_label( + "Browse..."); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(midi_mimpi_browse_button_clicked), + (gpointer)&mii); + gtk_widget_show(button); + + /* MIMPI ToneMap */ + gtk_signal_connect(GTK_OBJECT(mimpi_button), "clicked", + GTK_SIGNAL_FUNC(midi_mimpi_button_clicked), + (gpointer)&mii); + if (!Config.ToneMap) + gtk_signal_emit_by_name(GTK_OBJECT(mimpi_button), "clicked"); + gtk_signal_emit_by_name(GTK_OBJECT(mimpi_button), "clicked"); + + /* Enable MIDI */ + gtk_signal_connect(GTK_OBJECT(enable_button), "clicked", + GTK_SIGNAL_FUNC(midi_enable_button_clicked), + (gpointer)&mii); + if (!Config.MIDI_SW) + gtk_signal_emit_by_name(GTK_OBJECT(enable_button), "clicked"); + gtk_signal_emit_by_name(GTK_OBJECT(enable_button), "clicked"); + + return vbox; +} + +static void +midi_enable_button_clicked(GtkButton *b, gpointer d) +{ + midi_init_item_t *mii = (midi_init_item_t *)d; + + ConfigProp.MIDI_SW = GTK_TOGGLE_BUTTON(b)->active; + + if (ConfigProp.MIDI_SW) { + gtk_widget_set_sensitive(mii->init_combo, TRUE); + gtk_widget_set_sensitive(mii->init_label, TRUE); + gtk_widget_set_sensitive(mii->reset_button, TRUE); + gtk_widget_set_sensitive(mii->mimpi_button, TRUE); + if (ConfigProp.ToneMap) { + gtk_widget_set_sensitive(mii->mimpi_entry, TRUE); + gtk_widget_set_sensitive(mii->mimpi_browse_button,TRUE); + } + } else { + gtk_widget_set_sensitive(mii->init_combo, FALSE); + gtk_widget_set_sensitive(mii->init_label, FALSE); + gtk_widget_set_sensitive(mii->reset_button, FALSE); + gtk_widget_set_sensitive(mii->mimpi_button, FALSE); + gtk_widget_set_sensitive(mii->mimpi_entry, FALSE); + gtk_widget_set_sensitive(mii->mimpi_browse_button, FALSE); + } +} + +static void +midi_send_reset_button_clicked(GtkButton *b, gpointer d) +{ + + UNUSED(d); + + ConfigProp.MIDI_Reset = GTK_TOGGLE_BUTTON(b)->active; +} + +static void +midi_mimpi_browse_button_clicked(GtkButton *b, gpointer d) +{ + midi_init_item_t *mii = (midi_init_item_t *)d; + gchar *path = gtk_entry_get_text(GTK_ENTRY(mii->mimpi_entry)); + + UNUSED(b); + + file_selection(1, "MIMPI tone map", path, mii->mimpi_entry); +} + +static void +midi_mimpi_button_clicked(GtkButton *b, gpointer d) +{ + midi_init_item_t *mii = (midi_init_item_t *)d; + + ConfigProp.ToneMap = GTK_TOGGLE_BUTTON(b)->active; + if (ConfigProp.ToneMap) { + gtk_widget_set_sensitive(mii->mimpi_entry, TRUE); + gtk_widget_set_sensitive(mii->mimpi_browse_button, TRUE); + } else { + gtk_widget_set_sensitive(mii->mimpi_entry, FALSE); + gtk_widget_set_sensitive(mii->mimpi_browse_button, FALSE); + } +} + +static void +midi_init_entry_changed(GtkEditable *e, gpointer d) +{ + gchar *str; + int i; + + UNUSED(d); + + str = gtk_editable_get_chars(GTK_EDITABLE(e), 0, -1); + for (i = 0; i < NELEMENTS(MIDI_TYPE_NAME); ++i) { + if (strcmp(MIDI_TYPE_NAME[i], str) == 0) { + ConfigProp.MIDI_Type = i; + break; + } + } + g_free(str); +} + +/* + * Mouse note + */ +static void mouse_speed_rate_value_changed(GtkAdjustment *adj, gpointer d); + +static GtkWidget * +create_mouse_note(void) +{ + GtkWidget *w; + GtkWidget *frame; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *align; + GtkWidget *hscale; + GtkWidget *label; + GtkObject *adjust; + + w = gtk_vbox_new(FALSE, 1); + + frame = gtk_frame_new("Mouse speed"); + gtk_box_pack_start(GTK_BOX(w), frame, FALSE, FALSE, 0); + gtk_widget_show(frame); + + align = gtk_alignment_new(0.5, 0.5, 0.9, 0.9); + gtk_container_add(GTK_CONTAINER(frame), align); + gtk_widget_show(align); + + vbox = gtk_vbox_new(FALSE, 2); + gtk_container_add(GTK_CONTAINER(align), vbox); + gtk_widget_show(vbox); + + adjust = gtk_adjustment_new(10.0, 1.0, 20.0, 1.0, 1.0, 0.0); + hscale = gtk_hscale_new(GTK_ADJUSTMENT(adjust)); + gtk_scale_set_draw_value(GTK_SCALE(hscale), FALSE); + gtk_box_pack_start(GTK_BOX(vbox), hscale, TRUE, TRUE, 0); + gtk_widget_show(hscale); + + hbox = gtk_hbox_new(TRUE, 3); + gtk_box_pack_end(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); + gtk_widget_show(hbox); + + label = gtk_label_new("x0.1"); + gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); + gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); + gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); + gtk_widget_show(label); + + label = gtk_label_new("x1.0"); + gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER); + gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.0); + gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); + gtk_widget_show(label); + + label = gtk_label_new("x2.0"); + gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); + gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.0); + gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); + gtk_widget_show(label); + + /* Mouse speed rate */ + gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", + GTK_SIGNAL_FUNC(mouse_speed_rate_value_changed), 0); + gtk_adjustment_set_value(GTK_ADJUSTMENT(adjust), + (gfloat)Config.MouseSpeed); + + return w; +} + +static void +mouse_speed_rate_value_changed(GtkAdjustment *adj, gpointer d) +{ + + UNUSED(d); + + ConfigProp.MouseSpeed = (int)adj->value; + if (ConfigProp.MouseSpeed < 1) + ConfigProp.MouseSpeed = 1; + if (ConfigProp.MouseSpeed > 20) + ConfigProp.MouseSpeed = 20; +} + +/* + * Others note + */ +static void others_sasi_hdd_index_entry_changed(GtkEditable *e, gpointer d); +static void others_sasi_hdd_new_button_clicked(GtkButton *b, gpointer d); +static void others_sasi_hdd_remove_button_clicked(GtkButton *b, gpointer d); +static void others_sasi_hdd_browse_button_clicked(GtkButton *b, gpointer d); +static void others_show_fdd_status_button_clicked(GtkButton *b, gpointer d); +static void others_enable_virus_button_clicked(GtkButton *b, gpointer d); + +typedef struct { + int idx; + GtkWidget *entry; +} sasi_hdd_t; + +static GtkWidget * +create_others_note(void) +{ + static const char *sasi_drive_str[16] = { + "0", "1", "2", "3", "4", "5", "6", "7", "8", + "9", "10", "11", "12", "13", "14", "15", + }; + static sasi_hdd_t sasi_hdd = { 0, 0 }; + + GtkWidget *w; + GtkWidget *frame; + GtkWidget *align; + GtkWidget *table; + GtkWidget *label; + GtkWidget *combo; + GtkWidget *entry; + GtkWidget *button; + GList *items; + int i; + + w = gtk_vbox_new(FALSE, 3); + + frame = gtk_frame_new("HDD (SASI) Drive"); + gtk_box_pack_start(GTK_BOX(w), frame, FALSE, FALSE, 0); + gtk_widget_show(frame); + + align = gtk_alignment_new(0.5, 0.5, 0.9, 0.9); + gtk_container_add(GTK_CONTAINER(frame), align); + gtk_widget_show(align); + + table = gtk_table_new(2, 5, FALSE); + gtk_container_add(GTK_CONTAINER(align), table); + gtk_widget_show(table); + + label = gtk_label_new("Drive #:"); + gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); + gtk_widget_show(label); + + combo = gtk_combo_new(); + gtk_combo_set_value_in_list(GTK_COMBO(combo), TRUE, TRUE); + gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE); + for (items = 0, i = 0; i < NELEMENTS(sasi_drive_str); ++i) + items = g_list_append(items, (gpointer)sasi_drive_str[i]); + gtk_combo_set_popdown_strings(GTK_COMBO(combo), items); + g_list_free(items); + gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 2, 0, 1); + gtk_widget_show(combo); + + entry = GTK_COMBO(combo)->entry; + gtk_entry_set_editable(GTK_ENTRY(entry), FALSE); + gtk_signal_connect(GTK_OBJECT(entry), "changed", + GTK_SIGNAL_FUNC(others_sasi_hdd_index_entry_changed), + &sasi_hdd); + gtk_widget_show(entry); + + button = gtk_button_new_with_label("Remove"); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 0, 1); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(others_sasi_hdd_remove_button_clicked), + &sasi_hdd); + gtk_widget_show(button); + + button = gtk_button_new_with_label("New"); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 0, 1); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(others_sasi_hdd_new_button_clicked), + &sasi_hdd); +#if 1 + gtk_widget_set_sensitive(button, FALSE); +#endif + gtk_widget_show(button); + + label = gtk_label_new("Filename:"); + gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); + gtk_widget_show(label); + + sasi_hdd.entry = entry = gtk_entry_new(); + gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_PATH - 1); + gtk_entry_set_editable(GTK_ENTRY(entry), FALSE); + gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 4, 1, 2); + gtk_widget_show(entry); + gtk_entry_set_text(GTK_ENTRY(entry), Config.HDImage[0]); + + button = gtk_button_new_with_label("Browse..."); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 1, 2); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(others_sasi_hdd_browse_button_clicked), + &sasi_hdd); + gtk_widget_show(button); + + button = gtk_check_button_new_with_label("Show FDD status"); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_box_pack_start(GTK_BOX(w), button, FALSE, FALSE, 0); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(others_show_fdd_status_button_clicked), 0); +#if 1 + gtk_widget_set_sensitive(button, FALSE); +#else + if (Config.WindowFDDStat) + gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked"); +#endif + gtk_widget_show(button); + + button = gtk_check_button_new_with_label("Enable SRAM virus warning"); + gtk_container_set_border_width(GTK_CONTAINER(button), 5); + gtk_box_pack_start(GTK_BOX(w), button, FALSE, FALSE, 0); + gtk_signal_connect(GTK_OBJECT(button), "clicked", + GTK_SIGNAL_FUNC(others_enable_virus_button_clicked), 0); + if (Config.SRAMWarning) + gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked"); + gtk_widget_show(button); + + return w; +} + +static void +others_sasi_hdd_index_entry_changed(GtkEditable *e, gpointer d) +{ + sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)d; + char *str; + char *ep; + + str = gtk_editable_get_chars(GTK_EDITABLE(e), 0, -1); + if (str) { + unsigned long val; + + errno = 0; + val = strtoul(str, &ep, 10); + /* Not a number */ + if (str[0] == '\0' || *ep != '\0') + val = 0; + /* Out of range */ + if (errno == ERANGE && val == ULONG_MAX) + val = 0; + sasi_hdd->idx = (int)val; + + if (sasi_hdd->idx >= 0 && sasi_hdd->idx < 16) { + gtk_entry_set_text(GTK_ENTRY(sasi_hdd->entry), + ConfigProp.HDImage[sasi_hdd->idx]); + } + } +} + +static void +others_sasi_hdd_new_button_clicked(GtkButton *b, gpointer d) +{ + sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)d; + gchar *path = gtk_entry_get_text(GTK_ENTRY(sasi_hdd->entry)); + + UNUSED(b); + + file_selection(3, "Create SASI HDD", path, d); +} + +static void +others_sasi_hdd_remove_button_clicked(GtkButton *b, gpointer d) +{ + sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)d; + + UNUSED(b); + + bzero(ConfigProp.HDImage[sasi_hdd->idx], sizeof(ConfigProp.HDImage)); + gtk_entry_set_text(GTK_ENTRY(sasi_hdd->entry), ConfigProp.HDImage[sasi_hdd->idx]); +} + +static void +others_sasi_hdd_browse_button_clicked(GtkButton *b, gpointer d) +{ + sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)d; + gchar *path = gtk_entry_get_text(GTK_ENTRY(sasi_hdd->entry)); + + UNUSED(b); + + file_selection(2, "SASI HDD", path, d); +} + +static void +others_show_fdd_status_button_clicked(GtkButton *b, gpointer d) +{ + + UNUSED(d); + + ConfigProp.WindowFDDStat = GTK_TOGGLE_BUTTON(b)->active; +} + +static void +others_enable_virus_button_clicked(GtkButton *b, gpointer d) +{ + + UNUSED(d); + + ConfigProp.SRAMWarning = GTK_TOGGLE_BUTTON(b)->active; +} + +/* + * ---------- file selection + */ + +static void +file_selection_ok(GtkWidget *w, GtkFileSelection *gfs) +{ + file_selection_t *fsp = (file_selection_t *)gfs; + GtkFileSelection *fs = (GtkFileSelection *)fsp->fs; + char *p; + + UNUSED(w); + + p = (char *)gtk_file_selection_get_filename(fs); + if (p) { + struct stat st; + + if (stat(p, &st) == 0) { + if (!S_ISDIR(st.st_mode)) { + switch (fsp->type) { + case 1: // open MIMPI tone map + gtk_entry_set_text(GTK_ENTRY(fsp->arg), p); + strncpy(ConfigProp.ToneMapFile, p, sizeof(ConfigProp.ToneMapFile)); + break; + + case 2: // open SASI HDD + { + sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)fsp->arg; + strncpy(ConfigProp.HDImage[sasi_hdd->idx], p, sizeof(ConfigProp.HDImage[0])); + gtk_entry_set_text(GTK_ENTRY(sasi_hdd->entry), p); + } + break; + } + } + } else if (errno == ENOENT) { + switch (fsp->type) { + case 3: // create SASI HDD image + { + sasi_hdd_t *sasi_hdd = (sasi_hdd_t *)fsp->arg; + char buf[0x1000]; + FILEH *fh; + int i; + + fh = File_Create(p, FTYPE_NONE); + if (fh == INVALID_HANDLE_VALUE) + break; + + bzero(buf, sizeof(buf)); + for (i = 0; i < 0x2793 /* 40Mb/0x1000 */; ++i) + File_Write(fh, buf, 0x1000); + File_Close(fh); + + strncpy(ConfigProp.HDImage[sasi_hdd->idx], p, sizeof(ConfigProp.HDImage[0])); + gtk_entry_set_text(GTK_ENTRY(sasi_hdd->entry), p); + } + break; + } + } + } + gtk_widget_destroy(GTK_WIDGET(fs)); +} + +static void +file_selection_destroy(GtkWidget *w, GtkWidget **wp) +{ + file_selection_t *fsp = (file_selection_t *)wp; + + free(fsp); + gtk_widget_destroy(w); +} + +static void +file_selection(int type, char *title, char *defstr, void *arg) +{ + GtkWidget *file_dialog; + file_selection_t *fsp; + + fsp = malloc(sizeof(*fsp)); + if (fsp == 0) { + printf("file_selection: Can't alloc memory (size = %d)\n", + sizeof(*fsp)); + return; + } + bzero(fsp, sizeof(*fsp)); + + file_dialog = gtk_file_selection_new(title); + if (defstr) { + gtk_file_selection_set_filename( + GTK_FILE_SELECTION(file_dialog), defstr); + } + + fsp->fs = file_dialog; + fsp->type = type; + fsp->arg = arg; + + gtk_window_set_position(GTK_WINDOW(file_dialog), GTK_WIN_POS_CENTER); + gtk_window_set_modal(GTK_WINDOW(file_dialog), TRUE); + gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(file_dialog)); + gtk_signal_connect(GTK_OBJECT(file_dialog), "destroy", + GTK_SIGNAL_FUNC(file_selection_destroy), fsp); + gtk_signal_connect_object( + GTK_OBJECT(GTK_FILE_SELECTION(file_dialog)->cancel_button), + "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), + GTK_OBJECT(file_dialog)); + gtk_signal_connect( + GTK_OBJECT(GTK_FILE_SELECTION(file_dialog)->ok_button), + "clicked", GTK_SIGNAL_FUNC(file_selection_ok), fsp); + + gtk_widget_show(file_dialog); +} +#endif diff --git a/libretro/prop.h b/libretro/prop.h new file mode 100644 index 0000000..8addb00 --- /dev/null +++ b/libretro/prop.h @@ -0,0 +1,66 @@ +#ifndef _winx68k_config +#define _winx68k_config + +#include "common.h" + +typedef struct +{ + DWORD SampleRate; + DWORD BufferSize; + int WinPosX; + int WinPosY; + int OPM_VOL; + int PCM_VOL; + int MCR_VOL; + int JOY_BTN[2][8]; + int MouseSpeed; + int WindowFDDStat; + int FullScrFDDStat; + int DSAlert; + int MIDI_SW; + int MIDI_Type; + int MIDI_Reset; + int JoyKey; + int JoyKeyReverse; + int JoyKeyJoy2; + int SRAMWarning; + char HDImage[16][MAX_PATH]; + int ToneMap; + char ToneMapFile[MAX_PATH]; + int XVIMode; + int JoySwap; + int LongFileName; + int WinDrvFD; + int WinStrech; + int DSMixing; + int CDROM_ASPI; + int CDROM_ASPI_Drive; + int CDROM_IOCTRL_Drive; + int CDROM_SCSIID; + int CDROM_Enable; + int SSTP_Enable; + int SSTP_Port; + int Sound_LPF; + int SoundROMEO; + int MIDIDelay; + int MIDIAutoDelay; + char FDDImage[2][MAX_PATH]; + int VkeyScale; + int VbtnSwap; + int JoyOrMouse; + int HwJoyAxis[2]; + int HwJoyHat; + int HwJoyBtn[8]; + int NoWaitMode; + BYTE FrameRate; +} Win68Conf; + +extern Win68Conf Config; + +void LoadConfig(void); +void SaveConfig(void); +void PropPage_Init(void); + +int set_modulepath(char *path, size_t len); + +#endif //_winx68k_config diff --git a/libretro/status.c b/libretro/status.c new file mode 100644 index 0000000..b2fb88c --- /dev/null +++ b/libretro/status.c @@ -0,0 +1,344 @@ +/* $Id: status.c,v 1.3 2008/11/08 01:42:42 nonaka Exp $ */ + +/* + * Copyright (c) 2003 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#if 0 +/* -------------------------------------------------------------------------- * + * FDD状態表示用ステータスバー * + * -------------------------------------------------------------------------- */ + +#include "common.h" +#include "windraw.h" +#include "winx68k.h" +#include "prop.h" +#include "status.h" +#include "fileio.h" +#include "fdd.h" + +#if 0 +#include "../icons/fd_inserted.xpm" +#include "../icons/fd_inuse.xpm" +#include "../icons/fd_normal.xpm" +#include "../icons/fd_protected.xpm" +#include "../icons/hd_inserted.xpm" +#include "../icons/hd_inuse.xpm" +#include "../icons/hd_normal.xpm" +#include "../icons/nulldev.xpm" + +static char **pixmaps[] = { + fd_normal, + fd_inuse, + fd_inserted, + fd_protected, + hd_normal, + hd_inuse, + hd_inserted, + nulldev, +}; +#endif + +//static GtkWidget *statbar; +//static GtkWidget *devstat[2 /* FDD */ + 1 /* SASI */]; +//static GtkWidget *devlabel[2 /* FDD */ + 1 /* SASI */]; +//static GdkPixmap *devstat_pixmap[2 /* FDD */ + 1 /* SASI */]; +//static GdkPixmap *dev_pixmap[NELEMENTS(pixmaps)]; + +typedef struct { + int insert; + int access; + int blink; + int timer; + char file[MAX_PATH]; +} FDDLED; + +static FDDLED FddLed[2]; +//static int HddLed = 0, HddLedTmp = 0; + +#if 0 +/* ----- GTK signal handler */ +static gint +expose(GtkWidget *w, GdkEventExpose *ev, gpointer d) +{ + + if (ev->type == GDK_EXPOSE) { + if (ev->count == 0) { + gdk_draw_pixmap(w->window, + w->style->fg_gc[GTK_WIDGET_STATE(w)], + devstat_pixmap[(int)d], 0, 0, 0, 0, 16, 16); + } + return TRUE; + } + return FALSE; +} +/* ----- */ +#endif + +void +StatBar_Redraw(void) +{ + + if (Config.FullScrFDDStat) { + StatBar_FDD(0, 0, FddLed[0].access); + StatBar_FDD(0, 1, FddLed[0].insert); + StatBar_FDD(1, 0, FddLed[1].access); + StatBar_FDD(1, 1, FddLed[1].insert); + StatBar_FDName(0, FddLed[0].file); + StatBar_FDName(1, FddLed[1].file); + } +} + + +void +StatBar_Show(int sw) +{ +#if 1 + (void)sw; +#else + if (sw) { + if (statbar == 0) { + GdkVisual *visual; + GdkColormap *colormap; + GdkBitmap *mask; + int pos = 0; + int i; + + statbar = gtk_table_new(1, 18, FALSE); + gtk_box_pack_start(GTK_BOX(main_vbox), statbar, + FALSE, TRUE, 0); + + colormap = gtk_widget_get_colormap(window); + for (i = 0; i < NELEMENTS(dev_pixmap); ++i) { + dev_pixmap[i] = + gdk_pixmap_colormap_create_from_xpm_d(NULL, + colormap, &mask, NULL, pixmaps[i]); + } + + for (i = 0; i < NELEMENTS(devstat); ++i) { + GtkWidget *w; + int idx = 0; + + if (i == NELEMENTS(devstat) - 1) { + w = gtk_vseparator_new(); + gtk_table_attach(GTK_TABLE(statbar), w, + pos, pos + 1, 0, 1, 0, 0, 0, 0); + pos++; + gtk_widget_show(w); + idx += 4; + } + + w = devstat[i] = gtk_drawing_area_new(); + gtk_drawing_area_size(GTK_DRAWING_AREA(w), + 16, 16); + gtk_table_attach(GTK_TABLE(statbar), w, + pos, pos + 1, 0, 1, 0, 0, 0, 0); + pos++; + gtk_signal_connect(GTK_OBJECT(w),"expose_event", + GTK_SIGNAL_FUNC(expose), (gpointer)i); + gtk_widget_show(w); + + devlabel[i] = gtk_label_new( + (i == NELEMENTS(devstat) - 1) ? + "HDD" + : + " " + " " + " " + " "); + gtk_table_attach_defaults(GTK_TABLE(statbar), + devlabel[i], pos, pos + 3, 0, 1); + pos += 3; + gtk_widget_show(devlabel[i]); + + visual = gtk_widget_get_visual(w); + devstat_pixmap[i] = gdk_pixmap_new(w->window, + 16, 16, visual->depth); + gdk_draw_pixmap(devstat_pixmap[i], + w->style->fg_gc[GTK_WIDGET_STATE(w)], + dev_pixmap[idx], 0, 0, 0, 0, 16, 16); + } + + } + gtk_widget_show(statbar); + } else { + if (statbar) + gtk_widget_hide(statbar); + } +#endif +} + + +void +StatBar_UpdateTimer(void) +{ +#if 0 + FddLed[0].timer ^= 1; + FddLed[1].timer ^= 1; + + if (FddLed[0].blink && (!FddLed[0].file[0]) && statbar) { + gdk_draw_pixmap(devstat_pixmap[0], + devstat[0]->style->fg_gc[GTK_WIDGET_STATE(devstat[0])], + dev_pixmap[FddLed[0].timer], 0, 0, 0, 0, 16, 16); + } + if (FddLed[1].blink && (!FddLed[1].file[0]) && statbar) { + gdk_draw_pixmap(devstat_pixmap[1], + devstat[1]->style->fg_gc[GTK_WIDGET_STATE(devstat[1])], + dev_pixmap[FddLed[1].timer], 0, 0, 0, 0, 16, 16); + } + if (HddLed != HddLedTmp) { + HddLed = HddLedTmp; + if (statbar) { + gdk_draw_pixmap(devstat_pixmap[2], + devstat[2]->style->fg_gc[ + GTK_WIDGET_STATE(devstat[2])], + dev_pixmap[HddLed ? 5 : 4], 0, 0, 0, 0, 16, 16); + } + } + StatBar_Redraw(); +#endif +} + + +void +StatBar_HDD(int hd) +{ +#if 1 + (void)hd; +#else + HddLedTmp = hd; + if ((HddLed != hd) && (hd)) { + gdk_draw_pixmap(devstat_pixmap[2], + devstat[2]->style->fg_gc[GTK_WIDGET_STATE(devstat[2])], + dev_pixmap[HddLed ? 5 : 4], 0, 0, 0, 0, 16, 16); + HddLed = hd; + } + StatBar_Redraw(); +#endif +} + + +void +StatBar_SetFDD(int drv, char* file) +{ +#if 1 + (void)drv; + (void)file; +#else + char name[81]; + char *f; + int i; + + if ((drv < 0)||(drv > 1)) + return; + + f = (char *)getFileName(file); + strcpy(FddLed[drv].file, f); + g_snprintf(name, sizeof(name), "%s", f); + + if (f[0]) { + FddLed[drv].access = 1; + FddLed[drv].insert = 1; + } else { + FddLed[drv].access = 0; + FddLed[drv].insert = 0; + } + + if (statbar) { + int len = strlen(name); + int c = ((FddLed[drv].blink) && (!FddLed[drv].file[0])) ? FddLed[drv].timer : FddLed[drv].access; + gdk_draw_pixmap(devstat_pixmap[drv], + devstat[drv]->style->fg_gc[ + GTK_WIDGET_STATE(devstat[drv])], + dev_pixmap[c], 0, 0, 0, 0, 16, 16); + + memset(name + len, ' ', sizeof(name) - len); + name[80] = '\0'; + gtk_label_set_text(devlabel[drv], name); + } + StatBar_Redraw(); +#endif +} + + +void +StatBar_ParamFDD(int drv, int access, int insert, int blink) +{ +#if 1 + (void)drv; + (void)access; + (void)insert; + (void)blink; +#else + int update; + + if ((drv < 0) || (drv > 1)) + return; + + update = 0; + if (FddLed[drv].access != access) { + FddLed[drv].access = access; + update = 1; + } + if (FddLed[drv].insert != insert) { + FddLed[drv].insert = insert; + update = 1; + } + if (FddLed[drv].blink != blink) { + FddLed[drv].blink = blink; + update = 1; + } + + if (update) { + if (statbar) { + int c = ((FddLed[drv].blink) && (!FddLed[drv].file[0])) ? FddLed[drv].timer : FddLed[drv].access; + gdk_draw_pixmap(devstat_pixmap[drv], + devstat[drv]->style->fg_gc[ + GTK_WIDGET_STATE(devstat[drv])], + dev_pixmap[c], 0, 0, 0, 0, 16, 16); + } + StatBar_Redraw(); + } +#endif +} + + +void +StatBar_FDName(int drv, char* name) +{ + /* Full screen 専用 */ + (void)drv; + (void)name; +} + + +void +StatBar_FDD(int drv, int led, int col) +{ + /* Full screen 専用 */ + (void)drv; + (void)led; + (void)col; +} +#endif diff --git a/libretro/status.h b/libretro/status.h new file mode 100644 index 0000000..28c49b9 --- /dev/null +++ b/libretro/status.h @@ -0,0 +1,34 @@ +#ifndef winx68k_statusbar_h +#define winx68k_statusbar_h + +#ifdef __cplusplus +extern "C" { +#endif + +#if 1 + +#define StatBar_Show(s) +#define StatBar_UpdateTimer() +#define StatBar_SetFDD(d,f) +#define StatBar_ParamFDD(d,a,i,b) +#define StatBar_HDD(s) + +#else + +void StatBar_Redraw(void); +void StatBar_Show(int sw); +void StatBar_Draw(DRAWITEMSTRUCT* dis); +void StatBar_FDName(int drv, char* name); +void StatBar_FDD(int drv, int led, int col); +void StatBar_UpdateTimer(void); +void StatBar_SetFDD(int drv, char* file); +void StatBar_ParamFDD(int drv, int access, int insert, int blink); +void StatBar_HDD(int sw); + +#endif + +#ifdef __cplusplus +}; +#endif + +#endif //winx68k_statusbar_h diff --git a/libretro/timer.c b/libretro/timer.c new file mode 100644 index 0000000..f2b5a18 --- /dev/null +++ b/libretro/timer.c @@ -0,0 +1,36 @@ +// ----------------------------------------------------------------------- +// 55.6fpsキープ用たいまー +// ----------------------------------------------------------------------- +#include "common.h" +#include "crtc.h" +#include "mfp.h" + +DWORD timercnt = 0; +DWORD tick = 0; + +void Timer_Init(void) +{ + tick = timeGetTime(); +} + +void Timer_Reset(void) +{ + tick = timeGetTime(); +} + +WORD Timer_GetCount(void) +{ + DWORD ticknow = timeGetTime(); + DWORD dif = ticknow-tick; + DWORD TIMEBASE = ((CRTC_Regs[0x29]&0x10)?VSYNC_HIGH:VSYNC_NORM); + + timercnt += dif*10000; + tick = ticknow; + if ( timercnt>=TIMEBASE ) { +// timercnt = 0; + timercnt -= TIMEBASE; + if ( timercnt>=(TIMEBASE*2) ) timercnt = 0; + return 1; + } else + return 0; +} diff --git a/libretro/timer.h b/libretro/timer.h new file mode 100644 index 0000000..0b519e7 --- /dev/null +++ b/libretro/timer.h @@ -0,0 +1,9 @@ +#ifndef winx1_timer_h +#define winx1_timer_h + +void Timer_Init(void); +void Timer_Reset(void); +WORD Timer_GetCount(void); +void Timer_SetCount(WORD); + +#endif //winx1_timer_h diff --git a/libretro/version.h b/libretro/version.h new file mode 100644 index 0000000..3a2b503 --- /dev/null +++ b/libretro/version.h @@ -0,0 +1,15 @@ +// --------------------------------------------------------------------------- +// WinX68k - SHARP X680x0 Emulator +// Copyright (C) Kenjo 2000 +// --------------------------------------------------------------------------- + +#ifndef _version_h +#define _version_h + +#define APP_VER_MAJOR 0 +#define APP_VER_MINOR 65 +#define APP_VER_STRING "0.65" + +#define SOURCE_VERSION "20081108" + +#endif //_version_h diff --git a/libretro/windraw.c b/libretro/windraw.c new file mode 100644 index 0000000..dec3e5e --- /dev/null +++ b/libretro/windraw.c @@ -0,0 +1,1459 @@ +/* + * Copyright (c) 2003 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "common.h" + +#include "winx68k.h" +#include "winui.h" + +#include "bg.h" +#include "crtc.h" +#include "gvram.h" +#include "mouse.h" +#include "palette.h" +#include "prop.h" +#include "status.h" +#include "tvram.h" +#include "joystick.h" +#include "keyboard.h" + +#ifdef __LIBRETRO__ +extern unsigned short *videoBuffer; +#endif +WORD menu_buffer[800*600]; +#if 0 +#include "../icons/keropi.xpm" +#endif + +extern BYTE Debug_Text, Debug_Grp, Debug_Sp; + + +WORD *ScrBuf = 0; + +int Draw_Opaque; +int FullScreenFlag = 0; +extern BYTE Draw_RedrawAllFlag; +BYTE Draw_DrawFlag = 1; +BYTE Draw_ClrMenu = 0; + +BYTE Draw_BitMask[800]; +BYTE Draw_TextBitMask[800]; + +int winx = 0, winy = 0; +DWORD winh = 0, winw = 0; +DWORD root_width, root_height; +WORD FrameCount = 0; +int SplashFlag = 0; + +WORD WinDraw_Pal16B, WinDraw_Pal16R, WinDraw_Pal16G; + +DWORD WindowX = 0; +DWORD WindowY = 0; + +void WinDraw_InitWindowSize(WORD width, WORD height) +{ + static BOOL inited = FALSE; + + if (!inited) { + inited = TRUE; + } + + winw = width; + winh = height; + + if (root_width < winw) + winx = (root_width - winw) / 2; + else if (winx < 0) + winx = 0; + else if ((winx + winw) > root_width) + winx = root_width - winw; + if (root_height < winh) + winy = (root_height - winh) / 2; + else if (winy < 0) + winy = 0; + else if ((winy + winh) > root_height) + winy = root_height - winh; +} + +void WinDraw_ChangeSize(void) +{ + DWORD oldx = WindowX, oldy = WindowY; + int dif; + + Mouse_ChangePos(); + + switch (Config.WinStrech) { + case 0: + WindowX = TextDotX; + WindowY = TextDotY; + break; + + case 1: + WindowX = 768; + WindowY = 512; + break; + + case 2: + if (TextDotX <= 384) + WindowX = TextDotX * 2; + else + WindowX = TextDotX; + if (TextDotY <= 256) + WindowY = TextDotY * 2; + else + WindowY = TextDotY; + break; + + case 3: + if (TextDotX <= 384) + WindowX = TextDotX * 2; + else + WindowX = TextDotX; + if (TextDotY <= 256) + WindowY = TextDotY * 2; + else + WindowY = TextDotY; + dif = WindowX - WindowY; + if ((dif > -32) && (dif < 32)) { + // 正方形に近い画面なら、としておこう + WindowX = (int)(WindowX * 1.25); + } + break; + } + + if ((WindowX > 768) || (WindowX <= 0)) { + if (oldx) + WindowX = oldx; + else + WindowX = oldx = 768; + } + if ((WindowY > 512) || (WindowY <= 0)) { + if (oldy) + WindowY = oldy; + else + WindowY = oldy = 512; + } + + if ((oldx == WindowX) && (oldy == WindowY)) + return; + + WinDraw_InitWindowSize((WORD)WindowX, (WORD)WindowY); + StatBar_Show(Config.WindowFDDStat); + Mouse_ChangePos(); +} + +//static int dispflag = 0; +void WinDraw_StartupScreen(void) +{ +} + +void WinDraw_CleanupScreen(void) +{ +} + +void WinDraw_ChangeMode(int flag) +{ + + /* full screen mode(TRUE) <-> window mode(FALSE) */ + (void)flag; +} + +void WinDraw_ShowSplash(void) +{ +} + +void WinDraw_HideSplash(void) +{ +} + + +static void draw_kbd_to_tex(void); + +int WinDraw_Init(void) +{ + int i, j; + + WindowX = 768; + WindowY = 512; + + WinDraw_Pal16R = 0xf800; + WinDraw_Pal16G = 0x07e0; + WinDraw_Pal16B = 0x001f; + + printf("R: %x, G: %x, B: %x\n", WinDraw_Pal16R, WinDraw_Pal16G, WinDraw_Pal16B); + + ScrBuf = malloc(800 * 600 * 2); + + return TRUE; +} + +void +WinDraw_Cleanup(void) +{ +} + +void +WinDraw_Redraw(void) +{ + + TVRAM_SetAllDirty(); +} + + +extern int retrow,retroh,CHANGEAV; + +void FASTCALL +WinDraw_Draw(void) +{ + + static int oldtextx = -1, oldtexty = -1; + + if (oldtextx != TextDotX) { + oldtextx = TextDotX; + p6logd("TextDotX: %d\n", TextDotX); + CHANGEAV=1; + } + if (oldtexty != TextDotY) { + oldtexty = TextDotY; + p6logd("TextDotY: %d\n", TextDotY); + CHANGEAV=1; + } + + if(CHANGEAV==1){ + retrow=TextDotX; + retroh=TextDotY; + } + + videoBuffer=(unsigned short int *)ScrBuf; + + FrameCount++; + if (!Draw_DrawFlag/* && is_installed_idle_process()*/) + return; + Draw_DrawFlag = 0; + + if (SplashFlag) + WinDraw_ShowSplash(); +} + +#define WD_MEMCPY(src) memcpy(&ScrBuf[adr], (src), TextDotX * 2) + +#define WD_LOOP(start, end, sub) \ +{ \ + for (i = (start); i < (end); i++, adr++) { \ + sub(); \ + } \ +} + +#define WD_SUB(SUFFIX, src) \ +{ \ + w = (src); \ + if (w != 0) \ + ScrBuf##SUFFIX[adr] = w; \ +} + + +INLINE void WinDraw_DrawGrpLine(int opaq) +{ +#define _DGL_SUB(SUFFIX) WD_SUB(SUFFIX, Grp_LineBuf[i]) + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + WORD w; + int i; + + if (opaq) { + WD_MEMCPY(Grp_LineBuf); + } else { + WD_LOOP(0, TextDotX, _DGL_SUB); + } +} + +INLINE void WinDraw_DrawGrpLineNonSP(int opaq) +{ +#define _DGL_NSP_SUB(SUFFIX) WD_SUB(SUFFIX, Grp_LineBufSP2[i]) + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + WORD w; + int i; + + if (opaq) { + WD_MEMCPY(Grp_LineBufSP2); + } else { + WD_LOOP(0, TextDotX, _DGL_NSP_SUB); + } +} + +INLINE void WinDraw_DrawTextLine(int opaq, int td) +{ +#define _DTL_SUB2(SUFFIX) WD_SUB(SUFFIX, BG_LineBuf[i]) +#define _DTL_SUB(SUFFIX) \ +{ \ + if (Text_TrFlag[i] & 1) { \ + _DTL_SUB2(SUFFIX); \ + } \ +} + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + WORD w; + int i; + + if (opaq) { + WD_MEMCPY(&BG_LineBuf[16]); + } else { + if (td) { + WD_LOOP(16, TextDotX + 16, _DTL_SUB); + } else { + WD_LOOP(16, TextDotX + 16, _DTL_SUB2); + } + } +} + +INLINE void WinDraw_DrawTextLineTR(int opaq) +{ +#define _DTL_TR_SUB(SUFFIX) \ +{ \ + w = Grp_LineBufSP[i - 16]; \ + if (w != 0) { \ + w &= Pal_HalfMask; \ + v = BG_LineBuf[i]; \ + if (v & Ibit) \ + w += Pal_Ix2; \ + v &= Pal_HalfMask; \ + v += w; \ + v >>= 1; \ + } else { \ + if (Text_TrFlag[i] & 1) \ + v = BG_LineBuf[i]; \ + else \ + v = 0; \ + } \ + ScrBuf##SUFFIX[adr] = (WORD)v; \ +} + +#define _DTL_TR_SUB2(SUFFIX) \ +{ \ + if (Text_TrFlag[i] & 1) { \ + w = Grp_LineBufSP[i - 16]; \ + v = BG_LineBuf[i]; \ + \ + if (v != 0) { \ + if (w != 0) { \ + w &= Pal_HalfMask; \ + if (v & Ibit) \ + w += Pal_Ix2; \ + v &= Pal_HalfMask; \ + v += w; \ + v >>= 1; \ + } \ + ScrBuf##SUFFIX[adr] = (WORD)v; \ + } \ + } \ +} + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + DWORD v; + WORD w; + int i; + + if (opaq) { + WD_LOOP(16, TextDotX + 16, _DTL_TR_SUB); + } else { + WD_LOOP(16, TextDotX + 16, _DTL_TR_SUB2); + } +} + +INLINE void WinDraw_DrawBGLine(int opaq, int td) +{ +#define _DBL_SUB2(SUFFIX) WD_SUB(SUFFIX, BG_LineBuf[i]) +#define _DBL_SUB(SUFFIX) \ +{ \ + if (Text_TrFlag[i] & 2) { \ + _DBL_SUB2(SUFFIX); \ + } \ +} + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + WORD w; + int i; + +#if 0 // debug for segv + static int log_start = 0; + + if (TextDotX == 128 && TextDotY == 128) { + log_start = 1; + } + if (log_start) { + printf("opaq/td: %d/%d VLINE: %d, TextDotX: %d\n", opaq, td, VLINE, TextDotX); + } +#endif + + if (opaq) { + WD_MEMCPY(&BG_LineBuf[16]); + } else { + if (td) { + WD_LOOP(16, TextDotX + 16, _DBL_SUB); + } else { + WD_LOOP(16, TextDotX + 16, _DBL_SUB2); + } + } +} + +INLINE void WinDraw_DrawBGLineTR(int opaq) +{ + +#define _DBL_TR_SUB3() \ +{ \ + if (w != 0) { \ + w &= Pal_HalfMask; \ + if (v & Ibit) \ + w += Pal_Ix2; \ + v &= Pal_HalfMask; \ + v += w; \ + v >>= 1; \ + } \ +} + +#define _DBL_TR_SUB(SUFFIX) \ +{ \ + w = Grp_LineBufSP[i - 16]; \ + v = BG_LineBuf[i]; \ + \ + _DBL_TR_SUB3() \ + ScrBuf##SUFFIX[adr] = (WORD)v; \ +} + +#define _DBL_TR_SUB2(SUFFIX) \ +{ \ + if (Text_TrFlag[i] & 2) { \ + w = Grp_LineBufSP[i - 16]; \ + v = BG_LineBuf[i]; \ + \ + if (v != 0) { \ + _DBL_TR_SUB3() \ + ScrBuf##SUFFIX[adr] = (WORD)v; \ + } \ + } \ +} + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + DWORD v; + WORD w; + int i; + + if (opaq) { + WD_LOOP(16, TextDotX + 16, _DBL_TR_SUB); + } else { + WD_LOOP(16, TextDotX + 16, _DBL_TR_SUB2); + } + +} + +INLINE void WinDraw_DrawPriLine(void) +{ +#define _DPL_SUB(SUFFIX) WD_SUB(SUFFIX, Grp_LineBufSP[i]) + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + WORD w; + int i; + + WD_LOOP(0, TextDotX, _DPL_SUB); +} + +void WinDraw_DrawLine(void) +{ + int opaq, ton=0, gon=0, bgon=0, tron=0, pron=0, tdrawed=0; + + if (!TextDirtyLine[VLINE]) return; + TextDirtyLine[VLINE] = 0; + Draw_DrawFlag = 1; + + + if (Debug_Grp) + { + switch(VCReg0[1]&3) + { + case 0: // 16 colors + if (VCReg0[1]&4) // 1024dot + { + if (VCReg2[1]&0x10) + { + if ( (VCReg2[0]&0x14)==0x14 ) + { + Grp_DrawLine4hSP(); + pron = tron = 1; + } + else + { + Grp_DrawLine4h(); + gon=1; + } + } + } + else // 512dot + { + if ( (VCReg2[0]&0x10)&&(VCReg2[1]&1) ) + { + Grp_DrawLine4SP((VCReg1[1] )&3/*, 1*/); // 半透明の下準備 + pron = tron = 1; + } + opaq = 1; + if (VCReg2[1]&8) + { + Grp_DrawLine4((VCReg1[1]>>6)&3, 1); + opaq = 0; + gon=1; + } + if (VCReg2[1]&4) + { + Grp_DrawLine4((VCReg1[1]>>4)&3, opaq); + opaq = 0; + gon=1; + } + if (VCReg2[1]&2) + { + if ( ((VCReg2[0]&0x1e)==0x1e)&&(tron) ) + Grp_DrawLine4TR((VCReg1[1]>>2)&3, opaq); + else + Grp_DrawLine4((VCReg1[1]>>2)&3, opaq); + opaq = 0; + gon=1; + } + if (VCReg2[1]&1) + { +// if ( (VCReg2[0]&0x1e)==0x1e ) +// { +// Grp_DrawLine4SP((VCReg1[1] )&3, opaq); +// tron = pron = 1; +// } +// else + if ( (VCReg2[0]&0x14)!=0x14 ) + { + Grp_DrawLine4((VCReg1[1] )&3, opaq); + gon=1; + } + } + } + break; + case 1: + case 2: + opaq = 1; // 256 colors + if ( (VCReg1[1]&3) <= ((VCReg1[1]>>4)&3) ) // 同じ値の時は、GRP0が優先（ドラスピ） + { + if ( (VCReg2[0]&0x10)&&(VCReg2[1]&1) ) + { + Grp_DrawLine8SP(0); // 半透明の下準備 + tron = pron = 1; + } + if (VCReg2[1]&4) + { + if ( ((VCReg2[0]&0x1e)==0x1e)&&(tron) ) + Grp_DrawLine8TR(1, 1); + else + Grp_DrawLine8(1, 1); + opaq = 0; + gon=1; + } + if (VCReg2[1]&1) + { + if ( (VCReg2[0]&0x14)!=0x14 ) + { + Grp_DrawLine8(0, opaq); + gon=1; + } + } + } + else + { + if ( (VCReg2[0]&0x10)&&(VCReg2[1]&1) ) + { + Grp_DrawLine8SP(1); // 半透明の下準備 + tron = pron = 1; + } + if (VCReg2[1]&4) + { + if ( ((VCReg2[0]&0x1e)==0x1e)&&(tron) ) + Grp_DrawLine8TR(0, 1); + else + Grp_DrawLine8(0, 1); + opaq = 0; + gon=1; + } + if (VCReg2[1]&1) + { + if ( (VCReg2[0]&0x14)!=0x14 ) + { + Grp_DrawLine8(1, opaq); + gon=1; + } + } + } + break; + case 3: // 65536 colors + if (VCReg2[1]&15) + { + if ( (VCReg2[0]&0x14)==0x14 ) + { + Grp_DrawLine16SP(); + tron = pron = 1; + } + else + { + Grp_DrawLine16(); + gon=1; + } + } + break; + } + } + + +// if ( ( ((VCReg1[0]&0x30)>>4) < (VCReg1[0]&0x03) ) && (gon) ) +// gdrawed = 1; // GrpよりBGの方が上 + + if ( ((VCReg1[0]&0x30)>>2) < (VCReg1[0]&0x0c) ) + { // BGの方が上 + if ((VCReg2[1]&0x20)&&(Debug_Text)) + { + Text_DrawLine(1); + ton = 1; + } + else + ZeroMemory(Text_TrFlag, TextDotX+16); + + if ((VCReg2[1]&0x40)&&(BG_Regs[8]&2)&&(!(BG_Regs[0x11]&2))&&(Debug_Sp)) + { + int s1, s2; + s1 = (((BG_Regs[0x11] &4)?2:1)-((BG_Regs[0x11] &16)?1:0)); + s2 = (((CRTC_Regs[0x29]&4)?2:1)-((CRTC_Regs[0x29]&16)?1:0)); + VLINEBG = VLINE; + VLINEBG <<= s1; + VLINEBG >>= s2; + if ( !(BG_Regs[0x11]&16) ) VLINEBG -= ((BG_Regs[0x0f]>>s1)-(CRTC_Regs[0x0d]>>s2)); + BG_DrawLine(!ton, 0); + bgon = 1; + } + } + else + { // Textの方が上 + if ((VCReg2[1]&0x40)&&(BG_Regs[8]&2)&&(!(BG_Regs[0x11]&2))&&(Debug_Sp)) + { + int s1, s2; + s1 = (((BG_Regs[0x11] &4)?2:1)-((BG_Regs[0x11] &16)?1:0)); + s2 = (((CRTC_Regs[0x29]&4)?2:1)-((CRTC_Regs[0x29]&16)?1:0)); + VLINEBG = VLINE; + VLINEBG <<= s1; + VLINEBG >>= s2; + if ( !(BG_Regs[0x11]&16) ) VLINEBG -= ((BG_Regs[0x0f]>>s1)-(CRTC_Regs[0x0d]>>s2)); + ZeroMemory(Text_TrFlag, TextDotX+16); + BG_DrawLine(1, 1); + bgon = 1; + } + else + { + if ((VCReg2[1]&0x20)&&(Debug_Text)) + { + int i; + for (i = 16; i < TextDotX + 16; ++i) + BG_LineBuf[i] = TextPal[0]; + } else { // 20010120 （琥珀色） + bzero(&BG_LineBuf[16], TextDotX * 2); + } + ZeroMemory(Text_TrFlag, TextDotX+16); + bgon = 1; + } + + if ((VCReg2[1]&0x20)&&(Debug_Text)) + { + Text_DrawLine(!bgon); + ton = 1; + } + } + + + opaq = 1; + + +#if 0 + // Pri = 3（違反）に設定されている画面を表示 + if ( ((VCReg1[0]&0x30)==0x30)&&(bgon) ) + { + if ( ((VCReg2[0]&0x5d)==0x1d)&&((VCReg1[0]&0x03)!=0x03)&&(tron) ) + { + if ( (VCReg1[0]&3)<((VCReg1[0]>>2)&3) ) + { + WinDraw_DrawBGLineTR(opaq); + tdrawed = 1; + opaq = 0; + } + } + else + { + WinDraw_DrawBGLine(opaq, /*tdrawed*/0); + tdrawed = 1; + opaq = 0; + } + } + if ( ((VCReg1[0]&0x0c)==0x0c)&&(ton) ) + { + if ( ((VCReg2[0]&0x5d)==0x1d)&&((VCReg1[0]&0x03)!=0x0c)&&(tron) ) + WinDraw_DrawTextLineTR(opaq); + else + WinDraw_DrawTextLine(opaq, /*tdrawed*/((VCReg1[0]&0x30)==0x30)); + opaq = 0; + tdrawed = 1; + } +#endif + // Pri = 2 or 3（最下位）に設定されている画面を表示 + // プライオリティが同じ場合は、GRP>2)&3) ) + { + WinDraw_DrawBGLineTR(opaq); + tdrawed = 1; + opaq = 0; + } + } + else + { + WinDraw_DrawBGLine(opaq, /*0*/tdrawed); + tdrawed = 1; + opaq = 0; + } + } + if ( (VCReg1[0]&0x08)&&(ton) ) + { + if ( ((VCReg2[0]&0x5d)==0x1d)&&((VCReg1[0]&0x03)!=0x02)&&(tron) ) + WinDraw_DrawTextLineTR(opaq); + else + WinDraw_DrawTextLine(opaq, tdrawed/*((VCReg1[0]&0x30)>=0x20)*/); + opaq = 0; + tdrawed = 1; + } + + // Pri = 1（2番目）に設定されている画面を表示 + if ( ((VCReg1[0]&0x03)==0x01)&&(gon) ) + { + WinDraw_DrawGrpLine(opaq); + opaq = 0; + } + if ( ((VCReg1[0]&0x30)==0x10)&&(bgon) ) + { + if ( ((VCReg2[0]&0x5d)==0x1d)&&(!(VCReg1[0]&0x03))&&(tron) ) + { + if ( (VCReg1[0]&3)<((VCReg1[0]>>2)&3) ) + { + WinDraw_DrawBGLineTR(opaq); + tdrawed = 1; + opaq = 0; + } + } + else + { + WinDraw_DrawBGLine(opaq, ((VCReg1[0]&0xc)==0x8)); + tdrawed = 1; + opaq = 0; + } + } + if ( ((VCReg1[0]&0x0c)==0x04) && ((VCReg2[0]&0x5d)==0x1d) && (VCReg1[0]&0x03) && (((VCReg1[0]>>4)&3)>(VCReg1[0]&3)) && (bgon) && (tron) ) + { + WinDraw_DrawBGLineTR(opaq); + tdrawed = 1; + opaq = 0; + if (tron) + { + WinDraw_DrawGrpLineNonSP(opaq); + } + } + else if ( ((VCReg1[0]&0x03)==0x01)&&(tron)&&(gon)&&(VCReg2[0]&0x10) ) + { + WinDraw_DrawGrpLineNonSP(opaq); + opaq = 0; + } + if ( ((VCReg1[0]&0x0c)==0x04)&&(ton) ) + { + if ( ((VCReg2[0]&0x5d)==0x1d)&&(!(VCReg1[0]&0x03))&&(tron) ) + WinDraw_DrawTextLineTR(opaq); + else + WinDraw_DrawTextLine(opaq, ((VCReg1[0]&0x30)>=0x10)); + opaq = 0; + tdrawed = 1; + } + + // Pri = 0（最優先）に設定されている画面を表示 + if ( (!(VCReg1[0]&0x03))&&(gon) ) + { + WinDraw_DrawGrpLine(opaq); + opaq = 0; + } + if ( (!(VCReg1[0]&0x30))&&(bgon) ) + { + WinDraw_DrawBGLine(opaq, /*tdrawed*/((VCReg1[0]&0xc)>=0x4)); + tdrawed = 1; + opaq = 0; + } + if ( (!(VCReg1[0]&0x0c)) && ((VCReg2[0]&0x5d)==0x1d) && (((VCReg1[0]>>4)&3)>(VCReg1[0]&3)) && (bgon) && (tron) ) + { + WinDraw_DrawBGLineTR(opaq); + tdrawed = 1; + opaq = 0; + if (tron) + { + WinDraw_DrawGrpLineNonSP(opaq); + } + } + else if ( (!(VCReg1[0]&0x03))&&(tron)&&(VCReg2[0]&0x10) ) + { + WinDraw_DrawGrpLineNonSP(opaq); + opaq = 0; + } + if ( (!(VCReg1[0]&0x0c))&&(ton) ) + { + WinDraw_DrawTextLine(opaq, 1); + tdrawed = 1; + opaq = 0; + } + + // 特殊プライオリティ時のグラフィック + if ( ((VCReg2[0]&0x5c)==0x14)&&(pron) ) // 特殊Pri時は、対象プレーンビットは意味が無いらしい（ついんびー） + { + WinDraw_DrawPriLine(); + } + else if ( ((VCReg2[0]&0x5d)==0x1c)&&(tron) ) // 半透明時に全てが透明なドットをハーフカラーで埋める + { // （AQUALES） + +#define _DL_SUB(SUFFIX) \ +{ \ + w = Grp_LineBufSP[i]; \ + if (w != 0 && (ScrBuf##SUFFIX[adr] & 0xffff) == 0) \ + ScrBuf##SUFFIX[adr] = (w & Pal_HalfMask) >> 1; \ +} + + DWORD adr = VLINE*FULLSCREEN_WIDTH; + WORD w; + int i; + + WD_LOOP(0, TextDotX, _DL_SUB); + } + + + if (opaq) + { + DWORD adr = VLINE*FULLSCREEN_WIDTH; +#ifdef PSP + if (TextDotX > 512) { + bzero(&ScrBufL[adr], TextDotX * 2); + adr = VLINE * 256; + bzero(&ScrBufR[adr], (TextDotX - 512) * 2); + } else { + bzero(&ScrBufL[adr], TextDotX * 2); + } +#else + bzero(&ScrBuf[adr], TextDotX * 2); +#endif + } +} + +/********** menu 関連ルーチン **********/ + +struct _px68k_menu { + WORD *sbp; // surface buffer ptr + WORD *mlp; // menu locate ptr + WORD mcolor; // color of chars to write + WORD mbcolor; // back ground color of chars to write + int ml_x; + int ml_y; + int mfs; // menu font size; +} p6m; + +// 画面タイプを変更する +enum ScrType {x68k, pc98}; +int scr_type = x68k; + +/* sjis→jisコード変換 */ +static WORD sjis2jis(WORD w) +{ + BYTE wh, wl; + + wh = w / 256, wl = w % 256; + + wh <<= 1; + if (wl < 0x9f) { + wh += (wh < 0x3f)? 0x1f : -0x61; + wl -= (wl > 0x7e)? 0x20 : 0x1f; + } else { + wh += (wh < 0x3f)? 0x20 : -0x60; + wl -= 0x7e; + } + + return (wh * 256 + wl); +} + +/* JISコードから0 originのindexに変換する */ +/* ただし0x2921-0x2f7eはX68KのROM上にないので飛ばす */ +static WORD jis2idx(WORD jc) +{ + if (jc >= 0x3000) { + jc -= 0x3021; + } else { + jc -= 0x2121; + } + jc = jc % 256 + (jc / 256) * 0x5e; + + return jc; +} + +#define isHankaku(s) ((s) >= 0x20 && (s) <= 0x7e || (s) >= 0xa0 && (s) <= 0xdf) +#define MENU_WIDTH 800 + + +// fs : font size : 16 or 24 +// 半角文字の場合は16bitの上位8bitにデータを入れておくこと +// (半角or全角の判断ができるように) +static DWORD get_font_addr(WORD sjis, int fs) +{ + WORD jis, j_idx; + BYTE jhi; + int fsb; // file size in bytes + + // 半角文字 + if (isHankaku(sjis >> 8)) { + switch (fs) { + case 8: + return (0x3a000 + (sjis >> 8) * (1 * 8)); + case 16: + return (0x3a800 + (sjis >> 8) * (1 * 16)); + case 24: + return (0x3d000 + (sjis >> 8) * (2 * 24)); + default: + return -1; + } + } + + // 全角文字 + if (fs == 16) { + fsb = 2 * 16; + } else if (fs == 24) { + fsb = 3 * 24; + } else { + return -1; + } + + jis = sjis2jis(sjis); + j_idx = (DWORD)jis2idx(jis); + jhi = (BYTE)(jis >> 8); + +#if 0 + printf("sjis code = 0x%x\n", sjis); + printf("jis code = 0x%x\n", jis); + printf("jhi 0x%x j_idx 0x%x\n", jhi, j_idx); +#endif + + if (jhi >= 0x21 && jhi <= 0x28) { + // 非漢字 + return ((fs == 16)? 0x0 : 0x40000) + j_idx * fsb; + } else if (jhi >= 0x30 && jhi <= 0x74) { + // 第一水準/第二水準 + return ((fs == 16)? 0x5e00 : 0x4d380) + j_idx * fsb; + } else { + // ここにくることはないはず + return -1; + } +} + +// RGB565 +static void set_mcolor(WORD c) +{ + p6m.mcolor = c; +} + +// mbcolor = 0 なら透明色とする +static void set_mbcolor(WORD c) +{ + p6m.mbcolor = c; +} + +// グラフィック座標 +static void set_mlocate(int x, int y) +{ + p6m.ml_x = x, p6m.ml_y = y; +} + +// キャラクタ文字の座標 (横軸は1座標が半角文字幅になる) +static void set_mlocateC(int x, int y) +{ + p6m.ml_x = x * p6m.mfs / 2, p6m.ml_y = y * p6m.mfs; +} + +static void set_sbp(WORD *p) +{ + p6m.sbp = p; +} + +// menu font size (16 or 24) +static void set_mfs(int fs) +{ + p6m.mfs = fs; +} + +static WORD *get_ml_ptr() +{ + p6m.mlp = p6m.sbp + MENU_WIDTH * p6m.ml_y + p6m.ml_x; + return p6m.mlp; +} + +// ・半角文字の場合は16bitの上位8bitにデータを入れておくこと +// (半角or全角の判断ができるように) +// ・表示した分cursorは先に移動する +static void draw_char(WORD sjis) +{ + DWORD f; + WORD *p; + int i, j, k, wc, w; + BYTE c; + WORD bc; + + int h = p6m.mfs; + + p = get_ml_ptr(); + + f = get_font_addr(sjis, h); + + if (f < 0) + return; + + // h=8は半角のみ + w = (h == 8)? 8 : (isHankaku(sjis >> 8)? h / 2 : h); + + for (i = 0; i < h; i++) { + wc = w; + for (j = 0; j < ((w % 8 == 0)? w / 8 : w / 8 + 1); j++) { + c = FONT[f++]; + for (k = 0; k < 8 ; k++) { + bc = p6m.mbcolor? p6m.mbcolor : *p; + *p = (c & 0x80)? p6m.mcolor : bc; + p++; + c = c << 1; + wc--; + if (wc == 0) + break; + } + } + p = p + MENU_WIDTH - w; + } + + p6m.ml_x += w; +} + +static void draw_str(char *cp) +{ + int i, len; + BYTE *s; + WORD wc; + + len = strlen(cp); + s = (BYTE *)cp; + + for (i = 0; i < len; i++) { + if (isHankaku(*s)) { + // 最初の8bitで半全角を判断するので半角の場合は + // あらかじめ8bit左シフトしておく + draw_char((WORD)*s << 8); + s++; + } else { + wc = (WORD)(*s << 8) + *(s + 1); + draw_char(wc); + s += 2; + i++; + } + // 8x8描画(ソフトキーボードのFUNCキーは文字幅を縮める) + if (p6m.mfs == 8) { + p6m.ml_x -= 3; + } + } +} + +int WinDraw_MenuInit(void) +{ + set_sbp(menu_buffer); + set_mfs(16); + + set_mcolor(0xffff); + set_mbcolor(0); + + return TRUE; +} + +#include "menu_str_sjis.txt" + + +void WinDraw_DrawMenu(int menu_state, int mkey_pos, int mkey_y, int *mval_y) +{ + int i, drv; + char tmp[256]; + +// ソフトウェアキーボード描画時にset_sbp(kbd_buffer)されているので戻す + + set_sbp(menu_buffer); + set_mfs(16); + + // タイトル + if (scr_type == x68k) { + set_mcolor(0x07ff); // cyan + set_mlocateC(0, 0); + draw_str(twaku_str); + set_mlocateC(0, 1); + draw_str(twaku2_str); + set_mlocateC(0, 2); + draw_str(twaku3_str); + + set_mcolor(0xffff); + set_mlocateC(1, 1); + sprintf(tmp, "%s%s", title_str, PX68KVERSTR); + draw_str(tmp); + } else { + set_mcolor(0xffff); + set_mlocateC(0, 0); + sprintf(tmp, "%s%s", pc98_title1_str, PX68KVERSTR); + draw_str(tmp); + set_mlocateC(0, 2); + draw_str(pc98_title3_str); + set_mcolor(0x07ff); + set_mlocateC(0, 1); + draw_str(pc98_title2_str); + } + + // 真ん中 + if (scr_type == x68k) { + set_mcolor(0xffff); + set_mlocate(3 * p6m.mfs / 2, 3.5 * p6m.mfs); + draw_str(waku_val_str[0]); + set_mlocate(17 * p6m.mfs / 2, 3.5 * p6m.mfs); + draw_str(waku_val_str[1]); + + // 真ん中枠 + set_mcolor(0xffe0); // yellow + set_mlocateC(1, 4); + draw_str(waku_str); + for (i = 5; i < 12; i++) { + set_mlocateC(1, i); + draw_str(waku2_str); + } + set_mlocateC(1, 12); + draw_str(waku3_str); + } + + // アイテム/キーワード + set_mcolor(0xffff); + for (i = 0; i < 7; i++) { + set_mlocateC(3, 5 + i); + if (menu_state == ms_key && i == (mkey_y - mkey_pos)) { + set_mcolor(0x0); + set_mbcolor(0xffe0); // yellow); + } else { + set_mcolor(0xffff); + set_mbcolor(0x0); + } + draw_str(menu_item_key[i + mkey_pos]); + } + + // アイテム/現在値 + set_mcolor(0xffff); + set_mbcolor(0x0); + for (i = 0; i < 7; i++) { + if ((menu_state == ms_value || menu_state == ms_hwjoy_set) + && i == (mkey_y - mkey_pos)) { + set_mcolor(0x0); + set_mbcolor(0xffe0); // yellow); + } else { + set_mcolor(0xffff); + set_mbcolor(0x0); + } + if (scr_type == x68k) { + set_mlocateC(17, 5 + i); + } else { + set_mlocateC(25, 5 + i); + } + + drv = WinUI_get_drv_num(i + mkey_pos); + if (drv >= 0 && mval_y[i + mkey_pos] == 0) { + char *p; + if (drv < 2) { + p = Config.FDDImage[drv]; + } else { + p = Config.HDImage[drv - 2]; + } + + if (p[0] == '\0') { + draw_str(" -- no disk --"); + } else { + // 先頭のカレントディレクトリ名を表示しない + if (!strncmp(cur_dir_str, p, cur_dir_slen)) { + draw_str(p + cur_dir_slen); + } else { + draw_str(p); + } + } + } else { + draw_str(menu_items[i + mkey_pos][mval_y[i + mkey_pos]]); + } + } + + if (scr_type == x68k) { + // 下枠 + set_mcolor(0x07ff); // cyan + set_mbcolor(0x0); + set_mlocateC(0, 13); + draw_str(swaku_str); + set_mlocateC(0, 14); + draw_str(swaku2_str); + set_mlocateC(0, 15); + draw_str(swaku2_str); + set_mlocateC(0, 16); + draw_str(swaku3_str); + } + + // キャプション + set_mcolor(0xffff); + set_mbcolor(0x0); + set_mlocateC(2, 14); + draw_str(item_cap[mkey_y]); + if (menu_state == ms_value) { + set_mlocateC(2, 15); + draw_str(item_cap2[mkey_y]); + } + + videoBuffer=(unsigned short int *)menu_buffer; + +} + +void WinDraw_DrawMenufile(struct menu_flist *mfl) +{ + int i; + + // 下枠 + //set_mcolor(0xf800); // red + //set_mcolor(0xf81f); // magenta + set_mcolor(0xffff); + set_mbcolor(0x1); // 0x0だと透過モード + set_mlocateC(1, 1); + draw_str(swaku_str); + for (i = 2; i < 16; i++) { + set_mlocateC(1, i); + draw_str(swaku2_str); + } + set_mlocateC(1, 16); + draw_str(swaku3_str); + + for (i = 0; i < 14; i++) { + if (i + 1 > mfl->num) { + break; + } + if (i == mfl->y) { + set_mcolor(0x0); + set_mbcolor(0xffff); + } else { + set_mcolor(0xffff); + set_mbcolor(0x1); + } + // ディレクトリだったらファイル名を[]で囲う + set_mlocateC(3, i + 2); + if (mfl->type[i + mfl->ptr]) draw_str("["); + draw_str(mfl->name[i + mfl->ptr]); + if (mfl->type[i + mfl->ptr]) draw_str("]"); + } + + set_mbcolor(0x0); // 透過モードに戻しておく + + videoBuffer=(unsigned short int *)menu_buffer; +} + +void WinDraw_ClearMenuBuffer(void) +{ + memset(menu_buffer, 0, 800*600*2); +} + +/********** ソフトウェアキーボード描画 **********/ + +#if defined(PSP) || defined(USE_OGLES11) + +#if defined(PSP) +// display width 480, buffer width 512 +#define KBDBUF_WIDTH 512 +#elif defined(USE_OGLES11) +// display width 800, buffer width 1024 だけれど 800 にしないとだめ +#define KBDBUF_WIDTH 800 +#endif + +#define KBD_FS 16 // keyboard font size : 16 + +// キーを反転する +void WinDraw_reverse_key(int x, int y) +{ + WORD *p; + int kp; + int i, j; + + kp = Keyboard_get_key_ptr(kbd_kx, kbd_ky); + + p = kbd_buffer + KBDBUF_WIDTH * kbd_key[kp].y + kbd_key[kp].x; + + for (i = 0; i < kbd_key[kp].h; i++) { + for (j = 0; j < kbd_key[kp].w; j++) { + *p = ~(*p); + p++; + } + p = p + KBDBUF_WIDTH - kbd_key[kp].w; + } +} + +static void draw_kbd_to_tex() +{ + int i, x, y; + WORD *p; + + // SJIS 漢字コード + char zen[] = {0x91, 0x53, 0x00}; + char larw[] = {0x81, 0xa9, 0x00}; + char rarw[] = {0x81, 0xa8, 0x00}; + char uarw[] = {0x81, 0xaa, 0x00}; + char darw[] = {0x81, 0xab, 0x00}; + char ka[] = {0x82, 0xa9, 0x00}; + char ro[] = {0x83, 0x8d, 0x00}; + char ko[] = {0x83, 0x52, 0x00}; + char ki[] = {0x8b, 0x4c, 0x00}; + char to[] = {0x93, 0x6f, 0x00}; + char hi[] = {0x82, 0xd0, 0x00}; + + kbd_key[12].s = ka; + kbd_key[13].s = ro; + kbd_key[14].s = ko; + kbd_key[16].s = ki; + kbd_key[17].s = to; + kbd_key[76].s = uarw; + kbd_key[94].s = larw; + kbd_key[95].s = darw; + kbd_key[96].s = rarw; + kbd_key[101].s = hi; + kbd_key[108].s = zen; +#ifdef PSP + kbd_key[0].s = "BK"; + kbd_key[1].s = "CP"; + kbd_key[15].s = "CA"; + kbd_key[18].s = "HP"; + kbd_key[19].s = "EC"; + kbd_key[34].s = "HM"; + kbd_key[35].s = "IN"; + kbd_key[36].s = "DL"; + kbd_key[37].s = "CL"; + kbd_key[55].s = ""; + kbd_key[56].s = "RU"; + kbd_key[57].s = "RD"; + kbd_key[58].s = "UD"; + kbd_key[63].s = "CTR"; + kbd_key[81].s = ""; + kbd_key[93].s = ""; + kbd_key[100].s = ""; + kbd_key[102].s = "X1"; + kbd_key[103].s = "X2"; + kbd_key[105].s = "X3"; + kbd_key[106].s = "X4"; + kbd_key[107].s = "X5"; + kbd_key[109].s = "OP1"; + kbd_key[110].s = "OP2"; +#endif + + set_sbp(kbd_buffer); + set_mfs(KBD_FS); + set_mbcolor(0); + set_mcolor(0); + + // キーボードの背景 + p = kbd_buffer; + for (y = 0; y < kbd_h; y++) { + for (x = 0; x < kbd_w; x++) { + *p++ = (0x7800 | 0x03e0 | 0x000f); + } + p = p + KBDBUF_WIDTH - kbd_w; + } + + // キーの描画 + for (i = 0; kbd_key[i].x != -1; i++) { + p = kbd_buffer + kbd_key[i].y * KBDBUF_WIDTH + kbd_key[i].x; + for (y = 0; y < kbd_key[i].h; y++) { + for (x = 0; x < kbd_key[i].w; x++) { + if (x == (kbd_key[i].w - 1) + || y == (kbd_key[i].h - 1)) { + // キーに影をつけ立体的に見せる + *p++ = 0x0000; + } else { + *p++ = 0xffff; + } + } + p = p + KBDBUF_WIDTH - kbd_key[i].w; + } + if (strlen(kbd_key[i].s) == 3 && *(kbd_key[i].s) == 'F') { + // FUNCキー刻印描画 + set_mlocate(kbd_key[i].x + kbd_key[i].w / 2 + - strlen(kbd_key[i].s) * (8 / 2) + + (strlen(kbd_key[i].s) - 1) * 3 / 2, + kbd_key[i].y + kbd_key[i].h / 2 - 8 / 2); + set_mfs(8); + draw_str(kbd_key[i].s); + set_mfs(KBD_FS); + } else { + // 刻印は上下左右ともセンタリングする + set_mlocate(kbd_key[i].x + kbd_key[i].w / 2 + - strlen(kbd_key[i].s) * (KBD_FS / 2 / 2), + kbd_key[i].y + + kbd_key[i].h / 2 - KBD_FS / 2); + draw_str(kbd_key[i].s); + } + } + + WinDraw_reverse_key(kbd_kx, kbd_ky); +} + +#endif diff --git a/libretro/windraw.h b/libretro/windraw.h new file mode 100644 index 0000000..919ebce --- /dev/null +++ b/libretro/windraw.h @@ -0,0 +1,44 @@ +#ifndef _winx68k_windraw_h +#define _winx68k_windraw_h + +extern BYTE Draw_DrawFlag; +extern int winx, winy; +extern int winh, winw; +extern int FullScreenFlag; +extern BYTE Draw_ClrMenu; +extern WORD FrameCount; +extern WORD WinDraw_Pal16B, WinDraw_Pal16R, WinDraw_Pal16G; + +extern BYTE Draw_BitMask[800]; +extern BYTE Draw_TextBitMask[800]; + +extern int WindowX; +extern int WindowY; +extern int kbd_x, kbd_y, kbd_w, kbd_h; + +void WinDraw_InitWindowSize(WORD width, WORD height); +void WinDraw_ChangeMode(int flag); +int WinDraw_Init(void); +void WinDraw_Cleanup(void); +void WinDraw_Redraw(void); +void FASTCALL WinDraw_Draw(void); +void WinDraw_ShowMenu(int flag); +void WinDraw_DrawLine(void); +void WinDraw_HideSplash(void); +void WinDraw_ChangeSize(void); + +void WinDraw_StartupScreen(void); +void WinDraw_CleanupScreen(void); + +int WinDraw_MenuInit(void); +void WinDraw_DrawMenu(int menu_state, int mkey_pos, int mkey_y, int *mval_y); + +extern struct menu_flist mfl; + +void WinDraw_DrawMenufile(struct menu_flist *mfl); +void WinDraw_ClearMenuBuffer(void); +void WinDraw_reverse_key(int x, int y); + +#endif //winx68k_windraw_h + + diff --git a/libretro/winui.c b/libretro/winui.c new file mode 100644 index 0000000..f15253e --- /dev/null +++ b/libretro/winui.c @@ -0,0 +1,788 @@ +/* + * Copyright (c) 2003,2008 NONAKA Kimihiro + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* -------------------------------------------------------------------------- * + * WINUI.C - UI * + * -------------------------------------------------------------------------- */ + +#include +#include + +#include "common.h" +#include "about.h" +#include "keyboard.h" +#include "windraw.h" +#include "dswin.h" +#include "fileio.h" +#include "prop.h" +#include "status.h" +#include "joystick.h" +#include "mouse.h" +#include "winx68k.h" +#include "version.h" +#include "juliet.h" +#include "fdd.h" +#include "irqh.h" +#include "../m68000/m68000.h" +#include "crtc.h" +#include "mfp.h" +#include "fdc.h" +#include "disk_d88.h" +#include "dmac.h" +#include "ioc.h" +#include "rtc.h" +#include "sasi.h" +#include "bg.h" +#include "palette.h" +#include "crtc.h" +#include "pia.h" +#include "scc.h" +#include "midi.h" +#include "adpcm.h" +#include "mercury.h" +#include "tvram.h" +#include "winui.h" + +#include +#include + +#include "fmg_wrap.h" + +extern BYTE fdctrace; +extern BYTE traceflag; +extern WORD FrameCount; +extern DWORD TimerICount; +extern unsigned int hTimerID; + DWORD timertick=0; +extern int FullScreenFlag; + int UI_MouseFlag = 0; + int UI_MouseX = -1, UI_MouseY = -1; +extern short timertrace; + + BYTE MenuClearFlag = 0; + + BYTE Debug_Text=1, Debug_Grp=1, Debug_Sp=1; + + char filepath[MAX_PATH] = "."; + int fddblink = 0; + int fddblinkcount = 0; + int hddtrace = 0; +extern int dmatrace; + + DWORD LastClock[4] = {0, 0, 0, 0}; + +char cur_dir_str[MAX_PATH]; +int cur_dir_slen; + +struct menu_flist mfl; + +/***** menu items *****/ + +#define MENU_NUM 13 +#define MENU_WINDOW 7 + +int mval_y[] = {0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 1}; + +enum menu_id {M_SYS, M_JOM, M_FD0, M_FD1, M_HD0, M_HD1, M_FS, M_SR, M_VKS, M_VBS, M_HJS, M_NW, M_JK}; + +// Max # of characters is 15. +char menu_item_key[][15] = {"SYSTEM", "Joy/Mouse", "FDD0", "FDD1", "HDD0", "HDD1", "Frame Skip", "Sound Rate", "VKey Size", "VBtn Swap", "HwJoy Setting", "No Wait Mode", "JoyKey", "uhyo", ""}; + +// Max # of characters is 30. +// Max # of items including terminater `""' in each line is 15. +char menu_items[][15][30] = { + {"RESET", "NMI RESET", "QUIT", ""}, + {"Joystick", "Mouse", ""}, + {"dummy", "EJECT", ""}, + {"dummy", "EJECT", ""}, + {"dummy", "EJECT", ""}, + {"dummy", "EJECT", ""}, + {"Auto Frame Skip", "Full Frame", "1/2 Frame", "1/3 Frame", "1/4 Frame", "1/5 Frame", "1/6 Frame", "1/8 Frame", "1/16 Frame", "1/32 Frame", "1/60 Frame", ""}, + {"No Sound", "11025Hz", "22050Hz", "44100Hz", "48000Hz", ""}, + {"Ultra Huge", "Super Huge", "Huge", "Large", "Medium", "Small", ""}, + {"TRIG1 TRIG2", "TRIG2 TRIG1", ""}, + {"Axis0: xx", "Axis1: xx", "Hat: xx", "Button0: xx", "Button1: xx", ""}, + {"Off", "On", ""}, + {"Off", "On", ""} +}; + +static void menu_system(int v); +static void menu_joy_or_mouse(int v); +static void menu_create_flist(int v); +static void menu_frame_skip(int v); +static void menu_sound_rate(int v); +static void menu_vkey_size(int v); +static void menu_vbtn_swap(int v); +static void menu_hwjoy_setting(int v); +static void menu_nowait(int v); +static void menu_joykey(int v); + +struct _menu_func { + void (*func)(int v); + int imm; +}; + +struct _menu_func menu_func[] = { + {menu_system, 0}, + {menu_joy_or_mouse, 1}, + {menu_create_flist, 0}, + {menu_create_flist, 0}, + {menu_create_flist, 0}, + {menu_create_flist, 0}, + {menu_frame_skip, 1}, + {menu_sound_rate, 1}, + {menu_vkey_size, 1}, + {menu_vbtn_swap, 1}, + {menu_hwjoy_setting, 0}, + {menu_nowait, 1}, + {menu_joykey, 1} +}; + +int WinUI_get_drv_num(int key) +{ + char *s = menu_item_key[key]; + + if (!strncmp("FDD", s, 3)) { + return strcmp("FDD0", s)? + (strcmp("FDD1", s)? -1 : 1) : 0; + } else { + return strcmp("HDD0", s)? + (strcmp("HDD1", s)? -1: 3) : 2; + } +} + +static void menu_hwjoy_print(int v) +{ + if (v <= 1) { + sprintf(menu_items[M_HJS][v], "Axis%d(%s): %d", + v, + (v == 0)? "Left/Right" : "Up/Down", + Config.HwJoyAxis[v]); + } else if (v == 2) { + sprintf(menu_items[M_HJS][v], "Hat: %d", Config.HwJoyHat); + } else { + sprintf(menu_items[M_HJS][v], "Button%d: %d", + v - 3, + Config.HwJoyBtn[v - 3]); + } +} + +/****************************************************************************** + * init + ******************************************************************************/ +void +WinUI_Init(void) +{ + int i; + + mval_y[M_JOM] = Config.JoyOrMouse; + if (Config.FrameRate == 7) { + mval_y[M_FS] = 0; + } else if (Config.FrameRate == 8) { + mval_y[M_FS] = 7; + } else if (Config.FrameRate == 16) { + mval_y[M_FS] = 8; + } else if (Config.FrameRate == 32) { + mval_y[M_FS] = 9; + } else if (Config.FrameRate == 60) { + mval_y[M_FS] = 10; + } else { + mval_y[M_FS] = Config.FrameRate; + } + + if (Config.SampleRate == 0) { + mval_y[M_SR] = 0; + } else if (Config.SampleRate == 11025) { + mval_y[M_SR] = 1; + } else if (Config.SampleRate == 22050) { + mval_y[M_SR] = 2; + } else if (Config.SampleRate == 44100) { + mval_y[M_SR] = 3; + } else if (Config.SampleRate == 48000) { + mval_y[M_SR] = 4; + } else { + mval_y[M_SR] = 1; + } + + mval_y[M_VKS] = Config.VkeyScale; + mval_y[M_VBS] = Config.VbtnSwap; + + for (i = 0; i < 11; i++) { + menu_hwjoy_print(i); + } + + mval_y[M_NW] = Config.NoWaitMode; + mval_y[M_JK] = Config.JoyKey; + +#if defined(ANDROID) +#define CUR_DIR_STR winx68k_dir +#elif TARGET_OS_IPHONE && TARGET_IPHONE_SIMULATOR == 0 +#define CUR_DIR_STR "/var/mobile/px68k/" +#else + +#ifdef __LIBRETRO__ +#ifdef _WIN32 +#define CUR_DIR_STR "c:\\" +#else +#define CUR_DIR_STR "/" +#endif +#else +#define CUR_DIR_STR "./" +#endif + +#endif + + strcpy(cur_dir_str, CUR_DIR_STR); +#ifdef ANDROID + strcat(cur_dir_str, "/"); +#endif + cur_dir_slen = strlen(cur_dir_str); + p6logd("cur_dir_str %s %d\n", cur_dir_str, cur_dir_slen); + + for (i = 0; i < 4; i++) { + strcpy(mfl.dir[i], cur_dir_str); + } +} + +#if 0 +/* + * item function + */ +static void +reset(gpointer data, guint action, GtkWidget *w) +{ + WinX68k_Reset(); + if (Config.MIDI_SW && Config.MIDI_Reset) + MIDI_Reset(); +} + +static void +stretch(gpointer data, guint action, GtkWidget *w) +{ + UNUSED(data); + UNUSED(w); + + if (Config.WinStrech != (int)action) + Config.WinStrech = action; +} + +static void +xvimode(gpointer data, guint action, GtkWidget *w) +{ + UNUSED(data); + UNUSED(w); + + if (Config.XVIMode != (int)action) + Config.XVIMode = action; +} + +static void +videoreg_save(gpointer data, guint action, GtkWidget *w) +{ + char buf[256]; + + UNUSED(data); + UNUSED(action); + UNUSED(w); + + DSound_Stop(); + g_snprintf(buf, sizeof(buf), + "VCReg 0:$%02X%02X 1:$%02x%02X 2:$%02X%02X " + "CRTC00/02/05/06=%02X/%02X/%02X/%02X%02X " + "BGHT/HD/VD=%02X/%02X/%02X $%02X/$%02X", + VCReg0[0], VCReg0[1], VCReg1[0], VCReg1[1], VCReg2[0], VCReg2[1], + CRTC_Regs[0x01], CRTC_Regs[0x05], CRTC_Regs[0x0b], CRTC_Regs[0x0c], + CRTC_Regs[0x0d], + BG_Regs[0x0b], BG_Regs[0x0d], BG_Regs[0x0f], + CRTC_Regs[0x29], BG_Regs[0x11]); + Error(buf); + DSound_Play(); +} + +#endif + +float VKey_scale[] = {3.0, 2.5, 2.0, 1.5, 1.25, 1.0}; + +float WinUI_get_vkscale(void) +{ + int n = Config.VkeyScale; + + // failsafe against invalid values + if (n < 0 || n >= sizeof(VKey_scale)/sizeof(float)) { + return 1.0; + } + return VKey_scale[n]; +} + +int menu_state = ms_key; +int mkey_y = 0; +int mkey_pos = 0; + +static void menu_system(int v) +{ + switch (v) { + case 0 : + WinX68k_Reset(); + break; + case 1: + IRQH_Int(7, NULL); + break; + } +} + +static void menu_joy_or_mouse(int v) +{ + Config.JoyOrMouse = v; + Mouse_StartCapture(v == 1); +} + + +static void upper(char *s) +{ + while (*s != '\0') { + if (*s >= 'a' && *s <= 'z') { + *s = 'A' + *s - 'a'; + } + s++; + } +} + +static void menu_create_flist(int v) +{ + int drv; + //file extension of FD image + char support[] = "D8888DHDMDUP2HDDIMXDFIMG"; + + drv = WinUI_get_drv_num(mkey_y); + p6logd("*** drv:%d ***** %s \n", drv, mfl.dir[drv]); + if (drv < 0) { + return; + } + + // set current directory when FDD is ejected + if (v == 1) { + if (drv < 2) { + FDD_EjectFD(drv); + Config.FDDImage[drv][0] = '\0'; + } else { + Config.HDImage[drv - 2][0] = '\0'; + } + strcpy(mfl.dir[drv], cur_dir_str); + return; + } + + if (drv >= 2) { + strcpy(support, "HDF"); + } + + // This routine gets file lists. + DIR *dp; + struct dirent *dent; + struct stat buf; + int i, len; + char *n, ext[4], *p; + char ent_name[MAX_PATH]; + + dp = opendir(mfl.dir[drv]); + + // xxx check if dp is null... + + // xxx You can get only MFL_MAX files. + for (i = 0 ; i < MFL_MAX; i++) { + dent = readdir(dp); + if (dent == NULL) { + break; + } + n = dent->d_name; + strcpy(ent_name, mfl.dir[drv]); + strcat(ent_name, n); + stat(ent_name, &buf); + + if (!S_ISDIR(buf.st_mode)) { + // Check extension if this is file. + len = strlen(n); + if (len < 4 || *(n + len - 4) != '.') { + i--; + continue; + } + strcpy(ext, n + len - 3); + upper(ext); + p = strstr(support, ext); + if (p == NULL || (p - support) % 3 != 0) { + i--; + continue; + } + } else { + if (!strcmp(n, ".")) { + i--; + continue; + } + + // You can't go up over current directory. + if (!strcmp(n, "..") && + !strcmp(mfl.dir[drv], cur_dir_str)) { + i--; + continue; + } + } + + strcpy(mfl.name[i], n); + // set 1 if this is directory + mfl.type[i] = S_ISDIR(buf.st_mode)? 1 : 0; + printf("%s 0x%x\n", n, buf.st_mode); + } + + closedir(dp); + + strcpy(mfl.name[i], ""); + mfl.num = i; + mfl.ptr = 0; +} + +static void menu_frame_skip(int v) +{ + if (v == 0) { + Config.FrameRate = 7; + } else if (v == 7) { + Config.FrameRate = 8; + } else if (v == 8) { + Config.FrameRate = 16; + } else if (v == 9) { + Config.FrameRate = 32; + } else if (v == 10) { + Config.FrameRate = 60; + } else { + Config.FrameRate = v; + } +} + +static void menu_sound_rate(int v) +{ + if (v == 0) { + Config.SampleRate = 0; + } else if (v == 1) { + Config.SampleRate = 11025; + } else if (v == 2) { + Config.SampleRate = 22050; + } else if (v == 3) { + Config.SampleRate = 44100; + } else if (v == 4) { + Config.SampleRate = 48000; + } +} + +static void menu_vkey_size(int v) +{ + Config.VkeyScale = v; +} + +static void menu_vbtn_swap(int v) +{ + Config.VbtnSwap = v; +} + +static void menu_hwjoy_setting(int v) +{ + menu_state = ms_hwjoy_set; +} + +static void menu_nowait(int v) +{ + Config.NoWaitMode = v; +} + +static void menu_joykey(int v) +{ + Config.JoyKey = v; +} + +#ifdef __LIBRETRO__ +extern char slash; +#endif +// ex. ./hoge/.. -> ./ +// ( ./ ---down hoge dir--> ./hoge ---up hoge dir--> ./hoge/.. ) +static void shortcut_dir(int drv) +{ + int i, len, found = 0; + char *p; + + // len is larger than 2 + len = strlen(mfl.dir[drv]); + p = mfl.dir[drv] + len - 2; + for (i = len - 2; i >= 0; i--) { + if (*p == slash/*'/'*/) { + found = 1; + break; + } + p--; + } +#ifdef _WIN32 + if (found && strcmp(p, "\\..\\")) { +#else + if (found && strcmp(p, "/../")) { +#endif + *(p + 1) = '\0'; + } else { +#ifdef _WIN32 + strcat(mfl.dir[drv], "..\\"); +#else + strcat(mfl.dir[drv], "../"); +#endif + } +} + +int WinUI_Menu(int first) +{ + int i, n; + int cursor0; + BYTE joy; + int menu_redraw = 0; + int pad_changed = 0; + int mfile_redraw = 0; + + if (first) { + menu_state = ms_key; + mkey_y = 0; + mkey_pos = 0; + menu_redraw = 1; + first = 0; + // The screen is not rewritten without any key actions, + // so draw screen first. + WinDraw_ClearMenuBuffer(); + WinDraw_DrawMenu(menu_state, mkey_pos, mkey_y, mval_y); + } + + cursor0 = mkey_y; + joy = get_joy_downstate(); + reset_joy_downstate(); + + + if (!(joy & JOY_UP)) { + switch (menu_state) { + case ms_key: + if (mkey_y > 0) { + mkey_y--; + } + if (mkey_pos > mkey_y) { + mkey_pos--; + } + break; + case ms_value: + if (mval_y[mkey_y] > 0) { + mval_y[mkey_y]--; + + // do something immediately + if (menu_func[mkey_y].imm) { + menu_func[mkey_y].func(mval_y[mkey_y]); + } + + menu_redraw = 1; + } + break; + case ms_file: + if (mfl.y == 0) { + if (mfl.ptr > 0) { + mfl.ptr--; + } + } else { + mfl.y--; + } + mfile_redraw = 1; + break; + } + } + + if (!(joy & JOY_DOWN)) { + switch (menu_state) { + case ms_key: + if (mkey_y < MENU_NUM - 1) { + mkey_y++; + } + if (mkey_y > mkey_pos + MENU_WINDOW - 1) { + mkey_pos++; + } + break; + case ms_value: + if (menu_items[mkey_y][mval_y[mkey_y] + 1][0] != '\0') { + mval_y[mkey_y]++; + + if (menu_func[mkey_y].imm) { + menu_func[mkey_y].func(mval_y[mkey_y]); + } + + menu_redraw = 1; + } + break; + case ms_file: + if (mfl.y == 13) { + if (mfl.ptr + 14 < mfl.num + && mfl.ptr < MFL_MAX - 13) { + mfl.ptr++; + } + } else if (mfl.y + 1 < mfl.num) { + mfl.y++; + printf("mfl.y %d\n", mfl.y); + } + mfile_redraw = 1; + break; + } + } + + if (!(joy & JOY_TRG1)) { + int drv, y; + switch (menu_state) { + case ms_key: + menu_state = ms_value; + menu_redraw = 1; + break; + case ms_value: + menu_func[mkey_y].func(mval_y[mkey_y]); + + if (menu_state == ms_hwjoy_set) { + menu_redraw = 1; + break; + } + + // get back key_mode if value is set. + // go file_mode if value is filename. + menu_state = ms_key; + menu_redraw = 1; + + drv = WinUI_get_drv_num(mkey_y); + printf("**** drv:%d *****\n", drv); + if (drv >= 0) { + if (mval_y[mkey_y] == 0) { + // go file_mode + printf("hoge:%d", mval_y[mkey_y]); + menu_state = ms_file; + menu_redraw = 0; //reset + mfile_redraw = 1; + } else { // mval_y[mkey_y] == 1 + // FDD_EjectFD() is done, so set 0. + mval_y[mkey_y] = 0; + } + } else if (!strcmp("SYSTEM", menu_item_key[mkey_y])) { + if (mval_y[mkey_y] == 2) { + return WUM_EMU_QUIT; + } + return WUM_MENU_END; + } + break; + case ms_file: + drv = WinUI_get_drv_num(mkey_y); + printf("***** drv:%d *****\n", drv); + if (drv < 0) { + break; + } + y = mfl.ptr + mfl.y; + p6logd("file slect %s\n", mfl.name[y]); + if (mfl.type[y]) { + // directory operation + if (!strcmp(mfl.name[y], "..")) { + shortcut_dir(drv); + } else { + strcat(mfl.dir[drv], mfl.name[y]); +#ifdef _WIN32 + strcat(mfl.dir[drv], "\\"); +#else + strcat(mfl.dir[drv], "/"); +#endif + } + menu_func[mkey_y].func(0); + mfile_redraw = 1; + } else { + // file operation + if (strlen(mfl.name[y]) != 0) { + char tmpstr[MAX_PATH]; + strcpy(tmpstr, mfl.dir[drv]); + strcat(tmpstr, mfl.name[y]); + if (drv < 2) { + FDD_SetFD(drv, tmpstr, 0); + strcpy(Config.FDDImage[drv], tmpstr); + } else { + strcpy(Config.HDImage[drv - 2], tmpstr); + } + } + menu_state = ms_key; + menu_redraw = 1; + } + mfl.y = 0; + mfl.ptr = 0; + break; + case ms_hwjoy_set: + // Go back keymode + // if TRG1 of v-pad or hw keyboard was pushed. + if (!pad_changed) { + menu_state = ms_key; + menu_redraw = 1; + } + break; + } + } + + if (!(joy & JOY_TRG2)) { + switch (menu_state) { + case ms_file: + menu_state = ms_value; + // reset position of file cursor + mfl.y = 0; + mfl.ptr = 0; + menu_redraw = 1; + break; + case ms_value: + menu_state = ms_key; + menu_redraw = 1; + break; + case ms_hwjoy_set: + // Go back keymode + // if TRG2 of v-pad or hw keyboard was pushed. + if (!pad_changed) { + menu_state = ms_key; + menu_redraw = 1; + } + break; + } + } + + if (pad_changed) { + menu_redraw = 1; + } + + if (cursor0 != mkey_y) { + menu_redraw = 1; + } + + if (mfile_redraw) { + WinDraw_DrawMenufile(&mfl); + mfile_redraw = 0; + } + + if (menu_redraw) { + WinDraw_ClearMenuBuffer(); + WinDraw_DrawMenu(menu_state, mkey_pos, mkey_y, mval_y); + } + + return 0; +} diff --git a/libretro/winui.h b/libretro/winui.h new file mode 100644 index 0000000..623cbfa --- /dev/null +++ b/libretro/winui.h @@ -0,0 +1,41 @@ +#ifndef _winx68k_winui_h +#define _winx68k_winui_h + +#include "common.h" + +extern BYTE Debug_Text, Debug_Grp, Debug_Sp; +extern DWORD LastClock[4]; + +extern char cur_dir_str[]; +extern int cur_dir_slen; + +void WinUI_Init(void); +int WinUI_Menu(int first); +float WinUI_get_vkscale(void); +void send_key(void); + +#define WUM_MENU_END 1 +#define WUM_EMU_QUIT 2 + +enum MenuState {ms_key, ms_value, ms_file, ms_hwjoy_set}; + +#define MFL_MAX 1000 + +struct menu_flist { + char name[MFL_MAX][MAX_PATH]; + char type[MFL_MAX]; + char dir[4][MAX_PATH]; + int ptr; + int num; + int y; +}; + +extern char menu_item_key[][15]; +extern char menu_items[][15][30]; + +int WinUI_get_drv_num(int key); + +#ifndef _winx68k_gtkui_h +#define _winx68k_gtkui_h +#endif //winx68k_gtkui_h +#endif //winx68k_winui_h diff --git a/libretro/winx68k.cpp b/libretro/winx68k.cpp new file mode 100644 index 0000000..8ec9a1f --- /dev/null +++ b/libretro/winx68k.cpp @@ -0,0 +1,797 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#include "common.h" +#include "fileio.h" +#include "timer.h" +#include "keyboard.h" +#include "prop.h" +#include "status.h" +#include "joystick.h" +#include "mkcgrom.h" +#include "winx68k.h" +#include "windraw.h" +#include "winui.h" +#include "../x68k/m68000.h" // xxx 続狸尊狸辿俗谷尊 +#include "../m68000/m68000.h" +#include "../x68k/memory.h" +#include "mfp.h" +#include "opm.h" +#include "bg.h" +#include "adpcm.h" +#include "mercury.h" +#include "crtc.h" +#include "mfp.h" +#include "fdc.h" +#include "fdd.h" +#include "dmac.h" +#include "irqh.h" +#include "ioc.h" +#include "rtc.h" +#include "sasi.h" +#include "scsi.h" +#include "sysport.h" +#include "bg.h" +#include "palette.h" +#include "crtc.h" +#include "pia.h" +#include "scc.h" +#include "midi.h" +#include "sram.h" +#include "gvram.h" +#include "tvram.h" +#include "mouse.h" + +#include "dswin.h" +#include "fmg_wrap.h" + +#ifdef RFMDRV +int rfd_sock; +#endif + + //#define WIN68DEBUG + +#ifdef WIN68DEBUG +#include "d68k.h" +#endif + +//#include "../icons/keropi_mono.xbm" + +#define APPNAME "Keropi" + +extern WORD BG_CHREND; +extern WORD BG_BGTOP; +extern WORD BG_BGEND; +extern BYTE BG_CHRSIZE; + +const BYTE PrgName[] = "Keropi"; +const BYTE PrgTitle[] = APPNAME; + +char winx68k_dir[MAX_PATH]; +char winx68k_ini[MAX_PATH]; + +WORD VLINE_TOTAL = 567; +DWORD VLINE = 0; +DWORD vline = 0; + +extern int SplashFlag; + +BYTE DispFrame = 0; +DWORD SoundSampleRate; + +unsigned int hTimerID = 0; +DWORD TimerICount = 0; +extern DWORD timertick; +BYTE traceflag = 0; + +BYTE ForceDebugMode = 0; +DWORD skippedframes = 0; + +static int ClkUsed = 0; +static int FrameSkipCount = 0; +static int FrameSkipQueue = 0; + +#ifdef __cplusplus +}; +#endif + + +void +WinX68k_SCSICheck(void) +{ + static const BYTE SCSIIMG[] = { + 0x00, 0xfc, 0x00, 0x14, // $fc0000 SCSI袖俗属ﾂヅ‖ッ蛎ッ促棚促蔵促促狸促孫 + 0x00, 0xfc, 0x00, 0x16, // $fc0004 IOCS促促俗促多棚ﾂヅ‖ッ蛎ッ促棚促蔵促促狸促孫(測尊"Human"8促促促属) + 0x00, 0x00, 0x00, 0x00, // $fc0008 ? + 0x48, 0x75, 0x6d, 0x61, // $fc000c 蔵足 + 0x6e, 0x36, 0x38, 0x6b, // $fc0010 ID "Human68k" (測尊袖俗属促邸促坦促促棚促促促坦促ﾃ展属) + 0x4e, 0x75, // $fc0014 "rts" (袖俗属促邸促坦促促棚促促促坦促) + 0x23, 0xfc, 0x00, 0xfc, 0x00, 0x2a, // $fc0016 蔵足 (IOCS促促俗促多棚促邸促坦促促棚促促促坦促) + 0x00, 0x00, 0x07, 0xd4, // $fc001c "move.l #$fc002a, $7d4.l" + 0x74, 0xff, // $fc0020 "moveq #-1, d2" + 0x4e, 0x75, // $fc0022 "rts" +// 0x53, 0x43, 0x53, 0x49, 0x49, 0x4e, // $fc0024 ID "SCSIIN" +// 但蔵SCSI嘆ON孫谷臓蔵SASI束属捉OFF達辿揃臓 +// 竪臓蔵ID昤促促揃竪揃捉俗臓 + 0x44, 0x55, 0x4d, 0x4d, 0x59, 0x20, // $fc0024 ID "DUMMY " + 0x70, 0xff, // $fc002a "moveq #-1, d0" (SCSI IOCS促続臓促谷促邸促坦促促棚促促促坦促) + 0x4e, 0x75, // $fc002c "rts" + }; + +#if 0 + DWORD *p; +#endif + WORD *p1, *p2; + int scsi; + int i; + + scsi = 0; + for (i = 0x30600; i < 0x30c00; i += 2) { +#if 0 // 4ﾃ多担其旦多担促蔵促促狸促孫束辿4促促促孫促蔵促俗促損促孫MIPS袖箪 + p = (DWORD *)(&IPL[i]); + if (*p == 0x0000fc00) + scsi = 1; +#else + p1 = (WORD *)(&IPL[i]); + p2 = p1 + 1; + // xxx: works only for little endian guys + if (*p1 == 0xfc00 && *p2 == 0x0000) { + scsi = 1; + break; + } +#endif + } + + // SCSI促但促促谷足 + if (scsi) { + ZeroMemory(IPL, 0x2000); // 8kb + memset(&IPL[0x2000], 0xff, 0x1e000); // 損棚0xff + memcpy(IPL, SCSIIMG, sizeof(SCSIIMG)); // 促促坦促促足SCSI BIOS +// Memory_SetSCSIMode(); + } else { + // SASI促但促促谷IPL測転束邸谷 + memcpy(IPL, &IPL[0x20000], 0x20000); + } +} + +int +WinX68k_LoadROMs(void) +{ + static const char *BIOSFILE[] = { + "iplrom.dat", "iplrom30.dat", "iplromco.dat", "iplromxv.dat" + }; + static const char FONTFILE[] = "cgrom.dat"; + static const char FONTFILETMP[] = "cgrom.tmp"; + FILEH fp; + int i; + BYTE tmp; + + for (fp = 0, i = 0; fp == 0 && i < NELEMENTS(BIOSFILE); ++i) { + fp = File_OpenCurDir((char *)BIOSFILE[i]); + printf("fp:%d (%s)\n",fp,(char *)BIOSFILE[i]); + } + + if (fp == 0) { + Error("BIOS ROM 促促叩臓促転測転束束棚損坦."); + return FALSE; + } + + File_Read(fp, &IPL[0x20000], 0x20000); + File_Close(fp); + + WinX68k_SCSICheck(); // SCSI IPL辿臓蔵$fc0000臓SCSI BIOS嘆俗 + + for (i = 0; i < 0x40000; i += 2) { + tmp = IPL[i]; + IPL[i] = IPL[i + 1]; + IPL[i + 1] = tmp; + } + + fp = File_OpenCurDir((char *)FONTFILE); + if (fp == 0) { + // cgrom.tmp測蔵谷臓息 + fp = File_OpenCurDir((char *)FONTFILETMP); + if (fp == 0) { +#if 1 + // 促促息促坦促転速 XXX + printf("促促息促坦促ROM促促叩臓促転測転束束棚損坦\n"); + return FALSE; +#else + MessageBox(hWndMain, + "促促息促坦促ROM促促叩臓促転測転束束棚損坦.\nWindows促促息促坦促束辿多揃袖測尊樽速揃孫.", + "賊鱈臓ﾂッ‖ッ促損臓促転", MB_ICONWARNING | MB_OK); + SSTP_SendMes(SSTPMES_MAKEFONT); + make_cgromdat(FONT, FALSE, "贈贈 促貼促揃促促俗", "贈贈 束"); + //WinX68k_MakeFont(); + //DialogBox(hInst, MAKEINTRESOURCE(IDD_PROGBAR), + // hWndMain, (DLGPROC)MakeFontProc); + fp = File_CreateCurDir(FONTFILETMP); + if (fp) + { + File_Write(fp, FONT, 0xc0000); + File_Close(fp); + return TRUE; + } + return TRUE; +#endif + } + } + File_Read(fp, FONT, 0xc0000); + File_Close(fp); + + return TRUE; +} + +int +WinX68k_Reset(void) +{ + OPM_Reset(); + + C68k_Reset(&C68K); +/* + C68k_Set_Reg(&C68K, C68K_A7, (IPL[0x30001]<<24)|(IPL[0x30000]<<16)|(IPL[0x30003]<<8)|IPL[0x30002]); + C68k_Set_Reg(&C68K, C68K_PC, (IPL[0x30005]<<24)|(IPL[0x30004]<<16)|(IPL[0x30007]<<8)|IPL[0x30006]); +*/ + C68k_Set_AReg(&C68K, 7, (IPL[0x30001]<<24)|(IPL[0x30000]<<16)|(IPL[0x30003]<<8)|IPL[0x30002]); + C68k_Set_PC(&C68K, (IPL[0x30005]<<24)|(IPL[0x30004]<<16)|(IPL[0x30007]<<8)|IPL[0x30006]); + Memory_Init(); + CRTC_Init(); + DMA_Init(); + MFP_Init(); + FDC_Init(); + FDD_Reset(); + SASI_Init(); + SCSI_Init(); + IOC_Init(); + SCC_Init(); + PIA_Init(); + RTC_Init(); + TVRAM_Init(); + GVRAM_Init(); + BG_Init(); + Pal_Init(); + IRQH_Init(); + MIDI_Init(); + //WinDrv_Init(); + +// C68K.ICount = 0; + m68000_ICountBk = 0; + ICount = 0; + + DSound_Stop(); + SRAM_VirusCheck(); + //CDROM_Init(); + DSound_Play(); + + return TRUE; +} + + +int +WinX68k_Init(void) +{ + +#define MEM_SIZE 0xc00000 + + IPL = (BYTE*)malloc(0x40000); + MEM = (BYTE*)malloc(MEM_SIZE); + FONT = (BYTE*)malloc(0xc0000); + + if (MEM) + ZeroMemory(MEM, MEM_SIZE); + + if (MEM && FONT && IPL) { + m68000_init(); + return TRUE; + } else + return FALSE; +} + +void +WinX68k_Cleanup(void) +{ + + if (IPL) { + free(IPL); + IPL = 0; + } + if (MEM) { + free(MEM); + MEM = 0; + } + if (FONT) { + free(FONT); + FONT = 0; + } +} + +#define CLOCK_SLICE 200 +// ----------------------------------------------------------------------------------- +// 促続促蔵叩坦谷臓 +// ----------------------------------------------------------------------------------- +void WinX68k_Exec(void) +{ + //char *test = NULL; + int clk_total, clkdiv, usedclk, hsync, clk_next, clk_count, clk_line=0; + int KeyIntCnt = 0, MouseIntCnt = 0; + DWORD t_start = timeGetTime(), t_end; + + if ( Config.FrameRate != 7 ) { + DispFrame = (DispFrame+1)%Config.FrameRate; + } else { // Auto Frame Skip + if ( FrameSkipQueue ) { + if ( FrameSkipCount>15 ) { + FrameSkipCount = 0; + FrameSkipQueue++; + DispFrame = 0; + } else { + FrameSkipCount++; + FrameSkipQueue--; + DispFrame = 1; + } + } else { + FrameSkipCount = 0; + DispFrame = 0; + } + } + + vline = 0; + clk_count = -ICount; + clk_total = (CRTC_Regs[0x29] & 0x10) ? VSYNC_HIGH : VSYNC_NORM; + if (Config.XVIMode == 1) { + clk_total = (clk_total*16)/10; + clkdiv = 16; + } else if (Config.XVIMode == 2) { + clk_total = (clk_total*24)/10; + clkdiv = 24; + } else { + clkdiv = 10; + } + ICount += clk_total; + clk_next = (clk_total/VLINE_TOTAL); + hsync = 1; + + do { + int m, n = (ICount>CLOCK_SLICE)?CLOCK_SLICE:ICount; +// C68K.ICount = m68000_ICountBk = 0; // 続辰棚孫綻俗転属多邸捉束促促叩臓CARAT臓 + + if ( hsync ) { + hsync = 0; + clk_line = 0; + MFP_Int(0); + if ( (vline>=CRTC_VSTART)&&(vline=VLINE_TOTAL ) { + if ( (long)vline==(CRTC_VEND-VLINE_TOTAL) ) MFP_Int(9); // 促邸促足促袖促促促贈促坦促属促蔵促誰臓束臓TOTAL=0x2000)&&((regs.pc<=0x8e0e0))) tracing=50000; +// if (regs.pc<0x10000) tracing=1; +// if ( (regs.pc&1) ) +// fp=fopen("_trace68.txt", "a"); +// if ( (regs.pc==0x7176) /*&& (Memory_ReadW(oldpc)==0xff1a)*/ ) tracing=100; +// if ( (/*((regs.pc>=0x27000) && (regs.pc<=0x29000))||*/((regs.pc>=0x27000) && (regs.pc<=0x29000))) && (oldpc!=regs.pc)) + if (/*fdctrace&&*/(oldpc != C68k_Get_Reg(&C68K, C68K_PC))) + { +// //tracing--; + fprintf(fp, "D0:%08X D1:%08X D2:%08X D3:%08X D4:%08X D5:%08X D6:%08X D7:%08X CR:%04X\n", C68K.D[0], C68K.D[1], C68K.D[2], C68K.D[3], C68K.D[4], C68K.D[5], C68K.D[6], C68K.D[7], 0/* xxx 棚蔵邸尊0 C68K.ccr */); + fprintf(fp, "A0:%08X A1:%08X A2:%08X A3:%08X A4:%08X A5:%08X A6:%08X A7:%08X SR:%04X\n", C68K.A[0], C68K.A[1], C68K.A[2], C68K.A[3], C68K.A[4], C68K.A[5], C68K.A[6], C68K.A[7], C68k_Get_Reg(&C68K, C68K_SR) >> 8/* regs.sr_high*/); + fprintf(fp, "<%04X> (%08X ->) %08X : %s\n", Memory_ReadW(C68k_Get_Reg(&C68K, C68K_PC)), oldpc, C68k_Get_Reg(&C68K, C68K_PC), buf); + } + oldpc = C68k_Get_Reg(&C68K, C68K_PC); +// C68K.ICount = 1; +// C68k_Exec(&C68K, C68K.ICount); + C68k_Exec(&C68K, 1); + } + fclose(fp); + usedclk = clk_line = HSYNC_CLK; + clk_count = clk_next; + } + else +#endif + { +// C68K.ICount = n; +// C68k_Exec(&C68K, C68K.ICount); + C68k_Exec(&C68K, n); + m = (n-m68000_ICountBk); // 腟 +// m = (n-C68K.ICount-m68000_ICountBk); // 揃族叩促俗促鱈促促俗多担 + ClkUsed += m*10; + usedclk = ClkUsed/clkdiv; + clk_line += usedclk; + ClkUsed -= usedclk*clkdiv; + ICount -= m; + clk_count += m; +// C68K.ICount = m68000_ICountBk = 0; + } + + MFP_Timer(usedclk); + RTC_Timer(usedclk); + DMA_Exec(0); + DMA_Exec(1); + DMA_Exec(2); + + if ( clk_count>=clk_next ) { + //OPM_RomeoOut(Config.BufferSize*5); + //MIDI_DelayOut((Config.MIDIAutoDelay)?(Config.BufferSize*5):Config.MIDIDelay); + MFP_TimerA(); + if ( (MFP[MFP_AER]&0x40)&&(vline==CRTC_IntLine) ) + MFP_Int(1); + if ( (!DispFrame)&&(vline>=CRTC_VSTART)&&(vline(VLINE_TOTAL/4) ) { + KeyIntCnt = 0; + Keyboard_Int(); + } + MouseIntCnt++; + if ( MouseIntCnt>(VLINE_TOTAL/8) ) { + MouseIntCnt = 0; + SCC_IntCheck(); + } + DSound_Send0(clk_line); + + vline++; + clk_next = (clk_total*(vline+1))/VLINE_TOTAL; + hsync = 1; + } + } while ( vline((CRTC_Regs[0x29]&0x10)?14:16) ) { + FrameSkipQueue += ((t_end-t_start)/((CRTC_Regs[0x29]&0x10)?14:16))+1; + if ( FrameSkipQueue>100 ) + FrameSkipQueue = 100; + } +} + + +#ifdef __cplusplus +extern "C" { +#endif + +#include "libretro.h" + +extern retro_input_state_t input_state_cb; +extern char Core_Key_Sate[512]; +extern char Core_old_Key_Sate[512]; + +int mb1=0,mb2=0; +extern int retrow,retroh,CHANGEAV; +static int oldrw=0,oldrh=0; +int end_loop=0; + +enum {menu_out, menu_enter, menu_in}; +int menu_mode = menu_out; +#ifdef __cplusplus +}; +#endif +extern "C" int pmain(int argc, char *argv[]) +{ + + int raudio = -1; + + p6logd("PX68K Ver.%s\n", PX68KVERSTR); + +#ifdef RFMDRV + struct sockaddr_in dest; + + memset(&dest, 0, sizeof(dest)); + dest.sin_port = htons(2151); + dest.sin_family = AF_INET; + dest.sin_addr.s_addr = inet_addr("127.0.0.1"); + + rfd_sock = socket(AF_INET, SOCK_STREAM, 0); + connect (rfd_sock, (struct sockaddr *)&dest, sizeof(dest)); +#endif + + if (set_modulepath(winx68k_dir, sizeof(winx68k_dir))) + return 1; + + dosio_init(); + file_setcd(winx68k_dir); + puts(winx68k_dir); + + LoadConfig(); + + if (!WinDraw_MenuInit()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + return 1; + } + + SplashFlag = 20; + SoundSampleRate = Config.SampleRate; + + StatBar_Show(Config.WindowFDDStat); + WinDraw_ChangeSize(); + WinDraw_ChangeMode(FALSE); + + WinUI_Init(); + WinDraw_StartupScreen(); + + if (!WinX68k_Init()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + return 1; + } + + if (!WinX68k_LoadROMs()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + exit (1); + } + + Keyboard_Init(); //WinDraw_Init()属属属 + + if (!WinDraw_Init()) { + WinDraw_Cleanup(); + Error("Error: Can't init screen.\n"); + return 1; + } + + if ( SoundSampleRate ) { + ADPCM_Init(SoundSampleRate); + OPM_Init(4000000/*3579545*/, SoundSampleRate); +#ifndef NO_MERCURY + Mcry_Init(SoundSampleRate, winx68k_dir); +#endif + } else { + ADPCM_Init(100); + OPM_Init(4000000/*3579545*/, 100); +#ifndef NO_MERCURY + Mcry_Init(100, winx68k_dir); +#endif + } + + FDD_Init(); + SysPort_Init(); + Mouse_Init(); + Joystick_Init(); + SRAM_Init(); + WinX68k_Reset(); + Timer_Init(); + + MIDI_Init(); + MIDI_SetMimpiMap(Config.ToneMapFile); // 族損多則棚促促臓促促谷損多賊 + MIDI_EnableMimpiDef(Config.ToneMap); + + if (/*raudio == 0 &&*/ !DSound_Init(Config.SampleRate, Config.BufferSize)) { + + if (Config.DSAlert) + fprintf(stderr, "Can't init sound.\n"); + } + + ADPCM_SetVolume((BYTE)Config.PCM_VOL); + OPM_SetVolume((BYTE)Config.OPM_VOL); +#ifndef NO_MERCURY + Mcry_SetVolume((BYTE)Config.MCR_VOL); +#endif + DSound_Play(); + + // command line 束辿損棚揃多展狸孫巽 + if(argc==3 && argv[1][0]=='-' && argv[1][1]=='h') + strcpy(Config.HDImage[0], argv[2]); + else { + switch (argc) { + case 3: + strcpy(Config.FDDImage[1], argv[2]); + case 2: + strcpy(Config.FDDImage[0], argv[1]); + break; + } + } + + FDD_SetFD(0, Config.FDDImage[0], 0); + FDD_SetFD(1, Config.FDDImage[1], 0); + +} + +extern "C" void exec_app_retro(){ + + int menu_key_down; + //while (1) { + // OPM_RomeoOut(Config.BufferSize * 5); + if (menu_mode == menu_out + && (Config.NoWaitMode || Timer_GetCount())) { + WinX68k_Exec(); + + if (SplashFlag) { + SplashFlag--; + if (SplashFlag == 0) + WinDraw_HideSplash(); + } + } + + menu_key_down = -1; + //end_loop=1; + + static int mbL = 0, mbR = 0; + + int mouse_x = input_state_cb(0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_X); + int mouse_y = input_state_cb(0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_Y); + + Mouse_Event(0, mouse_x, mouse_y); + + int mouse_l = input_state_cb(0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT); + int mouse_r = input_state_cb(0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT); + + if(mbL==0 && mouse_l){ + mbL=1; + Mouse_Event(1,1.0,0); + } + else if(mbL==1 && !mouse_l) + { + mbL=0; + Mouse_Event(1,0,0); + } + if(mbR==0 && mouse_r){ + mbR=1; + Mouse_Event(2,1.0,0); + } + else if(mbR==1 && !mouse_r) + { + mbR=0; + Mouse_Event(2,0,0); + } + + int i; + + for(i=0;i<320;i++) + Core_Key_Sate[i]=input_state_cb(0, RETRO_DEVICE_KEYBOARD, 0,i) ? 0x80: 0; + + if(memcmp( Core_Key_Sate,Core_old_Key_Sate , sizeof(Core_Key_Sate) ) ) + for(i=0;i<320;i++) + if(Core_Key_Sate[i] && Core_Key_Sate[i]!=Core_old_Key_Sate[i] ) + { + if(i==RETROK_F12) + { + if (menu_mode == menu_out) { + oldrw=retrow;oldrh=retroh; + retroh=600;retrow=800; + CHANGEAV=1; + menu_mode = menu_enter; + DSound_Stop(); + } else { + CHANGEAV=1; + retrow=oldrw;retroh=oldrh; + DSound_Play(); + menu_mode = menu_out; + } + + continue; + } + +#ifdef WIN68DEBUG + if (i == RETROK_F10) { + traceflag ^= 1; + printf("trace %s\n", (traceflag)?"on":"off"); + } +#endif + if (menu_mode != menu_out) { + menu_key_down = i; + } else { + Keyboard_KeyDown(i); + } + //printf("press: %d \n",i); + + } + else if ( !Core_Key_Sate[i] && Core_Key_Sate[i]!=Core_old_Key_Sate[i] ) + { + //printf("release: %d \n",i); + Keyboard_KeyUp(i); + + } + + memcpy(Core_old_Key_Sate,Core_Key_Sate , sizeof(Core_Key_Sate) ); + + + if (menu_mode != menu_out) { + int ret; + + Joystick_Update(TRUE, menu_key_down); + + ret = WinUI_Menu(menu_mode == menu_enter); + menu_mode = menu_in; + if (ret == WUM_MENU_END) { + DSound_Play(); + menu_mode = menu_out; + } else if (ret == WUM_EMU_QUIT) { + end_loop=1; + } + } + + //} +} + +extern "C" void end_loop_retro(){ +//end_loop: + Memory_WriteB(0xe8e00d, 0x31); // SRAM単足孫綻袖旦族 + Memory_WriteD(0xed0040, Memory_ReadD(0xed0040)+1); // 損損族俗損綻貼(min.) + Memory_WriteD(0xed0044, Memory_ReadD(0xed0044)+1); // 損損袖俗属族坦多担 + + OPM_Cleanup(); +#ifndef NO_MERCURY + Mcry_Cleanup(); +#endif + + Joystick_Cleanup(); + SRAM_Cleanup(); + FDD_Cleanup(); + //CDROM_Cleanup(); + MIDI_Cleanup(); + DSound_Cleanup(); + WinX68k_Cleanup(); + WinDraw_Cleanup(); + WinDraw_CleanupScreen(); + + SaveConfig(); + + return 0; +} + diff --git a/libretro/winx68k.h b/libretro/winx68k.h new file mode 100644 index 0000000..f9adc49 --- /dev/null +++ b/libretro/winx68k.h @@ -0,0 +1,72 @@ +#ifndef winx68k_wincore_h +#define winx68k_wincore_h + +#include "common.h" + +#ifdef RFMDRV +#include +#include +#include + +extern int rfd_sock; +#endif + +#define vline HOGEvline // workaround for redefinition of 'vline' + +#define SCREEN_WIDTH 768 +#define SCREEN_HEIGHT 512 + +#define FULLSCREEN_WIDTH 800 +#define FULLSCREEN_HEIGHT 600 +#define FULLSCREEN_POSX ((FULLSCREEN_WIDTH - SCREEN_WIDTH) / 2) +#define FULLSCREEN_POSY ((FULLSCREEN_HEIGHT - SCREEN_HEIGHT) / 2) + +#define TOSTR(s) #s +#define _TOSTR(s) TOSTR(s) +#define PX68KVERSTR _TOSTR(PX68K_VERSION) + +extern BYTE* FONT; + +extern WORD VLINE_TOTAL; +extern DWORD VLINE; +extern DWORD vline; + +extern char winx68k_dir[MAX_PATH]; +extern char winx68k_ini[MAX_PATH]; +extern int BIOS030Flag; +extern BYTE FrameChanged; + +extern const BYTE PrgTitle[]; + +#if defined(ANDROID) || TARGET_OS_IPHONE +extern int realdisp_w, realdisp_h; +#endif + +int WinX68k_Reset(void); + +#ifndef winx68k_gtkwarpper_h +#define winx68k_gtkwarpper_h + +#include +#include + +#if 0 +#include +#include + +extern GtkWidget *window; +extern GtkWidget *main_vbox; +extern GtkWidget *menubar; +extern GtkWidget *drawarea; +extern GdkPixmap *splash_pixmap; +#endif + +BOOL is_installed_idle_process(void); +void install_idle_process(void); +void uninstall_idle_process(void); + +#define NELEMENTS(array) ((int)(sizeof(array) / sizeof(array[0]))) + +#endif //winx68k_gtkwarpper_h + +#endif //winx68k_wincore_h diff --git a/link.T b/link.T new file mode 100644 index 0000000..b0c262d --- /dev/null +++ b/link.T @@ -0,0 +1,5 @@ +{ + global: retro_*; + local: *; +}; + diff --git a/m68000/c68k/c68k.c b/m68000/c68k/c68k.c new file mode 100644 index 0000000..b904ef1 --- /dev/null +++ b/m68000/c68k/c68k.c @@ -0,0 +1,315 @@ +/* Copyright 2003-2004 Stephane Dallongeville + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/*! \file c68k.c + \brief C68K init, interrupt and memory access functions. +*/ + +/********************************************************************************* + * + * C68K (68000 CPU emulator) version 0.80 + * Compiled with Dev-C++ + * Copyright 2003-2004 Stephane Dallongeville + * + ********************************************************************************/ + +#include +#include + +#include "c68k.h" + +// shared global variable +////////////////////////// + +c68k_struc C68K; + +// include macro file +////////////////////// + +#include "c68kmac.inc" + +// prototype +///////////// + +u32 FASTCALL C68k_Read_Dummy(const u32 adr); +void FASTCALL C68k_Write_Dummy(const u32 adr, u32 data); + +u32 C68k_Read_Byte(c68k_struc *cpu, u32 adr); +u32 C68k_Read_Word(c68k_struc *cpu, u32 adr); +u32 C68k_Read_Long(c68k_struc *cpu, u32 adr); +void C68k_Write_Byte(c68k_struc *cpu, u32 adr, u32 data); +void C68k_Write_Word(c68k_struc *cpu, u32 adr, u32 data); +void C68k_Write_Long(c68k_struc *cpu, u32 adr, u32 data); + +s32 FASTCALL C68k_Interrupt_Ack_Dummy(s32 level); +void FASTCALL C68k_Reset_Dummy(void); + +// core main functions +/////////////////////// + +void C68k_Init(c68k_struc *cpu, C68K_INT_CALLBACK *int_cb) +{ + memset(cpu, 0, sizeof(c68k_struc)); + + C68k_Set_ReadB(cpu, C68k_Read_Dummy); + C68k_Set_ReadW(cpu, C68k_Read_Dummy); + + C68k_Set_WriteB(cpu, C68k_Write_Dummy); + C68k_Set_WriteW(cpu, C68k_Write_Dummy); + + if (int_cb) cpu->Interrupt_CallBack = int_cb; + else cpu->Interrupt_CallBack = C68k_Interrupt_Ack_Dummy; + cpu->Reset_CallBack = C68k_Reset_Dummy; + + // used to init JumpTable + cpu->Status |= C68K_DISABLE; + C68k_Exec(cpu, 0); + + cpu->Status &= ~C68K_DISABLE; +} + +s32 FASTCALL C68k_Reset(c68k_struc *cpu) +{ + memset(cpu, 0, ((u8 *)&(cpu->dirty1)) - ((u8 *)&(cpu->D[0]))); + + cpu->flag_notZ = 1; + cpu->flag_I = 7; + cpu->flag_S = C68K_SR_S; + + cpu->A[7] = C68k_Read_Long(cpu, 0); + C68k_Set_PC(cpu, C68k_Read_Long(cpu, 4)); + + return cpu->Status; +} + +///////////////////////////////// + +void FASTCALL C68k_Set_IRQ(c68k_struc *cpu, s32 level) +{ + cpu->IRQLine = level; + if (cpu->Status & C68K_RUNNING) + { + cpu->CycleSup = cpu->CycleIO; + cpu->CycleIO = 0; + } + cpu->Status &= ~(C68K_HALTED | C68K_WAITING); +} + +///////////////////////////////// + +s32 FASTCALL C68k_Get_CycleToDo(c68k_struc *cpu) +{ + if (!(cpu->Status & C68K_RUNNING)) return -1; + + return cpu->CycleToDo; +} + +s32 FASTCALL C68k_Get_CycleRemaining(c68k_struc *cpu) +{ + if (!(cpu->Status & C68K_RUNNING)) return -1; + + return (cpu->CycleIO + cpu->CycleSup); +} + +s32 FASTCALL C68k_Get_CycleDone(c68k_struc *cpu) +{ + if (!(cpu->Status & C68K_RUNNING)) return -1; + + return (cpu->CycleToDo - (cpu->CycleIO + cpu->CycleSup)); +} + +void FASTCALL C68k_Release_Cycle(c68k_struc *cpu) +{ + if (cpu->Status & C68K_RUNNING) cpu->CycleIO = cpu->CycleSup = 0; +} + +void FASTCALL C68k_Add_Cycle(c68k_struc *cpu, s32 cycle) +{ + if (cpu->Status & C68K_RUNNING) cpu->CycleIO -= cycle; +} + +// Read / Write dummy functions +//////////////////////////////// + +u32 FASTCALL C68k_Read_Dummy(__attribute ((unused)) const u32 adr) +{ + return 0; +} + +void FASTCALL C68k_Write_Dummy(__attribute ((unused)) const u32 adr, __attribute ((unused)) u32 data) +{ + +} + +s32 FASTCALL C68k_Interrupt_Ack_Dummy(s32 level) +{ + // return vector + return (C68K_INTERRUPT_AUTOVECTOR_EX + level); +} + +void FASTCALL C68k_Reset_Dummy(void) +{ + +} + +// Read / Write core functions +/////////////////////////////// + +u32 C68k_Read_Byte(c68k_struc *cpu, u32 adr) +{ + return cpu->Read_Byte(adr); +} + +u32 C68k_Read_Word(c68k_struc *cpu, u32 adr) +{ + return cpu->Read_Word(adr); +} + +u32 C68k_Read_Long(c68k_struc *cpu, u32 adr) +{ +#ifdef C68K_BIG_ENDIAN + return (cpu->Read_Word(adr) << 16) | (cpu->Read_Word(adr + 2) & 0xFFFF); +#else + return (cpu->Read_Word(adr) << 16) | (cpu->Read_Word(adr + 2) & 0xFFFF); +#endif +} + +void C68k_Write_Byte(c68k_struc *cpu, u32 adr, u32 data) +{ + cpu->Write_Byte(adr, data); +} + +void C68k_Write_Word(c68k_struc *cpu, u32 adr, u32 data) +{ + cpu->Write_Word(adr, data); +} + +void C68k_Write_Long(c68k_struc *cpu, u32 adr, u32 data) +{ +#ifdef C68K_BIG_ENDIAN + cpu->Write_Word(adr, data >> 16); + cpu->Write_Word(adr + 2, data & 0xFFFF); +#else + cpu->Write_Word(adr, data >> 16); + cpu->Write_Word(adr + 2, data & 0xFFFF); +#endif +} + +// setting core functions +////////////////////////// + +void C68k_Set_Fetch(c68k_struc *cpu, u32 low_adr, u32 high_adr, pointer fetch_adr) +{ + u32 i, j; + + i = (low_adr >> C68K_FETCH_SFT) & C68K_FETCH_MASK; + j = (high_adr >> C68K_FETCH_SFT) & C68K_FETCH_MASK; + fetch_adr -= i << C68K_FETCH_SFT; + while (i <= j) cpu->Fetch[i++] = fetch_adr; +} + +void C68k_Set_ReadB(c68k_struc *cpu, C68K_READ *Func) +{ + cpu->Read_Byte = Func; +} + +void C68k_Set_ReadW(c68k_struc *cpu, C68K_READ *Func) +{ + cpu->Read_Word = Func; +} + +void C68k_Set_WriteB(c68k_struc *cpu, C68K_WRITE *Func) +{ + cpu->Write_Byte = Func; +} + +void C68k_Set_WriteW(c68k_struc *cpu, C68K_WRITE *Func) +{ + cpu->Write_Word = Func; +} + +// externals main functions +//////////////////////////// + +u32 C68k_Get_DReg(c68k_struc *cpu, u32 num) +{ + return cpu->D[num]; +} + +u32 C68k_Get_AReg(c68k_struc *cpu, u32 num) +{ + return cpu->A[num]; +} + +u32 C68k_Get_PC(c68k_struc *cpu) +{ + return (cpu->PC - cpu->BasePC); +} + +u32 C68k_Get_SR(c68k_struc *cpu) +{ + c68k_struc *CPU = cpu; + return GET_SR; +} + +u32 C68k_Get_USP(c68k_struc *cpu) +{ + if (cpu->flag_S) return cpu->USP; + else return cpu->A[7]; +} + +u32 C68k_Get_MSP(c68k_struc *cpu) +{ + if (cpu->flag_S) return cpu->A[7]; + else return cpu->USP; +} + +void C68k_Set_DReg(c68k_struc *cpu, u32 num, u32 val) +{ + cpu->D[num] = val; +} + +void C68k_Set_AReg(c68k_struc *cpu, u32 num, u32 val) +{ + cpu->A[num] = val; +} + +void C68k_Set_PC(c68k_struc *cpu, u32 val) +{ + cpu->BasePC = cpu->Fetch[(val >> C68K_FETCH_SFT) & C68K_FETCH_MASK]; + cpu->PC = val + cpu->BasePC; +} + +void C68k_Set_SR(c68k_struc *cpu, u32 val) +{ + c68k_struc *CPU = cpu; + SET_SR(val); +} + +void C68k_Set_USP(c68k_struc *cpu, u32 val) +{ + if (cpu->flag_S) cpu->USP = val; + else cpu->A[7] = val; +} + +void C68k_Set_MSP(c68k_struc *cpu, u32 val) +{ + if (cpu->flag_S) cpu->A[7] = val; + else cpu->USP = val; +} diff --git a/m68000/c68k/c68k.h b/m68000/c68k/c68k.h new file mode 100644 index 0000000..e28d931 --- /dev/null +++ b/m68000/c68k/c68k.h @@ -0,0 +1,214 @@ +/* Copyright 2003-2004 Stephane Dallongeville + Copyright 2004 Theo Berkau + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/********************************************************************************* + * C68K.H : + * + * C68K include file + * + ********************************************************************************/ + +#ifndef _C68K_H_ +#define _C68K_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "core.h" +#include "common.h" + +// setting +/////////// + +//#define NEOCD_HLE + +//#define C68K_GEN +#define C68K_BYTE_SWAP_OPT + +#ifdef WORDS_BIGENDIAN +#define C68K_BIG_ENDIAN +#endif + +#ifdef C68K_BIG_ENDIAN + #define BYTE_OFF 3 + #define WORD_OFF 1 +#else + #define BYTE_OFF 0 + #define WORD_OFF 0 +#endif + +//#define C68K_NO_JUMP_TABLE +//#define C68K_DEBUG +#define C68K_TAS_CAN_SET_MEMORY +//#define C68K_CONST_JUMP_TABLE +//#define C68K_AUTOVECTOR_CALLBACK + +// 68K core types definitions +////////////////////////////// + +#define C68K_FETCH_BITS 8 // [4-12] default = 8 +#define C68K_ADR_BITS 24 + +#define C68K_FETCH_SFT (C68K_ADR_BITS - C68K_FETCH_BITS) +#define C68K_FETCH_BANK (1 << C68K_FETCH_BITS) +#define C68K_FETCH_MASK (C68K_FETCH_BANK - 1) + +#define C68K_SR_C_SFT 8 +#define C68K_SR_V_SFT 7 +#define C68K_SR_Z_SFT 0 +#define C68K_SR_N_SFT 7 +#define C68K_SR_X_SFT 8 + +#define C68K_SR_S_SFT 13 + +#define C68K_SR_C (1 << C68K_SR_C_SFT) +#define C68K_SR_V (1 << C68K_SR_V_SFT) +#define C68K_SR_Z 0 +#define C68K_SR_N (1 << C68K_SR_N_SFT) +#define C68K_SR_X (1 << C68K_SR_X_SFT) + +#define C68K_SR_S (1 << C68K_SR_S_SFT) + +#define C68K_CCR_MASK 0x1F +#define C68K_SR_MASK (0x2700 | C68K_CCR_MASK) + +// exception defines taken from musashi core +#define C68K_RESET_EX 1 +#define C68K_BUS_ERROR_EX 2 +#define C68K_ADDRESS_ERROR_EX 3 +#define C68K_ILLEGAL_INSTRUCTION_EX 4 +#define C68K_ZERO_DIVIDE_EX 5 +#define C68K_CHK_EX 6 +#define C68K_TRAPV_EX 7 +#define C68K_PRIVILEGE_VIOLATION_EX 8 +#define C68K_TRACE_EX 9 +#define C68K_1010_EX 10 +#define C68K_1111_EX 11 +#define C68K_FORMAT_ERROR_EX 14 +#define C68K_UNINITIALIZED_INTERRUPT_EX 15 +#define C68K_SPURIOUS_INTERRUPT_EX 24 +#define C68K_INTERRUPT_AUTOVECTOR_EX 24 +#define C68K_TRAP_BASE_EX 32 + +#define C68K_INT_ACK_AUTOVECTOR -1 + +#define C68K_RUNNING 0x01 +#define C68K_HALTED 0x02 +#define C68K_WAITING 0x04 +#define C68K_DISABLE 0x10 +#define C68K_FAULTED 0x40 + +typedef u32 FASTCALL C68K_READ(const u32 adr); +typedef void FASTCALL C68K_WRITE(const u32 adr, u32 data); + +typedef s32 FASTCALL C68K_INT_CALLBACK(s32 level); +typedef void FASTCALL C68K_RESET_CALLBACK(void); + +typedef struct { + u32 D[8]; // 32 bytes aligned + u32 A[8]; // 16 bytes aligned + + u32 flag_C; // 32 bytes aligned + u32 flag_V; + u32 flag_notZ; + u32 flag_N; + + u32 flag_X; // 16 bytes aligned + u32 flag_I; + u32 flag_S; + + u32 USP; + + pointer PC; // 32 bytes aligned + pointer BasePC; + u32 Status; + s32 IRQLine; + + s32 CycleToDo; // 16 bytes aligned + s32 CycleIO; + s32 CycleSup; + u32 dirty1; + + C68K_READ *Read_Byte; // 32 bytes aligned + C68K_READ *Read_Word; + + C68K_WRITE *Write_Byte; + C68K_WRITE *Write_Word; + + C68K_INT_CALLBACK *Interrupt_CallBack; // 16 bytes aligned + C68K_RESET_CALLBACK *Reset_CallBack; + + pointer Fetch[C68K_FETCH_BANK]; // 32 bytes aligned +} c68k_struc; + + +// 68K core var declaration +//////////////////////////// + +extern c68k_struc C68K; + + +// 68K core function declaration +///////////////////////////////// + +void C68k_Init(c68k_struc *cpu, C68K_INT_CALLBACK *int_cb); + +s32 FASTCALL C68k_Reset(c68k_struc *cpu); + +// if < 0 --> error (cpu state returned) +// if >= 0 --> number of extras cycles done +s32 FASTCALL C68k_Exec(c68k_struc *cpu, s32 cycle); + +void FASTCALL C68k_Set_IRQ(c68k_struc *cpu, s32 level); + +s32 FASTCALL C68k_Get_CycleToDo(c68k_struc *cpu); +s32 FASTCALL C68k_Get_CycleRemaining(c68k_struc *cpu); +s32 FASTCALL C68k_Get_CycleDone(c68k_struc *cpu); +void FASTCALL C68k_Release_Cycle(c68k_struc *cpu); +void FASTCALL C68k_Add_Cycle(c68k_struc *cpu, s32 cycle); + +void C68k_Set_Fetch(c68k_struc *cpu, u32 low_adr, u32 high_adr, pointer fetch_adr); + +void C68k_Set_ReadB(c68k_struc *cpu, C68K_READ *Func); +void C68k_Set_ReadW(c68k_struc *cpu, C68K_READ *Func); +void C68k_Set_WriteB(c68k_struc *cpu, C68K_WRITE *Func); +void C68k_Set_WriteW(c68k_struc *cpu, C68K_WRITE *Func); + +u32 C68k_Get_DReg(c68k_struc *cpu, u32 num); +u32 C68k_Get_AReg(c68k_struc *cpu, u32 num); +u32 C68k_Get_PC(c68k_struc *cpu); +u32 C68k_Get_SR(c68k_struc *cpu); +u32 C68k_Get_USP(c68k_struc *cpu); +u32 C68k_Get_MSP(c68k_struc *cpu); + +void C68k_Set_DReg(c68k_struc *cpu, u32 num, u32 val); +void C68k_Set_AReg(c68k_struc *cpu, u32 num, u32 val); +void C68k_Set_PC(c68k_struc *cpu, u32 val); +void C68k_Set_SR(c68k_struc *cpu, u32 val); +void C68k_Set_USP(c68k_struc *cpu, u32 val); +void C68k_Set_MSP(c68k_struc *cpu, u32 val); + +#ifdef __cplusplus +} +#endif + +#endif // _C68K_H_ + diff --git a/m68000/c68k/c68k_ini.inc b/m68000/c68k/c68k_ini.inc new file mode 100644 index 0000000..a9fba0c --- /dev/null +++ b/m68000/c68k/c68k_ini.inc @@ -0,0 +1,4002 @@ + for(i = 0x0000; i <= 0xFFFF; i += 0x0001) + JumpTable[0x0000 + i] = &&OP_0x4AFC; + for(i = 0x0000; i <= 0x0FFF; i += 0x0001) + JumpTable[0xA000 + i] = &&OP_0xA000; + for(i = 0x0000; i <= 0x0FFF; i += 0x0001) + JumpTable[0xF000 + i] = &&OP_0xF000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0000 + i] = &&OP_0x0000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0010 + i] = &&OP_0x0010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0018 + i] = &&OP_0x0018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0020 + i] = &&OP_0x0020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0028 + i] = &&OP_0x0028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0030 + i] = &&OP_0x0030; + JumpTable[0x0038] = &&OP_0x0038; + JumpTable[0x0039] = &&OP_0x0039; + JumpTable[0x001F] = &&OP_0x001F; + JumpTable[0x0027] = &&OP_0x0027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0040 + i] = &&OP_0x0040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0050 + i] = &&OP_0x0050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0058 + i] = &&OP_0x0058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0060 + i] = &&OP_0x0060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0068 + i] = &&OP_0x0068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0070 + i] = &&OP_0x0070; + JumpTable[0x0078] = &&OP_0x0078; + JumpTable[0x0079] = &&OP_0x0079; + JumpTable[0x005F] = &&OP_0x005F; + JumpTable[0x0067] = &&OP_0x0067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0080 + i] = &&OP_0x0080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0090 + i] = &&OP_0x0090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0098 + i] = &&OP_0x0098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x00A0 + i] = &&OP_0x00A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x00A8 + i] = &&OP_0x00A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x00B0 + i] = &&OP_0x00B0; + JumpTable[0x00B8] = &&OP_0x00B8; + JumpTable[0x00B9] = &&OP_0x00B9; + JumpTable[0x009F] = &&OP_0x009F; + JumpTable[0x00A7] = &&OP_0x00A7; + JumpTable[0x003C] = &&OP_0x003C; + JumpTable[0x007C] = &&OP_0x007C; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0200 + i] = &&OP_0x0200; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0210 + i] = &&OP_0x0210; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0218 + i] = &&OP_0x0218; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0220 + i] = &&OP_0x0220; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0228 + i] = &&OP_0x0228; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0230 + i] = &&OP_0x0230; + JumpTable[0x0238] = &&OP_0x0238; + JumpTable[0x0239] = &&OP_0x0239; + JumpTable[0x021F] = &&OP_0x021F; + JumpTable[0x0227] = &&OP_0x0227; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0240 + i] = &&OP_0x0240; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0250 + i] = &&OP_0x0250; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0258 + i] = &&OP_0x0258; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0260 + i] = &&OP_0x0260; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0268 + i] = &&OP_0x0268; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0270 + i] = &&OP_0x0270; + JumpTable[0x0278] = &&OP_0x0278; + JumpTable[0x0279] = &&OP_0x0279; + JumpTable[0x025F] = &&OP_0x025F; + JumpTable[0x0267] = &&OP_0x0267; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0280 + i] = &&OP_0x0280; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0290 + i] = &&OP_0x0290; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0298 + i] = &&OP_0x0298; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x02A0 + i] = &&OP_0x02A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x02A8 + i] = &&OP_0x02A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x02B0 + i] = &&OP_0x02B0; + JumpTable[0x02B8] = &&OP_0x02B8; + JumpTable[0x02B9] = &&OP_0x02B9; + JumpTable[0x029F] = &&OP_0x029F; + JumpTable[0x02A7] = &&OP_0x02A7; + JumpTable[0x023C] = &&OP_0x023C; + JumpTable[0x027C] = &&OP_0x027C; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A00 + i] = &&OP_0x0A00; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A10 + i] = &&OP_0x0A10; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0A18 + i] = &&OP_0x0A18; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0A20 + i] = &&OP_0x0A20; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A28 + i] = &&OP_0x0A28; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A30 + i] = &&OP_0x0A30; + JumpTable[0x0A38] = &&OP_0x0A38; + JumpTable[0x0A39] = &&OP_0x0A39; + JumpTable[0x0A1F] = &&OP_0x0A1F; + JumpTable[0x0A27] = &&OP_0x0A27; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A40 + i] = &&OP_0x0A40; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A50 + i] = &&OP_0x0A50; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0A58 + i] = &&OP_0x0A58; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0A60 + i] = &&OP_0x0A60; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A68 + i] = &&OP_0x0A68; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A70 + i] = &&OP_0x0A70; + JumpTable[0x0A78] = &&OP_0x0A78; + JumpTable[0x0A79] = &&OP_0x0A79; + JumpTable[0x0A5F] = &&OP_0x0A5F; + JumpTable[0x0A67] = &&OP_0x0A67; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A80 + i] = &&OP_0x0A80; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0A90 + i] = &&OP_0x0A90; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0A98 + i] = &&OP_0x0A98; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0AA0 + i] = &&OP_0x0AA0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0AA8 + i] = &&OP_0x0AA8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0AB0 + i] = &&OP_0x0AB0; + JumpTable[0x0AB8] = &&OP_0x0AB8; + JumpTable[0x0AB9] = &&OP_0x0AB9; + JumpTable[0x0A9F] = &&OP_0x0A9F; + JumpTable[0x0AA7] = &&OP_0x0AA7; + JumpTable[0x0A3C] = &&OP_0x0A3C; + JumpTable[0x0A7C] = &&OP_0x0A7C; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0400 + i] = &&OP_0x0400; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0410 + i] = &&OP_0x0410; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0418 + i] = &&OP_0x0418; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0420 + i] = &&OP_0x0420; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0428 + i] = &&OP_0x0428; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0430 + i] = &&OP_0x0430; + JumpTable[0x0438] = &&OP_0x0438; + JumpTable[0x0439] = &&OP_0x0439; + JumpTable[0x041F] = &&OP_0x041F; + JumpTable[0x0427] = &&OP_0x0427; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0440 + i] = &&OP_0x0440; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0450 + i] = &&OP_0x0450; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0458 + i] = &&OP_0x0458; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0460 + i] = &&OP_0x0460; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0468 + i] = &&OP_0x0468; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0470 + i] = &&OP_0x0470; + JumpTable[0x0478] = &&OP_0x0478; + JumpTable[0x0479] = &&OP_0x0479; + JumpTable[0x045F] = &&OP_0x045F; + JumpTable[0x0467] = &&OP_0x0467; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0480 + i] = &&OP_0x0480; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0490 + i] = &&OP_0x0490; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0498 + i] = &&OP_0x0498; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x04A0 + i] = &&OP_0x04A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x04A8 + i] = &&OP_0x04A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x04B0 + i] = &&OP_0x04B0; + JumpTable[0x04B8] = &&OP_0x04B8; + JumpTable[0x04B9] = &&OP_0x04B9; + JumpTable[0x049F] = &&OP_0x049F; + JumpTable[0x04A7] = &&OP_0x04A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0600 + i] = &&OP_0x0600; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0610 + i] = &&OP_0x0610; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0618 + i] = &&OP_0x0618; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0620 + i] = &&OP_0x0620; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0628 + i] = &&OP_0x0628; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0630 + i] = &&OP_0x0630; + JumpTable[0x0638] = &&OP_0x0638; + JumpTable[0x0639] = &&OP_0x0639; + JumpTable[0x061F] = &&OP_0x061F; + JumpTable[0x0627] = &&OP_0x0627; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0640 + i] = &&OP_0x0640; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0650 + i] = &&OP_0x0650; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0658 + i] = &&OP_0x0658; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0660 + i] = &&OP_0x0660; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0668 + i] = &&OP_0x0668; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0670 + i] = &&OP_0x0670; + JumpTable[0x0678] = &&OP_0x0678; + JumpTable[0x0679] = &&OP_0x0679; + JumpTable[0x065F] = &&OP_0x065F; + JumpTable[0x0667] = &&OP_0x0667; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0680 + i] = &&OP_0x0680; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0690 + i] = &&OP_0x0690; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0698 + i] = &&OP_0x0698; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x06A0 + i] = &&OP_0x06A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x06A8 + i] = &&OP_0x06A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x06B0 + i] = &&OP_0x06B0; + JumpTable[0x06B8] = &&OP_0x06B8; + JumpTable[0x06B9] = &&OP_0x06B9; + JumpTable[0x069F] = &&OP_0x069F; + JumpTable[0x06A7] = &&OP_0x06A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C00 + i] = &&OP_0x0C00; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C10 + i] = &&OP_0x0C10; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0C18 + i] = &&OP_0x0C18; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0C20 + i] = &&OP_0x0C20; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C28 + i] = &&OP_0x0C28; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C30 + i] = &&OP_0x0C30; + JumpTable[0x0C38] = &&OP_0x0C38; + JumpTable[0x0C39] = &&OP_0x0C39; + JumpTable[0x0C1F] = &&OP_0x0C1F; + JumpTable[0x0C27] = &&OP_0x0C27; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C40 + i] = &&OP_0x0C40; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C50 + i] = &&OP_0x0C50; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0C58 + i] = &&OP_0x0C58; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0C60 + i] = &&OP_0x0C60; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C68 + i] = &&OP_0x0C68; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C70 + i] = &&OP_0x0C70; + JumpTable[0x0C78] = &&OP_0x0C78; + JumpTable[0x0C79] = &&OP_0x0C79; + JumpTable[0x0C5F] = &&OP_0x0C5F; + JumpTable[0x0C67] = &&OP_0x0C67; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C80 + i] = &&OP_0x0C80; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0C90 + i] = &&OP_0x0C90; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0C98 + i] = &&OP_0x0C98; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0CA0 + i] = &&OP_0x0CA0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0CA8 + i] = &&OP_0x0CA8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0CB0 + i] = &&OP_0x0CB0; + JumpTable[0x0CB8] = &&OP_0x0CB8; + JumpTable[0x0CB9] = &&OP_0x0CB9; + JumpTable[0x0C9F] = &&OP_0x0C9F; + JumpTable[0x0CA7] = &&OP_0x0CA7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0800 + i] = &&OP_0x0800; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0810 + i] = &&OP_0x0810; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0818 + i] = &&OP_0x0818; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0820 + i] = &&OP_0x0820; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0828 + i] = &&OP_0x0828; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0830 + i] = &&OP_0x0830; + JumpTable[0x0838] = &&OP_0x0838; + JumpTable[0x0839] = &&OP_0x0839; + JumpTable[0x083A] = &&OP_0x083A; + JumpTable[0x083B] = &&OP_0x083B; + JumpTable[0x081F] = &&OP_0x081F; + JumpTable[0x0827] = &&OP_0x0827; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0840 + i] = &&OP_0x0840; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0850 + i] = &&OP_0x0850; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0858 + i] = &&OP_0x0858; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0860 + i] = &&OP_0x0860; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0868 + i] = &&OP_0x0868; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0870 + i] = &&OP_0x0870; + JumpTable[0x0878] = &&OP_0x0878; + JumpTable[0x0879] = &&OP_0x0879; + JumpTable[0x085F] = &&OP_0x085F; + JumpTable[0x0867] = &&OP_0x0867; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0880 + i] = &&OP_0x0880; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x0890 + i] = &&OP_0x0890; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x0898 + i] = &&OP_0x0898; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x08A0 + i] = &&OP_0x08A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x08A8 + i] = &&OP_0x08A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x08B0 + i] = &&OP_0x08B0; + JumpTable[0x08B8] = &&OP_0x08B8; + JumpTable[0x08B9] = &&OP_0x08B9; + JumpTable[0x089F] = &&OP_0x089F; + JumpTable[0x08A7] = &&OP_0x08A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x08C0 + i] = &&OP_0x08C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x08D0 + i] = &&OP_0x08D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x08D8 + i] = &&OP_0x08D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x08E0 + i] = &&OP_0x08E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x08E8 + i] = &&OP_0x08E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x08F0 + i] = &&OP_0x08F0; + JumpTable[0x08F8] = &&OP_0x08F8; + JumpTable[0x08F9] = &&OP_0x08F9; + JumpTable[0x08DF] = &&OP_0x08DF; + JumpTable[0x08E7] = &&OP_0x08E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0100 + i + j] = &&OP_0x0100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0110 + i + j] = &&OP_0x0110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0118 + i + j] = &&OP_0x0118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0120 + i + j] = &&OP_0x0120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0128 + i + j] = &&OP_0x0128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0130 + i + j] = &&OP_0x0130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x0138 + i] = &&OP_0x0138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x0139 + i] = &&OP_0x0139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x013A + i] = &&OP_0x013A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x013B + i] = &&OP_0x013B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x013C + i] = &&OP_0x013C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x011F + i] = &&OP_0x011F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x0127 + i] = &&OP_0x0127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0140 + i + j] = &&OP_0x0140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0150 + i + j] = &&OP_0x0150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0158 + i + j] = &&OP_0x0158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0160 + i + j] = &&OP_0x0160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0168 + i + j] = &&OP_0x0168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0170 + i + j] = &&OP_0x0170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x0178 + i] = &&OP_0x0178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x0179 + i] = &&OP_0x0179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x015F + i] = &&OP_0x015F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x0167 + i] = &&OP_0x0167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0180 + i + j] = &&OP_0x0180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0190 + i + j] = &&OP_0x0190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0198 + i + j] = &&OP_0x0198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01A0 + i + j] = &&OP_0x01A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01A8 + i + j] = &&OP_0x01A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01B0 + i + j] = &&OP_0x01B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01B8 + i] = &&OP_0x01B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01B9 + i] = &&OP_0x01B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x019F + i] = &&OP_0x019F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01A7 + i] = &&OP_0x01A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01C0 + i + j] = &&OP_0x01C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01D0 + i + j] = &&OP_0x01D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01D8 + i + j] = &&OP_0x01D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01E0 + i + j] = &&OP_0x01E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01E8 + i + j] = &&OP_0x01E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01F0 + i + j] = &&OP_0x01F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01F8 + i] = &&OP_0x01F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01F9 + i] = &&OP_0x01F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01DF + i] = &&OP_0x01DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x01E7 + i] = &&OP_0x01E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0108 + i + j] = &&OP_0x0108; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0148 + i + j] = &&OP_0x0148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x0188 + i + j] = &&OP_0x0188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x01C8 + i + j] = &&OP_0x01C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1000 + i + j] = &&OP_0x1000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1080 + i + j] = &&OP_0x1080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10C0 + i + j] = &&OP_0x10C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1100 + i + j] = &&OP_0x1100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1140 + i + j] = &&OP_0x1140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1180 + i + j] = &&OP_0x1180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x11C0 + i] = &&OP_0x11C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x13C0 + i] = &&OP_0x13C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1EC0 + i] = &&OP_0x1EC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1F00 + i] = &&OP_0x1F00; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1008 + i + j] = &&OP_0x1008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1088 + i + j] = &&OP_0x1088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10C8 + i + j] = &&OP_0x10C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1108 + i + j] = &&OP_0x1108; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1148 + i + j] = &&OP_0x1148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1188 + i + j] = &&OP_0x1188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x11C8 + i] = &&OP_0x11C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x13C8 + i] = &&OP_0x13C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1EC8 + i] = &&OP_0x1EC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1F08 + i] = &&OP_0x1F08; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1010 + i + j] = &&OP_0x1010; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1090 + i + j] = &&OP_0x1090; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10D0 + i + j] = &&OP_0x10D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1110 + i + j] = &&OP_0x1110; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1150 + i + j] = &&OP_0x1150; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1190 + i + j] = &&OP_0x1190; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x11D0 + i] = &&OP_0x11D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x13D0 + i] = &&OP_0x13D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1ED0 + i] = &&OP_0x1ED0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1F10 + i] = &&OP_0x1F10; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1018 + i + j] = &&OP_0x1018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1098 + i + j] = &&OP_0x1098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10D8 + i + j] = &&OP_0x10D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1118 + i + j] = &&OP_0x1118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1158 + i + j] = &&OP_0x1158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1198 + i + j] = &&OP_0x1198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x11D8 + i] = &&OP_0x11D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x13D8 + i] = &&OP_0x13D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x1ED8 + i] = &&OP_0x1ED8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x1F18 + i] = &&OP_0x1F18; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1020 + i + j] = &&OP_0x1020; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x10A0 + i + j] = &&OP_0x10A0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10E0 + i + j] = &&OP_0x10E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1120 + i + j] = &&OP_0x1120; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1160 + i + j] = &&OP_0x1160; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x11A0 + i + j] = &&OP_0x11A0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x11E0 + i] = &&OP_0x11E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x13E0 + i] = &&OP_0x13E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x1EE0 + i] = &&OP_0x1EE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x1F20 + i] = &&OP_0x1F20; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1028 + i + j] = &&OP_0x1028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x10A8 + i + j] = &&OP_0x10A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10E8 + i + j] = &&OP_0x10E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1128 + i + j] = &&OP_0x1128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1168 + i + j] = &&OP_0x1168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x11A8 + i + j] = &&OP_0x11A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x11E8 + i] = &&OP_0x11E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x13E8 + i] = &&OP_0x13E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1EE8 + i] = &&OP_0x1EE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1F28 + i] = &&OP_0x1F28; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1030 + i + j] = &&OP_0x1030; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x10B0 + i + j] = &&OP_0x10B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x10F0 + i + j] = &&OP_0x10F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x1130 + i + j] = &&OP_0x1130; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x1170 + i + j] = &&OP_0x1170; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x11B0 + i + j] = &&OP_0x11B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x11F0 + i] = &&OP_0x11F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x13F0 + i] = &&OP_0x13F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1EF0 + i] = &&OP_0x1EF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x1F30 + i] = &&OP_0x1F30; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x1038 + i] = &&OP_0x1038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x10B8 + i] = &&OP_0x10B8; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10F8 + i] = &&OP_0x10F8; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x1138 + i] = &&OP_0x1138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x1178 + i] = &&OP_0x1178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x11B8 + i] = &&OP_0x11B8; + JumpTable[0x11F8] = &&OP_0x11F8; + JumpTable[0x13F8] = &&OP_0x13F8; + JumpTable[0x1EF8] = &&OP_0x1EF8; + JumpTable[0x1F38] = &&OP_0x1F38; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x1039 + i] = &&OP_0x1039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x10B9 + i] = &&OP_0x10B9; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10F9 + i] = &&OP_0x10F9; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x1139 + i] = &&OP_0x1139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x1179 + i] = &&OP_0x1179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x11B9 + i] = &&OP_0x11B9; + JumpTable[0x11F9] = &&OP_0x11F9; + JumpTable[0x13F9] = &&OP_0x13F9; + JumpTable[0x1EF9] = &&OP_0x1EF9; + JumpTable[0x1F39] = &&OP_0x1F39; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x103A + i] = &&OP_0x103A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x10BA + i] = &&OP_0x10BA; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10FA + i] = &&OP_0x10FA; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x113A + i] = &&OP_0x113A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x117A + i] = &&OP_0x117A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x11BA + i] = &&OP_0x11BA; + JumpTable[0x11FA] = &&OP_0x11FA; + JumpTable[0x13FA] = &&OP_0x13FA; + JumpTable[0x1EFA] = &&OP_0x1EFA; + JumpTable[0x1F3A] = &&OP_0x1F3A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x103B + i] = &&OP_0x103B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x10BB + i] = &&OP_0x10BB; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10FB + i] = &&OP_0x10FB; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x113B + i] = &&OP_0x113B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x117B + i] = &&OP_0x117B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x11BB + i] = &&OP_0x11BB; + JumpTable[0x11FB] = &&OP_0x11FB; + JumpTable[0x13FB] = &&OP_0x13FB; + JumpTable[0x1EFB] = &&OP_0x1EFB; + JumpTable[0x1F3B] = &&OP_0x1F3B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x103C + i] = &&OP_0x103C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x10BC + i] = &&OP_0x10BC; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10FC + i] = &&OP_0x10FC; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x113C + i] = &&OP_0x113C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x117C + i] = &&OP_0x117C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x11BC + i] = &&OP_0x11BC; + JumpTable[0x11FC] = &&OP_0x11FC; + JumpTable[0x13FC] = &&OP_0x13FC; + JumpTable[0x1EFC] = &&OP_0x1EFC; + JumpTable[0x1F3C] = &&OP_0x1F3C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x101F + i] = &&OP_0x101F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x109F + i] = &&OP_0x109F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10DF + i] = &&OP_0x10DF; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x111F + i] = &&OP_0x111F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x115F + i] = &&OP_0x115F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x119F + i] = &&OP_0x119F; + JumpTable[0x11DF] = &&OP_0x11DF; + JumpTable[0x13DF] = &&OP_0x13DF; + JumpTable[0x1EDF] = &&OP_0x1EDF; + JumpTable[0x1F1F] = &&OP_0x1F1F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x1027 + i] = &&OP_0x1027; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x10A7 + i] = &&OP_0x10A7; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x10E7 + i] = &&OP_0x10E7; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x1127 + i] = &&OP_0x1127; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x1167 + i] = &&OP_0x1167; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x11A7 + i] = &&OP_0x11A7; + JumpTable[0x11E7] = &&OP_0x11E7; + JumpTable[0x13E7] = &&OP_0x13E7; + JumpTable[0x1EE7] = &&OP_0x1EE7; + JumpTable[0x1F27] = &&OP_0x1F27; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2000 + i + j] = &&OP_0x2000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2080 + i + j] = &&OP_0x2080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20C0 + i + j] = &&OP_0x20C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2100 + i + j] = &&OP_0x2100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2140 + i + j] = &&OP_0x2140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2180 + i + j] = &&OP_0x2180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x21C0 + i] = &&OP_0x21C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x23C0 + i] = &&OP_0x23C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2EC0 + i] = &&OP_0x2EC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2F00 + i] = &&OP_0x2F00; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2008 + i + j] = &&OP_0x2008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2088 + i + j] = &&OP_0x2088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20C8 + i + j] = &&OP_0x20C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2108 + i + j] = &&OP_0x2108; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2148 + i + j] = &&OP_0x2148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2188 + i + j] = &&OP_0x2188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x21C8 + i] = &&OP_0x21C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x23C8 + i] = &&OP_0x23C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2EC8 + i] = &&OP_0x2EC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2F08 + i] = &&OP_0x2F08; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2010 + i + j] = &&OP_0x2010; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2090 + i + j] = &&OP_0x2090; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20D0 + i + j] = &&OP_0x20D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2110 + i + j] = &&OP_0x2110; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2150 + i + j] = &&OP_0x2150; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2190 + i + j] = &&OP_0x2190; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x21D0 + i] = &&OP_0x21D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x23D0 + i] = &&OP_0x23D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2ED0 + i] = &&OP_0x2ED0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2F10 + i] = &&OP_0x2F10; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2018 + i + j] = &&OP_0x2018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2098 + i + j] = &&OP_0x2098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20D8 + i + j] = &&OP_0x20D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2118 + i + j] = &&OP_0x2118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2158 + i + j] = &&OP_0x2158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2198 + i + j] = &&OP_0x2198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x21D8 + i] = &&OP_0x21D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x23D8 + i] = &&OP_0x23D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x2ED8 + i] = &&OP_0x2ED8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x2F18 + i] = &&OP_0x2F18; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2020 + i + j] = &&OP_0x2020; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x20A0 + i + j] = &&OP_0x20A0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20E0 + i + j] = &&OP_0x20E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2120 + i + j] = &&OP_0x2120; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2160 + i + j] = &&OP_0x2160; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x21A0 + i + j] = &&OP_0x21A0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x21E0 + i] = &&OP_0x21E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x23E0 + i] = &&OP_0x23E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x2EE0 + i] = &&OP_0x2EE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x2F20 + i] = &&OP_0x2F20; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2028 + i + j] = &&OP_0x2028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x20A8 + i + j] = &&OP_0x20A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20E8 + i + j] = &&OP_0x20E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2128 + i + j] = &&OP_0x2128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2168 + i + j] = &&OP_0x2168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x21A8 + i + j] = &&OP_0x21A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x21E8 + i] = &&OP_0x21E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x23E8 + i] = &&OP_0x23E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2EE8 + i] = &&OP_0x2EE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2F28 + i] = &&OP_0x2F28; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2030 + i + j] = &&OP_0x2030; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x20B0 + i + j] = &&OP_0x20B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x20F0 + i + j] = &&OP_0x20F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x2130 + i + j] = &&OP_0x2130; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2170 + i + j] = &&OP_0x2170; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x21B0 + i + j] = &&OP_0x21B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x21F0 + i] = &&OP_0x21F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x23F0 + i] = &&OP_0x23F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2EF0 + i] = &&OP_0x2EF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x2F30 + i] = &&OP_0x2F30; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2038 + i] = &&OP_0x2038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x20B8 + i] = &&OP_0x20B8; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20F8 + i] = &&OP_0x20F8; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x2138 + i] = &&OP_0x2138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2178 + i] = &&OP_0x2178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x21B8 + i] = &&OP_0x21B8; + JumpTable[0x21F8] = &&OP_0x21F8; + JumpTable[0x23F8] = &&OP_0x23F8; + JumpTable[0x2EF8] = &&OP_0x2EF8; + JumpTable[0x2F38] = &&OP_0x2F38; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2039 + i] = &&OP_0x2039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x20B9 + i] = &&OP_0x20B9; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20F9 + i] = &&OP_0x20F9; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x2139 + i] = &&OP_0x2139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2179 + i] = &&OP_0x2179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x21B9 + i] = &&OP_0x21B9; + JumpTable[0x21F9] = &&OP_0x21F9; + JumpTable[0x23F9] = &&OP_0x23F9; + JumpTable[0x2EF9] = &&OP_0x2EF9; + JumpTable[0x2F39] = &&OP_0x2F39; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x203A + i] = &&OP_0x203A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x20BA + i] = &&OP_0x20BA; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20FA + i] = &&OP_0x20FA; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x213A + i] = &&OP_0x213A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x217A + i] = &&OP_0x217A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x21BA + i] = &&OP_0x21BA; + JumpTable[0x21FA] = &&OP_0x21FA; + JumpTable[0x23FA] = &&OP_0x23FA; + JumpTable[0x2EFA] = &&OP_0x2EFA; + JumpTable[0x2F3A] = &&OP_0x2F3A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x203B + i] = &&OP_0x203B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x20BB + i] = &&OP_0x20BB; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20FB + i] = &&OP_0x20FB; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x213B + i] = &&OP_0x213B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x217B + i] = &&OP_0x217B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x21BB + i] = &&OP_0x21BB; + JumpTable[0x21FB] = &&OP_0x21FB; + JumpTable[0x23FB] = &&OP_0x23FB; + JumpTable[0x2EFB] = &&OP_0x2EFB; + JumpTable[0x2F3B] = &&OP_0x2F3B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x203C + i] = &&OP_0x203C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x20BC + i] = &&OP_0x20BC; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20FC + i] = &&OP_0x20FC; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x213C + i] = &&OP_0x213C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x217C + i] = &&OP_0x217C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x21BC + i] = &&OP_0x21BC; + JumpTable[0x21FC] = &&OP_0x21FC; + JumpTable[0x23FC] = &&OP_0x23FC; + JumpTable[0x2EFC] = &&OP_0x2EFC; + JumpTable[0x2F3C] = &&OP_0x2F3C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x201F + i] = &&OP_0x201F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x209F + i] = &&OP_0x209F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20DF + i] = &&OP_0x20DF; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x211F + i] = &&OP_0x211F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x215F + i] = &&OP_0x215F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x219F + i] = &&OP_0x219F; + JumpTable[0x21DF] = &&OP_0x21DF; + JumpTable[0x23DF] = &&OP_0x23DF; + JumpTable[0x2EDF] = &&OP_0x2EDF; + JumpTable[0x2F1F] = &&OP_0x2F1F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2027 + i] = &&OP_0x2027; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x20A7 + i] = &&OP_0x20A7; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x20E7 + i] = &&OP_0x20E7; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x2127 + i] = &&OP_0x2127; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2167 + i] = &&OP_0x2167; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x21A7 + i] = &&OP_0x21A7; + JumpTable[0x21E7] = &&OP_0x21E7; + JumpTable[0x23E7] = &&OP_0x23E7; + JumpTable[0x2EE7] = &&OP_0x2EE7; + JumpTable[0x2F27] = &&OP_0x2F27; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3000 + i + j] = &&OP_0x3000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3080 + i + j] = &&OP_0x3080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30C0 + i + j] = &&OP_0x30C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3100 + i + j] = &&OP_0x3100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3140 + i + j] = &&OP_0x3140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3180 + i + j] = &&OP_0x3180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x31C0 + i] = &&OP_0x31C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x33C0 + i] = &&OP_0x33C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3EC0 + i] = &&OP_0x3EC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3F00 + i] = &&OP_0x3F00; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3008 + i + j] = &&OP_0x3008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3088 + i + j] = &&OP_0x3088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30C8 + i + j] = &&OP_0x30C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3108 + i + j] = &&OP_0x3108; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3148 + i + j] = &&OP_0x3148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3188 + i + j] = &&OP_0x3188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x31C8 + i] = &&OP_0x31C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x33C8 + i] = &&OP_0x33C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3EC8 + i] = &&OP_0x3EC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3F08 + i] = &&OP_0x3F08; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3010 + i + j] = &&OP_0x3010; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3090 + i + j] = &&OP_0x3090; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30D0 + i + j] = &&OP_0x30D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3110 + i + j] = &&OP_0x3110; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3150 + i + j] = &&OP_0x3150; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3190 + i + j] = &&OP_0x3190; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x31D0 + i] = &&OP_0x31D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x33D0 + i] = &&OP_0x33D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3ED0 + i] = &&OP_0x3ED0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3F10 + i] = &&OP_0x3F10; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3018 + i + j] = &&OP_0x3018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3098 + i + j] = &&OP_0x3098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30D8 + i + j] = &&OP_0x30D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3118 + i + j] = &&OP_0x3118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3158 + i + j] = &&OP_0x3158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3198 + i + j] = &&OP_0x3198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x31D8 + i] = &&OP_0x31D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x33D8 + i] = &&OP_0x33D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x3ED8 + i] = &&OP_0x3ED8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x3F18 + i] = &&OP_0x3F18; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3020 + i + j] = &&OP_0x3020; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x30A0 + i + j] = &&OP_0x30A0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30E0 + i + j] = &&OP_0x30E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3120 + i + j] = &&OP_0x3120; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3160 + i + j] = &&OP_0x3160; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x31A0 + i + j] = &&OP_0x31A0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x31E0 + i] = &&OP_0x31E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x33E0 + i] = &&OP_0x33E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x3EE0 + i] = &&OP_0x3EE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x3F20 + i] = &&OP_0x3F20; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3028 + i + j] = &&OP_0x3028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x30A8 + i + j] = &&OP_0x30A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30E8 + i + j] = &&OP_0x30E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3128 + i + j] = &&OP_0x3128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3168 + i + j] = &&OP_0x3168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x31A8 + i + j] = &&OP_0x31A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x31E8 + i] = &&OP_0x31E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x33E8 + i] = &&OP_0x33E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3EE8 + i] = &&OP_0x3EE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3F28 + i] = &&OP_0x3F28; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3030 + i + j] = &&OP_0x3030; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x30B0 + i + j] = &&OP_0x30B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x30F0 + i + j] = &&OP_0x30F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x3130 + i + j] = &&OP_0x3130; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3170 + i + j] = &&OP_0x3170; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x31B0 + i + j] = &&OP_0x31B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x31F0 + i] = &&OP_0x31F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x33F0 + i] = &&OP_0x33F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3EF0 + i] = &&OP_0x3EF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x3F30 + i] = &&OP_0x3F30; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3038 + i] = &&OP_0x3038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x30B8 + i] = &&OP_0x30B8; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30F8 + i] = &&OP_0x30F8; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x3138 + i] = &&OP_0x3138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3178 + i] = &&OP_0x3178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x31B8 + i] = &&OP_0x31B8; + JumpTable[0x31F8] = &&OP_0x31F8; + JumpTable[0x33F8] = &&OP_0x33F8; + JumpTable[0x3EF8] = &&OP_0x3EF8; + JumpTable[0x3F38] = &&OP_0x3F38; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3039 + i] = &&OP_0x3039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x30B9 + i] = &&OP_0x30B9; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30F9 + i] = &&OP_0x30F9; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x3139 + i] = &&OP_0x3139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3179 + i] = &&OP_0x3179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x31B9 + i] = &&OP_0x31B9; + JumpTable[0x31F9] = &&OP_0x31F9; + JumpTable[0x33F9] = &&OP_0x33F9; + JumpTable[0x3EF9] = &&OP_0x3EF9; + JumpTable[0x3F39] = &&OP_0x3F39; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x303A + i] = &&OP_0x303A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x30BA + i] = &&OP_0x30BA; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30FA + i] = &&OP_0x30FA; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x313A + i] = &&OP_0x313A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x317A + i] = &&OP_0x317A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x31BA + i] = &&OP_0x31BA; + JumpTable[0x31FA] = &&OP_0x31FA; + JumpTable[0x33FA] = &&OP_0x33FA; + JumpTable[0x3EFA] = &&OP_0x3EFA; + JumpTable[0x3F3A] = &&OP_0x3F3A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x303B + i] = &&OP_0x303B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x30BB + i] = &&OP_0x30BB; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30FB + i] = &&OP_0x30FB; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x313B + i] = &&OP_0x313B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x317B + i] = &&OP_0x317B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x31BB + i] = &&OP_0x31BB; + JumpTable[0x31FB] = &&OP_0x31FB; + JumpTable[0x33FB] = &&OP_0x33FB; + JumpTable[0x3EFB] = &&OP_0x3EFB; + JumpTable[0x3F3B] = &&OP_0x3F3B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x303C + i] = &&OP_0x303C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x30BC + i] = &&OP_0x30BC; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30FC + i] = &&OP_0x30FC; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x313C + i] = &&OP_0x313C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x317C + i] = &&OP_0x317C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x31BC + i] = &&OP_0x31BC; + JumpTable[0x31FC] = &&OP_0x31FC; + JumpTable[0x33FC] = &&OP_0x33FC; + JumpTable[0x3EFC] = &&OP_0x3EFC; + JumpTable[0x3F3C] = &&OP_0x3F3C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x301F + i] = &&OP_0x301F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x309F + i] = &&OP_0x309F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30DF + i] = &&OP_0x30DF; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x311F + i] = &&OP_0x311F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x315F + i] = &&OP_0x315F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x319F + i] = &&OP_0x319F; + JumpTable[0x31DF] = &&OP_0x31DF; + JumpTable[0x33DF] = &&OP_0x33DF; + JumpTable[0x3EDF] = &&OP_0x3EDF; + JumpTable[0x3F1F] = &&OP_0x3F1F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3027 + i] = &&OP_0x3027; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x30A7 + i] = &&OP_0x30A7; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x30E7 + i] = &&OP_0x30E7; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x3127 + i] = &&OP_0x3127; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3167 + i] = &&OP_0x3167; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x31A7 + i] = &&OP_0x31A7; + JumpTable[0x31E7] = &&OP_0x31E7; + JumpTable[0x33E7] = &&OP_0x33E7; + JumpTable[0x3EE7] = &&OP_0x3EE7; + JumpTable[0x3F27] = &&OP_0x3F27; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2040 + i + j] = &&OP_0x2040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2048 + i + j] = &&OP_0x2048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2050 + i + j] = &&OP_0x2050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2058 + i + j] = &&OP_0x2058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2060 + i + j] = &&OP_0x2060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2068 + i + j] = &&OP_0x2068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x2070 + i + j] = &&OP_0x2070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2078 + i] = &&OP_0x2078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2079 + i] = &&OP_0x2079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x207A + i] = &&OP_0x207A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x207B + i] = &&OP_0x207B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x207C + i] = &&OP_0x207C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x205F + i] = &&OP_0x205F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x2067 + i] = &&OP_0x2067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3040 + i + j] = &&OP_0x3040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3048 + i + j] = &&OP_0x3048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3050 + i + j] = &&OP_0x3050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3058 + i + j] = &&OP_0x3058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3060 + i + j] = &&OP_0x3060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3068 + i + j] = &&OP_0x3068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x3070 + i + j] = &&OP_0x3070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3078 + i] = &&OP_0x3078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3079 + i] = &&OP_0x3079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x307A + i] = &&OP_0x307A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x307B + i] = &&OP_0x307B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x307C + i] = &&OP_0x307C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x305F + i] = &&OP_0x305F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x3067 + i] = &&OP_0x3067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4000 + i] = &&OP_0x4000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4010 + i] = &&OP_0x4010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4018 + i] = &&OP_0x4018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4020 + i] = &&OP_0x4020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4028 + i] = &&OP_0x4028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4030 + i] = &&OP_0x4030; + JumpTable[0x4038] = &&OP_0x4038; + JumpTable[0x4039] = &&OP_0x4039; + JumpTable[0x401F] = &&OP_0x401F; + JumpTable[0x4027] = &&OP_0x4027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4040 + i] = &&OP_0x4040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4050 + i] = &&OP_0x4050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4058 + i] = &&OP_0x4058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4060 + i] = &&OP_0x4060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4068 + i] = &&OP_0x4068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4070 + i] = &&OP_0x4070; + JumpTable[0x4078] = &&OP_0x4078; + JumpTable[0x4079] = &&OP_0x4079; + JumpTable[0x405F] = &&OP_0x405F; + JumpTable[0x4067] = &&OP_0x4067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4080 + i] = &&OP_0x4080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4090 + i] = &&OP_0x4090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4098 + i] = &&OP_0x4098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x40A0 + i] = &&OP_0x40A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x40A8 + i] = &&OP_0x40A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x40B0 + i] = &&OP_0x40B0; + JumpTable[0x40B8] = &&OP_0x40B8; + JumpTable[0x40B9] = &&OP_0x40B9; + JumpTable[0x409F] = &&OP_0x409F; + JumpTable[0x40A7] = &&OP_0x40A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4200 + i] = &&OP_0x4200; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4210 + i] = &&OP_0x4210; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4218 + i] = &&OP_0x4218; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4220 + i] = &&OP_0x4220; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4228 + i] = &&OP_0x4228; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4230 + i] = &&OP_0x4230; + JumpTable[0x4238] = &&OP_0x4238; + JumpTable[0x4239] = &&OP_0x4239; + JumpTable[0x421F] = &&OP_0x421F; + JumpTable[0x4227] = &&OP_0x4227; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4240 + i] = &&OP_0x4240; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4250 + i] = &&OP_0x4250; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4258 + i] = &&OP_0x4258; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4260 + i] = &&OP_0x4260; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4268 + i] = &&OP_0x4268; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4270 + i] = &&OP_0x4270; + JumpTable[0x4278] = &&OP_0x4278; + JumpTable[0x4279] = &&OP_0x4279; + JumpTable[0x425F] = &&OP_0x425F; + JumpTable[0x4267] = &&OP_0x4267; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4280 + i] = &&OP_0x4280; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4290 + i] = &&OP_0x4290; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4298 + i] = &&OP_0x4298; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x42A0 + i] = &&OP_0x42A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x42A8 + i] = &&OP_0x42A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x42B0 + i] = &&OP_0x42B0; + JumpTable[0x42B8] = &&OP_0x42B8; + JumpTable[0x42B9] = &&OP_0x42B9; + JumpTable[0x429F] = &&OP_0x429F; + JumpTable[0x42A7] = &&OP_0x42A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4400 + i] = &&OP_0x4400; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4410 + i] = &&OP_0x4410; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4418 + i] = &&OP_0x4418; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4420 + i] = &&OP_0x4420; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4428 + i] = &&OP_0x4428; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4430 + i] = &&OP_0x4430; + JumpTable[0x4438] = &&OP_0x4438; + JumpTable[0x4439] = &&OP_0x4439; + JumpTable[0x441F] = &&OP_0x441F; + JumpTable[0x4427] = &&OP_0x4427; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4440 + i] = &&OP_0x4440; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4450 + i] = &&OP_0x4450; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4458 + i] = &&OP_0x4458; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4460 + i] = &&OP_0x4460; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4468 + i] = &&OP_0x4468; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4470 + i] = &&OP_0x4470; + JumpTable[0x4478] = &&OP_0x4478; + JumpTable[0x4479] = &&OP_0x4479; + JumpTable[0x445F] = &&OP_0x445F; + JumpTable[0x4467] = &&OP_0x4467; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4480 + i] = &&OP_0x4480; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4490 + i] = &&OP_0x4490; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4498 + i] = &&OP_0x4498; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x44A0 + i] = &&OP_0x44A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x44A8 + i] = &&OP_0x44A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x44B0 + i] = &&OP_0x44B0; + JumpTable[0x44B8] = &&OP_0x44B8; + JumpTable[0x44B9] = &&OP_0x44B9; + JumpTable[0x449F] = &&OP_0x449F; + JumpTable[0x44A7] = &&OP_0x44A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4600 + i] = &&OP_0x4600; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4610 + i] = &&OP_0x4610; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4618 + i] = &&OP_0x4618; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4620 + i] = &&OP_0x4620; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4628 + i] = &&OP_0x4628; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4630 + i] = &&OP_0x4630; + JumpTable[0x4638] = &&OP_0x4638; + JumpTable[0x4639] = &&OP_0x4639; + JumpTable[0x461F] = &&OP_0x461F; + JumpTable[0x4627] = &&OP_0x4627; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4640 + i] = &&OP_0x4640; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4650 + i] = &&OP_0x4650; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4658 + i] = &&OP_0x4658; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4660 + i] = &&OP_0x4660; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4668 + i] = &&OP_0x4668; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4670 + i] = &&OP_0x4670; + JumpTable[0x4678] = &&OP_0x4678; + JumpTable[0x4679] = &&OP_0x4679; + JumpTable[0x465F] = &&OP_0x465F; + JumpTable[0x4667] = &&OP_0x4667; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4680 + i] = &&OP_0x4680; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4690 + i] = &&OP_0x4690; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4698 + i] = &&OP_0x4698; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x46A0 + i] = &&OP_0x46A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x46A8 + i] = &&OP_0x46A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x46B0 + i] = &&OP_0x46B0; + JumpTable[0x46B8] = &&OP_0x46B8; + JumpTable[0x46B9] = &&OP_0x46B9; + JumpTable[0x469F] = &&OP_0x469F; + JumpTable[0x46A7] = &&OP_0x46A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x40C0 + i] = &&OP_0x40C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x40D0 + i] = &&OP_0x40D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x40D8 + i] = &&OP_0x40D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x40E0 + i] = &&OP_0x40E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x40E8 + i] = &&OP_0x40E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x40F0 + i] = &&OP_0x40F0; + JumpTable[0x40F8] = &&OP_0x40F8; + JumpTable[0x40F9] = &&OP_0x40F9; + JumpTable[0x40DF] = &&OP_0x40DF; + JumpTable[0x40E7] = &&OP_0x40E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x44C0 + i] = &&OP_0x44C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x44D0 + i] = &&OP_0x44D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x44D8 + i] = &&OP_0x44D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x44E0 + i] = &&OP_0x44E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x44E8 + i] = &&OP_0x44E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x44F0 + i] = &&OP_0x44F0; + JumpTable[0x44F8] = &&OP_0x44F8; + JumpTable[0x44F9] = &&OP_0x44F9; + JumpTable[0x44FA] = &&OP_0x44FA; + JumpTable[0x44FB] = &&OP_0x44FB; + JumpTable[0x44FC] = &&OP_0x44FC; + JumpTable[0x44DF] = &&OP_0x44DF; + JumpTable[0x44E7] = &&OP_0x44E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x46C0 + i] = &&OP_0x46C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x46D0 + i] = &&OP_0x46D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x46D8 + i] = &&OP_0x46D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x46E0 + i] = &&OP_0x46E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x46E8 + i] = &&OP_0x46E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x46F0 + i] = &&OP_0x46F0; + JumpTable[0x46F8] = &&OP_0x46F8; + JumpTable[0x46F9] = &&OP_0x46F9; + JumpTable[0x46FA] = &&OP_0x46FA; + JumpTable[0x46FB] = &&OP_0x46FB; + JumpTable[0x46FC] = &&OP_0x46FC; + JumpTable[0x46DF] = &&OP_0x46DF; + JumpTable[0x46E7] = &&OP_0x46E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4800 + i] = &&OP_0x4800; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4810 + i] = &&OP_0x4810; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4818 + i] = &&OP_0x4818; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4820 + i] = &&OP_0x4820; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4828 + i] = &&OP_0x4828; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4830 + i] = &&OP_0x4830; + JumpTable[0x4838] = &&OP_0x4838; + JumpTable[0x4839] = &&OP_0x4839; + JumpTable[0x481F] = &&OP_0x481F; + JumpTable[0x4827] = &&OP_0x4827; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4850 + i] = &&OP_0x4850; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4868 + i] = &&OP_0x4868; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4870 + i] = &&OP_0x4870; + JumpTable[0x4878] = &&OP_0x4878; + JumpTable[0x4879] = &&OP_0x4879; + JumpTable[0x487A] = &&OP_0x487A; + JumpTable[0x487B] = &&OP_0x487B; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4840 + i] = &&OP_0x4840; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4890 + i] = &&OP_0x4890; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x48A0 + i] = &&OP_0x48A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x48A8 + i] = &&OP_0x48A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x48B0 + i] = &&OP_0x48B0; + JumpTable[0x48B8] = &&OP_0x48B8; + JumpTable[0x48B9] = &&OP_0x48B9; + JumpTable[0x48A7] = &&OP_0x48A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x48D0 + i] = &&OP_0x48D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x48E0 + i] = &&OP_0x48E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x48E8 + i] = &&OP_0x48E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x48F0 + i] = &&OP_0x48F0; + JumpTable[0x48F8] = &&OP_0x48F8; + JumpTable[0x48F9] = &&OP_0x48F9; + JumpTable[0x48E7] = &&OP_0x48E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4880 + i] = &&OP_0x4880; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x48C0 + i] = &&OP_0x48C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A00 + i] = &&OP_0x4A00; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A10 + i] = &&OP_0x4A10; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4A18 + i] = &&OP_0x4A18; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4A20 + i] = &&OP_0x4A20; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A28 + i] = &&OP_0x4A28; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A30 + i] = &&OP_0x4A30; + JumpTable[0x4A38] = &&OP_0x4A38; + JumpTable[0x4A39] = &&OP_0x4A39; + JumpTable[0x4A1F] = &&OP_0x4A1F; + JumpTable[0x4A27] = &&OP_0x4A27; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A40 + i] = &&OP_0x4A40; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A50 + i] = &&OP_0x4A50; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4A58 + i] = &&OP_0x4A58; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4A60 + i] = &&OP_0x4A60; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A68 + i] = &&OP_0x4A68; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A70 + i] = &&OP_0x4A70; + JumpTable[0x4A78] = &&OP_0x4A78; + JumpTable[0x4A79] = &&OP_0x4A79; + JumpTable[0x4A5F] = &&OP_0x4A5F; + JumpTable[0x4A67] = &&OP_0x4A67; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A80 + i] = &&OP_0x4A80; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4A90 + i] = &&OP_0x4A90; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4A98 + i] = &&OP_0x4A98; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4AA0 + i] = &&OP_0x4AA0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4AA8 + i] = &&OP_0x4AA8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4AB0 + i] = &&OP_0x4AB0; + JumpTable[0x4AB8] = &&OP_0x4AB8; + JumpTable[0x4AB9] = &&OP_0x4AB9; + JumpTable[0x4A9F] = &&OP_0x4A9F; + JumpTable[0x4AA7] = &&OP_0x4AA7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4AC0 + i] = &&OP_0x4AC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4AD0 + i] = &&OP_0x4AD0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4AD8 + i] = &&OP_0x4AD8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4AE0 + i] = &&OP_0x4AE0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4AE8 + i] = &&OP_0x4AE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4AF0 + i] = &&OP_0x4AF0; + JumpTable[0x4AF8] = &&OP_0x4AF8; + JumpTable[0x4AF9] = &&OP_0x4AF9; + JumpTable[0x4ADF] = &&OP_0x4ADF; + JumpTable[0x4AE7] = &&OP_0x4AE7; + JumpTable[0x4AFC] = &&OP_0x4AFC; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4C90 + i] = &&OP_0x4C90; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4C98 + i] = &&OP_0x4C98; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4CA8 + i] = &&OP_0x4CA8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4CB0 + i] = &&OP_0x4CB0; + JumpTable[0x4CB8] = &&OP_0x4CB8; + JumpTable[0x4CB9] = &&OP_0x4CB9; + JumpTable[0x4CBA] = &&OP_0x4CBA; + JumpTable[0x4CBB] = &&OP_0x4CBB; + JumpTable[0x4C9F] = &&OP_0x4C9F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4CD0 + i] = &&OP_0x4CD0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x4CD8 + i] = &&OP_0x4CD8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4CE8 + i] = &&OP_0x4CE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4CF0 + i] = &&OP_0x4CF0; + JumpTable[0x4CF8] = &&OP_0x4CF8; + JumpTable[0x4CF9] = &&OP_0x4CF9; + JumpTable[0x4CFA] = &&OP_0x4CFA; + JumpTable[0x4CFB] = &&OP_0x4CFB; + JumpTable[0x4CDF] = &&OP_0x4CDF; + for(i = 0x0000; i <= 0x000F; i += 0x0001) + JumpTable[0x4E40 + i] = &&OP_0x4E40; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4E50 + i] = &&OP_0x4E50; + JumpTable[0x4E57] = &&OP_0x4E57; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4E58 + i] = &&OP_0x4E58; + JumpTable[0x4E5F] = &&OP_0x4E5F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4E60 + i] = &&OP_0x4E60; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4E68 + i] = &&OP_0x4E68; + JumpTable[0x4E70] = &&OP_0x4E70; + JumpTable[0x4E71] = &&OP_0x4E71; + JumpTable[0x4E72] = &&OP_0x4E72; + JumpTable[0x4E73] = &&OP_0x4E73; + JumpTable[0x4E75] = &&OP_0x4E75; + JumpTable[0x4E76] = &&OP_0x4E76; + JumpTable[0x4E77] = &&OP_0x4E77; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4E90 + i] = &&OP_0x4E90; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4EA8 + i] = &&OP_0x4EA8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4EB0 + i] = &&OP_0x4EB0; + JumpTable[0x4EB8] = &&OP_0x4EB8; + JumpTable[0x4EB9] = &&OP_0x4EB9; + JumpTable[0x4EBA] = &&OP_0x4EBA; + JumpTable[0x4EBB] = &&OP_0x4EBB; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4ED0 + i] = &&OP_0x4ED0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4EE8 + i] = &&OP_0x4EE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x4EF0 + i] = &&OP_0x4EF0; + JumpTable[0x4EF8] = &&OP_0x4EF8; + JumpTable[0x4EF9] = &&OP_0x4EF9; + JumpTable[0x4EFA] = &&OP_0x4EFA; + JumpTable[0x4EFB] = &&OP_0x4EFB; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x4180 + i + j] = &&OP_0x4180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x4190 + i + j] = &&OP_0x4190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x4198 + i + j] = &&OP_0x4198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x41A0 + i + j] = &&OP_0x41A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x41A8 + i + j] = &&OP_0x41A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x41B0 + i + j] = &&OP_0x41B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41B8 + i] = &&OP_0x41B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41B9 + i] = &&OP_0x41B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41BA + i] = &&OP_0x41BA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41BB + i] = &&OP_0x41BB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41BC + i] = &&OP_0x41BC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x419F + i] = &&OP_0x419F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41A7 + i] = &&OP_0x41A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x41D0 + i + j] = &&OP_0x41D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x41E8 + i + j] = &&OP_0x41E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x41F0 + i + j] = &&OP_0x41F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41F8 + i] = &&OP_0x41F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41F9 + i] = &&OP_0x41F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41FA + i] = &&OP_0x41FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x41FB + i] = &&OP_0x41FB; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x50C0 + i] = &&OP_0x50C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x51C0 + i] = &&OP_0x51C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x52C0 + i] = &&OP_0x52C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x53C0 + i] = &&OP_0x53C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x54C0 + i] = &&OP_0x54C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x55C0 + i] = &&OP_0x55C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x56C0 + i] = &&OP_0x56C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x57C0 + i] = &&OP_0x57C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x58C0 + i] = &&OP_0x58C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x59C0 + i] = &&OP_0x59C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5AC0 + i] = &&OP_0x5AC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5BC0 + i] = &&OP_0x5BC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5CC0 + i] = &&OP_0x5CC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5DC0 + i] = &&OP_0x5DC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5EC0 + i] = &&OP_0x5EC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5FC0 + i] = &&OP_0x5FC0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x50D0 + i] = &&OP_0x50D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x51D0 + i] = &&OP_0x51D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x52D0 + i] = &&OP_0x52D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x53D0 + i] = &&OP_0x53D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x54D0 + i] = &&OP_0x54D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x55D0 + i] = &&OP_0x55D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x56D0 + i] = &&OP_0x56D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x57D0 + i] = &&OP_0x57D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x58D0 + i] = &&OP_0x58D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x59D0 + i] = &&OP_0x59D0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5AD0 + i] = &&OP_0x5AD0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5BD0 + i] = &&OP_0x5BD0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5CD0 + i] = &&OP_0x5CD0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5DD0 + i] = &&OP_0x5DD0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5ED0 + i] = &&OP_0x5ED0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5FD0 + i] = &&OP_0x5FD0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x50D8 + i] = &&OP_0x50D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x51D8 + i] = &&OP_0x51D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x52D8 + i] = &&OP_0x52D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x53D8 + i] = &&OP_0x53D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x54D8 + i] = &&OP_0x54D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x55D8 + i] = &&OP_0x55D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x56D8 + i] = &&OP_0x56D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x57D8 + i] = &&OP_0x57D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x58D8 + i] = &&OP_0x58D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x59D8 + i] = &&OP_0x59D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5AD8 + i] = &&OP_0x5AD8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5BD8 + i] = &&OP_0x5BD8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5CD8 + i] = &&OP_0x5CD8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5DD8 + i] = &&OP_0x5DD8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5ED8 + i] = &&OP_0x5ED8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5FD8 + i] = &&OP_0x5FD8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x50E0 + i] = &&OP_0x50E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x51E0 + i] = &&OP_0x51E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x52E0 + i] = &&OP_0x52E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x53E0 + i] = &&OP_0x53E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x54E0 + i] = &&OP_0x54E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x55E0 + i] = &&OP_0x55E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x56E0 + i] = &&OP_0x56E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x57E0 + i] = &&OP_0x57E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x58E0 + i] = &&OP_0x58E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x59E0 + i] = &&OP_0x59E0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5AE0 + i] = &&OP_0x5AE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5BE0 + i] = &&OP_0x5BE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5CE0 + i] = &&OP_0x5CE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5DE0 + i] = &&OP_0x5DE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5EE0 + i] = &&OP_0x5EE0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x5FE0 + i] = &&OP_0x5FE0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x50E8 + i] = &&OP_0x50E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x51E8 + i] = &&OP_0x51E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x52E8 + i] = &&OP_0x52E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x53E8 + i] = &&OP_0x53E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x54E8 + i] = &&OP_0x54E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x55E8 + i] = &&OP_0x55E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x56E8 + i] = &&OP_0x56E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x57E8 + i] = &&OP_0x57E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x58E8 + i] = &&OP_0x58E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x59E8 + i] = &&OP_0x59E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5AE8 + i] = &&OP_0x5AE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5BE8 + i] = &&OP_0x5BE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5CE8 + i] = &&OP_0x5CE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5DE8 + i] = &&OP_0x5DE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5EE8 + i] = &&OP_0x5EE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5FE8 + i] = &&OP_0x5FE8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x50F0 + i] = &&OP_0x50F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x51F0 + i] = &&OP_0x51F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x52F0 + i] = &&OP_0x52F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x53F0 + i] = &&OP_0x53F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x54F0 + i] = &&OP_0x54F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x55F0 + i] = &&OP_0x55F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x56F0 + i] = &&OP_0x56F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x57F0 + i] = &&OP_0x57F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x58F0 + i] = &&OP_0x58F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x59F0 + i] = &&OP_0x59F0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5AF0 + i] = &&OP_0x5AF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5BF0 + i] = &&OP_0x5BF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5CF0 + i] = &&OP_0x5CF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5DF0 + i] = &&OP_0x5DF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5EF0 + i] = &&OP_0x5EF0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5FF0 + i] = &&OP_0x5FF0; + JumpTable[0x50F8] = &&OP_0x50F8; + JumpTable[0x51F8] = &&OP_0x51F8; + JumpTable[0x52F8] = &&OP_0x52F8; + JumpTable[0x53F8] = &&OP_0x53F8; + JumpTable[0x54F8] = &&OP_0x54F8; + JumpTable[0x55F8] = &&OP_0x55F8; + JumpTable[0x56F8] = &&OP_0x56F8; + JumpTable[0x57F8] = &&OP_0x57F8; + JumpTable[0x58F8] = &&OP_0x58F8; + JumpTable[0x59F8] = &&OP_0x59F8; + JumpTable[0x5AF8] = &&OP_0x5AF8; + JumpTable[0x5BF8] = &&OP_0x5BF8; + JumpTable[0x5CF8] = &&OP_0x5CF8; + JumpTable[0x5DF8] = &&OP_0x5DF8; + JumpTable[0x5EF8] = &&OP_0x5EF8; + JumpTable[0x5FF8] = &&OP_0x5FF8; + JumpTable[0x50F9] = &&OP_0x50F9; + JumpTable[0x51F9] = &&OP_0x51F9; + JumpTable[0x52F9] = &&OP_0x52F9; + JumpTable[0x53F9] = &&OP_0x53F9; + JumpTable[0x54F9] = &&OP_0x54F9; + JumpTable[0x55F9] = &&OP_0x55F9; + JumpTable[0x56F9] = &&OP_0x56F9; + JumpTable[0x57F9] = &&OP_0x57F9; + JumpTable[0x58F9] = &&OP_0x58F9; + JumpTable[0x59F9] = &&OP_0x59F9; + JumpTable[0x5AF9] = &&OP_0x5AF9; + JumpTable[0x5BF9] = &&OP_0x5BF9; + JumpTable[0x5CF9] = &&OP_0x5CF9; + JumpTable[0x5DF9] = &&OP_0x5DF9; + JumpTable[0x5EF9] = &&OP_0x5EF9; + JumpTable[0x5FF9] = &&OP_0x5FF9; + JumpTable[0x50DF] = &&OP_0x50DF; + JumpTable[0x51DF] = &&OP_0x51DF; + JumpTable[0x52DF] = &&OP_0x52DF; + JumpTable[0x53DF] = &&OP_0x53DF; + JumpTable[0x54DF] = &&OP_0x54DF; + JumpTable[0x55DF] = &&OP_0x55DF; + JumpTable[0x56DF] = &&OP_0x56DF; + JumpTable[0x57DF] = &&OP_0x57DF; + JumpTable[0x58DF] = &&OP_0x58DF; + JumpTable[0x59DF] = &&OP_0x59DF; + JumpTable[0x5ADF] = &&OP_0x5ADF; + JumpTable[0x5BDF] = &&OP_0x5BDF; + JumpTable[0x5CDF] = &&OP_0x5CDF; + JumpTable[0x5DDF] = &&OP_0x5DDF; + JumpTable[0x5EDF] = &&OP_0x5EDF; + JumpTable[0x5FDF] = &&OP_0x5FDF; + JumpTable[0x50E7] = &&OP_0x50E7; + JumpTable[0x51E7] = &&OP_0x51E7; + JumpTable[0x52E7] = &&OP_0x52E7; + JumpTable[0x53E7] = &&OP_0x53E7; + JumpTable[0x54E7] = &&OP_0x54E7; + JumpTable[0x55E7] = &&OP_0x55E7; + JumpTable[0x56E7] = &&OP_0x56E7; + JumpTable[0x57E7] = &&OP_0x57E7; + JumpTable[0x58E7] = &&OP_0x58E7; + JumpTable[0x59E7] = &&OP_0x59E7; + JumpTable[0x5AE7] = &&OP_0x5AE7; + JumpTable[0x5BE7] = &&OP_0x5BE7; + JumpTable[0x5CE7] = &&OP_0x5CE7; + JumpTable[0x5DE7] = &&OP_0x5DE7; + JumpTable[0x5EE7] = &&OP_0x5EE7; + JumpTable[0x5FE7] = &&OP_0x5FE7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x50C8 + i] = &&OP_0x50C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x51C8 + i] = &&OP_0x51C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x52C8 + i] = &&OP_0x52C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x53C8 + i] = &&OP_0x53C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x54C8 + i] = &&OP_0x54C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x55C8 + i] = &&OP_0x55C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x56C8 + i] = &&OP_0x56C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x57C8 + i] = &&OP_0x57C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x58C8 + i] = &&OP_0x58C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x59C8 + i] = &&OP_0x59C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5AC8 + i] = &&OP_0x5AC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5BC8 + i] = &&OP_0x5BC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5CC8 + i] = &&OP_0x5CC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5DC8 + i] = &&OP_0x5DC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5EC8 + i] = &&OP_0x5EC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0x5FC8 + i] = &&OP_0x5FC8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5000 + i + j] = &&OP_0x5000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5010 + i + j] = &&OP_0x5010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5018 + i + j] = &&OP_0x5018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5020 + i + j] = &&OP_0x5020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5028 + i + j] = &&OP_0x5028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5030 + i + j] = &&OP_0x5030; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5038 + i] = &&OP_0x5038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5039 + i] = &&OP_0x5039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x501F + i] = &&OP_0x501F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5027 + i] = &&OP_0x5027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5040 + i + j] = &&OP_0x5040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5048 + i + j] = &&OP_0x5048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5050 + i + j] = &&OP_0x5050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5058 + i + j] = &&OP_0x5058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5060 + i + j] = &&OP_0x5060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5068 + i + j] = &&OP_0x5068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5070 + i + j] = &&OP_0x5070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5078 + i] = &&OP_0x5078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5079 + i] = &&OP_0x5079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x505F + i] = &&OP_0x505F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5067 + i] = &&OP_0x5067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5080 + i + j] = &&OP_0x5080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5088 + i + j] = &&OP_0x5088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5090 + i + j] = &&OP_0x5090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5098 + i + j] = &&OP_0x5098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x50A0 + i + j] = &&OP_0x50A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x50A8 + i + j] = &&OP_0x50A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x50B0 + i + j] = &&OP_0x50B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x50B8 + i] = &&OP_0x50B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x50B9 + i] = &&OP_0x50B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x509F + i] = &&OP_0x509F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x50A7 + i] = &&OP_0x50A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5100 + i + j] = &&OP_0x5100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5110 + i + j] = &&OP_0x5110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5118 + i + j] = &&OP_0x5118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5120 + i + j] = &&OP_0x5120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5128 + i + j] = &&OP_0x5128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5130 + i + j] = &&OP_0x5130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5138 + i] = &&OP_0x5138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5139 + i] = &&OP_0x5139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x511F + i] = &&OP_0x511F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5127 + i] = &&OP_0x5127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5140 + i + j] = &&OP_0x5140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5148 + i + j] = &&OP_0x5148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5150 + i + j] = &&OP_0x5150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5158 + i + j] = &&OP_0x5158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5160 + i + j] = &&OP_0x5160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5168 + i + j] = &&OP_0x5168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5170 + i + j] = &&OP_0x5170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5178 + i] = &&OP_0x5178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5179 + i] = &&OP_0x5179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x515F + i] = &&OP_0x515F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x5167 + i] = &&OP_0x5167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5180 + i + j] = &&OP_0x5180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5188 + i + j] = &&OP_0x5188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5190 + i + j] = &&OP_0x5190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x5198 + i + j] = &&OP_0x5198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x51A0 + i + j] = &&OP_0x51A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x51A8 + i + j] = &&OP_0x51A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x51B0 + i + j] = &&OP_0x51B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x51B8 + i] = &&OP_0x51B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x51B9 + i] = &&OP_0x51B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x519F + i] = &&OP_0x519F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x51A7 + i] = &&OP_0x51A7; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6200 + i] = &&OP_0x6201; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6300 + i] = &&OP_0x6301; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6400 + i] = &&OP_0x6401; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6500 + i] = &&OP_0x6501; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6600 + i] = &&OP_0x6601; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6700 + i] = &&OP_0x6701; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6800 + i] = &&OP_0x6801; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6900 + i] = &&OP_0x6901; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6A00 + i] = &&OP_0x6A01; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6B00 + i] = &&OP_0x6B01; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6C00 + i] = &&OP_0x6C01; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6D00 + i] = &&OP_0x6D01; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6E00 + i] = &&OP_0x6E01; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6F00 + i] = &&OP_0x6F01; + JumpTable[0x6200] = &&OP_0x6200; + JumpTable[0x6300] = &&OP_0x6300; + JumpTable[0x6400] = &&OP_0x6400; + JumpTable[0x6500] = &&OP_0x6500; + JumpTable[0x6600] = &&OP_0x6600; + JumpTable[0x6700] = &&OP_0x6700; + JumpTable[0x6800] = &&OP_0x6800; + JumpTable[0x6900] = &&OP_0x6900; + JumpTable[0x6A00] = &&OP_0x6A00; + JumpTable[0x6B00] = &&OP_0x6B00; + JumpTable[0x6C00] = &&OP_0x6C00; + JumpTable[0x6D00] = &&OP_0x6D00; + JumpTable[0x6E00] = &&OP_0x6E00; + JumpTable[0x6F00] = &&OP_0x6F00; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6000 + i] = &&OP_0x6001; + JumpTable[0x6000] = &&OP_0x6000; + for(i = 0x0001; i <= 0x00FF; i += 0x0001) + JumpTable[0x6100 + i] = &&OP_0x6101; + JumpTable[0x6100] = &&OP_0x6100; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + for(j = 0x0000; j <= 0x00FF; j += 0x0001) + JumpTable[0x7000 + i + j] = &&OP_0x7000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8000 + i + j] = &&OP_0x8000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8010 + i + j] = &&OP_0x8010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8018 + i + j] = &&OP_0x8018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8020 + i + j] = &&OP_0x8020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8028 + i + j] = &&OP_0x8028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8030 + i + j] = &&OP_0x8030; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8038 + i] = &&OP_0x8038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8039 + i] = &&OP_0x8039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x803A + i] = &&OP_0x803A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x803B + i] = &&OP_0x803B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x803C + i] = &&OP_0x803C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x801F + i] = &&OP_0x801F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8027 + i] = &&OP_0x8027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8040 + i + j] = &&OP_0x8040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8050 + i + j] = &&OP_0x8050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8058 + i + j] = &&OP_0x8058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8060 + i + j] = &&OP_0x8060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8068 + i + j] = &&OP_0x8068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8070 + i + j] = &&OP_0x8070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8078 + i] = &&OP_0x8078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8079 + i] = &&OP_0x8079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x807A + i] = &&OP_0x807A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x807B + i] = &&OP_0x807B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x807C + i] = &&OP_0x807C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x805F + i] = &&OP_0x805F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8067 + i] = &&OP_0x8067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8080 + i + j] = &&OP_0x8080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8090 + i + j] = &&OP_0x8090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8098 + i + j] = &&OP_0x8098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80A0 + i + j] = &&OP_0x80A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80A8 + i + j] = &&OP_0x80A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80B0 + i + j] = &&OP_0x80B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80B8 + i] = &&OP_0x80B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80B9 + i] = &&OP_0x80B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80BA + i] = &&OP_0x80BA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80BB + i] = &&OP_0x80BB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80BC + i] = &&OP_0x80BC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x809F + i] = &&OP_0x809F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80A7 + i] = &&OP_0x80A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8110 + i + j] = &&OP_0x8110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8118 + i + j] = &&OP_0x8118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8120 + i + j] = &&OP_0x8120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8128 + i + j] = &&OP_0x8128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8130 + i + j] = &&OP_0x8130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8138 + i] = &&OP_0x8138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8139 + i] = &&OP_0x8139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x811F + i] = &&OP_0x811F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8127 + i] = &&OP_0x8127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8150 + i + j] = &&OP_0x8150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8158 + i + j] = &&OP_0x8158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8160 + i + j] = &&OP_0x8160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8168 + i + j] = &&OP_0x8168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8170 + i + j] = &&OP_0x8170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8178 + i] = &&OP_0x8178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8179 + i] = &&OP_0x8179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x815F + i] = &&OP_0x815F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x8167 + i] = &&OP_0x8167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8190 + i + j] = &&OP_0x8190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8198 + i + j] = &&OP_0x8198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81A0 + i + j] = &&OP_0x81A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81A8 + i + j] = &&OP_0x81A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81B0 + i + j] = &&OP_0x81B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81B8 + i] = &&OP_0x81B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81B9 + i] = &&OP_0x81B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x819F + i] = &&OP_0x819F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81A7 + i] = &&OP_0x81A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x8100 + i + j] = &&OP_0x8100; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x8108 + i + j] = &&OP_0x8108; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x810F + i] = &&OP_0x810F; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x8F08 + i] = &&OP_0x8F08; + JumpTable[0x8F0F] = &&OP_0x8F0F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80C0 + i + j] = &&OP_0x80C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80D0 + i + j] = &&OP_0x80D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80D8 + i + j] = &&OP_0x80D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80E0 + i + j] = &&OP_0x80E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80E8 + i + j] = &&OP_0x80E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x80F0 + i + j] = &&OP_0x80F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80F8 + i] = &&OP_0x80F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80F9 + i] = &&OP_0x80F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80FA + i] = &&OP_0x80FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80FB + i] = &&OP_0x80FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80FC + i] = &&OP_0x80FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80DF + i] = &&OP_0x80DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x80E7 + i] = &&OP_0x80E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81C0 + i + j] = &&OP_0x81C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81D0 + i + j] = &&OP_0x81D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81D8 + i + j] = &&OP_0x81D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81E0 + i + j] = &&OP_0x81E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81E8 + i + j] = &&OP_0x81E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x81F0 + i + j] = &&OP_0x81F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81F8 + i] = &&OP_0x81F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81F9 + i] = &&OP_0x81F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81FA + i] = &&OP_0x81FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81FB + i] = &&OP_0x81FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81FC + i] = &&OP_0x81FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81DF + i] = &&OP_0x81DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x81E7 + i] = &&OP_0x81E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9000 + i + j] = &&OP_0x9000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9008 + i + j] = &&OP_0x9008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9010 + i + j] = &&OP_0x9010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9018 + i + j] = &&OP_0x9018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9020 + i + j] = &&OP_0x9020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9028 + i + j] = &&OP_0x9028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9030 + i + j] = &&OP_0x9030; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9038 + i] = &&OP_0x9038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9039 + i] = &&OP_0x9039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x903A + i] = &&OP_0x903A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x903B + i] = &&OP_0x903B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x903C + i] = &&OP_0x903C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x901F + i] = &&OP_0x901F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9027 + i] = &&OP_0x9027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9040 + i + j] = &&OP_0x9040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9048 + i + j] = &&OP_0x9048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9050 + i + j] = &&OP_0x9050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9058 + i + j] = &&OP_0x9058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9060 + i + j] = &&OP_0x9060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9068 + i + j] = &&OP_0x9068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9070 + i + j] = &&OP_0x9070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9078 + i] = &&OP_0x9078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9079 + i] = &&OP_0x9079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x907A + i] = &&OP_0x907A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x907B + i] = &&OP_0x907B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x907C + i] = &&OP_0x907C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x905F + i] = &&OP_0x905F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9067 + i] = &&OP_0x9067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9080 + i + j] = &&OP_0x9080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9088 + i + j] = &&OP_0x9088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9090 + i + j] = &&OP_0x9090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9098 + i + j] = &&OP_0x9098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90A0 + i + j] = &&OP_0x90A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90A8 + i + j] = &&OP_0x90A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90B0 + i + j] = &&OP_0x90B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90B8 + i] = &&OP_0x90B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90B9 + i] = &&OP_0x90B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90BA + i] = &&OP_0x90BA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90BB + i] = &&OP_0x90BB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90BC + i] = &&OP_0x90BC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x909F + i] = &&OP_0x909F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90A7 + i] = &&OP_0x90A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9110 + i + j] = &&OP_0x9110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9118 + i + j] = &&OP_0x9118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9120 + i + j] = &&OP_0x9120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9128 + i + j] = &&OP_0x9128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9130 + i + j] = &&OP_0x9130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9138 + i] = &&OP_0x9138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9139 + i] = &&OP_0x9139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x911F + i] = &&OP_0x911F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9127 + i] = &&OP_0x9127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9150 + i + j] = &&OP_0x9150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9158 + i + j] = &&OP_0x9158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9160 + i + j] = &&OP_0x9160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9168 + i + j] = &&OP_0x9168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9170 + i + j] = &&OP_0x9170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9178 + i] = &&OP_0x9178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9179 + i] = &&OP_0x9179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x915F + i] = &&OP_0x915F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x9167 + i] = &&OP_0x9167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9190 + i + j] = &&OP_0x9190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9198 + i + j] = &&OP_0x9198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91A0 + i + j] = &&OP_0x91A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91A8 + i + j] = &&OP_0x91A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91B0 + i + j] = &&OP_0x91B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91B8 + i] = &&OP_0x91B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91B9 + i] = &&OP_0x91B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x919F + i] = &&OP_0x919F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91A7 + i] = &&OP_0x91A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9100 + i + j] = &&OP_0x9100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9140 + i + j] = &&OP_0x9140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x9180 + i + j] = &&OP_0x9180; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x9108 + i + j] = &&OP_0x9108; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x9148 + i + j] = &&OP_0x9148; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0x9188 + i + j] = &&OP_0x9188; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x910F + i] = &&OP_0x910F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x914F + i] = &&OP_0x914F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0x918F + i] = &&OP_0x918F; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x9F08 + i] = &&OP_0x9F08; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x9F48 + i] = &&OP_0x9F48; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0x9F88 + i] = &&OP_0x9F88; + JumpTable[0x9F0F] = &&OP_0x9F0F; + JumpTable[0x9F4F] = &&OP_0x9F4F; + JumpTable[0x9F8F] = &&OP_0x9F8F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90C0 + i + j] = &&OP_0x90C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90C8 + i + j] = &&OP_0x90C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90D0 + i + j] = &&OP_0x90D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90D8 + i + j] = &&OP_0x90D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90E0 + i + j] = &&OP_0x90E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90E8 + i + j] = &&OP_0x90E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x90F0 + i + j] = &&OP_0x90F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90F8 + i] = &&OP_0x90F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90F9 + i] = &&OP_0x90F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90FA + i] = &&OP_0x90FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90FB + i] = &&OP_0x90FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90FC + i] = &&OP_0x90FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90DF + i] = &&OP_0x90DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x90E7 + i] = &&OP_0x90E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91C0 + i + j] = &&OP_0x91C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91C8 + i + j] = &&OP_0x91C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91D0 + i + j] = &&OP_0x91D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91D8 + i + j] = &&OP_0x91D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91E0 + i + j] = &&OP_0x91E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91E8 + i + j] = &&OP_0x91E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0x91F0 + i + j] = &&OP_0x91F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91F8 + i] = &&OP_0x91F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91F9 + i] = &&OP_0x91F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91FA + i] = &&OP_0x91FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91FB + i] = &&OP_0x91FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91FC + i] = &&OP_0x91FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91DF + i] = &&OP_0x91DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0x91E7 + i] = &&OP_0x91E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB000 + i + j] = &&OP_0xB000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB008 + i + j] = &&OP_0xB008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB010 + i + j] = &&OP_0xB010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB018 + i + j] = &&OP_0xB018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB020 + i + j] = &&OP_0xB020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB028 + i + j] = &&OP_0xB028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB030 + i + j] = &&OP_0xB030; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB038 + i] = &&OP_0xB038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB039 + i] = &&OP_0xB039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB03A + i] = &&OP_0xB03A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB03B + i] = &&OP_0xB03B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB03C + i] = &&OP_0xB03C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB01F + i] = &&OP_0xB01F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB027 + i] = &&OP_0xB027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB040 + i + j] = &&OP_0xB040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB048 + i + j] = &&OP_0xB048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB050 + i + j] = &&OP_0xB050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB058 + i + j] = &&OP_0xB058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB060 + i + j] = &&OP_0xB060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB068 + i + j] = &&OP_0xB068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB070 + i + j] = &&OP_0xB070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB078 + i] = &&OP_0xB078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB079 + i] = &&OP_0xB079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB07A + i] = &&OP_0xB07A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB07B + i] = &&OP_0xB07B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB07C + i] = &&OP_0xB07C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB05F + i] = &&OP_0xB05F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB067 + i] = &&OP_0xB067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB080 + i + j] = &&OP_0xB080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB088 + i + j] = &&OP_0xB088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB090 + i + j] = &&OP_0xB090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB098 + i + j] = &&OP_0xB098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0A0 + i + j] = &&OP_0xB0A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0A8 + i + j] = &&OP_0xB0A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0B0 + i + j] = &&OP_0xB0B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0B8 + i] = &&OP_0xB0B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0B9 + i] = &&OP_0xB0B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0BA + i] = &&OP_0xB0BA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0BB + i] = &&OP_0xB0BB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0BC + i] = &&OP_0xB0BC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB09F + i] = &&OP_0xB09F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0A7 + i] = &&OP_0xB0A7; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xB108 + i + j] = &&OP_0xB108; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xB148 + i + j] = &&OP_0xB148; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xB188 + i + j] = &&OP_0xB188; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xB10F + i] = &&OP_0xB10F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xB14F + i] = &&OP_0xB14F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xB18F + i] = &&OP_0xB18F; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xBF08 + i] = &&OP_0xBF08; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xBF48 + i] = &&OP_0xBF48; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xBF88 + i] = &&OP_0xBF88; + JumpTable[0xBF0F] = &&OP_0xBF0F; + JumpTable[0xBF4F] = &&OP_0xBF4F; + JumpTable[0xBF8F] = &&OP_0xBF8F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB100 + i + j] = &&OP_0xB100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB110 + i + j] = &&OP_0xB110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB118 + i + j] = &&OP_0xB118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB120 + i + j] = &&OP_0xB120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB128 + i + j] = &&OP_0xB128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB130 + i + j] = &&OP_0xB130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB138 + i] = &&OP_0xB138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB139 + i] = &&OP_0xB139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB11F + i] = &&OP_0xB11F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB127 + i] = &&OP_0xB127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB140 + i + j] = &&OP_0xB140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB150 + i + j] = &&OP_0xB150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB158 + i + j] = &&OP_0xB158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB160 + i + j] = &&OP_0xB160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB168 + i + j] = &&OP_0xB168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB170 + i + j] = &&OP_0xB170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB178 + i] = &&OP_0xB178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB179 + i] = &&OP_0xB179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB15F + i] = &&OP_0xB15F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB167 + i] = &&OP_0xB167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB180 + i + j] = &&OP_0xB180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB190 + i + j] = &&OP_0xB190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB198 + i + j] = &&OP_0xB198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1A0 + i + j] = &&OP_0xB1A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1A8 + i + j] = &&OP_0xB1A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1B0 + i + j] = &&OP_0xB1B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1B8 + i] = &&OP_0xB1B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1B9 + i] = &&OP_0xB1B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB19F + i] = &&OP_0xB19F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1A7 + i] = &&OP_0xB1A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0C0 + i + j] = &&OP_0xB0C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0C8 + i + j] = &&OP_0xB0C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0D0 + i + j] = &&OP_0xB0D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0D8 + i + j] = &&OP_0xB0D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0E0 + i + j] = &&OP_0xB0E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0E8 + i + j] = &&OP_0xB0E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB0F0 + i + j] = &&OP_0xB0F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0F8 + i] = &&OP_0xB0F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0F9 + i] = &&OP_0xB0F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0FA + i] = &&OP_0xB0FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0FB + i] = &&OP_0xB0FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0FC + i] = &&OP_0xB0FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0DF + i] = &&OP_0xB0DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB0E7 + i] = &&OP_0xB0E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1C0 + i + j] = &&OP_0xB1C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1C8 + i + j] = &&OP_0xB1C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1D0 + i + j] = &&OP_0xB1D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1D8 + i + j] = &&OP_0xB1D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1E0 + i + j] = &&OP_0xB1E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1E8 + i + j] = &&OP_0xB1E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xB1F0 + i + j] = &&OP_0xB1F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1F8 + i] = &&OP_0xB1F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1F9 + i] = &&OP_0xB1F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1FA + i] = &&OP_0xB1FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1FB + i] = &&OP_0xB1FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1FC + i] = &&OP_0xB1FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1DF + i] = &&OP_0xB1DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xB1E7 + i] = &&OP_0xB1E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC000 + i + j] = &&OP_0xC000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC010 + i + j] = &&OP_0xC010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC018 + i + j] = &&OP_0xC018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC020 + i + j] = &&OP_0xC020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC028 + i + j] = &&OP_0xC028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC030 + i + j] = &&OP_0xC030; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC038 + i] = &&OP_0xC038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC039 + i] = &&OP_0xC039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC03A + i] = &&OP_0xC03A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC03B + i] = &&OP_0xC03B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC03C + i] = &&OP_0xC03C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC01F + i] = &&OP_0xC01F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC027 + i] = &&OP_0xC027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC040 + i + j] = &&OP_0xC040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC050 + i + j] = &&OP_0xC050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC058 + i + j] = &&OP_0xC058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC060 + i + j] = &&OP_0xC060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC068 + i + j] = &&OP_0xC068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC070 + i + j] = &&OP_0xC070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC078 + i] = &&OP_0xC078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC079 + i] = &&OP_0xC079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC07A + i] = &&OP_0xC07A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC07B + i] = &&OP_0xC07B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC07C + i] = &&OP_0xC07C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC05F + i] = &&OP_0xC05F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC067 + i] = &&OP_0xC067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC080 + i + j] = &&OP_0xC080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC090 + i + j] = &&OP_0xC090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC098 + i + j] = &&OP_0xC098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0A0 + i + j] = &&OP_0xC0A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0A8 + i + j] = &&OP_0xC0A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0B0 + i + j] = &&OP_0xC0B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0B8 + i] = &&OP_0xC0B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0B9 + i] = &&OP_0xC0B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0BA + i] = &&OP_0xC0BA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0BB + i] = &&OP_0xC0BB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0BC + i] = &&OP_0xC0BC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC09F + i] = &&OP_0xC09F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0A7 + i] = &&OP_0xC0A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC110 + i + j] = &&OP_0xC110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC118 + i + j] = &&OP_0xC118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC120 + i + j] = &&OP_0xC120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC128 + i + j] = &&OP_0xC128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC130 + i + j] = &&OP_0xC130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC138 + i] = &&OP_0xC138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC139 + i] = &&OP_0xC139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC11F + i] = &&OP_0xC11F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC127 + i] = &&OP_0xC127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC150 + i + j] = &&OP_0xC150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC158 + i + j] = &&OP_0xC158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC160 + i + j] = &&OP_0xC160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC168 + i + j] = &&OP_0xC168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC170 + i + j] = &&OP_0xC170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC178 + i] = &&OP_0xC178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC179 + i] = &&OP_0xC179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC15F + i] = &&OP_0xC15F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC167 + i] = &&OP_0xC167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC190 + i + j] = &&OP_0xC190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC198 + i + j] = &&OP_0xC198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1A0 + i + j] = &&OP_0xC1A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1A8 + i + j] = &&OP_0xC1A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1B0 + i + j] = &&OP_0xC1B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1B8 + i] = &&OP_0xC1B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1B9 + i] = &&OP_0xC1B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC19F + i] = &&OP_0xC19F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1A7 + i] = &&OP_0xC1A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC100 + i + j] = &&OP_0xC100; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xC108 + i + j] = &&OP_0xC108; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xC10F + i] = &&OP_0xC10F; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xCF08 + i] = &&OP_0xCF08; + JumpTable[0xCF0F] = &&OP_0xCF0F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0C0 + i + j] = &&OP_0xC0C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0D0 + i + j] = &&OP_0xC0D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0D8 + i + j] = &&OP_0xC0D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0E0 + i + j] = &&OP_0xC0E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0E8 + i + j] = &&OP_0xC0E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC0F0 + i + j] = &&OP_0xC0F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0F8 + i] = &&OP_0xC0F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0F9 + i] = &&OP_0xC0F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0FA + i] = &&OP_0xC0FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0FB + i] = &&OP_0xC0FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0FC + i] = &&OP_0xC0FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0DF + i] = &&OP_0xC0DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC0E7 + i] = &&OP_0xC0E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1C0 + i + j] = &&OP_0xC1C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1D0 + i + j] = &&OP_0xC1D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1D8 + i + j] = &&OP_0xC1D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1E0 + i + j] = &&OP_0xC1E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1E8 + i + j] = &&OP_0xC1E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC1F0 + i + j] = &&OP_0xC1F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1F8 + i] = &&OP_0xC1F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1F9 + i] = &&OP_0xC1F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1FA + i] = &&OP_0xC1FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1FB + i] = &&OP_0xC1FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1FC + i] = &&OP_0xC1FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1DF + i] = &&OP_0xC1DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xC1E7 + i] = &&OP_0xC1E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC140 + i + j] = &&OP_0xC140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC148 + i + j] = &&OP_0xC148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xC188 + i + j] = &&OP_0xC188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD000 + i + j] = &&OP_0xD000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD008 + i + j] = &&OP_0xD008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD010 + i + j] = &&OP_0xD010; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD018 + i + j] = &&OP_0xD018; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD020 + i + j] = &&OP_0xD020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD028 + i + j] = &&OP_0xD028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD030 + i + j] = &&OP_0xD030; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD038 + i] = &&OP_0xD038; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD039 + i] = &&OP_0xD039; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD03A + i] = &&OP_0xD03A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD03B + i] = &&OP_0xD03B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD03C + i] = &&OP_0xD03C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD01F + i] = &&OP_0xD01F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD027 + i] = &&OP_0xD027; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD040 + i + j] = &&OP_0xD040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD048 + i + j] = &&OP_0xD048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD050 + i + j] = &&OP_0xD050; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD058 + i + j] = &&OP_0xD058; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD060 + i + j] = &&OP_0xD060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD068 + i + j] = &&OP_0xD068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD070 + i + j] = &&OP_0xD070; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD078 + i] = &&OP_0xD078; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD079 + i] = &&OP_0xD079; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD07A + i] = &&OP_0xD07A; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD07B + i] = &&OP_0xD07B; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD07C + i] = &&OP_0xD07C; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD05F + i] = &&OP_0xD05F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD067 + i] = &&OP_0xD067; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD080 + i + j] = &&OP_0xD080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD088 + i + j] = &&OP_0xD088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD090 + i + j] = &&OP_0xD090; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD098 + i + j] = &&OP_0xD098; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0A0 + i + j] = &&OP_0xD0A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0A8 + i + j] = &&OP_0xD0A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0B0 + i + j] = &&OP_0xD0B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0B8 + i] = &&OP_0xD0B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0B9 + i] = &&OP_0xD0B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0BA + i] = &&OP_0xD0BA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0BB + i] = &&OP_0xD0BB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0BC + i] = &&OP_0xD0BC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD09F + i] = &&OP_0xD09F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0A7 + i] = &&OP_0xD0A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD110 + i + j] = &&OP_0xD110; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD118 + i + j] = &&OP_0xD118; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD120 + i + j] = &&OP_0xD120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD128 + i + j] = &&OP_0xD128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD130 + i + j] = &&OP_0xD130; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD138 + i] = &&OP_0xD138; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD139 + i] = &&OP_0xD139; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD11F + i] = &&OP_0xD11F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD127 + i] = &&OP_0xD127; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD150 + i + j] = &&OP_0xD150; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD158 + i + j] = &&OP_0xD158; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD160 + i + j] = &&OP_0xD160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD168 + i + j] = &&OP_0xD168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD170 + i + j] = &&OP_0xD170; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD178 + i] = &&OP_0xD178; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD179 + i] = &&OP_0xD179; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD15F + i] = &&OP_0xD15F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD167 + i] = &&OP_0xD167; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD190 + i + j] = &&OP_0xD190; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD198 + i + j] = &&OP_0xD198; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1A0 + i + j] = &&OP_0xD1A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1A8 + i + j] = &&OP_0xD1A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1B0 + i + j] = &&OP_0xD1B0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1B8 + i] = &&OP_0xD1B8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1B9 + i] = &&OP_0xD1B9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD19F + i] = &&OP_0xD19F; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1A7 + i] = &&OP_0xD1A7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD100 + i + j] = &&OP_0xD100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD140 + i + j] = &&OP_0xD140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD180 + i + j] = &&OP_0xD180; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xD108 + i + j] = &&OP_0xD108; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xD148 + i + j] = &&OP_0xD148; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0C00; j += 0x0200) + JumpTable[0xD188 + i + j] = &&OP_0xD188; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xD10F + i] = &&OP_0xD10F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xD14F + i] = &&OP_0xD14F; + for(i = 0x0000; i <= 0x0C00; i += 0x0200) + JumpTable[0xD18F + i] = &&OP_0xD18F; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xDF08 + i] = &&OP_0xDF08; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xDF48 + i] = &&OP_0xDF48; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xDF88 + i] = &&OP_0xDF88; + JumpTable[0xDF0F] = &&OP_0xDF0F; + JumpTable[0xDF4F] = &&OP_0xDF4F; + JumpTable[0xDF8F] = &&OP_0xDF8F; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0C0 + i + j] = &&OP_0xD0C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0C8 + i + j] = &&OP_0xD0C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0D0 + i + j] = &&OP_0xD0D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0D8 + i + j] = &&OP_0xD0D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0E0 + i + j] = &&OP_0xD0E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0E8 + i + j] = &&OP_0xD0E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD0F0 + i + j] = &&OP_0xD0F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0F8 + i] = &&OP_0xD0F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0F9 + i] = &&OP_0xD0F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0FA + i] = &&OP_0xD0FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0FB + i] = &&OP_0xD0FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0FC + i] = &&OP_0xD0FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0DF + i] = &&OP_0xD0DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD0E7 + i] = &&OP_0xD0E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1C0 + i + j] = &&OP_0xD1C0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1C8 + i + j] = &&OP_0xD1C8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1D0 + i + j] = &&OP_0xD1D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1D8 + i + j] = &&OP_0xD1D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1E0 + i + j] = &&OP_0xD1E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1E8 + i + j] = &&OP_0xD1E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xD1F0 + i + j] = &&OP_0xD1F0; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1F8 + i] = &&OP_0xD1F8; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1F9 + i] = &&OP_0xD1F9; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1FA + i] = &&OP_0xD1FA; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1FB + i] = &&OP_0xD1FB; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1FC + i] = &&OP_0xD1FC; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1DF + i] = &&OP_0xD1DF; + for(i = 0x0000; i <= 0x0E00; i += 0x0200) + JumpTable[0xD1E7 + i] = &&OP_0xD1E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE000 + i + j] = &&OP_0xE000; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE040 + i + j] = &&OP_0xE040; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE080 + i + j] = &&OP_0xE080; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE008 + i + j] = &&OP_0xE008; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE048 + i + j] = &&OP_0xE048; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE088 + i + j] = &&OP_0xE088; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE010 + i + j] = &&OP_0xE010; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE050 + i + j] = &&OP_0xE050; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE090 + i + j] = &&OP_0xE090; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE018 + i + j] = &&OP_0xE018; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE058 + i + j] = &&OP_0xE058; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE098 + i + j] = &&OP_0xE098; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE100 + i + j] = &&OP_0xE100; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE140 + i + j] = &&OP_0xE140; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE180 + i + j] = &&OP_0xE180; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE108 + i + j] = &&OP_0xE108; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE148 + i + j] = &&OP_0xE148; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE188 + i + j] = &&OP_0xE188; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE110 + i + j] = &&OP_0xE110; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE150 + i + j] = &&OP_0xE150; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE190 + i + j] = &&OP_0xE190; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE118 + i + j] = &&OP_0xE118; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE158 + i + j] = &&OP_0xE158; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE198 + i + j] = &&OP_0xE198; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE020 + i + j] = &&OP_0xE020; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE060 + i + j] = &&OP_0xE060; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE0A0 + i + j] = &&OP_0xE0A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE028 + i + j] = &&OP_0xE028; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE068 + i + j] = &&OP_0xE068; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE0A8 + i + j] = &&OP_0xE0A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE030 + i + j] = &&OP_0xE030; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE070 + i + j] = &&OP_0xE070; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE0B0 + i + j] = &&OP_0xE0B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE038 + i + j] = &&OP_0xE038; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE078 + i + j] = &&OP_0xE078; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE0B8 + i + j] = &&OP_0xE0B8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE120 + i + j] = &&OP_0xE120; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE160 + i + j] = &&OP_0xE160; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE1A0 + i + j] = &&OP_0xE1A0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE128 + i + j] = &&OP_0xE128; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE168 + i + j] = &&OP_0xE168; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE1A8 + i + j] = &&OP_0xE1A8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE130 + i + j] = &&OP_0xE130; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE170 + i + j] = &&OP_0xE170; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE1B0 + i + j] = &&OP_0xE1B0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE138 + i + j] = &&OP_0xE138; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE178 + i + j] = &&OP_0xE178; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + for(j = 0x0000; j <= 0x0E00; j += 0x0200) + JumpTable[0xE1B8 + i + j] = &&OP_0xE1B8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE0D0 + i] = &&OP_0xE0D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE0D8 + i] = &&OP_0xE0D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE0E0 + i] = &&OP_0xE0E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE0E8 + i] = &&OP_0xE0E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE0F0 + i] = &&OP_0xE0F0; + JumpTable[0xE0F8] = &&OP_0xE0F8; + JumpTable[0xE0F9] = &&OP_0xE0F9; + JumpTable[0xE0DF] = &&OP_0xE0DF; + JumpTable[0xE0E7] = &&OP_0xE0E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE2D0 + i] = &&OP_0xE2D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE2D8 + i] = &&OP_0xE2D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE2E0 + i] = &&OP_0xE2E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE2E8 + i] = &&OP_0xE2E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE2F0 + i] = &&OP_0xE2F0; + JumpTable[0xE2F8] = &&OP_0xE2F8; + JumpTable[0xE2F9] = &&OP_0xE2F9; + JumpTable[0xE2DF] = &&OP_0xE2DF; + JumpTable[0xE2E7] = &&OP_0xE2E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE4D0 + i] = &&OP_0xE4D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE4D8 + i] = &&OP_0xE4D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE4E0 + i] = &&OP_0xE4E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE4E8 + i] = &&OP_0xE4E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE4F0 + i] = &&OP_0xE4F0; + JumpTable[0xE4F8] = &&OP_0xE4F8; + JumpTable[0xE4F9] = &&OP_0xE4F9; + JumpTable[0xE4DF] = &&OP_0xE4DF; + JumpTable[0xE4E7] = &&OP_0xE4E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE6D0 + i] = &&OP_0xE6D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE6D8 + i] = &&OP_0xE6D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE6E0 + i] = &&OP_0xE6E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE6E8 + i] = &&OP_0xE6E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE6F0 + i] = &&OP_0xE6F0; + JumpTable[0xE6F8] = &&OP_0xE6F8; + JumpTable[0xE6F9] = &&OP_0xE6F9; + JumpTable[0xE6DF] = &&OP_0xE6DF; + JumpTable[0xE6E7] = &&OP_0xE6E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE1D0 + i] = &&OP_0xE1D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE1D8 + i] = &&OP_0xE1D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE1E0 + i] = &&OP_0xE1E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE1E8 + i] = &&OP_0xE1E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE1F0 + i] = &&OP_0xE1F0; + JumpTable[0xE1F8] = &&OP_0xE1F8; + JumpTable[0xE1F9] = &&OP_0xE1F9; + JumpTable[0xE1DF] = &&OP_0xE1DF; + JumpTable[0xE1E7] = &&OP_0xE1E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE3D0 + i] = &&OP_0xE3D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE3D8 + i] = &&OP_0xE3D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE3E0 + i] = &&OP_0xE3E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE3E8 + i] = &&OP_0xE3E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE3F0 + i] = &&OP_0xE3F0; + JumpTable[0xE3F8] = &&OP_0xE3F8; + JumpTable[0xE3F9] = &&OP_0xE3F9; + JumpTable[0xE3DF] = &&OP_0xE3DF; + JumpTable[0xE3E7] = &&OP_0xE3E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE5D0 + i] = &&OP_0xE5D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE5D8 + i] = &&OP_0xE5D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE5E0 + i] = &&OP_0xE5E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE5E8 + i] = &&OP_0xE5E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE5F0 + i] = &&OP_0xE5F0; + JumpTable[0xE5F8] = &&OP_0xE5F8; + JumpTable[0xE5F9] = &&OP_0xE5F9; + JumpTable[0xE5DF] = &&OP_0xE5DF; + JumpTable[0xE5E7] = &&OP_0xE5E7; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE7D0 + i] = &&OP_0xE7D0; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE7D8 + i] = &&OP_0xE7D8; + for(i = 0x0000; i <= 0x0006; i += 0x0001) + JumpTable[0xE7E0 + i] = &&OP_0xE7E0; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE7E8 + i] = &&OP_0xE7E8; + for(i = 0x0000; i <= 0x0007; i += 0x0001) + JumpTable[0xE7F0 + i] = &&OP_0xE7F0; + JumpTable[0xE7F8] = &&OP_0xE7F8; + JumpTable[0xE7F9] = &&OP_0xE7F9; + JumpTable[0xE7DF] = &&OP_0xE7DF; + JumpTable[0xE7E7] = &&OP_0xE7E7; diff --git a/m68000/c68k/c68k_op0.inc b/m68000/c68k/c68k_op0.inc new file mode 100644 index 0000000..501b870 --- /dev/null +++ b/m68000/c68k/c68k_op0.inc @@ -0,0 +1,5617 @@ + +// ORI +OP_0x0000: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ORI +OP_0x0010: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ORI +OP_0x0018: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ORI +OP_0x0020: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ORI +OP_0x0028: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ORI +OP_0x0030: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// ORI +OP_0x0038: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ORI +OP_0x0039: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// ORI +OP_0x001F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ORI +OP_0x0027: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ORI +OP_0x0040: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ORI +OP_0x0050: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ORI +OP_0x0058: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ORI +OP_0x0060: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ORI +OP_0x0068: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ORI +OP_0x0070: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// ORI +OP_0x0078: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ORI +OP_0x0079: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// ORI +OP_0x005F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ORI +OP_0x0067: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ORI +OP_0x0080: +{ + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(16) + +// ORI +OP_0x0090: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ORI +OP_0x0098: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ORI +OP_0x00A0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ORI +OP_0x00A8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// ORI +OP_0x00B0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// ORI +OP_0x00B8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// ORI +OP_0x00B9: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(36) + +// ORI +OP_0x009F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ORI +OP_0x00A7: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ORICCR +OP_0x003C: +{ + u32 res; + res = FETCH_BYTE & C68K_CCR_MASK; + PC += 2; + res |= GET_CCR; + SET_CCR(res) +} +RET(20) + +// ORISR +OP_0x007C: +{ + u32 res; + if (CPU->flag_S) + { + res = FETCH_WORD & C68K_SR_MASK; + PC += 2; + res |= GET_SR; + SET_SR(res) + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// ANDI +OP_0x0200: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ANDI +OP_0x0210: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ANDI +OP_0x0218: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ANDI +OP_0x0220: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ANDI +OP_0x0228: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ANDI +OP_0x0230: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// ANDI +OP_0x0238: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ANDI +OP_0x0239: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// ANDI +OP_0x021F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ANDI +OP_0x0227: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ANDI +OP_0x0240: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ANDI +OP_0x0250: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ANDI +OP_0x0258: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ANDI +OP_0x0260: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ANDI +OP_0x0268: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ANDI +OP_0x0270: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// ANDI +OP_0x0278: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ANDI +OP_0x0279: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// ANDI +OP_0x025F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ANDI +OP_0x0267: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ANDI +OP_0x0280: +{ + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(16) + +// ANDI +OP_0x0290: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ANDI +OP_0x0298: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ANDI +OP_0x02A0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ANDI +OP_0x02A8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// ANDI +OP_0x02B0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// ANDI +OP_0x02B8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// ANDI +OP_0x02B9: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(36) + +// ANDI +OP_0x029F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ANDI +OP_0x02A7: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ANDICCR +OP_0x023C: +{ + u32 res; + res = FETCH_BYTE & C68K_CCR_MASK; + PC += 2; + res &= GET_CCR; + SET_CCR(res) +} +RET(20) + +// ANDISR +OP_0x027C: +{ + u32 res; + if (CPU->flag_S) + { + res = FETCH_WORD & C68K_SR_MASK; + PC += 2; + res &= GET_SR; + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// EORI +OP_0x0A00: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// EORI +OP_0x0A10: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// EORI +OP_0x0A18: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// EORI +OP_0x0A20: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// EORI +OP_0x0A28: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// EORI +OP_0x0A30: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// EORI +OP_0x0A38: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// EORI +OP_0x0A39: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// EORI +OP_0x0A1F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// EORI +OP_0x0A27: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// EORI +OP_0x0A40: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// EORI +OP_0x0A50: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// EORI +OP_0x0A58: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// EORI +OP_0x0A60: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// EORI +OP_0x0A68: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// EORI +OP_0x0A70: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// EORI +OP_0x0A78: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// EORI +OP_0x0A79: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// EORI +OP_0x0A5F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// EORI +OP_0x0A67: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// EORI +OP_0x0A80: +{ + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(16) + +// EORI +OP_0x0A90: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// EORI +OP_0x0A98: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// EORI +OP_0x0AA0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// EORI +OP_0x0AA8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// EORI +OP_0x0AB0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// EORI +OP_0x0AB8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// EORI +OP_0x0AB9: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(36) + +// EORI +OP_0x0A9F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// EORI +OP_0x0AA7: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// EORICCR +OP_0x0A3C: +{ + u32 res; + res = FETCH_BYTE & C68K_CCR_MASK; + PC += 2; + res ^= GET_CCR; + SET_CCR(res) +} +RET(20) + +// EORISR +OP_0x0A7C: +{ + u32 res; + if (CPU->flag_S) + { + res = FETCH_WORD & C68K_SR_MASK; + PC += 2; + res ^= GET_SR; + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// SUBI +OP_0x0400: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + dst = (u8)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// SUBI +OP_0x0410: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBI +OP_0x0418: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBI +OP_0x0420: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBI +OP_0x0428: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// SUBI +OP_0x0430: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// SUBI +OP_0x0438: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// SUBI +OP_0x0439: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// SUBI +OP_0x041F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBI +OP_0x0427: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBI +OP_0x0440: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + dst = (u16)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// SUBI +OP_0x0450: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBI +OP_0x0458: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBI +OP_0x0460: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBI +OP_0x0468: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// SUBI +OP_0x0470: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// SUBI +OP_0x0478: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// SUBI +OP_0x0479: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// SUBI +OP_0x045F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBI +OP_0x0467: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBI +OP_0x0480: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + dst = (u32)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(16) + +// SUBI +OP_0x0490: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// SUBI +OP_0x0498: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// SUBI +OP_0x04A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// SUBI +OP_0x04A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// SUBI +OP_0x04B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// SUBI +OP_0x04B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// SUBI +OP_0x04B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(36) + +// SUBI +OP_0x049F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// SUBI +OP_0x04A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ADDI +OP_0x0600: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + dst = (u8)CPU->D[(Opcode >> 0) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ADDI +OP_0x0610: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDI +OP_0x0618: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDI +OP_0x0620: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDI +OP_0x0628: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ADDI +OP_0x0630: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// ADDI +OP_0x0638: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ADDI +OP_0x0639: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// ADDI +OP_0x061F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDI +OP_0x0627: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDI +OP_0x0640: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + dst = (u16)CPU->D[(Opcode >> 0) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ADDI +OP_0x0650: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDI +OP_0x0658: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDI +OP_0x0660: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDI +OP_0x0668: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ADDI +OP_0x0670: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// ADDI +OP_0x0678: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ADDI +OP_0x0679: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// ADDI +OP_0x065F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDI +OP_0x0667: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDI +OP_0x0680: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + dst = (u32)CPU->D[(Opcode >> 0) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(16) + +// ADDI +OP_0x0690: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ADDI +OP_0x0698: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ADDI +OP_0x06A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ADDI +OP_0x06A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// ADDI +OP_0x06B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// ADDI +OP_0x06B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// ADDI +OP_0x06B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(36) + +// ADDI +OP_0x069F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ADDI +OP_0x06A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// CMPI +OP_0x0C00: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + dst = (u8)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; +} +RET(8) + +// CMPI +OP_0x0C10: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMPI +OP_0x0C18: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMPI +OP_0x0C20: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(14) + +// CMPI +OP_0x0C28: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(16) + +// CMPI +OP_0x0C30: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(18) + +// CMPI +OP_0x0C38: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(16) + +// CMPI +OP_0x0C39: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(20) + +// CMPI +OP_0x0C1F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMPI +OP_0x0C27: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(14) + +// CMPI +OP_0x0C40: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + dst = (u16)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; +} +RET(8) + +// CMPI +OP_0x0C50: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMPI +OP_0x0C58: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMPI +OP_0x0C60: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(14) + +// CMPI +OP_0x0C68: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(16) + +// CMPI +OP_0x0C70: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(18) + +// CMPI +OP_0x0C78: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(16) + +// CMPI +OP_0x0C79: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(20) + +// CMPI +OP_0x0C5F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMPI +OP_0x0C67: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(14) + +// CMPI +OP_0x0C80: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + dst = (u32)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(14) + +// CMPI +OP_0x0C90: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMPI +OP_0x0C98: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMPI +OP_0x0CA0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(22) + +// CMPI +OP_0x0CA8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(24) + +// CMPI +OP_0x0CB0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(26) + +// CMPI +OP_0x0CB8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(24) + +// CMPI +OP_0x0CB9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(28) + +// CMPI +OP_0x0C9F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMPI +OP_0x0CA7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(22) + +// BTSTn +OP_0x0800: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; +} +RET(10) + +// BTSTn +OP_0x0810: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(12) + +// BTSTn +OP_0x0818: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(12) + +// BTSTn +OP_0x0820: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(14) + +// BTSTn +OP_0x0828: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(16) + +// BTSTn +OP_0x0830: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(18) + +// BTSTn +OP_0x0838: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(16) + +// BTSTn +OP_0x0839: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(20) + +// BTSTn +OP_0x083A: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(16) + +// BTSTn +OP_0x083B: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(18) + +// BTSTn +OP_0x081F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(12) + +// BTSTn +OP_0x0827: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(14) + +// BCHGn +OP_0x0840: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; + res ^= src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(12) + +// BCHGn +OP_0x0850: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCHGn +OP_0x0858: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCHGn +OP_0x0860: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BCHGn +OP_0x0868: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BCHGn +OP_0x0870: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// BCHGn +OP_0x0878: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BCHGn +OP_0x0879: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// BCHGn +OP_0x085F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCHGn +OP_0x0867: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BCLRn +OP_0x0880: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; + res &= ~src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(14) + +// BCLRn +OP_0x0890: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCLRn +OP_0x0898: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCLRn +OP_0x08A0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BCLRn +OP_0x08A8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BCLRn +OP_0x08B0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// BCLRn +OP_0x08B8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BCLRn +OP_0x08B9: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// BCLRn +OP_0x089F: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCLRn +OP_0x08A7: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BSETn +OP_0x08C0: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; + res |= src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(12) + +// BSETn +OP_0x08D0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BSETn +OP_0x08D8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BSETn +OP_0x08E0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BSETn +OP_0x08E8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BSETn +OP_0x08F0: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// BSETn +OP_0x08F8: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BSETn +OP_0x08F9: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// BSETn +OP_0x08DF: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BSETn +OP_0x08E7: +{ + u32 adr; + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BTST +OP_0x0100: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; +} +RET(6) + +// BTST +OP_0x0110: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(8) + +// BTST +OP_0x0118: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(8) + +// BTST +OP_0x0120: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(10) + +// BTST +OP_0x0128: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(12) + +// BTST +OP_0x0130: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(14) + +// BTST +OP_0x0138: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(12) + +// BTST +OP_0x0139: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(16) + +// BTST +OP_0x013A: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(12) + +// BTST +OP_0x013B: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(14) + +// BTST +OP_0x013C: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + res = FETCH_BYTE; + PC += 2; + CPU->flag_notZ = res & src; +} +RET(8) + +// BTST +OP_0x011F: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(8) + +// BTST +OP_0x0127: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + POST_IO +} +RET(10) + +// BCHG +OP_0x0140: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; + res ^= src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// BCHG +OP_0x0150: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BCHG +OP_0x0158: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BCHG +OP_0x0160: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// BCHG +OP_0x0168: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCHG +OP_0x0170: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BCHG +OP_0x0178: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCHG +OP_0x0179: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BCHG +OP_0x015F: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BCHG +OP_0x0167: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res ^= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// BCLR +OP_0x0180: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; + res &= ~src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(10) + +// BCLR +OP_0x0190: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BCLR +OP_0x0198: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BCLR +OP_0x01A0: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// BCLR +OP_0x01A8: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCLR +OP_0x01B0: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BCLR +OP_0x01B8: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BCLR +OP_0x01B9: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BCLR +OP_0x019F: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BCLR +OP_0x01A7: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res &= ~src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// BSET +OP_0x01C0: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 31); + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_notZ = res & src; + res |= src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// BSET +OP_0x01D0: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BSET +OP_0x01D8: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BSET +OP_0x01E0: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// BSET +OP_0x01E8: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BSET +OP_0x01F0: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// BSET +OP_0x01F8: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// BSET +OP_0x01F9: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// BSET +OP_0x01DF: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// BSET +OP_0x01E7: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + src = 1 << (src & 7); + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_notZ = res & src; + res |= src; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEPWaD +OP_0x0108: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr + 0, res) + READ_BYTE_F(adr + 2, src) + *(u16*)(&CPU->D[(Opcode >> 9) & 7]) = (res << 8) | src; + POST_IO +} +RET(24) + +// MOVEPLaD +OP_0x0148: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res <<= 24; + adr += 2; + READ_BYTE_F(adr, src) + res |= src << 16; + adr += 2; + READ_BYTE_F(adr, src) + res |= src << 8; + adr += 2; + READ_BYTE_F(adr, src) + CPU->D[(Opcode >> 9) & 7] = res | src; + POST_IO +} +RET(32) + +// MOVEPWDa +OP_0x0188: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr + 0, res >> 8) + WRITE_BYTE_F(adr + 2, res >> 0) + POST_IO +} +RET(24) + +// MOVEPLDa +OP_0x01C8: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res >> 24) + adr += 2; + WRITE_BYTE_F(adr, res >> 16) + adr += 2; + WRITE_BYTE_F(adr, res >> 8) + adr += 2; + WRITE_BYTE_F(adr, res >> 0) + POST_IO +} +RET(32) diff --git a/m68000/c68k/c68k_op1.inc b/m68000/c68k/c68k_op1.inc new file mode 100644 index 0000000..b913c5f --- /dev/null +++ b/m68000/c68k/c68k_op1.inc @@ -0,0 +1,2719 @@ + +// MOVEB +OP_0x1000: +{ + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// MOVEB +OP_0x1080: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x10C0: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1100: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1140: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1180: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x11C0: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x13C0: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1EC0: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1F00: +{ + u32 adr; + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1008: +{ + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// MOVEB +OP_0x1088: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x10C8: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1108: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1148: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1188: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x11C8: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x13C8: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1EC8: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1F08: +{ + u32 adr; + u32 res; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// MOVEB +OP_0x1010: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// MOVEB +OP_0x1090: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x10D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1110: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1150: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1190: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x11D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x13D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1ED0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1F10: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1018: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// MOVEB +OP_0x1098: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x10D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1118: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1158: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1198: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x11D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x13D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1ED8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1F18: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1020: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// MOVEB +OP_0x10A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x10E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1120: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1160: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x11A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x11E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x13E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x1EE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1F20: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1028: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEB +OP_0x10A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x10E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1128: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1168: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x11A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x11E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x13E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x1EE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1F28: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1030: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// MOVEB +OP_0x10B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x10F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x1130: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x1170: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x11B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x11F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x13F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(26) + +// MOVEB +OP_0x1EF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x1F30: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x1038: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEB +OP_0x10B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x10F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1138: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1178: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x11B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x11F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x13F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x1EF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1F38: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1039: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// MOVEB +OP_0x10B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x10F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1139: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1179: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x11B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(26) + +// MOVEB +OP_0x11F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x13F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(28) + +// MOVEB +OP_0x1EF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1F39: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x103A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEB +OP_0x10BA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x10FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x113A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x117A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x11BA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x11FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x13FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x1EFA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x1F3A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x103B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// MOVEB +OP_0x10BB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x10FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x113B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x117B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x11BB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(24) + +// MOVEB +OP_0x11FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x13FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(26) + +// MOVEB +OP_0x1EFB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x1F3B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x103C: +{ + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// MOVEB +OP_0x10BC: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x10FC: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x113C: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x117C: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x11BC: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x11FC: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x13FC: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1EFC: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1F3C: +{ + u32 adr; + u32 res; + res = FETCH_BYTE; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x101F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// MOVEB +OP_0x109F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x10DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x111F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x115F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x119F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x11DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// MOVEB +OP_0x13DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x1EDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1F1F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// MOVEB +OP_0x1027: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// MOVEB +OP_0x10A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x10E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1127: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1167: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x11A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// MOVEB +OP_0x11E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MOVEB +OP_0x13E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(22) + +// MOVEB +OP_0x1EE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// MOVEB +OP_0x1F27: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) diff --git a/m68000/c68k/c68k_op2.inc b/m68000/c68k/c68k_op2.inc new file mode 100644 index 0000000..e38cadd --- /dev/null +++ b/m68000/c68k/c68k_op2.inc @@ -0,0 +1,2870 @@ + +// MOVEL +OP_0x2000: +{ + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// MOVEL +OP_0x2080: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x20C0: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2100: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2140: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(16) + +// MOVEL +OP_0x2180: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(18) + +// MOVEL +OP_0x21C0: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(16) + +// MOVEL +OP_0x23C0: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2EC0: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2F00: +{ + u32 adr; + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2008: +{ + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// MOVEL +OP_0x2088: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x20C8: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2108: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2148: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(16) + +// MOVEL +OP_0x2188: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(18) + +// MOVEL +OP_0x21C8: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(16) + +// MOVEL +OP_0x23C8: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2EC8: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2F08: +{ + u32 adr; + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(12) + +// MOVEL +OP_0x2010: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEL +OP_0x2090: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x20D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2110: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2150: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2190: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x21D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x23D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2ED0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2F10: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2018: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEL +OP_0x2098: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x20D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2118: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2158: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2198: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x21D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x23D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2ED8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2F18: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2020: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// MOVEL +OP_0x20A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x20E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2120: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2160: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x21A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x21E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x23E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x2EE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2F20: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2028: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// MOVEL +OP_0x20A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x20E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2128: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2168: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x21A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x21E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x23E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x2EE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2F28: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2030: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// MOVEL +OP_0x20B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x20F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x2130: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x2170: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x21B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x21F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x23F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// MOVEL +OP_0x2EF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x2F30: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x2038: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// MOVEL +OP_0x20B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x20F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2138: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2178: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x21B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x21F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x23F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x2EF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2F38: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2039: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// MOVEL +OP_0x20B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x20F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2139: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2179: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x21B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// MOVEL +OP_0x21F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x23F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(36) + +// MOVEL +OP_0x2EF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2F39: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x203A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// MOVEL +OP_0x20BA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x20FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x213A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x217A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x21BA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x21FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x23FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x2EFA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x2F3A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x203B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// MOVEL +OP_0x20BB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x20FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x213B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x217B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x21BB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(32) + +// MOVEL +OP_0x21FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x23FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(34) + +// MOVEL +OP_0x2EFB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x2F3B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x203C: +{ + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(12) + +// MOVEL +OP_0x20BC: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x20FC: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x213C: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x217C: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x21BC: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x21FC: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x23FC: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2EFC: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2F3C: +{ + u32 adr; + u32 res; + res = FETCH_LONG; + PC += 4; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x201F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEL +OP_0x209F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x20DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x211F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x215F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x219F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x21DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// MOVEL +OP_0x23DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x2EDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2F1F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// MOVEL +OP_0x2027: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// MOVEL +OP_0x20A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x20E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2127: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2167: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x21A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// MOVEL +OP_0x21E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// MOVEL +OP_0x23E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// MOVEL +OP_0x2EE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7]; + CPU->A[7] += 4; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEL +OP_0x2F27: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVEAL +OP_0x2040: +{ + u32 res; + res = (s32)(s32)CPU->D[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(4) + +// MOVEAL +OP_0x2048: +{ + u32 res; + res = (s32)(s32)CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(4) + +// MOVEAL +OP_0x2050: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// MOVEAL +OP_0x2058: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// MOVEAL +OP_0x2060: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// MOVEAL +OP_0x2068: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// MOVEAL +OP_0x2070: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// MOVEAL +OP_0x2078: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// MOVEAL +OP_0x2079: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// MOVEAL +OP_0x207A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// MOVEAL +OP_0x207B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// MOVEAL +OP_0x207C: +{ + u32 res; + res = (s32)(s32)FETCH_LONG; + PC += 4; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(12) + +// MOVEAL +OP_0x205F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// MOVEAL +OP_0x2067: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READSX_LONG_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) diff --git a/m68000/c68k/c68k_op3.inc b/m68000/c68k/c68k_op3.inc new file mode 100644 index 0000000..cab96e6 --- /dev/null +++ b/m68000/c68k/c68k_op3.inc @@ -0,0 +1,2870 @@ + +// MOVEW +OP_0x3000: +{ + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// MOVEW +OP_0x3080: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x30C0: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3100: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3140: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3180: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x31C0: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x33C0: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3EC0: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3F00: +{ + u32 adr; + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3008: +{ + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// MOVEW +OP_0x3088: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x30C8: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3108: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3148: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3188: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x31C8: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x33C8: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3EC8: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3F08: +{ + u32 adr; + u32 res; + res = (u16)CPU->A[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(8) + +// MOVEW +OP_0x3010: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// MOVEW +OP_0x3090: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x30D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3110: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3150: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3190: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x31D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x33D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3ED0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3F10: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3018: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// MOVEW +OP_0x3098: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x30D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3118: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3158: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3198: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x31D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x33D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3ED8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3F18: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3020: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// MOVEW +OP_0x30A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x30E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3120: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3160: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x31A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x31E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x33E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x3EE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3F20: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3028: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEW +OP_0x30A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x30E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3128: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3168: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x31A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x31E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x33E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x3EE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3F28: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3030: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// MOVEW +OP_0x30B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x30F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x3130: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x3170: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x31B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x31F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x33F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(26) + +// MOVEW +OP_0x3EF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x3F30: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x3038: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEW +OP_0x30B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x30F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3138: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3178: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x31B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x31F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x33F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x3EF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3F38: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3039: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// MOVEW +OP_0x30B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x30F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3139: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3179: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x31B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(26) + +// MOVEW +OP_0x31F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x33F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(28) + +// MOVEW +OP_0x3EF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3F39: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x303A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// MOVEW +OP_0x30BA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x30FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x313A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x317A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x31BA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x31FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x33FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x3EFA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x3F3A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x303B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// MOVEW +OP_0x30BB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x30FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x313B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x317B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x31BB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(24) + +// MOVEW +OP_0x31FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x33FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(26) + +// MOVEW +OP_0x3EFB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x3F3B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x303C: +{ + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// MOVEW +OP_0x30BC: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x30FC: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x313C: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x317C: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x31BC: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x31FC: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x33FC: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3EFC: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3F3C: +{ + u32 adr; + u32 res; + res = FETCH_WORD; + PC += 2; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x301F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// MOVEW +OP_0x309F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x30DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x311F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x315F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x319F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x31DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVEW +OP_0x33DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x3EDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3F1F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVEW +OP_0x3027: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// MOVEW +OP_0x30A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x30E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3127: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3167: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x31A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[(Opcode >> 9) & 7]; + DECODE_EXT_WORD + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVEW +OP_0x31E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVEW +OP_0x33E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = (s32)FETCH_LONG; + PC += 4; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(22) + +// MOVEW +OP_0x3EE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7]; + CPU->A[7] += 2; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEW +OP_0x3F27: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEAW +OP_0x3040: +{ + u32 res; + res = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(4) + +// MOVEAW +OP_0x3048: +{ + u32 res; + res = (s32)(s16)CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(4) + +// MOVEAW +OP_0x3050: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(8) + +// MOVEAW +OP_0x3058: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(8) + +// MOVEAW +OP_0x3060: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(10) + +// MOVEAW +OP_0x3068: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// MOVEAW +OP_0x3070: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// MOVEAW +OP_0x3078: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// MOVEAW +OP_0x3079: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// MOVEAW +OP_0x307A: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// MOVEAW +OP_0x307B: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// MOVEAW +OP_0x307C: +{ + u32 res; + res = (s32)(s16)FETCH_WORD; + PC += 2; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// MOVEAW +OP_0x305F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(8) + +// MOVEAW +OP_0x3067: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READSX_WORD_F(adr, res) + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(10) diff --git a/m68000/c68k/c68k_op4.inc b/m68000/c68k/c68k_op4.inc new file mode 100644 index 0000000..99bdf67 --- /dev/null +++ b/m68000/c68k/c68k_op4.inc @@ -0,0 +1,5847 @@ + +// NEGX +OP_0x4000: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// NEGX +OP_0x4010: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NEGX +OP_0x4018: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NEGX +OP_0x4020: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// NEGX +OP_0x4028: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// NEGX +OP_0x4030: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// NEGX +OP_0x4038: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// NEGX +OP_0x4039: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// NEGX +OP_0x401F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NEGX +OP_0x4027: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// NEGX +OP_0x4040: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// NEGX +OP_0x4050: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NEGX +OP_0x4058: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NEGX +OP_0x4060: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// NEGX +OP_0x4068: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// NEGX +OP_0x4070: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// NEGX +OP_0x4078: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// NEGX +OP_0x4079: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// NEGX +OP_0x405F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NEGX +OP_0x4067: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// NEGX +OP_0x4080: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// NEGX +OP_0x4090: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NEGX +OP_0x4098: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NEGX +OP_0x40A0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// NEGX +OP_0x40A8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// NEGX +OP_0x40B0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// NEGX +OP_0x40B8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// NEGX +OP_0x40B9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// NEGX +OP_0x409F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NEGX +OP_0x40A7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = -src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// CLR +OP_0x4200: +{ + u32 res; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// CLR +OP_0x4210: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// CLR +OP_0x4218: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// CLR +OP_0x4220: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// CLR +OP_0x4228: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// CLR +OP_0x4230: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// CLR +OP_0x4238: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// CLR +OP_0x4239: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// CLR +OP_0x421F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// CLR +OP_0x4227: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// CLR +OP_0x4240: +{ + u32 res; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// CLR +OP_0x4250: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// CLR +OP_0x4258: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// CLR +OP_0x4260: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// CLR +OP_0x4268: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// CLR +OP_0x4270: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// CLR +OP_0x4278: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// CLR +OP_0x4279: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// CLR +OP_0x425F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// CLR +OP_0x4267: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// CLR +OP_0x4280: +{ + u32 res; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// CLR +OP_0x4290: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// CLR +OP_0x4298: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// CLR +OP_0x42A0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// CLR +OP_0x42A8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// CLR +OP_0x42B0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// CLR +OP_0x42B8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// CLR +OP_0x42B9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// CLR +OP_0x429F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// CLR +OP_0x42A7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + res = 0; + CPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0; + PRE_IO + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// NEG +OP_0x4400: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// NEG +OP_0x4410: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NEG +OP_0x4418: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NEG +OP_0x4420: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// NEG +OP_0x4428: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// NEG +OP_0x4430: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// NEG +OP_0x4438: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// NEG +OP_0x4439: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// NEG +OP_0x441F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NEG +OP_0x4427: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = -src; + CPU->flag_V = res & src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// NEG +OP_0x4440: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// NEG +OP_0x4450: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NEG +OP_0x4458: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NEG +OP_0x4460: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// NEG +OP_0x4468: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// NEG +OP_0x4470: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// NEG +OP_0x4478: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// NEG +OP_0x4479: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// NEG +OP_0x445F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NEG +OP_0x4467: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = -src; + CPU->flag_V = (res & src) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// NEG +OP_0x4480: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// NEG +OP_0x4490: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NEG +OP_0x4498: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NEG +OP_0x44A0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// NEG +OP_0x44A8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// NEG +OP_0x44B0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// NEG +OP_0x44B8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// NEG +OP_0x44B9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// NEG +OP_0x449F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NEG +OP_0x44A7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = -src; + CPU->flag_notZ = res; + CPU->flag_V = (res & src) >> 24; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// NOT +OP_0x4600: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// NOT +OP_0x4610: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NOT +OP_0x4618: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NOT +OP_0x4620: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// NOT +OP_0x4628: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// NOT +OP_0x4630: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// NOT +OP_0x4638: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// NOT +OP_0x4639: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// NOT +OP_0x461F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// NOT +OP_0x4627: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_N = res; + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// NOT +OP_0x4640: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// NOT +OP_0x4650: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NOT +OP_0x4658: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NOT +OP_0x4660: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// NOT +OP_0x4668: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// NOT +OP_0x4670: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// NOT +OP_0x4678: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// NOT +OP_0x4679: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// NOT +OP_0x465F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// NOT +OP_0x4667: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res & 0xFFFF; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// NOT +OP_0x4680: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// NOT +OP_0x4690: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NOT +OP_0x4698: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NOT +OP_0x46A0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// NOT +OP_0x46A8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// NOT +OP_0x46B0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// NOT +OP_0x46B8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// NOT +OP_0x46B9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// NOT +OP_0x469F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// NOT +OP_0x46A7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = ~src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// MOVESRa +OP_0x40C0: +{ + u32 res; + res = GET_SR; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// MOVESRa +OP_0x40D0: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVESRa +OP_0x40D8: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVESRa +OP_0x40E0: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVESRa +OP_0x40E8: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVESRa +OP_0x40F0: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// MOVESRa +OP_0x40F8: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// MOVESRa +OP_0x40F9: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// MOVESRa +OP_0x40DF: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// MOVESRa +OP_0x40E7: +{ + u32 adr; + u32 res; + res = GET_SR; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// MOVEaCCR +OP_0x44C0: +{ + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + SET_CCR(res) +} +RET(12) + +// MOVEaCCR +OP_0x44D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(16) + +// MOVEaCCR +OP_0x44D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(16) + +// MOVEaCCR +OP_0x44E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(18) + +// MOVEaCCR +OP_0x44E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(20) + +// MOVEaCCR +OP_0x44F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(22) + +// MOVEaCCR +OP_0x44F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(20) + +// MOVEaCCR +OP_0x44F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(24) + +// MOVEaCCR +OP_0x44FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(20) + +// MOVEaCCR +OP_0x44FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(22) + +// MOVEaCCR +OP_0x44FC: +{ + u32 res; + res = FETCH_WORD; + PC += 2; + SET_CCR(res) +} +RET(16) + +// MOVEaCCR +OP_0x44DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(16) + +// MOVEaCCR +OP_0x44E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + SET_CCR(res) + POST_IO +} +RET(18) + +// MOVEaSR +OP_0x46C0: +{ + u32 res; + if (CPU->flag_S) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 12; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46D0: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 16; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46D8: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 16; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46E0: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 18; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46E8: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46F0: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 22; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46F8: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46F9: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 24; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46FA: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46FB: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 22; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46FC: +{ + u32 res; + if (CPU->flag_S) + { + res = FETCH_WORD; + PC += 2; + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 16; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46DF: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 16; +goto C68k_Exec_End; + +// MOVEaSR +OP_0x46E7: +{ + u32 adr; + u32 res; + if (CPU->flag_S) + { + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + } + else + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } +} +POST_IO +CCnt -= 18; +goto C68k_Exec_End; + +// NBCD +OP_0x4800: +{ + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; +} +RET(6) + +// NBCD +OP_0x4810: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(12) + +// NBCD +OP_0x4818: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(12) + +// NBCD +OP_0x4820: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(14) + +// NBCD +OP_0x4828: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(16) + +// NBCD +OP_0x4830: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(18) + +// NBCD +OP_0x4838: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(16) + +// NBCD +OP_0x4839: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(20) + +// NBCD +OP_0x481F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(12) + +// NBCD +OP_0x4827: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + + if (res != 0x9a) + { + if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10; + res &= 0xFF; + WRITE_BYTE_F(adr, res) + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = res; + POST_IO +} +RET(14) + +// PEA +OP_0x4850: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(12) + +// PEA +OP_0x4868: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(16) + +// PEA +OP_0x4870: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(20) + +// PEA +OP_0x4878: +{ + u32 adr; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(16) + +// PEA +OP_0x4879: +{ + u32 adr; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(20) + +// PEA +OP_0x487A: +{ + u32 adr; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(16) + +// PEA +OP_0x487B: +{ + u32 adr; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + PUSH_32_F(adr) + POST_IO +} +RET(20) + +// SWAP +OP_0x4840: +{ + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + res = (res >> 16) | (res << 16); + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// MOVEMRa +OP_0x4890: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_WORD_F(adr, *(u16*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(12) + +// MOVEMRa +OP_0x48A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->A[7]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + adr -= 2; + WRITE_WORD_F(adr, *(u16*)src) + } + src -= 4; + } while (res >>= 1); + CPU->A[(Opcode >> 0) & 7] = adr; + POST_IO + CCnt -= (dst - adr) * 2; +} +RET(8) + +// MOVEMRa +OP_0x48A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_WORD_F(adr, *(u16*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(20) + +// MOVEMRa +OP_0x48B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_WORD_F(adr, *(u16*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(24) + +// MOVEMRa +OP_0x48B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_WORD_F(adr, *(u16*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(20) + +// MOVEMRa +OP_0x48B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_WORD_F(adr, *(u16*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMRa +OP_0x48A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + src = (pointer)(&CPU->A[7]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + adr -= 2; + WRITE_WORD_F(adr, *(u16*)src) + } + src -= 4; + } while (res >>= 1); + CPU->A[7] = adr; + POST_IO + CCnt -= (dst - adr) * 2; +} +RET(8) + +// MOVEMRa +OP_0x48D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(16) + +// MOVEMRa +OP_0x48E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->A[7]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + adr -= 4; + WRITE_LONG_DEC_F(adr, *(u32*)src) + } + src -= 4; + } while (res >>= 1); + CPU->A[(Opcode >> 0) & 7] = adr; + POST_IO + CCnt -= (dst - adr) * 2; +} +RET(8) + +// MOVEMRa +OP_0x48E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(24) + +// MOVEMRa +OP_0x48F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMRa +OP_0x48F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(24) + +// MOVEMRa +OP_0x48F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + WRITE_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(32) + +// MOVEMRa +OP_0x48E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + src = (pointer)(&CPU->A[7]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + adr -= 4; + WRITE_LONG_DEC_F(adr, *(u32*)src) + } + src -= 4; + } while (res >>= 1); + CPU->A[7] = adr; + POST_IO + CCnt -= (dst - adr) * 2; +} +RET(8) + +// EXT +OP_0x4880: +{ + u32 res; + res = (s32)(s8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// EXT +OP_0x48C0: +{ + u32 res; + res = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// TST +OP_0x4A00: +{ + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; +} +RET(4) + +// TST +OP_0x4A10: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(8) + +// TST +OP_0x4A18: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(8) + +// TST +OP_0x4A20: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(10) + +// TST +OP_0x4A28: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(12) + +// TST +OP_0x4A30: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(14) + +// TST +OP_0x4A38: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(12) + +// TST +OP_0x4A39: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(16) + +// TST +OP_0x4A1F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(8) + +// TST +OP_0x4A27: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + POST_IO +} +RET(10) + +// TST +OP_0x4A40: +{ + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; +} +RET(4) + +// TST +OP_0x4A50: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(8) + +// TST +OP_0x4A58: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(8) + +// TST +OP_0x4A60: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(10) + +// TST +OP_0x4A68: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(12) + +// TST +OP_0x4A70: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(14) + +// TST +OP_0x4A78: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(12) + +// TST +OP_0x4A79: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(16) + +// TST +OP_0x4A5F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(8) + +// TST +OP_0x4A67: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + POST_IO +} +RET(10) + +// TST +OP_0x4A80: +{ + u32 res; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; +} +RET(4) + +// TST +OP_0x4A90: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(12) + +// TST +OP_0x4A98: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(12) + +// TST +OP_0x4AA0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// TST +OP_0x4AA8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// TST +OP_0x4AB0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// TST +OP_0x4AB8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// TST +OP_0x4AB9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// TST +OP_0x4A9F: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(12) + +// TST +OP_0x4AA7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// TAS +OP_0x4AC0: +{ + u32 res; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// TAS +OP_0x4AD0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// TAS +OP_0x4AD8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// TAS +OP_0x4AE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(10) + +// TAS +OP_0x4AE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// TAS +OP_0x4AF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// TAS +OP_0x4AF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// TAS +OP_0x4AF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// TAS +OP_0x4ADF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(8) + +// TAS +OP_0x4AE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + res |= 0x80; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(10) + +// ILLEGAL +OP_0x4AFC: +{ + u32 res; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ILLEGAL_INSTRUCTION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO +} +RET(4) + +// MOVEMaR +OP_0x4C90: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(16) + +// MOVEMaR +OP_0x4C98: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + CPU->A[(Opcode >> 0) & 7] = adr; + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(12) + +// MOVEMaR +OP_0x4CA8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(24) + +// MOVEMaR +OP_0x4CB0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMaR +OP_0x4CB8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(24) + +// MOVEMaR +OP_0x4CB9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(32) + +// MOVEMaR +OP_0x4CBA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(24) + +// MOVEMaR +OP_0x4CBB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMaR +OP_0x4C9F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READSX_WORD_F(adr, *(s32*)src) + adr += 2; + } + src += 4; + } while (res >>= 1); + CPU->A[7] = adr; + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(12) + +// MOVEMaR +OP_0x4CD0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(20) + +// MOVEMaR +OP_0x4CD8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + CPU->A[(Opcode >> 0) & 7] = adr; + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(12) + +// MOVEMaR +OP_0x4CE8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMaR +OP_0x4CF0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(32) + +// MOVEMaR +OP_0x4CF8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMaR +OP_0x4CF9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (s32)FETCH_LONG; + PC += 4; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(36) + +// MOVEMaR +OP_0x4CFA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(28) + +// MOVEMaR +OP_0x4CFB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(32) + +// MOVEMaR +OP_0x4CDF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + res = FETCH_WORD; + PC += 2; + adr = CPU->A[7]; + src = (pointer)(&CPU->D[0]); + dst = adr; + PRE_IO + do + { + if (res & 1) + { + READ_LONG_F(adr, *(u32*)src) + adr += 4; + } + src += 4; + } while (res >>= 1); + CPU->A[7] = adr; + POST_IO + CCnt -= (adr - dst) * 2; +} +RET(12) + +// TRAP +OP_0x4E40: +{ + u32 res; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_TRAP_BASE_EX + (Opcode & 0xF); + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO +} +RET(4) + +// LINK +OP_0x4E50: +{ + u32 res; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + PRE_IO + PUSH_32_F(res) + res = CPU->A[7]; + CPU->A[(Opcode >> 0) & 7] = res; + CPU->A[7] += (s32)(s16)FETCH_WORD; + PC += 2; + POST_IO +} +RET(16) + +// LINKA7 +OP_0x4E57: +{ + CPU->A[7] -= 4; + PRE_IO + WRITE_LONG_DEC_F(CPU->A[7], CPU->A[7]) + CPU->A[7] += (s32)(s16)FETCH_WORD; + PC += 2; + POST_IO +} +RET(16) + +// ULNK +OP_0x4E58: +{ + u32 res; + pointer src; + src = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->A[7] = src + 4; + PRE_IO + READ_LONG_F(src, res) + CPU->A[(Opcode >> 0) & 7] = res; + POST_IO +} +RET(12) + +// ULNKA7 +OP_0x4E5F: +{ + PRE_IO + READ_LONG_F(CPU->A[7], CPU->A[7]) + POST_IO +} +RET(12) + +// MOVEAUSP +OP_0x4E60: +{ + u32 res; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(4) + } + res = (u32)CPU->A[(Opcode >> 0) & 7]; + CPU->USP = res; +} +RET(4) + +// MOVEUSPA +OP_0x4E68: +{ + u32 res; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(4) + } + res = CPU->USP; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(4) + +// RESET +OP_0x4E70: +{ + u32 res; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(4) + } + PRE_IO + CPU->Reset_CallBack(); + POST_IO +} +RET(132) + +// NOP +OP_0x4E71: +{ +} +RET(4) + +// STOP +OP_0x4E72: +{ + u32 res; + if (!CPU->flag_S) + { + PC += 2; + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(4) + } + res = FETCH_WORD & C68K_SR_MASK; + PC += 2; + SET_SR(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } + CPU->Status |= C68K_HALTED; + CCnt = 0; +} +CCnt -= 4; +goto C68k_Exec_End; + +// RTE +OP_0x4E73: +{ + u32 res; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + res = C68K_PRIVILEGE_VIOLATION_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(4) + } + PRE_IO + POP_16_F(res) + SET_SR(res) + POP_32_F(res) + SET_PC(res) + if (!CPU->flag_S) + { + res = CPU->A[7]; + CPU->A[7] = CPU->USP; + CPU->USP = res; + } +} +POST_IO +CCnt -= 20; +goto C68k_Exec_End; + +// RTS +OP_0x4E75: +{ + u32 res; + PRE_IO + POP_32_F(res) + SET_PC(res) + POST_IO +} +RET(16) + +// TRAPV +OP_0x4E76: +{ + u32 res; + if (CPU->flag_V & 0x80) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_TRAPV_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(4) + +// RTR +OP_0x4E77: +{ + u32 res; + PRE_IO + POP_16_F(res) + SET_CCR(res) + POP_32_F(res) + SET_PC(res) + POST_IO +} +RET(20) + +// JSR +OP_0x4E90: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(16) + +// JSR +OP_0x4EA8: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(18) + +// JSR +OP_0x4EB0: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(22) + +// JSR +OP_0x4EB8: +{ + u32 adr; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(18) + +// JSR +OP_0x4EB9: +{ + u32 adr; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(20) + +// JSR +OP_0x4EBA: +{ + u32 adr; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(18) + +// JSR +OP_0x4EBB: +{ + u32 adr; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + SET_PC(adr) + POST_IO +} +RET(22) + +// JMP +OP_0x4ED0: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7]; + SET_PC(adr) +} +RET(8) + +// JMP +OP_0x4EE8: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + SET_PC(adr) +} +RET(10) + +// JMP +OP_0x4EF0: +{ + u32 adr; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + SET_PC(adr) +} +RET(14) + +// JMP +OP_0x4EF8: +{ + u32 adr; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + SET_PC(adr) +} +RET(10) + +// JMP +OP_0x4EF9: +{ + u32 adr; + adr = (s32)FETCH_LONG; + PC += 4; + SET_PC(adr) +} +RET(12) + +// JMP +OP_0x4EFA: +{ + u32 adr; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + SET_PC(adr) +} +RET(10) + +// JMP +OP_0x4EFB: +{ + u32 adr; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + SET_PC(adr) +} +RET(14) + +// CHK +OP_0x4180: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(10) + +// CHK +OP_0x4190: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(14) + +// CHK +OP_0x4198: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(14) + +// CHK +OP_0x41A0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(16) + +// CHK +OP_0x41A8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(18) + +// CHK +OP_0x41B0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(20) + +// CHK +OP_0x41B8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(18) + +// CHK +OP_0x41B9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(22) + +// CHK +OP_0x41BA: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(18) + +// CHK +OP_0x41BB: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(20) + +// CHK +OP_0x41BC: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(14) + +// CHK +OP_0x419F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(14) + +// CHK +OP_0x41A7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + if (((s32)res < 0) || (res > src)) + { + CPU->flag_N = res >> 8; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_CHK_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + } + POST_IO +} +RET(16) + +// LEA +OP_0x41D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(4) + +// LEA +OP_0x41E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// LEA +OP_0x41F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(12) + +// LEA +OP_0x41F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// LEA +OP_0x41F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(12) + +// LEA +OP_0x41FA: +{ + u32 adr; + u32 res; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// LEA +OP_0x41FB: +{ + u32 adr; + u32 res; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + res = adr; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(12) diff --git a/m68000/c68k/c68k_op5.inc b/m68000/c68k/c68k_op5.inc new file mode 100644 index 0000000..6b57248 --- /dev/null +++ b/m68000/c68k/c68k_op5.inc @@ -0,0 +1,4921 @@ + +// STCC +OP_0x50C0: +{ + u32 res; + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) +} + +// STCC +OP_0x51C0: +{ + u32 res; + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x52C0: +{ + u32 res; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x53C0: +{ + u32 res; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x54C0: +{ + u32 res; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x55C0: +{ + u32 res; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x56C0: +{ + u32 res; + if (CPU->flag_notZ) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x57C0: +{ + u32 res; + if (!CPU->flag_notZ) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x58C0: +{ + u32 res; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x59C0: +{ + u32 res; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x5AC0: +{ + u32 res; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x5BC0: +{ + u32 res; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x5CC0: +{ + u32 res; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x5DC0: +{ + u32 res; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x5EC0: +{ + u32 res; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x5FC0: +{ + u32 res; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(4) +} + +// STCC +OP_0x50D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x51D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x52D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x53D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x54D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x55D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x56D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x57D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x58D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x59D0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5AD0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5BD0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5CD0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5DD0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5ED0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5FD0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x50D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x51D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x52D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x53D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x54D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x55D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x56D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x57D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x58D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x59D8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5AD8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5BD8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5CD8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5DD8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5ED8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5FD8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x50E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x51E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x52E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x53E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x54E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x55E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x56E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x57E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x58E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x59E0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5AE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5BE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5CE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5DE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5EE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5FE0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x50E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x51E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x52E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x53E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x54E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x55E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x56E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x57E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x58E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x59E8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5AE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5BE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5CE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5DE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5EE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5FE8: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x50F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x51F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x52F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x53F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x54F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x55F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x56F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x57F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x58F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x59F0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x5AF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x5BF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x5CF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x5DF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x5EF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x5FF0: +{ + u32 adr; + u32 res; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(18) +} + +// STCC +OP_0x50F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x51F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x52F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x53F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x54F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x55F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x56F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x57F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x58F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x59F8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5AF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5BF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5CF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5DF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5EF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x5FF8: +{ + u32 adr; + u32 res; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(16) +} + +// STCC +OP_0x50F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x51F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x52F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x53F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x54F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x55F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x56F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x57F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x58F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x59F9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x5AF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x5BF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x5CF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x5DF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x5EF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x5FF9: +{ + u32 adr; + u32 res; + adr = (s32)FETCH_LONG; + PC += 4; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(20) +} + +// STCC +OP_0x50DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x51DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x52DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x53DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x54DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x55DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x56DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x57DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x58DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x59DF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5ADF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5BDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5CDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5DDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5EDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x5FDF: +{ + u32 adr; + u32 res; + adr = CPU->A[7]; + CPU->A[7] += 2; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(12) +} + +// STCC +OP_0x50E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x51E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x52E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x53E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x54E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (!(CPU->flag_C & 0x100)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x55E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (CPU->flag_C & 0x100) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x56E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x57E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (!CPU->flag_notZ) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x58E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (!(CPU->flag_V & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x59E7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (CPU->flag_V & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5AE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (!(CPU->flag_N & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5BE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (CPU->flag_N & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5CE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5DE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5EE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// STCC +OP_0x5FE7: +{ + u32 adr; + u32 res; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = 0xFF; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) + } + res = 0; + PRE_IO + WRITE_BYTE_F(adr, res) + POST_IO + RET(14) +} + +// DBCC +OP_0x50C8: +{ + PC += 2; +} +RET(12) + +// DBCC +OP_0x51C8: +{ + u32 res; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x52C8: +{ + u32 res; + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x53C8: +{ + u32 res; + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x54C8: +{ + u32 res; + if (CPU->flag_C & 0x100) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x55C8: +{ + u32 res; + if (!(CPU->flag_C & 0x100)) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x56C8: +{ + u32 res; + if (!CPU->flag_notZ) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x57C8: +{ + u32 res; + if (CPU->flag_notZ) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x58C8: +{ + u32 res; + if (CPU->flag_V & 0x80) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x59C8: +{ + u32 res; + if (!(CPU->flag_V & 0x80)) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x5AC8: +{ + u32 res; + if (CPU->flag_N & 0x80) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x5BC8: +{ + u32 res; + if (!(CPU->flag_N & 0x80)) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x5CC8: +{ + u32 res; + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x5DC8: +{ + u32 res; + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x5EC8: +{ + u32 res; + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// DBCC +OP_0x5FC8: +{ + u32 res; + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res--; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + if ((s32)res != -1) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + } + else + { + PC += 2; + RET(12) + } + PC += 2; +} +RET(14) + +// ADDQ +OP_0x5000: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u8)CPU->D[(Opcode >> 0) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// ADDQ +OP_0x5010: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ADDQ +OP_0x5018: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ADDQ +OP_0x5020: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ADDQ +OP_0x5028: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDQ +OP_0x5030: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDQ +OP_0x5038: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDQ +OP_0x5039: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ADDQ +OP_0x501F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ADDQ +OP_0x5027: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ADDQ +OP_0x5040: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u16)CPU->D[(Opcode >> 0) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// ADDQ +OP_0x5048: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u32)CPU->A[(Opcode >> 0) & 7]; + res = dst + src; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(8) + +// ADDQ +OP_0x5050: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ADDQ +OP_0x5058: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ADDQ +OP_0x5060: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ADDQ +OP_0x5068: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDQ +OP_0x5070: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDQ +OP_0x5078: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDQ +OP_0x5079: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ADDQ +OP_0x505F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ADDQ +OP_0x5067: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ADDQ +OP_0x5080: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u32)CPU->D[(Opcode >> 0) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ADDQ +OP_0x5088: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u32)CPU->A[(Opcode >> 0) & 7]; + res = dst + src; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(8) + +// ADDQ +OP_0x5090: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ADDQ +OP_0x5098: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ADDQ +OP_0x50A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// ADDQ +OP_0x50A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ADDQ +OP_0x50B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// ADDQ +OP_0x50B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ADDQ +OP_0x50B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ADDQ +OP_0x509F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ADDQ +OP_0x50A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// SUBQ +OP_0x5100: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u8)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// SUBQ +OP_0x5110: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// SUBQ +OP_0x5118: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// SUBQ +OP_0x5120: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// SUBQ +OP_0x5128: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBQ +OP_0x5130: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBQ +OP_0x5138: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBQ +OP_0x5139: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// SUBQ +OP_0x511F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// SUBQ +OP_0x5127: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// SUBQ +OP_0x5140: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u16)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// SUBQ +OP_0x5148: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u32)CPU->A[(Opcode >> 0) & 7]; + res = dst - src; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(8) + +// SUBQ +OP_0x5150: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// SUBQ +OP_0x5158: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// SUBQ +OP_0x5160: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// SUBQ +OP_0x5168: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBQ +OP_0x5170: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBQ +OP_0x5178: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBQ +OP_0x5179: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// SUBQ +OP_0x515F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// SUBQ +OP_0x5167: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// SUBQ +OP_0x5180: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u32)CPU->D[(Opcode >> 0) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// SUBQ +OP_0x5188: +{ + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + dst = (u32)CPU->A[(Opcode >> 0) & 7]; + res = dst - src; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(8) + +// SUBQ +OP_0x5190: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// SUBQ +OP_0x5198: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// SUBQ +OP_0x51A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// SUBQ +OP_0x51A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// SUBQ +OP_0x51B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// SUBQ +OP_0x51B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// SUBQ +OP_0x51B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// SUBQ +OP_0x519F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// SUBQ +OP_0x51A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (((Opcode >> 9) - 1) & 7) + 1; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) diff --git a/m68000/c68k/c68k_op6.inc b/m68000/c68k/c68k_op6.inc new file mode 100644 index 0000000..126fe7f --- /dev/null +++ b/m68000/c68k/c68k_op6.inc @@ -0,0 +1,390 @@ + +// BCC +OP_0x6201: +{ + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6301: +{ + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6401: +{ + if (!(CPU->flag_C & 0x100)) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6501: +{ + if (CPU->flag_C & 0x100) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6601: +{ + if (CPU->flag_notZ) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6701: +{ + if (!CPU->flag_notZ) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6801: +{ + if (!(CPU->flag_V & 0x80)) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6901: +{ + if (CPU->flag_V & 0x80) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6A01: +{ + if (!(CPU->flag_N & 0x80)) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6B01: +{ + if (CPU->flag_N & 0x80) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6C01: +{ + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6D01: +{ + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6E01: +{ + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC +OP_0x6F01: +{ + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + PC += (s32)(s8)Opcode; + CCnt -= 2; + } +} +RET(8) + +// BCC16 +OP_0x6200: +{ + if (CPU->flag_notZ && (!(CPU->flag_C & 0x100))) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6300: +{ + if ((!CPU->flag_notZ) || (CPU->flag_C & 0x100)) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6400: +{ + if (!(CPU->flag_C & 0x100)) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6500: +{ + if (CPU->flag_C & 0x100) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6600: +{ + if (CPU->flag_notZ) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6700: +{ + if (!CPU->flag_notZ) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6800: +{ + if (!(CPU->flag_V & 0x80)) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6900: +{ + if (CPU->flag_V & 0x80) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6A00: +{ + if (!(CPU->flag_N & 0x80)) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6B00: +{ + if (CPU->flag_N & 0x80) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6C00: +{ + if (!((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6D00: +{ + if ((CPU->flag_N ^ CPU->flag_V) & 0x80) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6E00: +{ + if (CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80))) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BCC16 +OP_0x6F00: +{ + if ((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80)) + { + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); + RET(10) + } + PC += 2; +} +RET(12) + +// BRA +OP_0x6001: +{ + PC += (s32)(s8)Opcode; +} +RET(10) + +// BRA16 +OP_0x6000: +{ + PC += (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + SET_PC(PC); +} +RET(10) + +// BSR +OP_0x6101: +{ + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PC += (s32)(s8)Opcode; + POST_IO +} +RET(18) + +// BSR16 +OP_0x6100: +{ + u32 res; + res = (s32)(s16)FETCH_WORD; + PC -= CPU->BasePC; + PRE_IO + PUSH_32_F(PC + 2) + PC += (s32) res; + SET_PC(PC); + POST_IO +} +RET(18) diff --git a/m68000/c68k/c68k_op7.inc b/m68000/c68k/c68k_op7.inc new file mode 100644 index 0000000..e4a45da --- /dev/null +++ b/m68000/c68k/c68k_op7.inc @@ -0,0 +1,11 @@ + +// MOVEQ +OP_0x7000: +{ + u32 res; + res = (s32)(s8)Opcode; + CPU->flag_C = CPU->flag_V = 0; + CPU->flag_N = CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) diff --git a/m68000/c68k/c68k_op8.inc b/m68000/c68k/c68k_op8.inc new file mode 100644 index 0000000..bd57030 --- /dev/null +++ b/m68000/c68k/c68k_op8.inc @@ -0,0 +1,2958 @@ + +// ORaD +OP_0x8000: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ORaD +OP_0x8010: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ORaD +OP_0x8018: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ORaD +OP_0x8020: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ORaD +OP_0x8028: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ORaD +OP_0x8030: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ORaD +OP_0x8038: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ORaD +OP_0x8039: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ORaD +OP_0x803A: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ORaD +OP_0x803B: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ORaD +OP_0x803C: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ORaD +OP_0x801F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ORaD +OP_0x8027: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ORaD +OP_0x8040: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ORaD +OP_0x8050: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ORaD +OP_0x8058: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ORaD +OP_0x8060: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ORaD +OP_0x8068: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ORaD +OP_0x8070: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ORaD +OP_0x8078: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ORaD +OP_0x8079: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ORaD +OP_0x807A: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ORaD +OP_0x807B: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ORaD +OP_0x807C: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ORaD +OP_0x805F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ORaD +OP_0x8067: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ORaD +OP_0x8080: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// ORaD +OP_0x8090: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ORaD +OP_0x8098: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ORaD +OP_0x80A0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// ORaD +OP_0x80A8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ORaD +OP_0x80B0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// ORaD +OP_0x80B8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ORaD +OP_0x80B9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(24) + +// ORaD +OP_0x80BA: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ORaD +OP_0x80BB: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// ORaD +OP_0x80BC: +{ + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(14) + +// ORaD +OP_0x809F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ORaD +OP_0x80A7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// ORDa +OP_0x8110: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ORDa +OP_0x8118: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ORDa +OP_0x8120: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ORDa +OP_0x8128: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ORDa +OP_0x8130: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ORDa +OP_0x8138: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ORDa +OP_0x8139: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ORDa +OP_0x811F: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ORDa +OP_0x8127: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ORDa +OP_0x8150: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ORDa +OP_0x8158: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ORDa +OP_0x8160: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ORDa +OP_0x8168: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ORDa +OP_0x8170: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ORDa +OP_0x8178: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ORDa +OP_0x8179: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ORDa +OP_0x815F: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ORDa +OP_0x8167: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ORDa +OP_0x8190: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ORDa +OP_0x8198: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ORDa +OP_0x81A0: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// ORDa +OP_0x81A8: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ORDa +OP_0x81B0: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// ORDa +OP_0x81B8: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ORDa +OP_0x81B9: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ORDa +OP_0x819F: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ORDa +OP_0x81A7: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res |= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// SBCD +OP_0x8100: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = (dst & 0xF) - (src & 0xF) - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res -= 6; + res += (dst & 0xF0) - (src & 0xF0); + if (res > 0x99) + { + res += 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// SBCDM +OP_0x8108: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) - (src & 0xF) - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res -= 6; + res += (dst & 0xF0) - (src & 0xF0); + if (res > 0x99) + { + res += 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SBCD7M +OP_0x810F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) - (src & 0xF) - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res -= 6; + res += (dst & 0xF0) - (src & 0xF0); + if (res > 0x99) + { + res += 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SBCDM7 +OP_0x8F08: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) - (src & 0xF) - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res -= 6; + res += (dst & 0xF0) - (src & 0xF0); + if (res > 0x99) + { + res += 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SBCD7M7 +OP_0x8F0F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) - (src & 0xF) - ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res -= 6; + res += (dst & 0xF0) - (src & 0xF0); + if (res > 0x99) + { + res += 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// DIVU +OP_0x80C0: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(10) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(70) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(90) + +// DIVU +OP_0x80D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(74) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(94) + +// DIVU +OP_0x80D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(74) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(94) + +// DIVU +OP_0x80E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(16) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(76) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(96) + +// DIVU +OP_0x80E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(18) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(78) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(98) + +// DIVU +OP_0x80F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(20) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(80) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(100) + +// DIVU +OP_0x80F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(18) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(78) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(98) + +// DIVU +OP_0x80F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(22) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(82) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(102) + +// DIVU +OP_0x80FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(18) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(78) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(98) + +// DIVU +OP_0x80FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(20) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(80) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(100) + +// DIVU +OP_0x80FC: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(74) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(94) + +// DIVU +OP_0x80DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(74) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(94) + +// DIVU +OP_0x80E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(16) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + { + u32 q, r; + + q = dst / src; + r = dst % src; + + if (q & 0xFFFF0000) + { + CPU->flag_V = C68K_SR_V; + RET(76) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(96) + +// DIVS +OP_0x81C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(10) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(50) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(80) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(108) + +// DIVS +OP_0x81D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(54) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(84) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(112) + +// DIVS +OP_0x81D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(54) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(84) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(112) + +// DIVS +OP_0x81E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(16) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(56) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(86) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(114) + +// DIVS +OP_0x81E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(18) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(58) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(88) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(116) + +// DIVS +OP_0x81F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(20) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(60) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(90) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(118) + +// DIVS +OP_0x81F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(18) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(58) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(88) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(116) + +// DIVS +OP_0x81F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(22) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(62) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(92) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(120) + +// DIVS +OP_0x81FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(18) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(58) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(88) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(116) + +// DIVS +OP_0x81FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(20) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(60) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(90) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(118) + +// DIVS +OP_0x81FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)FETCH_WORD; + PC += 2; + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(54) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(84) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(112) + +// DIVS +OP_0x81DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(14) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(54) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(84) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(112) + +// DIVS +OP_0x81E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + if (src == 0) + { + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_ZERO_DIVIDE_EX; + POST_IO + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO + RET(16) + } + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + if ((dst == 0x80000000) && (src == -1)) + { + CPU->flag_notZ = CPU->flag_N = 0; + CPU->flag_V = CPU->flag_C = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + RET(56) + } + { + s32 q, r; + + q = (s32)dst / (s32)src; + r = (s32)dst % (s32)src; + + if ((q > 0x7FFF) || (q < -0x8000)) + { + CPU->flag_V = C68K_SR_V; + RET(86) + } + q &= 0x0000FFFF; + CPU->flag_notZ = q; + CPU->flag_N = q >> 8; + CPU->flag_V = CPU->flag_C = 0; + res = q | (r << 16); + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + } +} +RET(114) diff --git a/m68000/c68k/c68k_op9.inc b/m68000/c68k/c68k_op9.inc new file mode 100644 index 0000000..17423ad --- /dev/null +++ b/m68000/c68k/c68k_op9.inc @@ -0,0 +1,2230 @@ + +// SUBaD +OP_0x9000: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// SUBaD +OP_0x9008: +{ + u32 res; + pointer dst; + pointer src; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// SUBaD +OP_0x9010: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// SUBaD +OP_0x9018: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// SUBaD +OP_0x9020: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// SUBaD +OP_0x9028: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// SUBaD +OP_0x9030: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// SUBaD +OP_0x9038: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// SUBaD +OP_0x9039: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// SUBaD +OP_0x903A: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// SUBaD +OP_0x903B: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// SUBaD +OP_0x903C: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// SUBaD +OP_0x901F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// SUBaD +OP_0x9027: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// SUBaD +OP_0x9040: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// SUBaD +OP_0x9048: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->A[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// SUBaD +OP_0x9050: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// SUBaD +OP_0x9058: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// SUBaD +OP_0x9060: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// SUBaD +OP_0x9068: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// SUBaD +OP_0x9070: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// SUBaD +OP_0x9078: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// SUBaD +OP_0x9079: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// SUBaD +OP_0x907A: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// SUBaD +OP_0x907B: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// SUBaD +OP_0x907C: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// SUBaD +OP_0x905F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// SUBaD +OP_0x9067: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// SUBaD +OP_0x9080: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// SUBaD +OP_0x9088: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// SUBaD +OP_0x9090: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// SUBaD +OP_0x9098: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// SUBaD +OP_0x90A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// SUBaD +OP_0x90A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// SUBaD +OP_0x90B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// SUBaD +OP_0x90B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// SUBaD +OP_0x90B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(24) + +// SUBaD +OP_0x90BA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// SUBaD +OP_0x90BB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// SUBaD +OP_0x90BC: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(14) + +// SUBaD +OP_0x909F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// SUBaD +OP_0x90A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// SUBDa +OP_0x9110: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// SUBDa +OP_0x9118: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// SUBDa +OP_0x9120: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// SUBDa +OP_0x9128: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBDa +OP_0x9130: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBDa +OP_0x9138: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// SUBDa +OP_0x9139: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// SUBDa +OP_0x911F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// SUBDa +OP_0x9127: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// SUBDa +OP_0x9150: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// SUBDa +OP_0x9158: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// SUBDa +OP_0x9160: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// SUBDa +OP_0x9168: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBDa +OP_0x9170: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBDa +OP_0x9178: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// SUBDa +OP_0x9179: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// SUBDa +OP_0x915F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// SUBDa +OP_0x9167: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// SUBDa +OP_0x9190: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// SUBDa +OP_0x9198: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// SUBDa +OP_0x91A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// SUBDa +OP_0x91A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// SUBDa +OP_0x91B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// SUBDa +OP_0x91B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// SUBDa +OP_0x91B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// SUBDa +OP_0x919F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// SUBDa +OP_0x91A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// SUBX +OP_0x9100: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ |= res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// SUBX +OP_0x9140: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// SUBX +OP_0x9180: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// SUBXM +OP_0x9108: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBXM +OP_0x9148: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_WORD_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBXM +OP_0x9188: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_LONG_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// SUBX7M +OP_0x910F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBX7M +OP_0x914F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_WORD_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBX7M +OP_0x918F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_LONG_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// SUBXM7 +OP_0x9F08: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBXM7 +OP_0x9F48: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_WORD_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBXM7 +OP_0x9F88: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + READ_LONG_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// SUBX7M7 +OP_0x9F0F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// SUBX7M7 +OP_0x9F4F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_WORD_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// SUBX7M7 +OP_0x9F8F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + READ_LONG_F(adr, dst) + res = dst - src - ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// SUBA +OP_0x90C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// SUBA +OP_0x90C8: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// SUBA +OP_0x90D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// SUBA +OP_0x90D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// SUBA +OP_0x90E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// SUBA +OP_0x90E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// SUBA +OP_0x90F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// SUBA +OP_0x90F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// SUBA +OP_0x90F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// SUBA +OP_0x90FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// SUBA +OP_0x90FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// SUBA +OP_0x90FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)FETCH_WORD; + PC += 2; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(12) + +// SUBA +OP_0x90DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// SUBA +OP_0x90E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// SUBA +OP_0x91C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(6) + +// SUBA +OP_0x91C8: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(6) + +// SUBA +OP_0x91D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// SUBA +OP_0x91D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// SUBA +OP_0x91E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// SUBA +OP_0x91E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// SUBA +OP_0x91F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(22) + +// SUBA +OP_0x91F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// SUBA +OP_0x91F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(24) + +// SUBA +OP_0x91FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// SUBA +OP_0x91FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(22) + +// SUBA +OP_0x91FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)FETCH_LONG; + PC += 4; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(14) + +// SUBA +OP_0x91DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// SUBA +OP_0x91E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) diff --git a/m68000/c68k/c68k_opA.inc b/m68000/c68k/c68k_opA.inc new file mode 100644 index 0000000..a4eb015 --- /dev/null +++ b/m68000/c68k/c68k_opA.inc @@ -0,0 +1,23 @@ + +// 1010 +OP_0xA000: +{ + u32 res; + PC -= 2; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_1010_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO +} +RET(4) diff --git a/m68000/c68k/c68k_opB.inc b/m68000/c68k/c68k_opB.inc new file mode 100644 index 0000000..33a0a29 --- /dev/null +++ b/m68000/c68k/c68k_opB.inc @@ -0,0 +1,2250 @@ + +// CMP +OP_0xB000: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; +} +RET(4) + +// CMP +OP_0xB008: +{ + u32 res; + pointer dst; + pointer src; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; +} +RET(4) + +// CMP +OP_0xB010: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(8) + +// CMP +OP_0xB018: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(8) + +// CMP +OP_0xB020: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(10) + +// CMP +OP_0xB028: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMP +OP_0xB030: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(14) + +// CMP +OP_0xB038: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMP +OP_0xB039: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(16) + +// CMP +OP_0xB03A: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMP +OP_0xB03B: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(14) + +// CMP +OP_0xB03C: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; +} +RET(8) + +// CMP +OP_0xB01F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(8) + +// CMP +OP_0xB027: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(10) + +// CMP +OP_0xB040: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; +} +RET(4) + +// CMP +OP_0xB048: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->A[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; +} +RET(4) + +// CMP +OP_0xB050: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(8) + +// CMP +OP_0xB058: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(8) + +// CMP +OP_0xB060: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(10) + +// CMP +OP_0xB068: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMP +OP_0xB070: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(14) + +// CMP +OP_0xB078: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMP +OP_0xB079: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(16) + +// CMP +OP_0xB07A: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMP +OP_0xB07B: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(14) + +// CMP +OP_0xB07C: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; +} +RET(8) + +// CMP +OP_0xB05F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(8) + +// CMP +OP_0xB067: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(10) + +// CMP +OP_0xB080: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(6) + +// CMP +OP_0xB088: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(6) + +// CMP +OP_0xB090: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// CMP +OP_0xB098: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// CMP +OP_0xB0A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// CMP +OP_0xB0A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMP +OP_0xB0B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(22) + +// CMP +OP_0xB0B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMP +OP_0xB0B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(24) + +// CMP +OP_0xB0BA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMP +OP_0xB0BB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(22) + +// CMP +OP_0xB0BC: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(14) + +// CMP +OP_0xB09F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// CMP +OP_0xB0A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// CMPM +OP_0xB108: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMPM +OP_0xB148: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMPM +OP_0xB188: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMP7M +OP_0xB10F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 1; + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMP7M +OP_0xB14F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 2; + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMP7M +OP_0xB18F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] += 4; + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMPM7 +OP_0xBF08: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7]; + CPU->A[7] += 2; + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMPM7 +OP_0xBF48: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[7]; + CPU->A[7] += 2; + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMPM7 +OP_0xBF88: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[7]; + CPU->A[7] += 4; + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMP7M7 +OP_0xBF0F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7]; + CPU->A[7] += 2; + READ_BYTE_F(adr, dst) + res = dst - src; + CPU->flag_N = CPU->flag_C = res; + CPU->flag_V = (src ^ dst) & (res ^ dst); + CPU->flag_notZ = res & 0xFF; + POST_IO +} +RET(12) + +// CMP7M7 +OP_0xBF4F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[7]; + CPU->A[7] += 2; + READ_WORD_F(adr, dst) + res = dst - src; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8; + CPU->flag_N = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + POST_IO +} +RET(12) + +// CMP7M7 +OP_0xBF8F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[7]; + CPU->A[7] += 4; + READ_LONG_F(adr, dst) + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// EORDa +OP_0xB100: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + res = (u8)CPU->D[(Opcode >> 0) & 7]; + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// EORDa +OP_0xB110: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// EORDa +OP_0xB118: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// EORDa +OP_0xB120: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// EORDa +OP_0xB128: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// EORDa +OP_0xB130: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// EORDa +OP_0xB138: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// EORDa +OP_0xB139: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// EORDa +OP_0xB11F: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// EORDa +OP_0xB127: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// EORDa +OP_0xB140: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + res = (u16)CPU->D[(Opcode >> 0) & 7]; + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(4) + +// EORDa +OP_0xB150: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// EORDa +OP_0xB158: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// EORDa +OP_0xB160: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// EORDa +OP_0xB168: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// EORDa +OP_0xB170: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// EORDa +OP_0xB178: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// EORDa +OP_0xB179: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// EORDa +OP_0xB15F: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// EORDa +OP_0xB167: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// EORDa +OP_0xB180: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// EORDa +OP_0xB190: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// EORDa +OP_0xB198: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// EORDa +OP_0xB1A0: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// EORDa +OP_0xB1A8: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// EORDa +OP_0xB1B0: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// EORDa +OP_0xB1B8: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// EORDa +OP_0xB1B9: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// EORDa +OP_0xB19F: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// EORDa +OP_0xB1A7: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res ^= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// CMPA +OP_0xB0C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(6) + +// CMPA +OP_0xB0C8: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(6) + +// CMPA +OP_0xB0D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(10) + +// CMPA +OP_0xB0D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(10) + +// CMPA +OP_0xB0E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(12) + +// CMPA +OP_0xB0E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// CMPA +OP_0xB0F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// CMPA +OP_0xB0F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// CMPA +OP_0xB0F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// CMPA +OP_0xB0FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// CMPA +OP_0xB0FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// CMPA +OP_0xB0FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)FETCH_WORD; + PC += 2; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(10) + +// CMPA +OP_0xB0DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(10) + +// CMPA +OP_0xB0E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(12) + +// CMPA +OP_0xB1C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(6) + +// CMPA +OP_0xB1C8: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(6) + +// CMPA +OP_0xB1D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// CMPA +OP_0xB1D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// CMPA +OP_0xB1E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) + +// CMPA +OP_0xB1E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// CMPA +OP_0xB1F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMPA +OP_0xB1F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// CMPA +OP_0xB1F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(22) + +// CMPA +OP_0xB1FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(18) + +// CMPA +OP_0xB1FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(20) + +// CMPA +OP_0xB1FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)FETCH_LONG; + PC += 4; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; +} +RET(14) + +// CMPA +OP_0xB1DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(14) + +// CMPA +OP_0xB1E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst - src; + CPU->flag_notZ = res; + CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23; + CPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24; + CPU->flag_N = res >> 24; + POST_IO +} +RET(16) diff --git a/m68000/c68k/c68k_opC.inc b/m68000/c68k/c68k_opC.inc new file mode 100644 index 0000000..66946e6 --- /dev/null +++ b/m68000/c68k/c68k_opC.inc @@ -0,0 +1,2035 @@ + +// ANDaD +OP_0xC000: +{ + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ANDaD +OP_0xC010: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ANDaD +OP_0xC018: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ANDaD +OP_0xC020: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ANDaD +OP_0xC028: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ANDaD +OP_0xC030: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ANDaD +OP_0xC038: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ANDaD +OP_0xC039: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ANDaD +OP_0xC03A: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ANDaD +OP_0xC03B: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ANDaD +OP_0xC03C: +{ + u32 res; + pointer src; + src = FETCH_BYTE; + PC += 2; + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ANDaD +OP_0xC01F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ANDaD +OP_0xC027: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + res = (u8)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ANDaD +OP_0xC040: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ANDaD +OP_0xC050: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ANDaD +OP_0xC058: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ANDaD +OP_0xC060: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ANDaD +OP_0xC068: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ANDaD +OP_0xC070: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ANDaD +OP_0xC078: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ANDaD +OP_0xC079: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ANDaD +OP_0xC07A: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ANDaD +OP_0xC07B: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ANDaD +OP_0xC07C: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ANDaD +OP_0xC05F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ANDaD +OP_0xC067: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ANDaD +OP_0xC080: +{ + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// ANDaD +OP_0xC090: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ANDaD +OP_0xC098: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ANDaD +OP_0xC0A0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// ANDaD +OP_0xC0A8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ANDaD +OP_0xC0B0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// ANDaD +OP_0xC0B8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ANDaD +OP_0xC0B9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(24) + +// ANDaD +OP_0xC0BA: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ANDaD +OP_0xC0BB: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// ANDaD +OP_0xC0BC: +{ + u32 res; + pointer src; + src = FETCH_LONG; + PC += 4; + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(14) + +// ANDaD +OP_0xC09F: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ANDaD +OP_0xC0A7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + res = (u32)CPU->D[(Opcode >> 9) & 7]; + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// ANDDa +OP_0xC110: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ANDDa +OP_0xC118: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ANDDa +OP_0xC120: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ANDDa +OP_0xC128: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ANDDa +OP_0xC130: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ANDDa +OP_0xC138: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ANDDa +OP_0xC139: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ANDDa +OP_0xC11F: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ANDDa +OP_0xC127: +{ + u32 adr; + u32 res; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ANDDa +OP_0xC150: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ANDDa +OP_0xC158: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ANDDa +OP_0xC160: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ANDDa +OP_0xC168: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ANDDa +OP_0xC170: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ANDDa +OP_0xC178: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ANDDa +OP_0xC179: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ANDDa +OP_0xC15F: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ANDDa +OP_0xC167: +{ + u32 adr; + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 8; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ANDDa +OP_0xC190: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ANDDa +OP_0xC198: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ANDDa +OP_0xC1A0: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// ANDDa +OP_0xC1A8: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ANDDa +OP_0xC1B0: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// ANDDa +OP_0xC1B8: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ANDDa +OP_0xC1B9: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ANDDa +OP_0xC19F: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ANDDa +OP_0xC1A7: +{ + u32 adr; + u32 res; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, res) + res &= src; + CPU->flag_C = 0; + CPU->flag_V = 0; + CPU->flag_notZ = res; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// ABCD +OP_0xC100: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = (dst & 0xF) + (src & 0xF) + ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res += 6; + res += (dst & 0xF0) + (src & 0xF0); + if (res > 0x99) + { + res -= 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// ABCDM +OP_0xC108: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) + (src & 0xF) + ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res += 6; + res += (dst & 0xF0) + (src & 0xF0); + if (res > 0x99) + { + res -= 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ABCD7M +OP_0xC10F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) + (src & 0xF) + ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res += 6; + res += (dst & 0xF0) + (src & 0xF0); + if (res > 0x99) + { + res -= 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ABCDM7 +OP_0xCF08: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) + (src & 0xF) + ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res += 6; + res += (dst & 0xF0) + (src & 0xF0); + if (res > 0x99) + { + res -= 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ABCD7M7 +OP_0xCF0F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = (dst & 0xF) + (src & 0xF) + ((CPU->flag_X >> C68K_SR_X_SFT) & 1); + if (res > 9) res += 6; + res += (dst & 0xF0) + (src & 0xF0); + if (res > 0x99) + { + res -= 0xA0; + CPU->flag_X = CPU->flag_C = C68K_SR_C; + } + else CPU->flag_X = CPU->flag_C = 0; + CPU->flag_notZ |= res & 0xFF; + CPU->flag_N = res; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// MULU +OP_0xC0C0: +{ + u32 res; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(50) + +// MULU +OP_0xC0D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(54) + +// MULU +OP_0xC0D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(54) + +// MULU +OP_0xC0E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(56) + +// MULU +OP_0xC0E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(58) + +// MULU +OP_0xC0F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(60) + +// MULU +OP_0xC0F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(58) + +// MULU +OP_0xC0F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(62) + +// MULU +OP_0xC0FA: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(58) + +// MULU +OP_0xC0FB: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(60) + +// MULU +OP_0xC0FC: +{ + u32 res; + pointer src; + src = FETCH_WORD; + PC += 2; + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(54) + +// MULU +OP_0xC0DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(54) + +// MULU +OP_0xC0E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + res = (u16)CPU->D[(Opcode >> 9) & 7]; + res *= src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(56) + +// MULS +OP_0xC1C0: +{ + u32 res; + pointer src; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(50) + +// MULS +OP_0xC1D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(54) + +// MULS +OP_0xC1D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(54) + +// MULS +OP_0xC1E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(56) + +// MULS +OP_0xC1E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(58) + +// MULS +OP_0xC1F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(60) + +// MULS +OP_0xC1F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(58) + +// MULS +OP_0xC1F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(62) + +// MULS +OP_0xC1FA: +{ + u32 adr; + u32 res; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(58) + +// MULS +OP_0xC1FB: +{ + u32 adr; + u32 res; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(60) + +// MULS +OP_0xC1FC: +{ + u32 res; + pointer src; + src = (s32)(s16)FETCH_WORD; + PC += 2; + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(54) + +// MULS +OP_0xC1DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(54) + +// MULS +OP_0xC1E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + res = (s32)(s16)CPU->D[(Opcode >> 9) & 7]; + res *= (s32)src; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + CPU->flag_V = CPU->flag_C = 0; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(56) + +// EXGDD +OP_0xC140: +{ + u32 res; + pointer src; + res = (u32)CPU->D[(Opcode >> 0) & 7]; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + res = src; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// EXGAA +OP_0xC148: +{ + u32 res; + pointer src; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + src = (u32)CPU->A[(Opcode >> 9) & 7]; + CPU->A[(Opcode >> 9) & 7] = res; + res = src; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(6) + +// EXGAD +OP_0xC188: +{ + u32 res; + pointer src; + res = (u32)CPU->A[(Opcode >> 0) & 7]; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + res = src; + CPU->A[(Opcode >> 0) & 7] = res; +} +RET(6) diff --git a/m68000/c68k/c68k_opD.inc b/m68000/c68k/c68k_opD.inc new file mode 100644 index 0000000..5ef6816 --- /dev/null +++ b/m68000/c68k/c68k_opD.inc @@ -0,0 +1,2230 @@ + +// ADDaD +OP_0xD000: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ADDaD +OP_0xD008: +{ + u32 res; + pointer dst; + pointer src; + // can't read byte from Ax registers ! + CPU->Status |= C68K_FAULTED; + CCnt = 0; + goto C68k_Exec_Really_End; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ADDaD +OP_0xD010: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ADDaD +OP_0xD018: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ADDaD +OP_0xD020: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ADDaD +OP_0xD028: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ADDaD +OP_0xD030: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ADDaD +OP_0xD038: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ADDaD +OP_0xD039: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ADDaD +OP_0xD03A: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ADDaD +OP_0xD03B: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ADDaD +OP_0xD03C: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_BYTE; + PC += 2; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ADDaD +OP_0xD01F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ADDaD +OP_0xD027: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ADDaD +OP_0xD040: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ADDaD +OP_0xD048: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->A[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ADDaD +OP_0xD050: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ADDaD +OP_0xD058: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ADDaD +OP_0xD060: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ADDaD +OP_0xD068: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ADDaD +OP_0xD070: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ADDaD +OP_0xD078: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ADDaD +OP_0xD079: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ADDaD +OP_0xD07A: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(12) + +// ADDaD +OP_0xD07B: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(14) + +// ADDaD +OP_0xD07C: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_WORD; + PC += 2; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ADDaD +OP_0xD05F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(8) + +// ADDaD +OP_0xD067: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(10) + +// ADDaD +OP_0xD080: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// ADDaD +OP_0xD088: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(6) + +// ADDaD +OP_0xD090: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ADDaD +OP_0xD098: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ADDaD +OP_0xD0A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// ADDaD +OP_0xD0A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ADDaD +OP_0xD0B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// ADDaD +OP_0xD0B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ADDaD +OP_0xD0B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(24) + +// ADDaD +OP_0xD0BA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(20) + +// ADDaD +OP_0xD0BB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(22) + +// ADDaD +OP_0xD0BC: +{ + u32 res; + pointer dst; + pointer src; + src = FETCH_LONG; + PC += 4; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(14) + +// ADDaD +OP_0xD09F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(16) + +// ADDaD +OP_0xD0A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; + POST_IO +} +RET(18) + +// ADDDa +OP_0xD110: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ADDDa +OP_0xD118: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 1; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ADDDa +OP_0xD120: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ADDDa +OP_0xD128: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDDa +OP_0xD130: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDDa +OP_0xD138: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(16) + +// ADDDa +OP_0xD139: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(20) + +// ADDDa +OP_0xD11F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(12) + +// ADDDa +OP_0xD127: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, dst) + res = dst + src; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ = res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(14) + +// ADDDa +OP_0xD150: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ADDDa +OP_0xD158: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ADDDa +OP_0xD160: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ADDDa +OP_0xD168: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDDa +OP_0xD170: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDDa +OP_0xD178: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ADDDa +OP_0xD179: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ADDDa +OP_0xD15F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ADDDa +OP_0xD167: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, dst) + res = dst + src; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ = res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ADDDa +OP_0xD190: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ADDDa +OP_0xD198: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ADDDa +OP_0xD1A0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// ADDDa +OP_0xD1A8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ADDDa +OP_0xD1B0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(26) + +// ADDDa +OP_0xD1B8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(24) + +// ADDDa +OP_0xD1B9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(28) + +// ADDDa +OP_0xD19F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(20) + +// ADDDa +OP_0xD1A7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 9) & 7]; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, dst) + res = dst + src; + CPU->flag_notZ = res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(22) + +// ADDX +OP_0xD100: +{ + u32 res; + pointer dst; + pointer src; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + dst = (u8)CPU->D[(Opcode >> 9) & 7]; + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ |= res & 0xFF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ADDX +OP_0xD140: +{ + u32 res; + pointer dst; + pointer src; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + dst = (u16)CPU->D[(Opcode >> 9) & 7]; + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(4) + +// ADDX +OP_0xD180: +{ + u32 res; + pointer dst; + pointer src; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->D[(Opcode >> 9) & 7]; + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + *((u32*)(&CPU->D[(Opcode >> 9) & 7])) = res; +} +RET(8) + +// ADDXM +OP_0xD108: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDXM +OP_0xD148: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_WORD_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDXM +OP_0xD188: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_LONG_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ADDX7M +OP_0xD10F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 1; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_BYTE_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDX7M +OP_0xD14F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 2; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_WORD_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDX7M +OP_0xD18F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[(Opcode >> 9) & 7] - 4; + CPU->A[(Opcode >> 9) & 7] = adr; + READ_LONG_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ADDXM7 +OP_0xDF08: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 1; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDXM7 +OP_0xDF48: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_WORD_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDXM7 +OP_0xDF88: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + READ_LONG_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ADDX7M7 +OP_0xDF0F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_BYTE_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_BYTE_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_N = CPU->flag_X = CPU->flag_C = res; + CPU->flag_V = (src ^ res) & (dst ^ res); + CPU->flag_notZ |= res & 0xFF; + WRITE_BYTE_F(adr, res) + POST_IO +} +RET(18) + +// ADDX7M7 +OP_0xDF4F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + READ_WORD_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8; + CPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_notZ |= res & 0xFFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ADDX7M7 +OP_0xDF8F: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READ_LONG_F(adr, src) + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + READ_LONG_F(adr, dst) + res = dst + src + ((CPU->flag_X >> 8) & 1); + CPU->flag_notZ |= res; + CPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23; + CPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24; + CPU->flag_N = res >> 24; + WRITE_LONG_F(adr, res) + POST_IO +} +RET(30) + +// ADDA +OP_0xD0C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// ADDA +OP_0xD0C8: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(8) + +// ADDA +OP_0xD0D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// ADDA +OP_0xD0D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// ADDA +OP_0xD0E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// ADDA +OP_0xD0E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// ADDA +OP_0xD0F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// ADDA +OP_0xD0F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// ADDA +OP_0xD0F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// ADDA +OP_0xD0FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// ADDA +OP_0xD0FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// ADDA +OP_0xD0FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s16)FETCH_WORD; + PC += 2; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(12) + +// ADDA +OP_0xD0DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(12) + +// ADDA +OP_0xD0E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READSX_WORD_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(14) + +// ADDA +OP_0xD1C0: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)CPU->D[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(6) + +// ADDA +OP_0xD1C8: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)CPU->A[(Opcode >> 0) & 7]; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(6) + +// ADDA +OP_0xD1D0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// ADDA +OP_0xD1D8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// ADDA +OP_0xD1E0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 4; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) + +// ADDA +OP_0xD1E8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// ADDA +OP_0xD1F0: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(22) + +// ADDA +OP_0xD1F8: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// ADDA +OP_0xD1F9: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(24) + +// ADDA +OP_0xD1FA: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(20) + +// ADDA +OP_0xD1FB: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = PC - CPU->BasePC; + DECODE_EXT_WORD + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(22) + +// ADDA +OP_0xD1FC: +{ + u32 res; + pointer dst; + pointer src; + src = (s32)(s32)FETCH_LONG; + PC += 4; + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; +} +RET(14) + +// ADDA +OP_0xD1DF: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 4; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(16) + +// ADDA +OP_0xD1E7: +{ + u32 adr; + u32 res; + pointer dst; + pointer src; + adr = CPU->A[7] - 4; + CPU->A[7] = adr; + PRE_IO + READSX_LONG_F(adr, src) + dst = (u32)CPU->A[(Opcode >> 9) & 7]; + res = dst + src; + CPU->A[(Opcode >> 9) & 7] = res; + POST_IO +} +RET(18) diff --git a/m68000/c68k/c68k_opE.inc b/m68000/c68k/c68k_opE.inc new file mode 100644 index 0000000..57785d6 --- /dev/null +++ b/m68000/c68k/c68k_opE.inc @@ -0,0 +1,2842 @@ + +// ASRk +OP_0xE000: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (s32)(s8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((s32)src) >> sft; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ASRk +OP_0xE040: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((s32)src) >> sft; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ASRk +OP_0xE080: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (s32)(s32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((s32)src) >> sft; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// LSRk +OP_0xE008: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// LSRk +OP_0xE048: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// LSRk +OP_0xE088: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ROXRk +OP_0xE010: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src >> sft) | (src << (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ROXRk +OP_0xE050: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src >> sft) | (src << (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ROXRk +OP_0xE090: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + if (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))); + else res = (src >> sft) | (src << (33 - sft)) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + sft))); + CPU->flag_X = CPU->flag_C; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// RORk +OP_0xE018: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = (src >> sft) | (src << (8 - sft)); + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// RORk +OP_0xE058: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = (src >> sft) | (src << (16 - sft)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// RORk +OP_0xE098: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = (src >> sft) | (src << (32 - sft)); + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ASLk +OP_0xE100: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft < 8) + { + CPU->flag_X = CPU->flag_C = src << (0 + sft); + res = src << sft; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_V = 0; + if ((sft > 7) && (src)) CPU->flag_V = C68K_SR_V; + else + { + u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) + } + + if (src) CPU->flag_V = C68K_SR_V; + else CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_N = 0; + CPU->flag_notZ = 0; +} +RET(6) + +// ASLk +OP_0xE140: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_X = CPU->flag_C = src >> (8 - sft); + res = src << sft; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_V = 0; + { + u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } +} +RET(6) + +// ASLk +OP_0xE180: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_X = CPU->flag_C = src >> (24 - sft); + res = src << sft; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res & 0xFFFFFFFF; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_V = 0; + { + u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } +} +RET(8) + +// LSLk +OP_0xE108: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << (0 + sft); + res = src << sft; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// LSLk +OP_0xE148: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> (8 - sft); + res = src << sft; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// LSLk +OP_0xE188: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> (24 - sft); + res = src << sft; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res & 0xFFFFFFFF; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ROXLk +OP_0xE110: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src << sft) | (src >> (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ROXLk +OP_0xE150: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src << sft) | (src >> (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ROXLk +OP_0xE190: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_C = src >> ((32 - C68K_SR_C_SFT) - sft); + if (sft == 1) res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - 1)); + else res = (src << sft) | (src >> (33 - sft)) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - sft)); + CPU->flag_X = CPU->flag_C; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ROLk +OP_0xE118: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_C = src << (0 + sft); + res = (src << sft) | (src >> (8 - sft)); + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ROLk +OP_0xE158: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_C = src >> (8 - sft); + res = (src << sft) | (src >> (16 - sft)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(6) + +// ROLk +OP_0xE198: +{ + u32 res; + pointer src; + u32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + CCnt -= sft * 2; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + CPU->flag_V = 0; + CPU->flag_C = src >> (24 - sft); + res = (src << sft) | (src >> (32 - sft)); + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; +} +RET(8) + +// ASRD +OP_0xE020: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (s32)(s8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 8) + { + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((s32)src) >> sft; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + if (src & (1 << 7)) + { + CPU->flag_N = C68K_SR_N; + CPU->flag_notZ = 1; + CPU->flag_V = 0; + CPU->flag_C = C68K_SR_C; + CPU->flag_X = C68K_SR_X; + res = 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_X = 0; + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// ASRD +OP_0xE060: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (s32)(s16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 16) + { + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = ((s32)src) >> sft; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + if (src & (1 << 15)) + { + CPU->flag_N = C68K_SR_N; + CPU->flag_notZ = 1; + CPU->flag_V = 0; + CPU->flag_C = C68K_SR_C; + CPU->flag_X = C68K_SR_X; + res = 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_X = 0; + res = 0; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// ASRD +OP_0xE0A0: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (s32)(s32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 32) + { + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = ((s32)src) >> sft; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + if (src & (1 << 31)) + { + CPU->flag_N = C68K_SR_N; + CPU->flag_notZ = 1; + CPU->flag_V = 0; + CPU->flag_C = C68K_SR_C; + CPU->flag_X = C68K_SR_X; + res = 0xFFFFFFFF; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_X = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// LSRD +OP_0xE028: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft <= 8) + { + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// LSRD +OP_0xE068: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft <= 16) + { + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = src >> sft; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + res = 0; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// LSRD +OP_0xE0A8: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 32) + { + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = src >> sft; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + if (sft == 32) CPU->flag_C = src >> (31 - C68K_SR_C_SFT); + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// ROXRD +OP_0xE030: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft %= 9; + + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src >> sft) | (src << (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// ROXRD +OP_0xE070: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft %= 17; + + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src >> sft) | (src << (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// ROXRD +OP_0xE0B0: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft %= 33; + + if (sft != 0) + { + if (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))); + else res = (src >> sft) | (src << (33 - sft)) | (((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))) >> (sft - 1)); + CPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT; + } + else res = src; + CPU->flag_C = CPU->flag_X; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// RORD +OP_0xE038: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft &= 0x07; + + CPU->flag_C = src << (C68K_SR_C_SFT - ((sft - 1) & 7)); + res = (src >> sft) | (src << (8 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// RORD +OP_0xE078: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft &= 0x0F; + + CPU->flag_C = (src >> ((sft - 1) & 15)) << C68K_SR_C_SFT; + res = (src >> sft) | (src << (16 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// RORD +OP_0xE0B8: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft &= 0x1F; + + CPU->flag_C = (src >> ((sft - 1) & 31)) << C68K_SR_C_SFT; + res = (src >> sft) | (src << (32 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// ASLD +OP_0xE120: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 8) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 0; + res = (src << sft) & 0x000000FF; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_V = 0; + { + u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) + } + + if (sft == 256) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + if (src) CPU->flag_V = C68K_SR_V; + else CPU->flag_V = 0; + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// ASLD +OP_0xE160: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 16) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 8; + res = (src << sft) & 0x0000FFFF; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_V = 0; + { + u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) + } + + if (sft == 65536) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + if (src) CPU->flag_V = C68K_SR_V; + else CPU->flag_V = 0; + res = 0; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// ASLD +OP_0xE1A0: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 32) + { + CPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT; + res = src << sft; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_V = 0; + { + u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(8) + } + + if (sft == 0) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + if (src) CPU->flag_V = C68K_SR_V; + else CPU->flag_V = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// LSLD +OP_0xE128: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft <= 8) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 0; + res = (src << sft) & 0x000000FF; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + res = 0; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// LSLD +OP_0xE168: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft <= 16) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 8; + res = (src << sft) & 0x0000FFFF; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + res = 0; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// LSLD +OP_0xE1A8: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft < 32) + { + CPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT; + res = src << sft; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + if (sft == 32) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_N = 0; + CPU->flag_notZ = 0; + CPU->flag_V = 0; + res = 0; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// ROXLD +OP_0xE130: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft %= 9; + + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src << sft) | (src >> (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res & 0x000000FF; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// ROXLD +OP_0xE170: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft %= 17; + + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src << sft) | (src >> (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// ROXLD +OP_0xE1B0: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + sft %= 33; + + if (sft != 0) + { + if (sft == 1) res = (src << 1) | ((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1); + else res = (src << sft) | (src >> (33 - sft)) | (((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1)); + CPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT; + } + else res = src; + CPU->flag_C = CPU->flag_X; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// ROLD +OP_0xE138: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u8)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft &= 0x07) + { + CPU->flag_C = (src << sft) >> 0; + res = ((src << sft) | (src >> (8 - sft))) & 0x000000FF; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_notZ = res; + *(BYTE_OFF + (u8*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_notZ = src; +} +RET(6) + +// ROLD +OP_0xE178: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u16)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft &= 0x0F) + { + CPU->flag_C = (src << sft) >> 8; + res = ((src << sft) | (src >> (16 - sft))) & 0x0000FFFF; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + *(WORD_OFF + (u16*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_notZ = src; +} +RET(6) + +// ROLD +OP_0xE1B8: +{ + u32 res; + pointer src; + u32 sft; + + sft = CPU->D[(Opcode >> 9) & 7] & 0x3F; + src = (u32)CPU->D[(Opcode >> 0) & 7]; + if (sft) + { + CCnt -= sft * 2; + if (sft &= 0x1F) + { + CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT; + res = (src << sft) | (src >> (32 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_notZ = res; + *((u32*)(&CPU->D[(Opcode >> 0) & 7])) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_notZ = src; +} +RET(8) + +// ASR +OP_0xE0D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ASR +OP_0xE0D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ASR +OP_0xE0E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ASR +OP_0xE0E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ASR +OP_0xE0F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ASR +OP_0xE0F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ASR +OP_0xE0F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ASR +OP_0xE0DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ASR +OP_0xE0E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// LSR +OP_0xE2D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// LSR +OP_0xE2D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// LSR +OP_0xE2E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// LSR +OP_0xE2E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// LSR +OP_0xE2F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// LSR +OP_0xE2F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// LSR +OP_0xE2F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// LSR +OP_0xE2DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// LSR +OP_0xE2E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROXR +OP_0xE4D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROXR +OP_0xE4D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROXR +OP_0xE4E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROXR +OP_0xE4E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROXR +OP_0xE4F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ROXR +OP_0xE4F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROXR +OP_0xE4F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ROXR +OP_0xE4DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROXR +OP_0xE4E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROR +OP_0xE6D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROR +OP_0xE6D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROR +OP_0xE6E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROR +OP_0xE6E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROR +OP_0xE6F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ROR +OP_0xE6F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROR +OP_0xE6F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ROR +OP_0xE6DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROR +OP_0xE6E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ASL +OP_0xE1D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ASL +OP_0xE1D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ASL +OP_0xE1E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ASL +OP_0xE1E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ASL +OP_0xE1F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ASL +OP_0xE1F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ASL +OP_0xE1F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ASL +OP_0xE1DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ASL +OP_0xE1E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// LSL +OP_0xE3D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// LSL +OP_0xE3D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// LSL +OP_0xE3E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// LSL +OP_0xE3E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// LSL +OP_0xE3F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// LSL +OP_0xE3F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// LSL +OP_0xE3F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// LSL +OP_0xE3DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// LSL +OP_0xE3E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROXL +OP_0xE5D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROXL +OP_0xE5D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROXL +OP_0xE5E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROXL +OP_0xE5E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROXL +OP_0xE5F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ROXL +OP_0xE5F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROXL +OP_0xE5F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ROXL +OP_0xE5DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROXL +OP_0xE5E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROL +OP_0xE7D0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROL +OP_0xE7D8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + CPU->A[(Opcode >> 0) & 7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROL +OP_0xE7E0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] - 2; + CPU->A[(Opcode >> 0) & 7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) + +// ROL +OP_0xE7E8: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7] + (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROL +OP_0xE7F0: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[(Opcode >> 0) & 7]; + DECODE_EXT_WORD + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(18) + +// ROL +OP_0xE7F8: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)(s16)FETCH_WORD; + PC += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(16) + +// ROL +OP_0xE7F9: +{ + u32 adr; + u32 res; + pointer src; + adr = (s32)FETCH_LONG; + PC += 4; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(20) + +// ROL +OP_0xE7DF: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7]; + CPU->A[7] += 2; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(12) + +// ROL +OP_0xE7E7: +{ + u32 adr; + u32 res; + pointer src; + adr = CPU->A[7] - 2; + CPU->A[7] = adr; + PRE_IO + READ_WORD_F(adr, src) + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_notZ = res & 0x0000FFFF; + WRITE_WORD_F(adr, res) + POST_IO +} +RET(14) diff --git a/m68000/c68k/c68k_opF.inc b/m68000/c68k/c68k_opF.inc new file mode 100644 index 0000000..fbf4937 --- /dev/null +++ b/m68000/c68k/c68k_opF.inc @@ -0,0 +1,23 @@ + +// 1111 +OP_0xF000: +{ + u32 res; + PC -= 2; + if (!CPU->flag_S) + { + res = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = res; + } + res = C68K_1111_EX; + CCnt -= c68k_exception_cycle_table[res]; + PRE_IO + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + CPU->flag_S = C68K_SR_S; + READ_LONG_F(res * 4, PC) + SET_PC(PC) + POST_IO +} +RET(4) diff --git a/m68000/c68k/c68kexec.c b/m68000/c68k/c68kexec.c new file mode 100644 index 0000000..0b57ed2 --- /dev/null +++ b/m68000/c68k/c68kexec.c @@ -0,0 +1,339 @@ +/* Copyright 2003-2004 Stephane Dallongeville + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/*! \file c68kexec.c + \brief C68K emulation execution and instruction functions. +*/ + +#include "core.h" +#include "c68k.h" + +// #define TRACE_WITH_Q68 // Define to use Q68 tracing code to trace insns + // (requires Q68 built in, of course) + +#ifdef NEOCD_HLE +void cdrom_load_files(void); +void neogeo_cdda_control(void); +void neogeo_prio_switch(void); +void neogeo_upload(void); +#endif + +// exception cycle table (taken from musashi core) +static const s32 c68k_exception_cycle_table[256] = +{ + 4, // 0: Reset - Initial Stack Pointer + 4, // 1: Reset - Initial Program Counter + 50, // 2: Bus Error + 50, // 3: Address Error + 34, // 4: Illegal Instruction + 38, // 5: Divide by Zero + 40, // 6: CHK + 34, // 7: TRAPV + 34, // 8: Privilege Violation + 34, // 9: Trace + 4, // 10: + 4, // 11: + 4, // 12: RESERVED + 4, // 13: Coprocessor Protocol Violation + 4, // 14: Format Error + 44, // 15: Uninitialized Interrupt + 4, // 16: RESERVED + 4, // 17: RESERVED + 4, // 18: RESERVED + 4, // 19: RESERVED + 4, // 20: RESERVED + 4, // 21: RESERVED + 4, // 22: RESERVED + 4, // 23: RESERVED + 44, // 24: Spurious Interrupt + 44, // 25: Level 1 Interrupt Autovector + 44, // 26: Level 2 Interrupt Autovector + 44, // 27: Level 3 Interrupt Autovector + 44, // 28: Level 4 Interrupt Autovector + 44, // 29: Level 5 Interrupt Autovector + 44, // 30: Level 6 Interrupt Autovector + 44, // 31: Level 7 Interrupt Autovector + 34, // 32: TRAP #0 + 34, // 33: TRAP #1 + 34, // 34: TRAP #2 + 34, // 35: TRAP #3 + 34, // 36: TRAP #4 + 34, // 37: TRAP #5 + 34, // 38: TRAP #6 + 34, // 39: TRAP #7 + 34, // 40: TRAP #8 + 34, // 41: TRAP #9 + 34, // 42: TRAP #10 + 34, // 43: TRAP #11 + 34, // 44: TRAP #12 + 34, // 45: TRAP #13 + 34, // 46: TRAP #14 + 34, // 47: TRAP #15 + 4, // 48: FP Branch or Set on Unknown Condition + 4, // 49: FP Inexact Result + 4, // 50: FP Divide by Zero + 4, // 51: FP Underflow + 4, // 52: FP Operand Error + 4, // 53: FP Overflow + 4, // 54: FP Signaling NAN + 4, // 55: FP Unimplemented Data Type + 4, // 56: MMU Configuration Error + 4, // 57: MMU Illegal Operation Error + 4, // 58: MMU Access Level Violation Error + 4, // 59: RESERVED + 4, // 60: RESERVED + 4, // 61: RESERVED + 4, // 62: RESERVED + 4, // 63: RESERVED + // 64-255: User Defined + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4 +}; + +// global variable +/////////////////// + +#ifndef C68K_GEN + +#ifndef C68K_NO_JUMP_TABLE +#ifndef C68K_CONST_JUMP_TABLE +static void *JumpTable[0x10000]; +#endif +#endif + +static u32 C68k_Initialised = 0; + +#endif // C68K_GEN + +#ifdef NEOCD_HLE +extern int img_display; +#endif + +// include macro file +////////////////////// + +#include "c68kmac.inc" + +#ifndef C68K_GEN +# ifdef TRACE_WITH_Q68 +#include "../q68/q68.h" +static c68k_struc *TRACE_CPU; +static uint32_t readw(uint32_t address) { + return TRACE_CPU->Read_Word(address); +} +/* Make our own version of the structure to avoid the overhead of dozens of + * function calls every instruction */ +static struct { + u32 D[8], A[8], PC, SR, USP, SSP, dummy[7]; + void *readb, *readw, *writeb, *writew; +} state = {.readw = readw}; +void TRACE(int PC,c68k_struc *CPU,int Opcode,int CCnt) { + static FILE *f; + if (!f) f = fopen("c68k.log", "w"); + TRACE_CPU = CPU; + memcpy(state.D, CPU->D, 16*4); + state.PC = PC - 2 - CPU->BasePC; + state.SR = GET_SR; + if (f) q68_trace((Q68State *)&state, f, + CPU->CycleToDo - CCnt, CPU->CycleToDo); +} +# endif // TRACE_WITH_Q68 +#endif // !C68K_GEN + +// main exec function +////////////////////// + +s32 FASTCALL C68k_Exec(c68k_struc *cpu, s32 cycle) +{ +#ifndef C68K_GEN +#if 0 + register c68k_struc *CPU asm ("ebx"); + register pointer PC asm ("esi"); + register s32 CCnt asm ("edi"); +// register u32 Opcode asm ("edi"); +// c68k_struc *CPU; +// u32 PC; +// s32 CCnt; + u32 Opcode; +#else +// register c68k_struc *CPU asm ("r10"); +// register u32 PC asm ("r11"); +// register s32 CCnt asm ("r12"); +// register u32 Opcode asm ("r13"); + c68k_struc *CPU; + pointer PC; + s32 CCnt; + u32 Opcode; +#endif +#endif + +#ifndef C68K_GEN + +#ifndef C68K_NO_JUMP_TABLE +#ifdef C68K_CONST_JUMP_TABLE + #include "c68k_ini.inc" +#endif +#else + C68k_Initialised = 1; +#endif + + CPU = cpu; + PC = CPU->PC; + + if (CPU->Status & (C68K_RUNNING | C68K_DISABLE | C68K_FAULTED)) + { +#ifndef C68K_NO_JUMP_TABLE +#ifndef C68K_CONST_JUMP_TABLE + if (!C68k_Initialised) goto C68k_Init; +#endif +#endif + return (CPU->Status | 0x80000000); + } + + if (cycle <= 0) return -cycle; + + CPU->CycleToDo = CCnt = cycle; + +#ifndef C68K_DEBUG + CHECK_INT +#else + { + s32 line, vect; + + line = CPU->IRQLine; + + if ((line == 7) || (line > CPU->flag_I)) + { + PRE_IO + + /* get vector */ + CPU->IRQLine = 0; + vect = CPU->Interrupt_CallBack(line); + if (vect == C68K_INT_ACK_AUTOVECTOR) + vect = C68K_INTERRUPT_AUTOVECTOR_EX + (line & 7); + + /* adjust CCnt */ + CCnt -= c68k_exception_cycle_table[vect]; + + /* swap A7 and USP */ + if (!CPU->flag_S) + { + u32 tmpSP; + + tmpSP = CPU->USP; + CPU->USP = CPU->A[7]; + CPU->A[7] = tmpSP; + } + + /* push PC and SR */ + PUSH_32_F(PC - CPU->BasePC) + PUSH_16_F(GET_SR) + + /* adjust SR */ + CPU->flag_S = C68K_SR_S; + CPU->flag_I = line; + + /* fetch new PC */ + READ_LONG_F(vect * 4, PC) + SET_PC(PC) + + POST_IO + } + } +#endif + + if (CPU->Status & (C68K_HALTED | C68K_WAITING)) return CPU->CycleToDo; + + CPU->CycleSup = 0; + CPU->Status |= C68K_RUNNING; + +#ifndef C68K_DEBUG + NEXT +#else +#ifdef C68K_NO_JUMP_TABLE + NEXT +#else + Opcode = FETCH_WORD; + PC += 2; + goto *JumpTable[Opcode]; +#endif +#endif + +#ifdef C68K_NO_JUMP_TABLE +SwitchTable: + switch(Opcode) + { +#endif + #include "c68k_op0.inc" + #include "c68k_op1.inc" + #include "c68k_op2.inc" + #include "c68k_op3.inc" + #include "c68k_op4.inc" + #include "c68k_op5.inc" + #include "c68k_op6.inc" + #include "c68k_op7.inc" + #include "c68k_op8.inc" + #include "c68k_op9.inc" + #include "c68k_opA.inc" + #include "c68k_opB.inc" + #include "c68k_opC.inc" + #include "c68k_opD.inc" + #include "c68k_opE.inc" + #include "c68k_opF.inc" +#ifdef C68K_NO_JUMP_TABLE + } +#endif + +C68k_Exec_End: + CHECK_INT + if ((CCnt += CPU->CycleSup) > 0) + { + CPU->CycleSup = 0; + NEXT; + } + +C68k_Exec_Really_End: + CPU->Status &= ~C68K_RUNNING; + CPU->PC = PC; + + return (CPU->CycleToDo - CCnt); + +#ifndef C68K_CONST_JUMP_TABLE +#ifndef C68K_NO_JUMP_TABLE +C68k_Init: + { + u32 i, j; + + #include "c68k_ini.inc" + + C68k_Initialised = 1; + } + + return 0; +#endif +#endif +#else + return 0; +#endif +} + diff --git a/m68000/c68k/c68kmac.inc b/m68000/c68k/c68kmac.inc new file mode 100644 index 0000000..25767be --- /dev/null +++ b/m68000/c68k/c68kmac.inc @@ -0,0 +1,307 @@ +/* Copyright 2003-2004 Stephane Dallongeville + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +// internals core macros +///////////////////////// + +#define LSL(A, C) ((A) << (C)) +#define LSR(A, C) ((A) >> (C)) + +#define LSR_32(A, C) ((C) < 32 ? (A) >> (C) : 0) +#define LSL_32(A, C) ((C) < 32 ? (A) << (C) : 0) + +#define ROL_8(A, C) (LSL(A, C) | LSR(A, 8-(C))) +#define ROL_9(A, C) (LSL(A, C) | LSR(A, 9-(C))) +#define ROL_16(A, C) (LSL(A, C) | LSR(A, 16-(C))) +#define ROL_17(A, C) (LSL(A, C) | LSR(A, 17-(C))) +#define ROL_32(A, C) (LSL_32(A, C) | LSR_32(A, 32-(C))) +#define ROL_33(A, C) (LSL_32(A, C) | LSR_32(A, 33-(C))) + +#define ROR_8(A, C) (LSR(A, C) | LSL(A, 8-(C))) +#define ROR_9(A, C) (LSR(A, C) | LSL(A, 9-(C))) +#define ROR_16(A, C) (LSR(A, C) | LSL(A, 16-(C))) +#define ROR_17(A, C) (LSR(A, C) | LSL(A, 17-(C))) +#define ROR_32(A, C) (LSR_32(A, C) | LSL_32(A, 32-(C))) +#define ROR_33(A, C) (LSR_32(A, C) | LSL_32(A, 33-(C))) + + +#ifdef TRACE_WITH_Q68 +extern void TRACE(int,c68k_struc*,int,int); +#else +# define TRACE(a,b,c,d) /*nothing*/ +#endif +#ifndef C68K_NO_JUMP_TABLE +#define NEXT \ + PRE_IO \ + Opcode = FETCH_WORD; \ + PC += 2; \ + TRACE(PC, CPU, Opcode, CCnt); \ + goto *JumpTable[Opcode]; +#else +#define NEXT \ + PRE_IO \ + Opcode = FETCH_WORD; \ + PC += 2; \ + TRACE(PC, CPU, Opcode, CCnt); \ + goto SwitchTable; +#endif + +#define RET(A) \ + CCnt -= (A); \ + if (CCnt <= 0) goto C68k_Exec_End; \ + NEXT + +#define SET_PC(A) \ + CPU->BasePC = CPU->Fetch[((A) >> C68K_FETCH_SFT) & C68K_FETCH_MASK]; \ + CPU->BasePC -= (A) & 0xFF000000; \ + PC = (A) + CPU->BasePC; + +#define PRE_IO \ + CPU->CycleIO = CCnt; + +#define POST_IO \ + CCnt = CPU->CycleIO; + +#define READ_BYTE_F(A, D) \ + D = CPU->Read_Byte(A) & 0xFF; + +#define READ_WORD_F(A, D) \ + D = CPU->Read_Word(A) & 0xFFFF; + +#ifdef C68K_BIG_ENDIAN + #define READ_LONG_F(A, D) \ + D = CPU->Read_Word((A)) << 16; \ + D |= CPU->Read_Word((A) + 2) & 0xFFFF; + + #define READ_LONG_DEC_F(A, D) \ + D = CPU->Read_Word((A) + 2) & 0xFFFF; \ + D |= CPU->Read_Word((A)) << 16; +#else + #define READ_LONG_F(A, D) \ + D = CPU->Read_Word((A)) << 16; \ + D |= CPU->Read_Word((A) + 2) & 0xFFFF; + + #define READ_LONG_DEC_F(A, D) \ + D = CPU->Read_Word((A) + 2) & 0xFFFF; \ + D |= CPU->Read_Word((A)) << 16; +#endif + +#define READSX_BYTE_F(A, D) \ + D = (s32)(s8)CPU->Read_Byte(A); + +#define READSX_WORD_F(A, D) \ + D = (s32)(s16)CPU->Read_Word(A); + +#ifdef C68K_BIG_ENDIAN + #define READSX_LONG_F(A, D) \ + D = CPU->Read_Word((A)) << 16; \ + D |= CPU->Read_Word((A) + 2) & 0xFFFF; + + #define READSX_LONG_DEC_F(A, D) \ + D = CPU->Read_Word((A) + 2) & 0xFFFF; \ + D |= CPU->Read_Word((A)) << 16; +#else + #define READSX_LONG_F(A, D) \ + D = CPU->Read_Word((A)) << 16; \ + D |= CPU->Read_Word((A) + 2) & 0xFFFF; + + #define READSX_LONG_DEC_F(A, D) \ + D = CPU->Read_Word((A) + 2) & 0xFFFF; \ + D |= CPU->Read_Word((A)) << 16; +#endif + +#define WRITE_BYTE_F(A, D) \ + CPU->Write_Byte(A, D); + +#define WRITE_WORD_F(A, D) \ + CPU->Write_Word(A, D); + +#ifdef C68K_BIG_ENDIAN + #define WRITE_LONG_F(A, D) \ + CPU->Write_Word((A), (D) >> 16); \ + CPU->Write_Word((A) + 2, (D) & 0xFFFF); + + #define WRITE_LONG_DEC_F(A, D) \ + CPU->Write_Word((A) + 2, (D) & 0xFFFF); \ + CPU->Write_Word((A), (D) >> 16); +#else + #define WRITE_LONG_F(A, D) \ + CPU->Write_Word((A), (D) >> 16); \ + CPU->Write_Word((A) + 2, (D) & 0xFFFF); + + #define WRITE_LONG_DEC_F(A, D) \ + CPU->Write_Word((A) + 2, (D) & 0xFFFF); \ + CPU->Write_Word((A), (D) >> 16); +#endif + +#define PUSH_16_F(D) \ + CPU->Write_Word(CPU->A[7] -= 2, D); \ + +#define POP_16_F(D) \ + D = (u16)CPU->Read_Word(CPU->A[7]); \ + CPU->A[7] += 2; + +#ifdef C68K_BIG_ENDIAN + #define PUSH_32_F(D) \ + CPU->A[7] -= 4; \ + CPU->Write_Word(CPU->A[7] + 2, (D) & 0xFFFF); \ + CPU->Write_Word(CPU->A[7], (D) >> 16); + + #define POP_32_F(D) \ + D = CPU->Read_Word(CPU->A[7]) << 16; \ + D |= CPU->Read_Word(CPU->A[7] + 2) & 0xFFFF; \ + CPU->A[7] += 4; +#else + #define PUSH_32_F(D) \ + CPU->A[7] -= 4; \ + CPU->Write_Word(CPU->A[7] + 2, (D) & 0xFFFF); \ + CPU->Write_Word(CPU->A[7], (D) >> 16); + + #define POP_32_F(D) \ + D = CPU->Read_Word(CPU->A[7]) << 16; \ + D |= CPU->Read_Word(CPU->A[7] + 2) & 0xFFFF; \ + CPU->A[7] += 4; +#endif + +#define FETCH_BYTE \ +((*(u16*)PC) & 0xFF) + +#define FETCH_WORD \ +(*(u16*)PC) + + +#define FETCH_LONG \ +(*(u32*)PC) + +#define DECODE_EXT_WORD \ +{ \ + u32 ext; \ + \ + ext = (*(u16*)PC); \ + PC += 2; \ + \ + adr += (s32)((s8)(ext)); \ + if (ext & 0x0800) adr += (s32) CPU->D[ext >> 12]; \ + else adr += (s32)((s16)(CPU->D[ext >> 12])); \ +} + +#ifndef C68K_BIG_ENDIAN +#ifdef C68K_BYTE_SWAP_OPT + #undef FETCH_LONG + #define FETCH_LONG \ + ((((u32)(*(u16*)PC)) << 16) | ((u32)(*(u16*)(PC + 2)))) +// ((((u32)(*(u8*)(PC + 2))) | (((u32)(*(u8*)(PC + 3))) << 8) | (((u32)(*(u8*)PC)) << 16) | (((u32)(*(u8*)(PC + 1))) << 24))) +#else + #undef FETCH_BYTE + #define FETCH_BYTE \ + (*(u16*)PC) >> 8) + + #undef FETCH_WORD + #define FETCH_WORD \ + ((((u16)(*(u8*)PC)) << 8) | ((u16)(*(u8*)(PC + 1)))) +// ((((u16)(*(u8*)(PC + 1))) | (((u16)(*(u8*)PC)) << 8))) + + #undef FETCH_LONG + #define FETCH_LONG \ + ((((u32)(*(u8*)PC)) << 24) | (((u32)(*(u8*)(PC + 1))) << 16) | (((u32)(*(u8*)(PC + 2))) << 8) | ((u32)(*(u8*)(PC + 3)))) +// ((((u32)(*(u8*)(PC + 3))) | (((u32)(*(u8*)(PC + 2))) << 8) | (((u32)(*(u8*)(PC + 1))) << 16) | (((u32)(*(u8*)PC)) << 24))) + + #undef DECODE_EXT_WORD + #define DECODE_EXT_WORD \ + { \ + u32 ext; \ + \ + ext = (*(u16*)PC); \ + PC += 2; \ + \ + adr += (s32)((s8)(ext >> 8)); \ + if (ext & 0x0008) adr += (s32) CPU->D[(ext >> 4) & 0x000F]; \ + else adr += (s32)((s16)(CPU->D[(ext >> 4) & 0x000F])); \ + } +#endif +#endif + +#define GET_CCR \ + (((CPU->flag_C >> (C68K_SR_C_SFT - 0)) & 1) | \ + ((CPU->flag_V >> (C68K_SR_V_SFT - 1)) & 2) | \ + (((!CPU->flag_notZ) & 1) << 2) | \ + ((CPU->flag_N >> (C68K_SR_N_SFT - 3)) & 8) | \ + ((CPU->flag_X >> (C68K_SR_X_SFT - 4)) & 0x10)) + +#define GET_SR \ + ((CPU->flag_S << 0) | \ + (CPU->flag_I << 8) | \ + GET_CCR) + +#define SET_CCR(A) \ + CPU->flag_C = (A) << (C68K_SR_C_SFT - 0); \ + CPU->flag_V = (A) << (C68K_SR_V_SFT - 1); \ + CPU->flag_notZ = ~(A) & 4; \ + CPU->flag_N = (A) << (C68K_SR_N_SFT - 3); \ + CPU->flag_X = (A) << (C68K_SR_X_SFT - 4); + +#define SET_SR(A) \ + SET_CCR(A) \ + CPU->flag_I = ((A) >> 8) & 7; \ + CPU->flag_S = (A) & C68K_SR_S; + +#define CHECK_INT \ + { \ + s32 line, vect; \ + \ + line = CPU->IRQLine; \ + \ + if ((line == 7) || (line > CPU->flag_I)) \ + { \ + /* get vector */ \ + CPU->IRQLine = 0; \ + vect = CPU->Interrupt_CallBack(line); \ + if (vect == C68K_INT_ACK_AUTOVECTOR) \ + vect = C68K_INTERRUPT_AUTOVECTOR_EX + (line & 7); \ + \ + /* adjust CCnt */ \ + CCnt -= c68k_exception_cycle_table[vect]; \ + \ + /* swap A7 and USP */ \ + if (!CPU->flag_S) \ + { \ + u32 tmpSP; \ + \ + tmpSP = CPU->USP; \ + CPU->USP = CPU->A[7]; \ + CPU->A[7] = tmpSP; \ + } \ + \ + PRE_IO \ + \ + /* push PC and SR */ \ + PUSH_32_F(PC - CPU->BasePC) \ + PUSH_16_F(GET_SR) \ + \ + /* adjust SR */ \ + CPU->flag_S = C68K_SR_S; \ + CPU->flag_I = line; \ + \ + /* fetch new PC */ \ + READ_LONG_F(vect * 4, PC) \ + SET_PC(PC) \ + \ + POST_IO \ + } \ + } diff --git a/m68000/c68k/core.h b/m68000/c68k/core.h new file mode 100644 index 0000000..16fa04c --- /dev/null +++ b/m68000/c68k/core.h @@ -0,0 +1,327 @@ +/* Copyright 2005 Guillaume Duhamel + Copyright 2005-2006 Theo Berkau + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef CORE_H +#define CORE_H + +#include +#include + +#ifndef ALIGNED +#ifdef _MSC_VER +#define ALIGNED(x) __declspec(align(x)) +#else +#define ALIGNED(x) __attribute__((aligned(x))) +#endif +#endif + +#ifndef STDCALL +#ifdef _MSC_VER +#define STDCALL __stdcall +#else +#define STDCALL +#endif +#endif + +#ifndef FASTCALL +#ifdef __MINGW32__ +#define FASTCALL __attribute__((fastcall)) +#elif defined (__i386__) +#define FASTCALL __attribute__((regparm(3))) +#else +#define FASTCALL +#endif +#endif + +/* When building multiple arches on OS X you must use the compiler- + provided endian flags instead of the one provided by autoconf */ +#if defined(__BIG_ENDIAN__) || defined(__LITTLE_ENDIAN__) + #undef WORDS_BIGENDIAN + #ifdef __BIG_ENDIAN__ + #define WORDS_BIGENDIAN + #endif +#endif + + +#ifndef INLINE +#ifdef _MSC_VER +#define INLINE _inline +#else +#define INLINE inline +#endif +#endif + +#ifdef GEKKO +/* Wii have both stdint.h and "yabause" definitions of fixed +size types */ +#include +typedef unsigned long pointer; + +#else /* ! GEKKO */ + +#ifdef HAVE_STDINT_H + +#include +typedef uint8_t u8; +typedef int8_t s8; +typedef uint16_t u16; +typedef int16_t s16; +typedef uint32_t u32; +typedef int32_t s32; +typedef uint64_t u64; +typedef int64_t s64; +typedef uintptr_t pointer; + +#else // !HAVE_STDINT_H + +typedef unsigned char u8; +typedef unsigned short u16; + +typedef signed char s8; +typedef signed short s16; + +#if defined(__LP64__) +// Generic 64-bit +typedef unsigned int u32; +typedef unsigned long u64; +typedef unsigned long pointer; + +typedef signed int s32; +typedef signed long s64; + +#elif defined(_MSC_VER) +typedef unsigned long u32; +typedef unsigned __int64 u64; +typedef unsigned long long u64; +#ifdef _WIN64 +typedef __int64 pointer; +#else +typedef unsigned long pointer; +#endif + +typedef signed long s32; +typedef __int64 s64; +typedef signed long long s64; + +#else +// 32-bit Linux GCC/MINGW/etc. +typedef unsigned long u32; +typedef unsigned long long u64; +typedef unsigned long pointer; + +typedef signed long s32; +typedef signed long long s64; +#endif + +#endif // !HAVE_STDINT_H + +#endif // !GEKKO + +#if 0 +typedef struct { + unsigned int size; + unsigned int done; +} IOCheck_struct; + +static INLINE void ywrite(IOCheck_struct * check, void * ptr, size_t size, size_t nmemb, FILE * stream) { + check->done += (unsigned int)fwrite(ptr, size, nmemb, stream); + check->size += (unsigned int)nmemb; +} + +static INLINE void yread(IOCheck_struct * check, void * ptr, size_t size, size_t nmemb, FILE * stream) { + check->done += (unsigned int)fread(ptr, size, nmemb, stream); + check->size += (unsigned int)nmemb; +} + +static INLINE int StateWriteHeader(FILE *fp, const char *name, int version) { + IOCheck_struct check; + fprintf(fp, "%s", name); + check.done = 0; + check.size = 0; + ywrite(&check, (void *)&version, sizeof(version), 1, fp); + ywrite(&check, (void *)&version, sizeof(version), 1, fp); // place holder for size + return (check.done == check.size) ? ftell(fp) : -1; +} + +static INLINE int StateFinishHeader(FILE *fp, int offset) { + IOCheck_struct check; + int size = 0; + size = ftell(fp) - offset; + fseek(fp, offset - 4, SEEK_SET); + check.done = 0; + check.size = 0; + ywrite(&check, (void *)&size, sizeof(size), 1, fp); // write true size + fseek(fp, 0, SEEK_END); + return (check.done == check.size) ? (size + 12) : -1; +} + +static INLINE int StateCheckRetrieveHeader(FILE *fp, const char *name, int *version, int *size) { + char id[4]; + size_t ret; + + if ((ret = fread((void *)id, 1, 4, fp)) != 4) + return -1; + + if (strncmp(name, id, 4) != 0) + return -2; + + if ((ret = fread((void *)version, 4, 1, fp)) != 1) + return -1; + + if (fread((void *)size, 4, 1, fp) != 1) + return -1; + + return 0; +} +#endif +////////////////////////////////////////////////////////////////////////////// + +// Terrible, but I'm not sure how to do the equivalent in inline +#ifdef HAVE_C99_VARIADIC_MACROS +#define AddString(s, ...) \ + { \ + sprintf(s, __VA_ARGS__); \ + s += strlen(s); \ + } +#else +#define AddString(s, r...) \ + { \ + sprintf(s, ## r); \ + s += strlen(s); \ + } +#endif + +////////////////////////////////////////////////////////////////////////////// + +#ifdef HAVE_LIBMINI18N +#include "mini18n.h" +#else +#ifndef _ +#define _(a) (a) +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// + +/* Minimum/maximum values */ + +#undef MIN +#undef MAX +#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MAX(a,b) ((a) > (b) ? (a) : (b)) + +////////////////////////////////////////////////////////////////////////////// + +/* + * BSWAP16(x) swaps two bytes in a 16-bit value (AABB -> BBAA) or adjacent + * bytes in a 32-bit value (AABBCCDD -> BBAADDCC). + * + * BSWAP32(x) reverses four bytes in a 32-bit value (AABBCCDD -> DDCCBBAA). + * + * WSWAP32(x) swaps two 16-bit words in a 32-bit value (AABBCCDD -> CCDDAABB). + * + * Any of these can be left undefined if there is no platform-specific + * optimization for them; the defaults below will then be used instead. + */ + +#ifdef PSP +# define BSWAP16(x) ((typeof(x)) __builtin_allegrex_wsbh((x))) +# define BSWAP16L(x) BSWAP16(x) +# define BSWAP32(x) ((typeof(x)) __builtin_allegrex_wsbw((x))) +# define WSWAP32(x) ((typeof(x)) __builtin_allegrex_rotr((x), 16)) +#endif + +#ifdef __GNUC__ +#ifdef HAVE_BUILTIN_BSWAP16 +# define BSWAP16(x) ((__builtin_bswap16((x) >> 16) << 16) | __builtin_bswap16((x))) +# define BSWAP16L(x) (__builtin_bswap16((x))) +#endif +# define BSWAP32(x) (__builtin_bswap32((x))) +#endif + +#ifdef _MSC_VER +# define BSWAP16(x) ((_byteswap_ushort((x) >> 16) << 16) | _byteswap_ushort((x))) +# define BSWAP16L(x) (_byteswap_ushort((x))) +# define BSWAP32(x) (_byteswap_ulong((x))) +# define WSWAP32(x) (_lrotr((x), 16)) +#endif + +/* Defaults: */ + +#ifndef BSWAP16 +# define BSWAP16(x) (((u32)(x)>>8 & 0x00FF00FF) | ((u32)(x) & 0x00FF00FF) << 8) +#endif +#ifndef BSWAP16L +# define BSWAP16L(x) (((u16)(x)>>8 & 0xFF) | ((u16)(x) & 0xFF) << 8) +#endif +#ifndef BSWAP32 +# define BSWAP32(x) ((u32)(x)>>24 | ((u32)(x)>>8 & 0xFF00) | ((u32)(x) & 0xFF00)<<8 | (u32)(x)<<24) +#endif +#ifndef WSWAP32 +# define WSWAP32(x) ((u32)(x)>>16 | (u32)(x)<<16) +#endif + +////////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUC__ + +#ifndef UNUSED +#define UNUSED __attribute ((unused)) +#endif + +#ifdef DEBUG +#define USED_IF_DEBUG +#else +#define USED_IF_DEBUG __attribute ((unused)) +#endif + +#ifdef SMPC_DEBUG +#define USED_IF_SMPC_DEBUG +#else +#define USED_IF_SMPC_DEBUG __attribute ((unused)) +#endif + +/* LIKELY(x) indicates that x is likely to be true (nonzero); + * UNLIKELY(x) indicates that x is likely to be false (zero). + * Use like: "if (UNLIKELY(a < b)) {...}" */ +#define LIKELY(x) (__builtin_expect(!!(x), 1)) +#define UNLIKELY(x) (__builtin_expect(!!(x), 0)) + +#else + +#define UNUSED +#define USED_IF_DEBUG +#define USED_IF_SMPC_DEBUG +#define LIKELY(x) (x) +#define UNLIKELY(x) (x) + +#endif + +#ifdef USE_16BPP +typedef u16 pixel_t; +#else +typedef u32 pixel_t; +#endif + +#ifdef _MSC_VER +#define snprintf sprintf_s +#endif + +#endif diff --git a/m68000/c68k/gen68k.c b/m68000/c68k/gen68k.c new file mode 100644 index 0000000..cd12966 --- /dev/null +++ b/m68000/c68k/gen68k.c @@ -0,0 +1,3820 @@ +/* Copyright 2003-2004 Stephane Dallongeville + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/********************************************************************************* + * GEN68K.C : + * + * C68K generator source file + * + ********************************************************************************/ + +#include +#ifdef __WIN32__ +#include +#endif + +#include "core.h" +#include "c68k.h" +#include "gen68k.h" + +#ifdef C68K_GEN + +#include "gen68k.inc" + +// to do : +// need accurate cycles calculations in MUL and DIV instruction +// some bugs to fix + +// opcode generation function +////////////////////////////// + +static void GenLogicI(char op) +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + if (current_ea != EA_DREG) current_cycle += 4; + switch (current_size) + { + case SIZE_BYTE: + wf_op("\tsrc = FETCH_BYTE;\n"); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_WORD: + wf_op("\tsrc = FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_LONG: + wf_op("\tsrc = FETCH_LONG;\n"); + wf_op("\tPC += 4;\n"); + current_cycle += 8; + break; + } + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // op + wf_op("\tres %c= src;\n", op); + // flag calculation + set_logic_flag(); + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenLogicICCR(char op) +{ + // generate jump table & opcode declaration + start_all(GEN_RES); + + wf_op("\tres = FETCH_BYTE & C68K_CCR_MASK;\n"); + wf_op("\tPC += 2;\n"); + wf_op("\tres %c= GET_CCR;\n", op); + wf_op("\tSET_CCR(res)\n"); + + terminate_op(20); +} + +static void GenLogicISR(char op) +{ + // generate jump table & opcode declaration + start_all(GEN_RES); + + wf_op("\tif (CPU->flag_S)\n"); + wf_op("\t{\n"); + wf_op("\t\tres = FETCH_WORD & C68K_SR_MASK;\n"); + wf_op("\t\tPC += 2;\n"); + wf_op("\t\tres %c= GET_SR;\n", op); + wf_op("\t\tSET_SR(res)\n"); + if (op != '|') + { + wf_op("\t\tif (!CPU->flag_S)\n"); + wf_op("\t\t{\n"); + wf_op("\t\t\tres = CPU->A[7];\n"); + wf_op("\t\t\tCPU->A[7] = CPU->USP;\n"); + wf_op("\t\t\tCPU->USP = res;\n"); + wf_op("\t\t}\n"); + } + wf_op("\t}\n"); + wf_op("\telse\n"); + wf_op("\t{\n"); + gen_privilege_exception("\t\t"); + wf_op("\t}\n"); + + // check for interrupt + fterminate_op(20); +} + +static void GenORI() +{ + GenLogicI('|'); +} + +static void GenORICCR() +{ + GenLogicICCR('|'); +} + +static void GenORISR() +{ + GenLogicISR('|'); +} + +static void GenANDI() +{ + GenLogicI('&'); +} + +static void GenANDICCR() +{ + GenLogicICCR('&'); +} + +static void GenANDISR() +{ + GenLogicISR('&'); +} + +static void GenEORI() +{ + GenLogicI('^'); +} + +static void GenEORICCR() +{ + GenLogicICCR('^'); +} + +static void GenEORISR() +{ + GenLogicISR('^'); +} + +static void GenArithI(char op) +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC | GEN_DST); + else + start_all(GEN_ALL); + + if ((op != ' ') && (current_ea != EA_DREG)) current_cycle += 4; + switch (current_size) + { + case SIZE_BYTE: + wf_op("\tsrc = FETCH_BYTE;\n"); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_WORD: + wf_op("\tsrc = FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_LONG: + wf_op("\tsrc = FETCH_LONG;\n"); + wf_op("\tPC += 4;\n"); + if (op == ' ') + { + if (current_ea == EA_DREG) current_cycle += 6; + else current_cycle += 4; + } else current_cycle += 8; + break; + } + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_dst(current_ea, current_op->reg_sft); + if (op == ' ') + { + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + } + else + { + // op + wf_op("\tres = dst %c src;\n", op); + // flag calculation + if (op == '+') set_add_flag(); + else set_sub_flag(); + // write + _ea_write(current_ea, current_op->reg_sft); + } + + terminate_op(8); +} + +static void GenSUBI() +{ + GenArithI('-'); +} + +static void GenADDI() +{ + GenArithI('+'); +} + +static void GenCMPI() +{ + GenArithI(' '); +} + +static void GenBitsOp(char op, u32 dyn) +{ + // generate jump table & opcode declaration + if (dyn) current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + if (current_ea == EA_DREG) + { + set_current_size(SIZE_LONG); + if ((op == 'c') || (op == ' ')) current_cycle += 2; + } + else set_current_size(SIZE_BYTE); + + // get shift value in src + if (dyn) + { + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_src(current_ea2, current_op->reg2_sft); + } + else + { + wf_op("\tsrc = FETCH_BYTE;\n"); + wf_op("\tPC += 2;\n"); + current_cycle += 4; + } + wf_op("\tsrc = 1 << (src & %d);\n", current_sft_mask); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // flag calculation + wf_op("\tCPU->flag_notZ = res & src;\n"); + // op + switch(op) + { + case 'c': + wf_op("\tres &= ~src;\n"); + break; + + case 'g': + wf_op("\tres ^= src;\n"); + break; + + case 's': + wf_op("\tres |= src;\n"); + break; + } + // write + if (op != ' ') + { + _ea_write(current_ea, current_op->reg_sft); + current_cycle += 4; + } + + terminate_op(4); +} + +static void GenBTSTn() +{ + GenBitsOp(' ', 0); +} + +static void GenBCHGn() +{ + GenBitsOp('g', 0); +} + +static void GenBCLRn() +{ + GenBitsOp('c', 0); +} + +static void GenBSETn() +{ + GenBitsOp('s', 0); +} + +static void GenBTST() +{ + GenBitsOp(' ', 1); +} + +static void GenBCHG() +{ + GenBitsOp('g', 1); +} + +static void GenBCLR() +{ + GenBitsOp('c', 1); +} + +static void GenBSET() +{ + GenBitsOp('s', 1); +} + +static void GenMOVEPWaD() +{ + // generate jump table & opcode declaration + current_ea = EA_D16A; + current_ea2 = EA_DREG; + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + set_current_size(SIZE_BYTE); + _ea_calc(current_ea, current_op->reg_sft); + mem_op("\tREAD_BYTE_F(adr + 0, res)\n"); + mem_op("\tREAD_BYTE_F(adr + 2, src)\n"); + // write + wf_op("\t*(u16*)(&CPU->D[(Opcode >> %d) & 7]) = (res << 8) | src;\n", current_op->reg2_sft); + + terminate_op(16); +} + +static void GenMOVEPLaD() +{ + // generate jump table & opcode declaration + current_ea = EA_D16A; + current_ea2 = EA_DREG; + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + set_current_size(SIZE_BYTE); + _ea_calc(EA_D16A, current_op->reg_sft); + mem_op("\tREAD_BYTE_F(adr, res)\n"); + wf_op("\tres <<= 24;\n"); + wf_op("\tadr += 2;\n"); + mem_op("\tREAD_BYTE_F(adr, src)\n"); + wf_op("\tres |= src << 16;\n"); + wf_op("\tadr += 2;\n"); + mem_op("\tREAD_BYTE_F(adr, src)\n"); + wf_op("\tres |= src << 8;\n"); + wf_op("\tadr += 2;\n"); + mem_op("\tREAD_BYTE_F(adr, src)\n"); + // write + wf_op("\tCPU->D[(Opcode >> %d) & 7] = res | src;\n", current_op->reg2_sft); + + terminate_op(24); +} + +static void GenMOVEPWDa() +{ + // generate jump table & opcode declaration + current_ea = EA_D16A; + current_ea2 = EA_DREG; + start_all(GEN_ADR | GEN_RES); + + // read + set_current_size(SIZE_LONG); + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read(current_ea2, current_op->reg2_sft); + // write + set_current_size(SIZE_BYTE); + _ea_calc(current_ea, current_op->reg_sft); + mem_op("\tWRITE_BYTE_F(adr + 0, res >> 8)\n"); + mem_op("\tWRITE_BYTE_F(adr + 2, res >> 0)\n"); + + terminate_op(16); +} + +static void GenMOVEPLDa() +{ + // generate jump table & opcode declaration + current_ea = EA_D16A; + current_ea2 = EA_DREG; + start_all(GEN_ADR | GEN_RES); + + // read + set_current_size(SIZE_LONG); + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read(current_ea2, current_op->reg2_sft); + // write + set_current_size(SIZE_BYTE); + _ea_calc(current_ea, current_op->reg_sft); + mem_op("\tWRITE_BYTE_F(adr, res >> 24)\n"); + wf_op("\tadr += 2;\n"); + mem_op("\tWRITE_BYTE_F(adr, res >> 16)\n"); + wf_op("\tadr += 2;\n"); + mem_op("\tWRITE_BYTE_F(adr, res >> 8)\n"); + wf_op("\tadr += 2;\n"); + mem_op("\tWRITE_BYTE_F(adr, res >> 0)\n"); + + terminate_op(24); +} + +static void GenMOVE(u32 size) +{ + set_current_size(size); + + // generate jump table & opcode declaration + if (((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) && + ((current_ea2 == EA_AREG) || (current_ea2 == EA_DREG) || (current_ea2 == EA_IMM))) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // flag calculation + set_logic_flag(); + if ((current_ea2 == EA_ADEC) || (current_ea2 == EA_ADEC7)) current_cycle -= 2; + // write + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(4); +} + +static void GenMOVEB() +{ + GenMOVE(SIZE_BYTE); +} + +static void GenMOVEW() +{ + GenMOVE(SIZE_WORD); +} + +static void GenMOVEL() +{ + GenMOVE(SIZE_LONG); +} + +static void GenMOVEA(u32 size) +{ + set_current_size(size); + + // generate jump table & opcode declaration + current_ea2 = EA_AREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_sx(current_ea, current_op->reg_sft); + // write (dst = Ax) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(4); +} + +static void GenMOVEAW() +{ + GenMOVEA(SIZE_WORD); +} + +static void GenMOVEAL() +{ + GenMOVEA(SIZE_LONG); +} + +static void GenMOVEQ() +{ + u32 base = get_current_opcode_base(); + + // generate jump table + current_ea = EA_DREG; + gen_opjumptable_ext(base, 0x00, 0xFF, 1, base); + + // generate label & declarations + start_op(base, GEN_RES); + + // read + set_current_size(SIZE_BYTE); + wf_op("\tres = (s32)(s8)Opcode;\n"); + // fast flag calculation for moveQ + wf_op("\tCPU->flag_C = CPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_N = CPU->flag_notZ = res;\n"); + // write + set_current_size(SIZE_LONG); + _ea_calc(current_ea, current_op->reg_sft); + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(4); +} + +static void GenSingle(char op) +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) { + if (op == 'c') + start_all(GEN_RES); + else + start_all(GEN_RES | GEN_SRC); + } else { + if (op == 'c') + start_all(GEN_ADR | GEN_RES); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + } + + if (current_size == SIZE_LONG) current_cycle = 6; + else current_cycle= 4; + if (is_ea_memory(current_ea)) current_cycle *= 2; + + // read + _ea_calc(current_ea, current_op->reg_sft); + if (op != 'c') _ea_read_src(current_ea, current_op->reg_sft); + // op + switch (op) + { + case 'x': // negx + wf_op("\tres = -src - ((CPU->flag_X >> 8) & 1);\n"); + break; + + case 'g': // neg + wf_op("\tres = -src;\n"); + break; + + case 'n': // not + wf_op("\tres = ~src;\n"); + break; + + case 'c': // clr + wf_op("\tres = 0;\n"); + break; + } + // flag calculation + switch (op) + { + case 'x': // negx + set_negx_flag(); + break; + + case 'g': // neg + set_neg_flag(); + break; + + case 'n': // not + set_logicl_flag(); + break; + + case 'c': // clr + wf_op("\tCPU->flag_N = CPU->flag_notZ = CPU->flag_V = CPU->flag_C = 0;\n"); + break; + } + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(0); +} + +static void GenCLR() +{ + GenSingle('c'); +} + +static void GenNEGX() +{ + GenSingle('x'); +} + +static void GenNEG() +{ + GenSingle('g'); +} + +static void GenNOT() +{ + GenSingle('n'); +} + +static void GenMOVESRa() +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + // read + wf_op("\tres = GET_SR;\n"); + // write + set_current_size(SIZE_WORD); + if (is_ea_memory(current_ea)) current_cycle += 2; + _ea_calc(current_ea, current_op->reg_sft); + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenMOVEaSR() +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + wf_op("\tif (CPU->flag_S)\n"); + wf_op("\t{\n"); + // read + set_current_size(SIZE_WORD); + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + wf_op("\t\tSET_SR(res)\n"); + wf_op("\t\tif (!CPU->flag_S)\n"); + wf_op("\t\t{\n"); + wf_op("\t\t\tres = CPU->A[7];\n"); + wf_op("\t\t\tCPU->A[7] = CPU->USP;\n"); + wf_op("\t\t\tCPU->USP = res;\n"); + wf_op("\t\t}\n"); + wf_op("\t}\n"); + wf_op("\telse\n"); + wf_op("\t{\n"); + gen_privilege_exception("\t\t"); + wf_op("\t}\n"); + + // force terminaison to check for interrupt + fterminate_op(12); +} + +static void GenMOVEaCCR() +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + // read + set_current_size(SIZE_WORD); + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // write + wf_op("\tSET_CCR(res)\n"); + + terminate_op(12); +} + +static void GenMOVEAUSP() +{ + current_ea = EA_AREG; + + // generate jump table & opcode declaration + start_all(GEN_RES); + + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + gen_privilege_exception("\t\t"); + quick_terminate_op(4); + wf_op("\t}\n"); + + // read + set_current_size(SIZE_LONG); + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // write + wf_op("\tCPU->USP = res;\n"); + + terminate_op(4); +} + +static void GenMOVEUSPA() +{ + current_ea = EA_AREG; + + // generate jump table & opcode declaration + start_all(GEN_RES); + + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + gen_privilege_exception("\t\t"); + quick_terminate_op(4); + wf_op("\t}\n"); + + // read + wf_op("\tres = CPU->USP;\n"); + // write + set_current_size(SIZE_LONG); + _ea_calc(current_ea, current_op->reg_sft); + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(4); +} + +static void GenPEA() +{ + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(0); + else + start_all(GEN_ADR); + + _ea_calc_free(current_ea, current_op->reg_sft); + mem_op("\tPUSH_32_F(adr)\n"); + + terminate_op(lea_pea_cycle_table[current_ea] + 12); +} + +static void GenSWAP() +{ + current_ea = EA_DREG; + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + start_all(GEN_RES); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // op + wf_op("\tres = (res >> 16) | (res << 16);\n"); + // flag calculation + set_logic_flag(); + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(4); +} + +static void GenMOVEMaR() +{ + // generate jump table & opcode declaration + start_all(GEN_ALL); + + // get register mask + wf_op("\tres = FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + // get adr + if (current_ea == EA_AINC) wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", current_op->reg_sft); + else if (current_ea == EA_AINC7) wf_op("\tadr = CPU->A[7];\n"); + else _ea_calc(current_ea, current_op->reg_sft); + wf_op("\tsrc = (pointer)(&CPU->D[0]);\n"); + + wf_op("\tdst = adr;\n"); + do_pre_io(); + + wf_op("\tdo\n"); + wf_op("\t{\n"); + wf_op("\t\tif (res & 1)\n"); + wf_op("\t\t{\n"); + + if (current_size == SIZE_WORD) + { + wf_op("\t\t\tREADSX_WORD_F(adr, *(s32*)src)\n"); + wf_op("\t\t\tadr += 2;\n"); + } + else + { + wf_op("\t\t\tREAD_LONG_F(adr, *(u32*)src)\n"); + wf_op("\t\t\tadr += 4;\n"); + } + wf_op("\t\t}\n"); + wf_op("\t\tsrc += 4;\n"); + wf_op("\t} while (res >>= 1);\n"); + + if (current_ea == EA_AINC) wf_op("\tCPU->A[(Opcode >> %d) & 7] = adr;\n", current_op->reg_sft); + else if (current_ea == EA_AINC7) wf_op("\tCPU->A[7] = adr;\n"); + adds_CCnt("(adr - dst) * 2"); + + terminate_op(movem_cycle_table[current_ea] + 12); +} + +static void GenMOVEMRa() +{ + // generate jump table & opcode declaration + start_all(GEN_ALL); + + // get register mask + wf_op("\tres = FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + // get adr + if (current_ea == EA_ADEC) wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", current_op->reg_sft); + else if (current_ea == EA_ADEC7) wf_op("\tadr = CPU->A[7];\n"); + else _ea_calc(current_ea, current_op->reg_sft); + if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) wf_op("\tsrc = (pointer)(&CPU->A[7]);\n"); + else wf_op("\tsrc = (pointer)(&CPU->D[0]);\n"); + + wf_op("\tdst = adr;\n"); + do_pre_io(); + + wf_op("\tdo\n"); + wf_op("\t{\n"); + wf_op("\t\tif (res & 1)\n"); + wf_op("\t\t{\n"); + + if (current_size == SIZE_WORD) + { + if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) wf_op("\t\t\tadr -= 2;\n"); + wf_op("\t\t\tWRITE_WORD_F(adr, *(u16*)src)\n"); + if (!((current_ea == EA_ADEC) || (current_ea == EA_ADEC7))) wf_op("\t\t\tadr += 2;\n"); + } + else + { + if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) + { + wf_op("\t\t\tadr -= 4;\n"); + wf_op("\t\t\tWRITE_LONG_DEC_F(adr, *(u32*)src)\n"); + } + else + { + wf_op("\t\t\tWRITE_LONG_F(adr, *(u32*)src)\n"); + wf_op("\t\t\tadr += 4;\n"); + } + } + wf_op("\t\t}\n"); + if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) wf_op("\t\tsrc -= 4;\n"); + else wf_op("\t\tsrc += 4;\n"); + wf_op("\t} while (res >>= 1);\n"); + + if (current_ea == EA_ADEC) wf_op("\tCPU->A[(Opcode >> %d) & 7] = adr;\n", current_op->reg_sft); + else if (current_ea == EA_ADEC7) wf_op("\tCPU->A[7] = adr;\n"); + if ((current_ea == EA_ADEC) || (current_ea == EA_ADEC7)) adds_CCnt("(dst - adr) * 2"); + else adds_CCnt("(adr - dst) * 2"); + + terminate_op(movem_cycle_table[current_ea] + 8); +} + +static void GenEXT() +{ + current_ea = EA_DREG; + // generate jump table & opcode declaration + start_all(GEN_RES); + + // read + set_current_size(current_size - 1); + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_sx(current_ea, current_op->reg_sft); + // flag calculation + set_logic_flag(); + // write + set_current_size(current_size + 1); + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(4); +} + +static void GenTST() +{ + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // flag calculation + set_logic_flag(); + + terminate_op(4); +} + +static void GenTAS() +{ + set_current_size(SIZE_BYTE); + + if (is_ea_memory(current_ea)) current_cycle += 6; + + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // flag calculation + set_logic_flag(); +#ifndef C68K_TAS_CAN_SET_MEMORY + if (current_ea < EA_AIND) + { +#endif + // flag calculation + wf_op("\tres |= 0x80;\n"); + // write + _ea_write(current_ea, current_op->reg_sft); +#ifndef C68K_TAS_CAN_SET_MEMORY + } +#endif + + terminate_op(4); +} + +static void GenTRAP() +{ + u32 base; + + base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable_ext(base, (0 << 0), (15 << 0), (1 << 0), base); + + // generate label & declarations + start_op(base, GEN_RES); + + gen_exception("\t", "C68K_TRAP_BASE_EX + (Opcode & 0xF)"); + + terminate_op(4); +} + +static void GenTRAPV() +{ + // generate label & declarations + start_all(GEN_RES); + + wf_op("\tif %s\n", get_cond_as_cond(COND_VS, 0)); + wf_op("\t{\n"); + gen_exception("\t\t", "C68K_TRAPV_EX"); + wf_op("\t}\n"); + + terminate_op(4); +} + +static void GenLINK() +{ + current_ea = EA_AREG; + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + start_all(GEN_RES); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // push + mem_op("\tPUSH_32_F(res)\n"); + wf_op("\tres = CPU->A[7];\n"); + // write + _ea_write(current_ea, current_op->reg_sft); + // update SP + wf_op("\tCPU->A[7] += (s32)(s16)FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + + terminate_op(16); +} + +static void GenLINKA7() +{ + current_ea = EA_AREG; + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + start_all(0); + + // push A7 + wf_op("\tCPU->A[7] -= 4;\n"); + mem_op("\tWRITE_LONG_DEC_F(CPU->A[7], CPU->A[7])\n"); + // update A7 + wf_op("\tCPU->A[7] += (s32)(s16)FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + + terminate_op(16); +} + +static void GenULNK() +{ + current_ea = EA_AREG; + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + start_all(GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // pop + wf_op("\tCPU->A[7] = src + 4;\n"); + mem_op("\tREAD_LONG_F(src, res)\n"); + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(12); +} + +static void GenULNKA7() +{ + current_ea = EA_AREG; + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + start_all(0); + + mem_op("\tREAD_LONG_F(CPU->A[7], CPU->A[7])\n"); + + terminate_op(12); +} + +static void GenRESET() +{ + // generate jump table & opcode declaration + start_all(GEN_RES); + + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + gen_privilege_exception("\t\t"); + quick_terminate_op(4); + wf_op("\t}\n"); + + // Reset callback function + mem_op("\tCPU->Reset_CallBack();\n"); + + terminate_op(132); +} + +static void GenLEA() +{ + current_ea2 = EA_AREG; + set_current_size(SIZE_LONG); + // generate jump table & opcode declaration + start_all(GEN_ADR | GEN_RES); + + _ea_calc_free(current_ea, current_op->reg_sft); + wf_op("\tres = adr;\n"); + current_cycle = lea_pea_cycle_table[current_ea]; + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(4); +} + +static void GenNOP() +{ + start_all(0); + terminate_op(4); +} + +static void GenILLEGAL() +{ + start_all(GEN_RES); + + gen_exception("\t\t", "C68K_ILLEGAL_INSTRUCTION_EX"); + + terminate_op(4); +} + +static void GenCHK() +{ + current_ea2 = EA_DREG; + set_current_size(SIZE_WORD); + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read Src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read Dx + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read(current_ea2, current_op->reg2_sft); + + wf_op("\tif (((s32)res < 0) || (res > src))\n"); + wf_op("\t{\n"); + wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + gen_exception("\t\t", "C68K_CHK_EX"); + wf_op("\t}\n"); + + terminate_op(10); +} + +static void GenSTOP() +{ + // generate jump table & opcode declaration + start_all(GEN_RES); + + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + wf_op("\t\tPC += 2;\n"); + gen_privilege_exception("\t\t"); + quick_terminate_op(4); + wf_op("\t}\n"); + + // read & set SR + wf_op("\tres = FETCH_WORD & C68K_SR_MASK;\n"); + wf_op("\tPC += 2;\n"); + wf_op("\tSET_SR(res)\n"); + + // if S flag not set --> we swap stack pointer + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + wf_op("\t\tres = CPU->A[7];\n"); + wf_op("\t\tCPU->A[7] = CPU->USP;\n"); + wf_op("\t\tCPU->USP = res;\n"); + wf_op("\t}\n"); + + wf_op("\tCPU->Status |= C68K_HALTED;\n"); + wf_op("\tCCnt = 0;\n"); + + // force end execution + fterminate_op(4); +} + +static void GenRTE() +{ + start_all(GEN_RES); + + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + gen_privilege_exception("\t\t"); + quick_terminate_op(4); + wf_op("\t}\n"); + + // restore SR and PC + mem_op("\tPOP_16_F(res)\n"); + wf_op("\tSET_SR(res)\n"); + mem_op("\tPOP_32_F(res)\n"); + wf_op("\tSET_PC(res)\n"); + + // if S flag not set --> we swap stack pointer + wf_op("\tif (!CPU->flag_S)\n"); + wf_op("\t{\n"); + wf_op("\t\tres = CPU->A[7];\n"); + wf_op("\t\tCPU->A[7] = CPU->USP;\n"); + wf_op("\t\tCPU->USP = res;\n"); + wf_op("\t}\n"); + + // check for interrupt + fterminate_op(20); +} + +static void GenRTS() +{ + start_all(GEN_RES); + + mem_op("\tPOP_32_F(res)\n"); + wf_op("\tSET_PC(res)\n"); + + terminate_op(16); +} + +static void GenRTR() +{ + start_all(GEN_RES); + + mem_op("\tPOP_16_F(res)\n"); + wf_op("\tSET_CCR(res)\n"); + mem_op("\tPOP_32_F(res)\n"); + wf_op("\tSET_PC(res)\n"); + + terminate_op(20); +} + +static void GenJSR() +{ + start_all(GEN_ADR); + + // get adr + _ea_calc_free(current_ea, current_op->reg_sft); + mem_op("\tPUSH_32_F(PC - CPU->BasePC)\n"); + wf_op("\tSET_PC(adr)\n"); + + terminate_op(jmp_jsr_cycle_table[current_ea] + 12); +} + +static void GenJMP() +{ + start_all(GEN_ADR); + + // get adr + _ea_calc_free(current_ea, current_op->reg_sft); + wf_op("\tSET_PC(adr)\n"); + + terminate_op(jmp_jsr_cycle_table[current_ea] + 4); +} + +static void GenSTCC() +{ + u32 base, cond; + + base = get_current_opcode_base(); + + for(cond = 0; cond < 0x10; cond++) + { + // generate jump table + gen_opjumptable(base + (cond << 8)); + // generate label & declarations + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_op(base + (cond << 8), GEN_RES); + else + start_op(base + (cond << 8), GEN_ADR | GEN_RES); + + set_current_size(SIZE_BYTE); + + if (is_ea_memory(current_ea)) current_cycle += 4; + + // op + _ea_calc(current_ea, current_op->reg_sft); + if ((cond != COND_TR) && (cond != COND_FA)) + { + wf_op("\tif %s\n", get_cond_as_cond(cond, 0)); + wf_op("\t{\n"); + } + if (cond != COND_FA) + { + wf_op("\tres = 0xFF;\n"); + // write + _ea_write(current_ea, current_op->reg_sft); + if (!is_ea_memory(current_ea)) quick_terminate_op(6); + else quick_terminate_op(4); + } + if ((cond != COND_TR) && (cond != COND_FA)) + { + wf_op("\t}\n"); + } + if (cond != COND_TR) + { + wf_op("\tres = 0;\n"); + // write + _ea_write(current_ea, current_op->reg_sft); + quick_terminate_op(4); + } + + wf_op("}\n"); + } +} + +static void GenDBCC() +{ + u32 base, cond; + + base = get_current_opcode_base(); + + current_ea = EA_DREG; + set_current_size(SIZE_WORD); + + for(cond = 0; cond < 0x10; cond++) + { + // generate jump table + gen_opjumptable(base + (cond << 8)); + // generate label & declarations + start_op(base + (cond << 8), cond==COND_TR ? 0 : GEN_RES); + + if (cond != COND_TR) + { + if (cond != COND_FA) + { + wf_op("\tif %s\n", get_cond_as_cond(cond, 1)); + wf_op("\t{\n"); + } + + // read Dx + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // dec Dx + wf_op("\tres--;\n"); + // write Dx + _ea_write(current_ea, current_op->reg_sft); + wf_op("\tif ((s32)res != -1)\n"); + wf_op("\t{\n"); + wf_op("\t\tPC += (s32)(s16)FETCH_WORD;\n"); + // unbase PC + wf_op("\t\tPC -= CPU->BasePC;\n"); + // rebase PC + wf_op("\t\tSET_PC(PC);\n"); + quick_terminate_op(10); + wf_op("\t}\n"); + + if (cond != COND_FA) + { + wf_op("\t}\n"); + wf_op("\telse\n"); + wf_op("\t{\n"); + wf_op("\t\tPC += 2;\n"); + quick_terminate_op(12); + wf_op("\t}\n"); + } + } + + wf_op("\tPC += 2;\n"); + + if (cond == COND_TR) terminate_op(12); + else terminate_op(14); + } +} + +static void GenBCC() +{ + u32 base, cond; + + base = get_current_opcode_base(); + + for(cond = 2; cond < 0x10; cond++) + { + // generate jump table + gen_opjumptable_ext(base + (cond << 8), 0x01, 0xFF, 1, base + (cond << 8) + 0x01); + // generate label & declarations + start_op(base + (cond << 8) + 0x01, 0); + + // op + wf_op("\tif %s\n", get_cond_as_cond(cond, 0)); + wf_op("\t{\n"); + wf_op("\t\tPC += (s32)(s8)Opcode;\n"); // no rebase needed for 8 bits deplacement + add_CCnt(2); + wf_op("\t}\n"); + + terminate_op(8); + } +} + +static void GenBCC16() +{ + u32 base, cond; + + base = get_current_opcode_base(); + + for(cond = 2; cond < 0x10; cond++) + { + // generate jump table + gen_opjumptable(base + (cond << 8)); + // generate label & declarations + start_op(base + (cond << 8), 0); + + // op + wf_op("\tif %s\n", get_cond_as_cond(cond, 0)); + wf_op("\t{\n"); + wf_op("\t\tPC += (s32)(s16)FETCH_WORD;\n"); + // unbase PC + wf_op("\t\tPC -= CPU->BasePC;\n"); + // rebase PC + wf_op("\t\tSET_PC(PC);\n"); + quick_terminate_op(10); + wf_op("\t}\n"); + + wf_op("\tPC += 2;\n"); + + terminate_op(12); + } +} + +static void GenBRA() +{ + u32 base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable_ext(base, 0x01, 0xFF, 1, base + 0x01); + // generate label & declarations + start_op(base + 0x01, 0); + + wf_op("\tPC += (s32)(s8)Opcode;\n"); // no rebase needed for 8 bits deplacement + + terminate_op(10); +} + +static void GenBRA16() +{ + u32 base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable(base + 0x00); + // generate label & declarations + start_op(base + 0x00, 0); + + wf_op("\tPC += (s32)(s16)FETCH_WORD;\n"); + // unbase PC + wf_op("\tPC -= CPU->BasePC;\n"); + // rebase PC + wf_op("\tSET_PC(PC);\n"); + + terminate_op(10); +} + +static void GenBSR() +{ + u32 base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable_ext(base, 0x01, 0xFF, 1, base + 0x01); + // generate label & declarations + start_op(base + 0x01, 0); + + mem_op("\tPUSH_32_F(PC - CPU->BasePC)\n"); + wf_op("\tPC += (s32)(s8)Opcode;\n"); // no rebase needed for 8 bits deplacement + + terminate_op(18); +} + +static void GenBSR16() +{ + u32 base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable(base + 0x00); + // generate label & declarations + start_op(base + 0x00, GEN_RES); + + wf_op("\tres = (s32)(s16)FETCH_WORD;\n"); + // unbase PC + wf_op("\tPC -= CPU->BasePC;\n"); + mem_op("\tPUSH_32_F(PC + 2)\n"); + wf_op("\tPC += (s32) res;\n"); + // rebase PC for 16 bits deplacement + wf_op("\tSET_PC(PC);\n"); + + terminate_op(18); +} + +static void GenArithQ(char op) +{ + u32 base; + + if ((current_ea == EA_AREG) && (current_size == SIZE_BYTE)) return; + + base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable_ext(base, (0 << 9), (7 << 9), (1 << 9), base); + + // generate label & declarations + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_op(base, GEN_DST | GEN_RES | GEN_SRC); + else + start_op(base, GEN_ALL); + + if (current_ea == EA_AREG) set_current_size(SIZE_LONG); + + if (is_ea_memory(current_ea)) current_cycle += 4; + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src + wf_op("\tsrc = (((Opcode >> 9) - 1) & 7) + 1;\n"); + // read dst + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_dst(current_ea, current_op->reg_sft); + // op + wf_op("\tres = dst %c src;\n", op); + // flag calculation + if (current_ea != EA_AREG) + { + if (op == '+') set_add_flag(); + else set_sub_flag(); + } + // write dst + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(4); +} + +static void GenADDQ() +{ + GenArithQ('+'); +} + +static void GenSUBQ() +{ + GenArithQ('-'); +} + +static void GenLogicaD(char op) +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) + { + if (!is_ea_memory(current_ea)) current_cycle += 2; + else current_cycle += 4; + } + + // read src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read(current_ea2, current_op->reg2_sft); + // op + wf_op("\tres %c= src;\n", op); + // flag calculation + set_logic_flag(); + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(4); +} + +static void GenLogicDa(char op) +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_src(current_ea2, current_op->reg2_sft); + // read dst + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // op + wf_op("\tres %c= src;\n", op); + // flag calculation + set_logic_flag(); + // write dst + _ea_write(current_ea, current_op->reg_sft); + + if (current_ea == EA_DREG) terminate_op(4); + else terminate_op(8); +} + +static void GenANDaD() +{ + GenLogicaD('&'); +} + +static void GenANDDa() +{ + GenLogicDa('&'); +} + +static void GenORaD() +{ + GenLogicaD('|'); +} + +static void GenORDa() +{ + GenLogicDa('|'); +} + +static void GenEORDa() +{ + GenLogicDa('^'); +} + +static void GenNBCD() +{ + set_current_size(SIZE_BYTE); + + // generate jump table & opcode declaration + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES); + else + start_all(GEN_ADR | GEN_RES); + + if (is_ea_memory(current_ea)) current_cycle += 2; + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + + // op + wf_op("\tres = 0x9a - res - ((CPU->flag_X >> C68K_SR_X_SFT) & 1);\n"); + wf_op("\n"); + wf_op("\tif (res != 0x9a)\n"); + wf_op("\t{\n"); + wf_op("\t\tif ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;\n"); + wf_op("\t\tres &= 0xFF;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + // flag calculation + wf_op("\t\tCPU->flag_notZ |= res;\n"); + wf_op("\t\tCPU->flag_X = CPU->flag_C = C68K_SR_C;\n"); + + wf_op("\t}\n"); + wf_op("\telse CPU->flag_X = CPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = res;\n"); + + terminate_op(6); +} + +static void GenBCD(char op) +{ + // op + wf_op("\tres = (dst & 0xF) %c (src & 0xF) %c ((CPU->flag_X >> C68K_SR_X_SFT) & 1);\n", op, op); + wf_op("\tif (res > 9) res %c= 6;\n", op); + wf_op("\tres += (dst & 0xF0) %c (src & 0xF0);\n", op, op); + + // flag calculation + wf_op("\tif (res > 0x99)\n"); + wf_op("\t{\n"); + switch (op) + { + case '+': + wf_op("\t\tres -= 0xA0;\n"); + break; + + case '-': + wf_op("\t\tres += 0xA0;\n"); + break; + } + wf_op("\t\tCPU->flag_X = CPU->flag_C = C68K_SR_C;\n"); + wf_op("\t}\n"); + wf_op("\telse CPU->flag_X = CPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFF;\n"); + wf_op("\tCPU->flag_N = res;\n"); +} + +static void GenxBCD(char op) +{ + set_current_size(SIZE_BYTE); + + // generate jump table & opcode declaration + current_ea = EA_DREG; + current_ea2 = EA_DREG; + start_all(GEN_DST | GEN_RES | GEN_SRC); + + // read src (Dx) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + + // op & flag calculation + GenBCD(op); + + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(6); +} + +static void GenxBCDM(char op) +{ + set_current_size(SIZE_BYTE); + + // generate jump table & opcode declaration + current_ea = EA_ADEC; + current_ea2 = EA_ADEC; + start_all(GEN_ALL); + + // read src (ADEC) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (ADEC) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + + // op & flag calculation + GenBCD(op); + + // write dst (ADEC) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(6); +} + +static void GenxBCD7M(char op) +{ + set_current_size(SIZE_BYTE); + + // generate jump table & opcode declaration + current_ea = EA_ADEC7; + current_ea2 = EA_ADEC; + start_all(GEN_ALL); + + // read src (ADEC7) + _ea_calc(current_ea, 0); + _ea_read_src(current_ea, 0); + // read dst (ADEC) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + + // op & flag calculation + GenBCD(op); + + // write dst (ADEC) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(6); +} + +static void GenxBCDM7(char op) +{ + set_current_size(SIZE_BYTE); + + // generate jump table & opcode declaration + current_ea = EA_ADEC; + current_ea2 = EA_ADEC7; + start_all(GEN_ALL); + + // read src (ADEC) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (ADEC7) + _ea_calc(current_ea2, 0); + _ea_read_dst(current_ea2, 0); + + // op & flag calculation + GenBCD(op); + + // write dst (ADEC7) + _ea_write(current_ea2, 0); + + terminate_op(6); +} + +static void GenxBCD7M7(char op) +{ + set_current_size(SIZE_BYTE); + + // generate jump table & opcode declaration + current_ea = EA_ADEC7; + current_ea2 = EA_ADEC7; + start_all(GEN_ALL); + + // read src (ADEC7) + _ea_calc(current_ea, 0); + _ea_read_src(current_ea, 0); + // read dst (ADEC7) + _ea_calc(current_ea2, 0); + _ea_read_dst(current_ea2, 0); + + // op & flag calculation + GenBCD(op); + + // write dst (ADEC7) + _ea_write(current_ea2, 0); + + terminate_op(6); +} + +static void GenABCD() +{ + GenxBCD('+'); +} + +static void GenABCDM() +{ + GenxBCDM('+'); +} + +static void GenABCD7M() +{ + GenxBCD7M('+'); +} + +static void GenABCDM7() +{ + GenxBCDM7('+'); +} + +static void GenABCD7M7() +{ + GenxBCD7M7('+'); +} + +static void GenSBCD() +{ + GenxBCD('-'); +} + +static void GenSBCDM() +{ + GenxBCDM('-'); +} + +static void GenSBCD7M() +{ + GenxBCD7M('-'); +} + +static void GenSBCDM7() +{ + GenxBCDM7('-'); +} + +static void GenSBCD7M7() +{ + GenxBCD7M7('-'); +} + +static void GenDIVU() +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_DST | GEN_RES | GEN_SRC); + else + start_all(GEN_ALL); + + set_current_size(SIZE_WORD); + + // read src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // division by zero + wf_op("\tif (src == 0)\n"); + wf_op("\t{\n"); + gen_exception("\t\t", "C68K_ZERO_DIVIDE_EX"); + quick_terminate_op(10); + wf_op("\t}\n"); + + set_current_size(SIZE_LONG); + + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + + wf_op("\t{\n"); + wf_op("\t\tu32 q, r;\n"); + wf_op("\n"); + wf_op("\t\tq = dst / src;\n"); + wf_op("\t\tr = dst %% src;\n"); + wf_op("\n"); + + wf_op("\t\tif (q & 0xFFFF0000)\n"); + wf_op("\t\t{\n"); + // overflow occured + wf_op("\t\t\tCPU->flag_V = C68K_SR_V;\n"); + quick_terminate_op(70); + wf_op("\t\t}\n"); + + // quotient size = word + set_current_size(SIZE_WORD); + + wf_op("\t\tq &= 0x%.8X;\n", current_bits_mask); + wf_op("\t\tCPU->flag_notZ = q;\n"); + wf_op("\t\tCPU->flag_N = q >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\tCPU->flag_V = CPU->flag_C = 0;\n"); + + wf_op("\t\tres = q | (r << 16);\n"); + + set_current_size(SIZE_LONG); + + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + wf_op("\t}\n"); + + // max cycle = 140 + terminate_op(140 - 50); +} + +static void GenDIVS() +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_DST | GEN_RES | GEN_SRC); + else + start_all(GEN_ALL); + + set_current_size(SIZE_WORD); + + // read src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src_sx(current_ea, current_op->reg_sft); + + // division by zero + wf_op("\tif (src == 0)\n"); + wf_op("\t{\n"); + gen_exception("\t\t", "C68K_ZERO_DIVIDE_EX"); + quick_terminate_op(10); + wf_op("\t}\n"); + + set_current_size(SIZE_LONG); + + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + + // division by zero + wf_op("\tif ((dst == 0x80000000) && (src == -1))\n"); + wf_op("\t{\n"); + wf_op("\t\tCPU->flag_notZ = CPU->flag_N = 0;\n"); + wf_op("\t\tCPU->flag_V = CPU->flag_C = 0;\n"); + wf_op("\t\tres = 0;\n"); + + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + + quick_terminate_op(50); + wf_op("\t}\n"); + + wf_op("\t{\n"); + wf_op("\t\ts32 q, r;\n"); + wf_op("\n"); + wf_op("\t\tq = (s32)dst / (s32)src;\n"); + wf_op("\t\tr = (s32)dst %% (s32)src;\n"); + wf_op("\n"); + + wf_op("\t\tif ((q > 0x7FFF) || (q < -0x8000))\n"); + wf_op("\t\t{\n"); + // overflow occured + wf_op("\t\t\tCPU->flag_V = C68K_SR_V;\n"); + quick_terminate_op(80); + wf_op("\t\t}\n"); + + // quotient size = word + set_current_size(SIZE_WORD); + + wf_op("\t\tq &= 0x%.8X;\n", current_bits_mask); + wf_op("\t\tCPU->flag_notZ = q;\n"); + wf_op("\t\tCPU->flag_N = q >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\tCPU->flag_V = CPU->flag_C = 0;\n"); + + wf_op("\t\tres = q | (r << 16);\n"); + + set_current_size(SIZE_LONG); + + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + wf_op("\t}\n"); + + // max cycle = 158 + terminate_op(158 - 50); +} + +static void GenMULU() +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + set_current_size(SIZE_WORD); + + // read src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read(current_ea2, current_op->reg2_sft); + + set_current_size(SIZE_LONG); + // op + wf_op("\tres *= src;\n"); + + // flag calculation + wf_op("\tCPU->flag_N = res >> 24;\n"); + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_V = CPU->flag_C = 0;\n"); + + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + + // min cycle = 38; max cycle = 70 + terminate_op(38 + (2 * 6)); +} + +static void GenMULS() +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_RES | GEN_SRC); + else + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + set_current_size(SIZE_WORD); + // read src signed + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src_sx(current_ea, current_op->reg_sft); + // read dst signed (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_sx(current_ea2, current_op->reg2_sft); + + set_current_size(SIZE_LONG); + // op + //wf_op("\t(s32)res *= (s32)src;\n"); + wf_op("\tres *= (s32)src;\n"); // antime fix + + // flag calculation + wf_op("\tCPU->flag_N = res >> 24;\n"); + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_V = CPU->flag_C = 0;\n"); + + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + + // min cycle = 38; max cycle = 70 + terminate_op(38 + (2 * 6)); +} + +static void GenArithaD(char op) +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_DST | GEN_RES | GEN_SRC); + else + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) + { + if (!is_ea_memory(current_ea)) current_cycle += 2; + else current_cycle += 4; + } + + // read src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + if (op == ' ') + { + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + } + else + { + // op + wf_op("\tres = dst %c src;\n", op); + // flag calculation + if (op == '+') set_add_flag(); + else set_sub_flag(); + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + } + + terminate_op(4); +} + +static void GenArithDa(char op) +{ + // generate jump table & opcode declaration + current_ea2 = EA_DREG; + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_src(current_ea2, current_op->reg2_sft); + // read dst + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_dst(current_ea, current_op->reg_sft); + // op + wf_op("\tres = dst %c src;\n", op); + // flag calculation + if (op == '+') set_add_flag(); + else set_sub_flag(); + // write dst + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenArithA(char op) +{ + // generate jump table & opcode declaration + current_ea2 = EA_AREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_DST | GEN_RES | GEN_SRC); + else + start_all(GEN_ALL); + + if ((op != ' ') && ((current_size == SIZE_WORD) || (is_ea_memory(current_ea)))) current_cycle += 2; + + // read src + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src_sx(current_ea, current_op->reg_sft); + // read dst (Ax) + set_current_size(SIZE_LONG); + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + // op + if (op == ' ') + { + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + } + else + { + // op + wf_op("\tres = dst %c src;\n", op); + // write dst (Ax) + _ea_write(current_ea2, current_op->reg2_sft); + } + + terminate_op(6); +} + +static void GenArithX(char op) +{ + // generate jump table & opcode declaration + current_ea = EA_DREG; + current_ea2 = EA_DREG; + if ((current_ea == EA_AREG) || (current_ea == EA_DREG) || (current_ea == EA_IMM)) + start_all(GEN_DST | GEN_RES | GEN_SRC); + else + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (Dx) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (Dx) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + // op + wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op); + // flag calculation + if (op == '+') set_addx_flag(); + else set_subx_flag(); + // write dst (Dx) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(4); +} + +static void GenArithXM(char op) +{ + // generate jump table & opcode declaration + current_ea = EA_ADEC; + current_ea2 = EA_ADEC; + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (ADEC) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (ADEC) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + // op + wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op); + // flag calculation + if (op == '+') set_addx_flag(); + else set_subx_flag(); + // write dst (ADEC) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(6); +} + +static void GenArithX7M(char op) +{ + // generate jump table & opcode declaration + current_ea = EA_ADEC7; + current_ea2 = EA_ADEC; + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (ADEC7) + _ea_calc(current_ea, 0); + _ea_read_src(current_ea, 0); + // read dst (ADEC) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + // op + wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op); + // flag calculation + if (op == '+') set_addx_flag(); + else set_subx_flag(); + // write dst (ADEC) + _ea_write(current_ea2, current_op->reg2_sft); + + terminate_op(6); +} + +static void GenArithXM7(char op) +{ + // generate jump table & opcode declaration + current_ea = EA_ADEC; + current_ea2 = EA_ADEC7; + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (ADEC) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (ADEC7) + _ea_calc(current_ea2, 0); + _ea_read_dst(current_ea2, 0); + // op + wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op); + // flag calculation + if (op == '+') set_addx_flag(); + else set_subx_flag(); + // write dst (ADEC7) + _ea_write(current_ea2, 0); + + terminate_op(6); +} + +static void GenArithX7M7(char op) +{ + // generate jump table & opcode declaration + current_ea = EA_ADEC7; + current_ea2 = EA_ADEC7; + start_all(GEN_ALL); + + if (current_size == SIZE_LONG) current_cycle += 4; + + // read src (ADEC7) + _ea_calc(current_ea, 0); + _ea_read_src(current_ea, 0); + // read dst (ADEC7) + _ea_calc(current_ea2, 0); + _ea_read_dst(current_ea2, 0); + // op + wf_op("\tres = dst %c src %c ((CPU->flag_X >> 8) & 1);\n", op, op); + // flag calculation + if (op == '+') set_addx_flag(); + else set_subx_flag(); + // write dst (ADEC7) + _ea_write(current_ea2, 0); + + terminate_op(6); +} + +static void GenADDaD() +{ + GenArithaD('+'); +} + +static void GenADDDa() +{ + GenArithDa('+'); +} + +static void GenADDA() +{ + GenArithA('+'); +} + +static void GenADDX() +{ + GenArithX('+'); +} + +static void GenADDXM() +{ + GenArithXM('+'); +} + +static void GenADDX7M() +{ + GenArithX7M('+'); +} + +static void GenADDXM7() +{ + GenArithXM7('+'); +} + +static void GenADDX7M7() +{ + GenArithX7M7('+'); +} + +static void GenSUBaD() +{ + GenArithaD('-'); +} + +static void GenSUBDa() +{ + GenArithDa('-'); +} + +static void GenSUBA() +{ + GenArithA('-'); +} + +static void GenSUBX() +{ + GenArithX('-'); +} + +static void GenSUBXM() +{ + GenArithXM('-'); +} + +static void GenSUBX7M() +{ + GenArithX7M('-'); +} + +static void GenSUBXM7() +{ + GenArithXM7('-'); +} + +static void GenSUBX7M7() +{ + GenArithX7M7('-'); +} + +static void GenCMP() +{ + GenArithaD(' '); +} + +static void GenCMPA() +{ + GenArithA(' '); +} + +static void GenCMPM() +{ + // generate jump table & opcode declaration + current_ea = EA_AINC; + current_ea2 = EA_AINC; + start_all(GEN_ALL); + + // read src (ADEC) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (ADEC) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + + terminate_op(4); + +} + +static void GenCMP7M() +{ + // generate jump table & opcode declaration + current_ea = EA_AINC7; + current_ea2 = EA_AINC; + start_all(GEN_ALL); + + // read src (ADEC) + _ea_calc(current_ea, 0); + _ea_read_src(current_ea, 0); + // read dst (ADEC) + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_dst(current_ea2, current_op->reg2_sft); + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + + terminate_op(4); + +} + +static void GenCMPM7() +{ + // generate jump table & opcode declaration + current_ea = EA_AINC; + current_ea2 = EA_AINC7; + start_all(GEN_ALL); + + // read src (ADEC) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + // read dst (ADEC) + _ea_calc(current_ea2, 0); + _ea_read_dst(current_ea2, 0); + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + + terminate_op(4); + +} + +static void GenCMP7M7() +{ + // generate jump table & opcode declaration + current_ea = EA_AINC7; + current_ea2 = EA_AINC7; + start_all(GEN_ALL); + + // read src (ADEC) + _ea_calc(current_ea, 0); + _ea_read_src(current_ea, 0); + // read dst (ADEC) + _ea_calc(current_ea2, 0); + _ea_read_dst(current_ea2, 0); + // op + wf_op("\tres = dst - src;\n"); + // flag calculation + set_cmp_flag(); + + terminate_op(4); + +} + +static void GenEXGDD() +{ + // generate jump table & opcode declaration + set_current_size(SIZE_LONG); + current_ea = EA_DREG; + current_ea2 = EA_DREG; + start_all(GEN_RES | GEN_SRC); + + // read R1 + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // read R2 + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_src(current_ea2, current_op->reg2_sft); + // write R1 + _ea_write(current_ea2, current_op->reg2_sft); + wf_op("\tres = src;\n"); + // write R2 + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenEXGAA() +{ + // generate jump table & opcode declaration + set_current_size(SIZE_LONG); + current_ea = EA_AREG; + current_ea2 = EA_AREG; + start_all(GEN_RES | GEN_SRC); + + // read R1 + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // read R2 + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_src(current_ea2, current_op->reg2_sft); + // write R1 + _ea_write(current_ea2, current_op->reg2_sft); + wf_op("\tres = src;\n"); + // write R2 + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenEXGAD() +{ + // generate jump table & opcode declaration + set_current_size(SIZE_LONG); + current_ea = EA_AREG; + current_ea2 = EA_DREG; + start_all(GEN_RES | GEN_SRC); + + // read R1 + _ea_calc(current_ea, current_op->reg_sft); + _ea_read(current_ea, current_op->reg_sft); + // read R2 + _ea_calc(current_ea2, current_op->reg2_sft); + _ea_read_src(current_ea2, current_op->reg2_sft); + // write R1 + _ea_write(current_ea2, current_op->reg2_sft); + wf_op("\tres = src;\n"); + // write R2 + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenASRk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read (sign extend) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src_sx(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n"); + wf_op("\tres = ((s32)src) >> sft;\n"); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenLSRk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_N = CPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n"); + wf_op("\tres = src >> sft;\n"); + wf_op("\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenROXRk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & C / X flags calculation + if (current_size != SIZE_LONG) + { + wf_op("\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + wf_op("\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 2); + wf_op("\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + } + else + { + wf_op("\tCPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n"); + wf_op("\tif (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1)));\n"); + wf_op("\telse res = (src >> sft) | (src << (33 - sft)) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + sft)));\n"); + wf_op("\tCPU->flag_X = CPU->flag_C;\n"); + } + + // V / N / Z flags calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n"); + else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenRORk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n"); + wf_op("\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 1); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n"); + else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenASLk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift < size op) ... only for BYTE here + if (current_size == SIZE_BYTE) + { + wf_op("\tif (sft < %d)\n", current_sft_mask + 1); + wf_op("\t{\n"); + } + + // op & flag X, C, N, Z calculation + if (((current_sft_mask + 1) - C68K_SR_C_SFT) < 8) + wf_op("\t\tCPU->flag_X = CPU->flag_C = src << (%d + sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT); + else wf_op("\t\tCPU->flag_X = CPU->flag_C = src >> (%d - sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT); + wf_op("\t\tres = src << sft;\n"); + wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + // we do V flag calculation at end for a better register usage + wf_op("\t\tCPU->flag_V = 0;\n"); + if (current_size == SIZE_BYTE) + { + wf_op("\t\tif ((sft > %d) && (src)) CPU->flag_V = C68K_SR_V;\n", current_sft_mask); + wf_op("\t\telse\n"); + } + wf_op("\t\t{\n"); + wf_op("\t\t\tu32 msk = (((s32)0x80000000) >> (sft + %d)) & 0x%.8X;\n", 31 - current_sft_mask, current_bits_mask); + wf_op("\t\t\tsrc &= msk;\n"); + wf_op("\t\t\tif ((src) && (src != msk)) CPU->flag_V = C68K_SR_V;\n"); + wf_op("\t\t}\n"); + + if (current_size == SIZE_BYTE) + { + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of shift == size op (sft = 8 for byte operation) + wf_op("\tif (src) CPU->flag_V = C68K_SR_V;\n"); + wf_op("\telse CPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT;\n"); + + // write + wf_op("\tres = 0;\n"); + _ea_write(current_ea, current_op->reg_sft); + + // others flags + wf_op("\tCPU->flag_N = 0;\n"); + wf_op("\tCPU->flag_notZ = 0;\n"); + } + + terminate_op(6); +} + +static void GenLSLk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + if (((current_sft_mask + 1) - C68K_SR_C_SFT) < 8) + wf_op("\tCPU->flag_X = CPU->flag_C = src << (%d + sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT); + else wf_op("\tCPU->flag_X = CPU->flag_C = src >> (%d - sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT); + wf_op("\tres = src << sft;\n"); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenROXLk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & C / X flags calculation + if (current_size != SIZE_LONG) + { + wf_op("\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + wf_op("\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 2); + wf_op("\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + } + else + { + wf_op("\tCPU->flag_C = src >> ((32 - C68K_SR_C_SFT) - sft);\n"); + wf_op("\tif (sft == 1) res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - 1));\n"); + wf_op("\telse res = (src << sft) | (src >> (33 - sft)) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - sft));\n"); + wf_op("\tCPU->flag_X = CPU->flag_C;\n"); + } + + // V / N / Z flags calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n"); + else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenROLk() +{ + u32 base; + + current_ea = EA_DREG; // dst = Dx + + base = get_current_opcode_base(); + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0E00, 0x0200, base); + // generate label & declarations + start_op(base, GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = (((Opcode >> 9) - 1) & 7) + 1;\n"); + adds_CCnt("sft * 2"); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + if (((current_sft_mask + 1) - C68K_SR_C_SFT) < 8) + wf_op("\tCPU->flag_C = src << (%d + sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT); + else wf_op("\tCPU->flag_C = src >> (%d - sft);\n", current_sft_mask + 1 - C68K_SR_C_SFT); + wf_op("\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 1); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\tCPU->flag_notZ = res;\n"); + else wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(6); +} + +static void GenASRD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read (sign extend) + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src_sx(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + // if (shift < size op) + wf_op("\t\tif (sft < %d)\n", current_sft_mask + 1); + wf_op("\t\t{\n"); + + // op & flag calculation + wf_op("\t\t\tCPU->flag_V = 0;\n"); + if (current_size == SIZE_BYTE) wf_op("\t\t\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n"); + else wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT;\n"); + wf_op("\t\t\tres = ((s32)src) >> sft;\n", szcs); + wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\t\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t\t}\n"); + wf_op("\n"); + + // special case of shift >= size op + + // if signed + wf_op("\t\tif (src & (1 << %d))\n", current_sft_mask); + wf_op("\t\t{\n"); + + // op & flag calculation + wf_op("\t\t\tCPU->flag_N = C68K_SR_N;\n"); + wf_op("\t\t\tCPU->flag_notZ = 1;\n"); + wf_op("\t\t\tCPU->flag_V = 0;\n"); + wf_op("\t\t\tCPU->flag_C = C68K_SR_C;\n"); + wf_op("\t\t\tCPU->flag_X = C68K_SR_X;\n"); + wf_op("\t\t\tres = 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t\t}\n"); + wf_op("\n"); + + // if not signed + wf_op("\t\tCPU->flag_N = 0;\n"); + wf_op("\t\tCPU->flag_notZ = 0;\n"); + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tCPU->flag_C = 0;\n"); + wf_op("\t\tCPU->flag_X = 0;\n"); + wf_op("\t\tres = 0;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenLSRD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + // if (shift <= size op) + if (current_size == SIZE_LONG) wf_op("\t\tif (sft < 32)\n"); + else wf_op("\t\tif (sft <= %d)\n", current_sft_mask + 1); + wf_op("\t\t{\n"); + + // op & flag calculation + wf_op("\t\t\tCPU->flag_N = CPU->flag_V = 0;\n"); + if (current_size == SIZE_BYTE) wf_op("\t\t\tCPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft);\n"); + else wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT;\n"); + wf_op("\t\t\tres = src >> sft;\n", szcs); + wf_op("\t\t\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t\t}\n"); + wf_op("\n"); + + // special case of shift > size op + if (current_size == SIZE_LONG) + { + wf_op("\t\tif (sft == 32) CPU->flag_C = src >> (31 - C68K_SR_C_SFT);\n"); + wf_op("\t\telse CPU->flag_C = 0;\n"); + wf_op("\t\tCPU->flag_X = CPU->flag_C;\n"); + } + else wf_op("\t\tCPU->flag_X = CPU->flag_C = 0;\n"); + wf_op("\t\tCPU->flag_N = 0;\n"); + wf_op("\t\tCPU->flag_notZ = 0;\n"); + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tres = 0;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenROXRD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + wf_op("\t\tsft %%= %d;\n", current_sft_mask + 2); + wf_op("\n"); + + // op & C / X flag calculation + if (current_size != SIZE_LONG) + { + wf_op("\t\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + wf_op("\t\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 2); + wf_op("\t\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + } + else + { + wf_op("\t\tif (sft != 0)\n"); + wf_op("\t\t{\n"); + wf_op("\t\t\tif (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1)));\n"); + wf_op("\t\t\telse res = (src >> sft) | (src << (33 - sft)) | (((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))) >> (sft - 1));\n"); + wf_op("\t\t\tCPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT;\n"); + wf_op("\t\t}\n"); + wf_op("\t\telse res = src;\n"); + wf_op("\t\tCPU->flag_C = CPU->flag_X;\n"); + } + + // V / N / Z flag calculation + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\t\tCPU->flag_notZ = res;\n"); + else wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = CPU->flag_X;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenRORD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + wf_op("\t\tsft &= 0x%.2X;\n", current_sft_mask); + wf_op("\t\t\n"); + + // op & flag calculation + if (current_size == SIZE_BYTE) + wf_op("\t\tCPU->flag_C = src << (C68K_SR_C_SFT - ((sft - 1) & 7));\n"); + else + wf_op("\t\tCPU->flag_C = (src >> ((sft - 1) & %d)) << C68K_SR_C_SFT;\n", current_sft_mask); + wf_op("\t\tres = (src >> sft) | (src << (%d - sft));\n", current_sft_mask + 1); + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\t\tCPU->flag_notZ = res;\n"); + else wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenASLD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + // if (shift < size op) + wf_op("\t\tif (sft < %d)\n", current_sft_mask + 1); + wf_op("\t\t{\n"); + + // op & flag calculation + if (current_size != SIZE_LONG) + { + wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src << sft) >> %d;\n", (current_sft_mask + 1) - C68K_SR_C_SFT); + wf_op("\t\t\tres = (src << sft) & 0x%.8X;\n", current_bits_mask); + } + else + { + wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT;\n"); + wf_op("\t\t\tres = src << sft;\n"); + } + wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\t\tCPU->flag_notZ = res;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + // we do V flag calculation at end for a better register usage + wf_op("\t\t\tCPU->flag_V = 0;\n"); + wf_op("\t\t\t{\n"); + wf_op("\t\t\t\tu32 msk = (((s32)0x80000000) >> (sft + %d)) & 0x%.8X;\n", 31 - current_sft_mask, current_bits_mask); + wf_op("\t\t\t\tsrc &= msk;\n"); + wf_op("\t\t\t\tif ((src) && (src != msk)) CPU->flag_V = C68K_SR_V;\n"); + wf_op("\t\t\t}\n"); + + quick_terminate_op(6); + wf_op("\t\t}\n"); + wf_op("\n"); + + // special case of shift >= size op + wf_op("\t\tif (sft == %d) CPU->flag_C = src << C68K_SR_C_SFT;\n", current_bits_mask + 1); + wf_op("\t\telse CPU->flag_C = 0;\n"); + wf_op("\t\tCPU->flag_X = CPU->flag_C;\n"); + wf_op("\t\tif (src) CPU->flag_V = C68K_SR_V;\n"); + wf_op("\t\telse CPU->flag_V = 0;\n"); + + wf_op("\t\tres = 0;\n"); + // write + _ea_write(current_ea, current_op->reg_sft); + + // others flags + wf_op("\t\tCPU->flag_N = 0;\n"); + wf_op("\t\tCPU->flag_notZ = 0;\n"); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenLSLD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + // if (shift <= size op) + if (current_size == SIZE_LONG) wf_op("\t\tif (sft < 32)\n"); + else wf_op("\t\tif (sft <= %d)\n", current_sft_mask + 1); + wf_op("\t\t{\n"); + + // op & flag calculation + if (current_size != SIZE_LONG) + { + wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src << sft) >> %d;\n", (current_sft_mask + 1) - C68K_SR_C_SFT); + wf_op("\t\t\tres = (src << sft) & 0x%.8X;\n", current_bits_mask); + } + else + { + wf_op("\t\t\tCPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT;\n"); + wf_op("\t\t\tres = src << sft;\n"); + } + wf_op("\t\t\tCPU->flag_V = 0;\n"); + wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\t\tCPU->flag_notZ = res;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t\t}\n"); + wf_op("\n"); + + // special case of shift > size op + if (current_size == SIZE_LONG) + { + wf_op("\t\tif (sft == 32) CPU->flag_C = src << C68K_SR_C_SFT;\n"); + wf_op("\t\telse CPU->flag_C = 0;\n"); + wf_op("\t\tCPU->flag_X = CPU->flag_C;\n"); + } + else wf_op("\t\tCPU->flag_X = CPU->flag_C = 0;\n"); + wf_op("\t\tCPU->flag_N = 0;\n"); + wf_op("\t\tCPU->flag_notZ = 0;\n"); + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tres = 0;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenROXLD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + wf_op("\t\tsft %%= %d;\n", current_sft_mask + 2); + wf_op("\n"); + + // op & C/X flags calculation + if (current_size != SIZE_LONG) + { + wf_op("\t\tsrc |= (CPU->flag_X & C68K_SR_X) << %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + wf_op("\t\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 2); + wf_op("\t\tCPU->flag_X = CPU->flag_C = res >> %d;\n", (current_sft_mask + 1) - C68K_SR_X_SFT); + } + else + { + wf_op("\t\tif (sft != 0)\n"); + wf_op("\t\t{\n"); + wf_op("\t\t\tif (sft == 1) res = (src << 1) | ((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1);\n"); + wf_op("\t\t\telse res = (src << sft) | (src >> (33 - sft)) | (((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));\n"); + wf_op("\t\t\tCPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT;\n"); + wf_op("\t\t}\n"); + wf_op("\t\telse res = src;\n"); + wf_op("\t\tCPU->flag_C = CPU->flag_X;\n"); + } + + // V / N / Z flags calculation + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + if (current_size == SIZE_LONG) wf_op("\t\tCPU->flag_notZ = res;\n"); + else wf_op("\t\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = CPU->flag_X;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenROLD() +{ +// u32 base = get_current_opcode_base(); + + current_ea = EA_DREG; // dst = Dx + + start_all(GEN_RES | GEN_SRC); + + if (current_size == SIZE_LONG) current_cycle += 2; + + wf_op("\tu32 sft;\n"); + wf_op("\n"); + wf_op("\tsft = CPU->D[(Opcode >> %d) & 7] & 0x3F;\n", current_op->reg2_sft); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // if (shift != 0) + wf_op("\tif (sft)\n"); + wf_op("\t{\n"); + + adds_CCnt("sft * 2"); + + // if ((shift & size op) != 0) + wf_op("\t\tif (sft &= 0x%.2X)\n", current_sft_mask); + wf_op("\t\t{\n"); + + // op & flag calculation + if (current_size != SIZE_LONG) + { + wf_op("\t\t\tCPU->flag_C = (src << sft) >> %d;\n", (current_sft_mask + 1) - C68K_SR_C_SFT); + wf_op("\t\t\tres = ((src << sft) | (src >> (%d - sft))) & 0x%.8X;\n", current_sft_mask + 1, current_bits_mask); + } + else + { + wf_op("\t\t\tCPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT;\n"); + wf_op("\t\t\tres = (src << sft) | (src >> (%d - sft));\n", current_sft_mask + 1); + } + wf_op("\t\t\tCPU->flag_V = 0;\n"); + wf_op("\t\t\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\t\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + quick_terminate_op(6); + wf_op("\t\t}\n"); + wf_op("\n"); + + // special case of ((shift & size op) == 0) + wf_op("\t\tCPU->flag_V = 0;\n"); + wf_op("\t\tCPU->flag_C = src << C68K_SR_C_SFT;\n"); + wf_op("\t\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\t\tCPU->flag_notZ = src;\n"); + + quick_terminate_op(6); + wf_op("\t}\n"); + wf_op("\n"); + + // special case of (shift == 0) + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_N = src >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = src;\n"); + + terminate_op(6); +} + +static void GenASR() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT;\n"); + wf_op("\tres = (src >> 1) | (src & (1 << %d));\n", current_sft_mask); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenLSR() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_N = CPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT;\n"); + wf_op("\tres = src >> 1;\n"); + wf_op("\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenROXR() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tres = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << %d);\n", current_sft_mask - C68K_SR_X_SFT); + wf_op("\tCPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT;\n"); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res;\n"); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenROR() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = src << C68K_SR_C_SFT;\n"); + wf_op("\tres = (src >> 1) | (src << %d);\n", current_sft_mask); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenASL() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_X = CPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT); + wf_op("\tres = src << 1;\n"); + wf_op("\tCPU->flag_V = (src ^ res) >> %d;\n", current_sft_mask - C68K_SR_V_SFT); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenLSL() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT); + wf_op("\tres = src << 1;\n"); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenROXL() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tres = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> %d);\n", C68K_SR_X_SFT); + wf_op("\tCPU->flag_X = CPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void GenROL() +{ + set_current_size(SIZE_WORD); // dst = mem (word operation) + start_all(GEN_ADR | GEN_RES | GEN_SRC); + + // read + _ea_calc(current_ea, current_op->reg_sft); + _ea_read_src(current_ea, current_op->reg_sft); + + // op & flag calculation + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_C = src >> %d;\n", current_sft_mask - C68K_SR_C_SFT); + wf_op("\tres = (src << 1) | (src >> %d);\n", current_sft_mask); + wf_op("\tCPU->flag_N = res >> %d;\n", current_sft_mask - C68K_SR_N_SFT); + wf_op("\tCPU->flag_notZ = res & 0x%.8X;\n", current_bits_mask); + + // write + _ea_write(current_ea, current_op->reg_sft); + + terminate_op(8); +} + +static void Gen1010() +{ + u32 base; + base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0FFF, 0x1, base); + + // generate label & declarations + start_op(base, GEN_RES); + wf_op("\tPC -= 2;\n"); + gen_exception("\t", "C68K_1010_EX"); + terminate_op(4); +} + +static void Gen1111() +{ + u32 base; + base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable_ext(base, 0x0000, 0x0FFF, 0x1, base); + + // generate label & declarations + start_op(base, GEN_RES); + wf_op("\tPC -= 2;\n"); + gen_exception("\t", "C68K_1111_EX"); + terminate_op(4); +} + +#ifdef NEOCD_HLE +static void Gen0xFABE() +{ + start_all(GEN_ALL); + + wf_op("\tneogeo_exit();\n"); + + terminate_op(0); +} + +static void Gen0xFABF() +{ + start_all(GEN_ALL); + + wf_op("\timg_display = 1;\n"); + wf_op("\tcdrom_load_files();\n"); + + terminate_op(0); +} + +static void Gen0xFAC0() +{ + start_all(GEN_ALL); + + wf_op("\timg_display = 0;\n"); + wf_op("\tcdrom_load_files();\n"); + + terminate_op(0); +} + +static void Gen0xFAC1() +{ + start_all(GEN_ALL); + + wf_op("\tneogeo_upload();\n"); + + terminate_op(0); +} + +static void Gen0xFAC2() +{ + start_all(GEN_ALL); + + wf_op("\tneogeo_prio_switch();\n"); + + terminate_op(0); +} + +static void Gen0xFAC3() +{ + start_all(GEN_ALL); + + wf_op("\tneogeo_cdda_control();\n"); + + terminate_op(0); +} +#endif + + +// main function +///////////////// +int main(void) +{ + u32 i; + u32 s; + u32 smax; + + // clear opcode files + for(i = 0; i < 0x10; i++) + { + char fn[16]; + + sprintf(fn, "c68k_op%.1X.inc", (int)i); + opcode_file = fopen(fn, "wt"); + if (opcode_file != NULL) + { + fclose(opcode_file); + opcode_file = NULL; + } + } + + // init opcode jump table + ini_file = fopen("c68k_ini.inc", "wt"); +#ifndef C68K_NO_JUMP_TABLE +#ifdef C68K_CONST_JUMP_TABLE + for(i = 0; i < 0x10000; i++) op_jump_table[i] = OP_ILLEGAL; +#else + // defaut ILLEGAL instruction + gen_jumptable(0x0000, 0x0000, 0xFFFF, 1, 0, 0, 0, 0, 0, 0, 0x4AFC); +#endif +#endif + // generate opcode files + for(i = 0; i < OP_INFO_TABLE_LEN; i++) + { + current_op = &(op_info_table[i]); + if (prepare_generate()) return 1; + + // s = size to start + current_size = 0; + smax = SIZE_LONG; + if (current_op->size_type == 0) smax = 0; + else if (current_op->size_type == 1) current_size = 1; + + for(s = current_size; s <= smax; s++) + { + if (current_op->eam_sft != -1) + { + for(current_ea = 0; current_ea <= EA_ADEC7; current_ea++) + { + if (!has_ea(current_ea)) continue; + current_eam = _ea_to_eamreg(current_ea) >> 3; + current_reg = _ea_to_eamreg(current_ea) & 7; + + if (op_info_table[i].eam2_sft != -1) + { + for(current_ea2 = 0; current_ea2 <= EA_ADEC7; current_ea2++) + { + if (!has_ea2(current_ea2)) continue; + current_eam2 = _ea_to_eamreg(current_ea2) >> 3; + current_reg2 = _ea_to_eamreg(current_ea2) & 7; + + set_current_size(s); + current_op->genfunc(); + } + } + else + { + current_reg2 = 0; + set_current_size(s); + current_op->genfunc(); + } + } + } + else + { + current_reg = 0; + set_current_size(s); + current_op->genfunc(); + } + } + } + + // generate jumptable file +#ifdef C68K_CONST_JUMP_TABLE + if (ini_file != NULL) + { + fprintf(ini_file, "\tstatic const void *JumpTable[0x10000] =\n"); + fprintf(ini_file, "\t{\n"); + + for(i = 0; i < (0x10000 - 4); i += 4) + fprintf(ini_file, "\t\t&&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X,\n", op_jump_table[i + 0], op_jump_table[i + 1], op_jump_table[i + 2], op_jump_table[i + 3]); + fprintf(ini_file, "\t\t&&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X, &&OP_0x%.4X\n", op_jump_table[0xFFFC], op_jump_table[0xFFFD], op_jump_table[0xFFFE], op_jump_table[0xFFFF]); + + fprintf(ini_file, "\t};\n\n"); + } +#endif + + // close handle + if (ini_file != NULL) fclose(ini_file); + if (opcode_file != NULL) fclose(opcode_file); + + return 0; +} +#endif diff --git a/m68000/c68k/gen68k.h b/m68000/c68k/gen68k.h new file mode 100644 index 0000000..e8b71d8 --- /dev/null +++ b/m68000/c68k/gen68k.h @@ -0,0 +1,68 @@ +/* Copyright 2003-2004 Stephane Dallongeville + Copyright 2004 Theo Berkau + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/********************************************************************************* + * GEN68K.H : + * + * C68K generator include file + * + ********************************************************************************/ + +#ifndef _GEN68K_H_ +#define _GEN68K_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +// setting +/////////// + +// structure definition +//////////////////////// + +typedef struct { + u32 name; + u32 mask; + u32 match; +} c68k_ea_info_struc; + +typedef struct __c68k_op_info_struc { + s8 op_name[8 + 1]; + u16 op_base; + u16 op_mask; + s8 size_type; + s8 size_sft; + s8 eam_sft; + s8 reg_sft; + s8 eam2_sft; + s8 reg2_sft; + s8 ea_supported[12 + 1]; + s8 ea2_supported[12 + 1]; + void (*genfunc)(void); +} c68k_op_info_struc; + + +#ifdef __cplusplus +} +#endif + +#endif // _GEN68K_H_ + diff --git a/m68000/c68k/gen68k.inc b/m68000/c68k/gen68k.inc new file mode 100644 index 0000000..483a4f7 --- /dev/null +++ b/m68000/c68k/gen68k.inc @@ -0,0 +1,1649 @@ +/* Copyright 2003-2004 Stephane Dallongeville + + This file is part of Yabause. + + Yabause 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. + + Yabause 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 Yabause; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include +#include + +#define EA_DREG 0 +#define EA_AREG 1 +#define EA_AIND 2 +#define EA_AINC 3 +#define EA_ADEC 4 +#define EA_D16A 5 +#define EA_D8AX 6 +#define EA_A16 7 +#define EA_A32 8 +#define EA_D16P 9 +#define EA_D8PX 10 +#define EA_IMM 11 +#define EA_AINC7 12 +#define EA_ADEC7 13 +#define EA_ILLEGAL 15 + +#define SIZE_BYTE 0 +#define SIZE_WORD 1 +#define SIZE_LONG 2 + +#define COND_TR 0 +#define COND_FA 1 +#define COND_HI 2 +#define COND_LS 3 +#define COND_CC 4 +#define COND_CS 5 +#define COND_NE 6 +#define COND_EQ 7 +#define COND_VC 8 +#define COND_VS 9 +#define COND_PL 10 +#define COND_MI 11 +#define COND_GE 12 +#define COND_LT 13 +#define COND_GT 14 +#define COND_LE 15 + +#define COND_NOT_TR COND_FA +#define COND_NOT_FA COND_TR +#define COND_NOT_HI COND_LS +#define COND_NOT_LS COND_HI +#define COND_NOT_CC COND_CS +#define COND_NOT_CS COND_CC +#define COND_NOT_NE COND_EQ +#define COND_NOT_EQ COND_NE +#define COND_NOT_VC COND_VS +#define COND_NOT_VS COND_VC +#define COND_NOT_PL COND_MI +#define COND_NOT_MI COND_PL +#define COND_NOT_GE COND_LT +#define COND_NOT_LT COND_GE +#define COND_NOT_GT COND_LE +#define COND_NOT_LE COND_GT + +#define OP_ILLEGAL 0x4AFC + +static void GenORI(void); +static void GenORICCR(void); +static void GenORISR(void); +static void GenANDI(void); +static void GenANDICCR(void); +static void GenANDISR(void); +static void GenEORI(void); +static void GenEORICCR(void); +static void GenEORISR(void); +static void GenSUBI(void); +static void GenADDI(void); +static void GenCMPI(void); +static void GenBTSTn(void); +static void GenBCHGn(void); +static void GenBCLRn(void); +static void GenBSETn(void); +static void GenBTST(void); +static void GenBCHG(void); +static void GenBCLR(void); +static void GenBSET(void); +static void GenMOVEPWaD(void); +static void GenMOVEPLaD(void); +static void GenMOVEPWDa(void); +static void GenMOVEPLDa(void); +static void GenMOVEB(void); +static void GenMOVEL(void); +static void GenMOVEW(void); +static void GenMOVEAL(void); +static void GenMOVEAW(void); +static void GenNEGX(void); +static void GenCLR(void); +static void GenNEG(void); +static void GenNOT(void); +static void GenMOVESRa(void); +static void GenMOVEaSR(void); +static void GenMOVEaCCR(void); +static void GenNBCD(void); +static void GenPEA(void); +static void GenSWAP(void); +static void GenMOVEMaR(void); +static void GenEXT(void); +static void GenTST(void); +static void GenTAS(void); +static void GenILLEGAL(void); +static void GenMOVEMRa(void); +static void GenTRAP(void); +static void GenLINK(void); +static void GenLINKA7(void); +static void GenULNK(void); +static void GenULNKA7(void); +static void GenMOVEAUSP(void); +static void GenMOVEUSPA(void); +static void GenRESET(void); +static void GenNOP(void); +static void GenSTOP(void); +static void GenRTE(void); +static void GenRTS(void); +static void GenTRAPV(void); +static void GenRTR(void); +static void GenJSR(void); +static void GenJMP(void); +static void GenCHK(void); +static void GenLEA(void); +static void GenSTCC(void); +static void GenDBCC(void); +static void GenADDQ(void); +static void GenSUBQ(void); +static void GenBCC(void); +static void GenBCC16(void); +static void GenBRA(void); +static void GenBRA16(void); +static void GenBSR(void); +static void GenBSR16(void); +static void GenMOVEQ(void); +static void GenORaD(void); +static void GenORDa(void); +static void GenSBCD(void); +static void GenSBCDM(void); +static void GenSBCD7M(void); +static void GenSBCDM7(void); +static void GenSBCD7M7(void); +static void GenDIVU(void); +static void GenDIVS(void); +static void GenSUBaD(void); +static void GenSUBDa(void); +static void GenSUBX(void); +static void GenSUBXM(void); +static void GenSUBX7M(void); +static void GenSUBXM7(void); +static void GenSUBX7M7(void); +static void GenSUBA(void); +static void GenCMP(void); +static void GenCMPM(void); +static void GenCMP7M(void); +static void GenCMPM7(void); +static void GenCMP7M7(void); +static void GenEORDa(void); +static void GenCMPA(void); +static void GenANDaD(void); +static void GenANDDa(void); +static void GenABCD(void); +static void GenABCDM(void); +static void GenABCD7M(void); +static void GenABCDM7(void); +static void GenABCD7M7(void); +static void GenMULU(void); +static void GenMULS(void); +static void GenEXGDD(void); +static void GenEXGAA(void); +static void GenEXGAD(void); +static void GenADDaD(void); +static void GenADDDa(void); +static void GenADDX(void); +static void GenADDXM(void); +static void GenADDX7M(void); +static void GenADDXM7(void); +static void GenADDX7M7(void); +static void GenADDA(void); +static void GenASRk(void); +static void GenLSRk(void); +static void GenROXRk(void); +static void GenRORk(void); +static void GenASLk(void); +static void GenLSLk(void); +static void GenROXLk(void); +static void GenROLk(void); +static void GenASRD(void); +static void GenLSRD(void); +static void GenROXRD(void); +static void GenRORD(void); +static void GenASLD(void); +static void GenLSLD(void); +static void GenROXLD(void); +static void GenROLD(void); +static void GenASR(void); +static void GenLSR(void); +static void GenROXR(void); +static void GenROR(void); +static void GenASL(void); +static void GenLSL(void); +static void GenROXL(void); +static void GenROL(void); +static void Gen1010(void); +static void Gen1111(void); +#ifdef NEOCD_HLE +static void Gen0xFABE(void); +static void Gen0xFABF(void); +static void Gen0xFAC0(void); +static void Gen0xFAC1(void); +static void Gen0xFAC2(void); +static void Gen0xFAC3(void); +#endif + +#ifdef NEOCD_HLE +#define OP_INFO_TABLE_LEN (142 + 6) +#else +#define OP_INFO_TABLE_LEN 144 +#endif + +static c68k_op_info_struc op_info_table[OP_INFO_TABLE_LEN] = +{ // DAAAAddaaddi DAAAAddaaddi + // iid181318m iid181318m + // siz siz eam ear eam ear nne6A626Pm nne6A626Pm + // opname opbase opmask typ sft 1 1 2 2 dccAX PX dccAX PX GenFunc + { "1010", 0xA000, 0xF000, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen1010 }, + { "1111", 0xF000, 0xF000, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen1111 }, + { "ORI", 0x0000, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenORI }, + { "ORICCR", 0x003C, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenORICCR }, + { "ORISR", 0x007C, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenORISR }, + { "ANDI", 0x0200, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenANDI }, + { "ANDICCR", 0x023C, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenANDICCR }, + { "ANDISR", 0x027C, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenANDISR }, + { "EORI", 0x0A00, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenEORI }, + { "EORICCR", 0x0A3C, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenEORICCR }, + { "EORISR", 0x0A7C, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenEORISR }, + + { "SUBI", 0x0400, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenSUBI }, + { "ADDI", 0x0600, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenADDI }, + { "CMPI", 0x0C00, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenCMPI }, + + { "BTSTn", 0x0800, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooooo-", "------------", GenBTSTn }, + { "BCHGn", 0x0840, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenBCHGn }, + { "BCLRn", 0x0880, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenBCLRn }, + { "BSETn", 0x08C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenBSETn }, + + { "BTST", 0x0100, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-oooooooooo", "------------", GenBTST }, + { "BCHG", 0x0140, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-ooooooo---", "------------", GenBCHG }, + { "BCLR", 0x0180, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-ooooooo---", "------------", GenBCLR }, + { "BSET", 0x01C0, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-ooooooo---", "------------", GenBSET }, + + { "MOVEPWaD", 0x0108, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenMOVEPWaD }, + { "MOVEPLaD", 0x0148, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenMOVEPLaD }, + { "MOVEPWDa", 0x0188, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenMOVEPWDa }, + { "MOVEPLDa", 0x01C8, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenMOVEPLDa }, + + { "MOVEB", 0x1000, 0xF000, 0, 0, 3, 0, 6, 9, "oooooooooooo", "o-ooooooo---", GenMOVEB }, + { "MOVEL", 0x2000, 0xF000, 0, 0, 3, 0, 6, 9, "oooooooooooo", "o-ooooooo---", GenMOVEL }, + { "MOVEW", 0x3000, 0xF000, 0, 0, 3, 0, 6, 9, "oooooooooooo", "o-ooooooo---", GenMOVEW }, + { "MOVEAL", 0x2040, 0xF1C0, 0, 0, 3, 0, -1, 9, "oooooooooooo", "------------", GenMOVEAL }, + { "MOVEAW", 0x3040, 0xF1C0, 0, 0, 3, 0, -1, 9, "oooooooooooo", "------------", GenMOVEAW }, + + { "NEGX", 0x4000, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenNEGX }, + { "CLR", 0x4200, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenCLR }, + { "NEG", 0x4400, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenNEG }, + { "NOT", 0x4600, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenNOT }, + + { "MOVESRa", 0x40C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenMOVESRa }, + { "MOVEaCCR", 0x44C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-oooooooooo", "------------", GenMOVEaCCR }, + { "MOVEaSR", 0x46C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-oooooooooo", "------------", GenMOVEaSR }, + + { "NBCD", 0x4800, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenNBCD }, + { "PEA", 0x4840, 0xFFC0, 0, 0, 3, 0, -1, -1, "--o--oooooo-", "------------", GenPEA }, + { "SWAP", 0x4840, 0xFFF8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenSWAP }, + + { "MOVEMRa", 0x4880, 0xFF80, 1, 6, 3, 0, -1, -1, "--o-ooooo---", "------------", GenMOVEMRa }, + { "EXT", 0x4880, 0xFFB8, 1, 6, -1, 0, -1, -1, "------------", "------------", GenEXT }, + { "TST", 0x4A00, 0xFF00, 2, 6, 3, 0, -1, -1, "o-ooooooo---", "------------", GenTST }, + { "TAS", 0x4AC0, 0xFFC0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenTAS }, + { "ILLEGAL", 0x4AFC, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenILLEGAL }, + { "MOVEMaR", 0x4C80, 0xFF80, 1, 6, 3, 0, -1, -1, "--oo-oooooo-", "------------", GenMOVEMaR }, + + { "TRAP", 0x4E40, 0xFFF0, 0, 0, -1, -1, -1, -1, "------------", "------------", GenTRAP }, + { "LINK", 0x4E50, 0xFFF8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenLINK }, + { "LINKA7", 0x4E57, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenLINKA7 }, + { "ULNK", 0x4E58, 0xFFF8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenULNK }, + { "ULNKA7", 0x4E5F, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenULNKA7 }, + { "MOVEAUSP", 0x4E60, 0xFFF8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenMOVEAUSP }, + { "MOVEUSPA", 0x4E68, 0xFFF8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenMOVEUSPA }, + + { "RESET", 0x4E70, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenRESET }, + { "NOP", 0x4E71, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenNOP }, + { "STOP", 0x4E72, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenSTOP }, + { "RTE", 0x4E73, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenRTE }, + { "RTS", 0x4E75, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenRTS }, + { "TRAPV", 0x4E76, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenTRAPV }, + { "RTR", 0x4E77, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenRTR }, + + { "JSR", 0x4E80, 0xFFC0, 0, 0, 3, 0, -1, -1, "--o--oooooo-", "------------", GenJSR }, + { "JMP", 0x4EC0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--o--oooooo-", "------------", GenJMP }, + + { "CHK", 0x4180, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-oooooooooo", "------------", GenCHK }, + { "LEA", 0x41C0, 0xF1C0, 0, 0, 3, 0, -1, 9, "--o--oooooo-", "------------", GenLEA }, + + { "STCC", 0x50C0, 0xF0C0, 0, 0, 3, 0, -1, -1, "o-ooooooo---", "------------", GenSTCC }, + { "DBCC", 0x50C8, 0xF0F8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenDBCC }, + + { "ADDQ", 0x5000, 0xF100, 2, 6, 3, 0, -1, -1, "ooooooooo---", "------------", GenADDQ }, + { "SUBQ", 0x5100, 0xF100, 2, 6, 3, 0, -1, -1, "ooooooooo---", "------------", GenSUBQ }, + + { "BCC", 0x6000, 0xF000, 0, 0, -1, -1, -1, -1, "------------", "------------", GenBCC }, + { "BCC16", 0x6000, 0xF0FF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenBCC16 }, + { "BRA", 0x6000, 0xFF00, 0, 0, -1, -1, -1, -1, "------------", "------------", GenBRA }, + { "BRA16", 0x6000, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenBRA16 }, + { "BSR", 0x6100, 0xFF00, 0, 0, -1, -1, -1, -1, "------------", "------------", GenBSR }, + { "BSR16", 0x6100, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenBSR16 }, + + { "MOVEQ", 0x7000, 0xF100, 0, 0, -1, 9, -1, -1, "------------", "------------", GenMOVEQ }, + + { "ORaD", 0x8000, 0xF100, 2, 6, 3, 0, -1, 9, "o-oooooooooo", "------------", GenORaD }, + { "ORDa", 0x8100, 0xF100, 2, 6, 3, 0, -1, 9, "--ooooooo---", "------------", GenORDa }, + { "SBCD", 0x8100, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenSBCD }, + { "SBCDM", 0x8108, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenSBCDM }, + { "SBCD7M", 0x810F, 0xF1FF, 0, 0, -1, 0, -1, 9, "------------", "------------", GenSBCD7M }, + { "SBCDM7", 0x8F08, 0xFFF8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenSBCDM7 }, + { "SBCD7M7", 0x8F0F, 0xFFFF, 0, 0, -1, 0, -1, 9, "------------", "------------", GenSBCD7M7 }, + { "DIVU", 0x80C0, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-oooooooooo", "------------", GenDIVU }, + { "DIVS", 0x81C0, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-oooooooooo", "------------", GenDIVS }, + + { "SUBaD", 0x9000, 0xF100, 2, 6, 3, 0, -1, 9, "oooooooooooo", "------------", GenSUBaD }, + { "SUBDa", 0x9100, 0xF100, 2, 6, 3, 0, -1, 9, "--ooooooo---", "------------", GenSUBDa }, + { "SUBX", 0x9100, 0xF138, 2, 6, -1, 0, -1, 9, "------------", "------------", GenSUBX }, + { "SUBXM", 0x9108, 0xF138, 2, 6, -1, 0, -1, 9, "------------", "------------", GenSUBXM }, + { "SUBX7M", 0x910F, 0xF13F, 2, 6, -1, -1, -1, 9, "------------", "------------", GenSUBX7M }, + { "SUBXM7", 0x9F08, 0xFF38, 2, 6, -1, 0, -1, -1, "------------", "------------", GenSUBXM7 }, + { "SUBX7M7", 0x9F0F, 0xFF3F, 2, 6, -1, -1, -1, -1, "------------", "------------", GenSUBX7M7 }, + { "SUBA", 0x90C0, 0xF0C0, 1, 8, 3, 0, -1, 9, "oooooooooooo", "------------", GenSUBA }, + + { "CMP", 0xB000, 0xF100, 2, 6, 3, 0, -1, 9, "oooooooooooo", "------------", GenCMP }, + { "CMPM", 0xB108, 0xF138, 2, 6, -1, 0, -1, 9, "------------", "------------", GenCMPM }, + { "CMP7M", 0xB10F, 0xF13F, 2, 6, -1, -1, -1, 9, "------------", "------------", GenCMP7M }, + { "CMPM7", 0xBF08, 0xFF38, 2, 6, -1, 0, -1, -1, "------------", "------------", GenCMPM7 }, + { "CMP7M7", 0xBF0F, 0xFF3F, 2, 6, -1, -1, -1, -1, "------------", "------------", GenCMP7M7 }, + { "EORDa", 0xB100, 0xF100, 2, 6, 3, 0, -1, 9, "o-ooooooo---", "------------", GenEORDa }, + { "CMPA", 0xB0C0, 0xF0C0, 1, 8, 3, 0, -1, 9, "oooooooooooo", "------------", GenCMPA }, + + { "ANDaD", 0xC000, 0xF100, 2, 6, 3, 0, -1, 9, "o-oooooooooo", "------------", GenANDaD }, + { "ANDDa", 0xC100, 0xF100, 2, 6, 3, 0, -1, 9, "--ooooooo---", "------------", GenANDDa }, + { "ABCD", 0xC100, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenABCD }, + { "ABCDM", 0xC108, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenABCDM }, + { "ABCD7M", 0xC10F, 0xF1FF, 0, 0, -1, -1, -1, 9, "------------", "------------", GenABCD7M }, + { "ABCDM7", 0xCF08, 0xFFF8, 0, 0, -1, 0, -1, -1, "------------", "------------", GenABCDM7 }, + { "ABCD7M7", 0xCF0F, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", GenABCD7M7 }, + { "MULU", 0xC0C0, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-oooooooooo", "------------", GenMULU }, + { "MULS", 0xC1C0, 0xF1C0, 0, 0, 3, 0, -1, 9, "o-oooooooooo", "------------", GenMULS }, + { "EXGDD", 0xC140, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenEXGDD }, + { "EXGAA", 0xC148, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenEXGAA }, + { "EXGAD", 0xC188, 0xF1F8, 0, 0, -1, 0, -1, 9, "------------", "------------", GenEXGAD }, + + { "ADDaD", 0xD000, 0xF100, 2, 6, 3, 0, -1, 9, "oooooooooooo", "------------", GenADDaD }, + { "ADDDa", 0xD100, 0xF100, 2, 6, 3, 0, -1, 9, "--ooooooo---", "------------", GenADDDa }, + { "ADDX", 0xD100, 0xF138, 2, 6, -1, 0, -1, 9, "------------", "------------", GenADDX }, + { "ADDXM", 0xD108, 0xF138, 2, 6, -1, 0, -1, 9, "------------", "------------", GenADDXM }, + { "ADDX7M", 0xD10F, 0xF13F, 2, 6, -1, -1, -1, 9, "------------", "------------", GenADDX7M }, + { "ADDXM7", 0xDF08, 0xFF38, 2, 6, -1, 0, -1, -1, "------------", "------------", GenADDXM7 }, + { "ADDX7M7", 0xDF0F, 0xFF3F, 2, 6, -1, -1, -1, -1, "------------", "------------", GenADDX7M7 }, + { "ADDA", 0xD0C0, 0xF0C0, 1, 8, 3, 0, -1, 9, "oooooooooooo", "------------", GenADDA }, + + { "ASRk", 0xE000, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenASRk }, + { "LSRk", 0xE008, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenLSRk }, + { "ROXRk", 0xE010, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenROXRk }, + { "RORk", 0xE018, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenRORk }, + { "ASLk", 0xE100, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenASLk }, + { "LSLk", 0xE108, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenLSLk }, + { "ROXLk", 0xE110, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenROXLk }, + { "ROLk", 0xE118, 0xF138, 2, 6, -1, 0, -1, -1, "o-----------", "------------", GenROLk }, + + { "ASRD", 0xE020, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenASRD }, + { "LSRD", 0xE028, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenLSRD }, + { "ROXRD", 0xE030, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenROXRD }, + { "RORD", 0xE038, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenRORD }, + { "ASLD", 0xE120, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenASLD }, + { "LSLD", 0xE128, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenLSLD }, + { "ROXLD", 0xE130, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenROXLD }, + { "ROLD", 0xE138, 0xF138, 2, 6, -1, 0, -1, 9, "o-----------", "o-----------", GenROLD }, + + { "ASR", 0xE0C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenASR }, + { "LSR", 0xE2C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenLSR }, + { "ROXR", 0xE4C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenROXR }, + { "ROR", 0xE6C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenROR }, + { "ASL", 0xE1C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenASL }, + { "LSL", 0xE3C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenLSL }, + { "ROXL", 0xE5C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenROXL }, + { "ROL", 0xE7C0, 0xFFC0, 0, 0, 3, 0, -1, -1, "--ooooooo---", "------------", GenROL } + +#ifdef NEOCD_HLE + , + { "0xFABE", 0xFABE, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen0xFABE }, + { "0xFABF", 0xFABF, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen0xFABF }, + { "0xFAC0", 0xFAC0, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen0xFAC0 }, + { "0xFAC1", 0xFAC1, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen0xFAC1 }, + { "0xFAC2", 0xFAC2, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen0xFAC2 }, + { "0xFAC3", 0xFAC3, 0xFFFF, 0, 0, -1, -1, -1, -1, "------------", "------------", Gen0xFAC3 } +#endif +}; + +#ifndef C68K_NO_JUMP_TABLE +#ifdef C68K_CONST_JUMP_TABLE +static u16 op_jump_table[0x10000]; +#endif +#endif + +// files where code is generated +static FILE* ini_file = NULL; +static FILE* opcode_file = NULL; + +// current generated instruction infos +static c68k_op_info_struc *current_op; +static u32 current_ea; +static u32 current_eam; +static u32 current_reg; +static u32 current_ea2; +static u32 current_eam2; +static u32 current_reg2; +static u32 current_size; +static u32 current_cycle; +static u32 current_io_sav; + +static char current_cond_char[128]; + +static char szc[20]; +static char szcs[20]; +static char szcf[20]; +static char szcsf[20]; + +static u32 current_bits_mask; +static u8 current_sft_mask; + +#define EA_DREG 0 +#define EA_AREG 1 +#define EA_AIND 2 +#define EA_AINC 3 +#define EA_ADEC 4 +#define EA_D16A 5 +#define EA_D8AX 6 +#define EA_A16 7 +#define EA_A32 8 +#define EA_D16P 9 +#define EA_D8PX 10 +#define EA_IMM 11 +#define EA_AINC7 12 +#define EA_ADEC7 13 +#define EA_ILLEGAL 15 + +static const u32 jmp_jsr_cycle_table[16] = +{ + 0, 0, + 4, + 0, + 0, + 6, + 10, + 6, + 8, + 6, + 10, + 0, 0, 0, 0 +}; + +static const u32 lea_pea_cycle_table[16] = +{ + 0, 0, + 0, + 0, + 0, + 4, + 8, + 4, + 8, + 4, + 8, + 0, 0, 0, 0 +}; + +static const u32 movem_cycle_table[16] = +{ + 0, 0, + 0, + 0, + 0, + 4, + 6, + 4, + 8, + 4, + 6, + 0, 0, 0, 0 +}; + +// general emitter function +//////////////////////////// + +static u32 prepare_generate(void) +{ + char filename[32]; + + sprintf(filename, "c68k_op%.1X.inc", (current_op->op_base >> 12) & 0xF); + if (opcode_file != NULL) + { + fclose(opcode_file); + opcode_file = NULL; + } + opcode_file = fopen(filename, "at"); + if (opcode_file == NULL) + { + printf("Can't open %s\n", filename); + return 1; + } + return 0; +} + +static void wf_op(char* fmt, ...) +{ + va_list args; + + if (opcode_file == NULL) return; + + va_start(args, fmt); + vfprintf(opcode_file, fmt, args); + va_end(args); +} + +static void gen_jumptable(u32 base, u32 start1, u32 end1, u32 step1, u32 start2, u32 end2, u32 step2, u32 start3, u32 end3, u32 step3, u32 op) +{ +#ifdef C68K_CONST_JUMP_TABLE + u32 i, j, k; +#endif +#ifdef C68K_NO_JUMP_TABLE + u32 i, j, k; +#endif + + + base &= 0xFFFF; + start1 &= 0xFFFF; + end1 &= 0xFFFF; + step1 &= 0xFFFF; + if (end1 < start1) end1 = start1; + start2 &= 0xFFFF; + end2 &= 0xFFFF; + step2 &= 0xFFFF; + if (end2 < start2) end2 = start2; + op &= 0xFFFF; + +#ifndef C68K_NO_JUMP_TABLE +#ifdef C68K_CONST_JUMP_TABLE + if (step1 == 0) step1 = 1; + if (step2 == 0) step2 = 1; + if (step3 == 0) step3 = 1; + + for(i = start1; i <= end1; i += step1) + for(j = start2; j <= end2; j += step2) + for(k = start3; k <= end3; k += step3) + op_jump_table[base + i + j + k] = op; + +#else + if (ini_file == NULL) return; + + if (start1 != end1) + { + fprintf(ini_file, "\t\tfor(i = 0x%.4X; i <= 0x%.4X; i += 0x%.4X)\n", (int)start1, (int)end1, (int)step1); + if (start2 != end2) + { + fprintf(ini_file, "\t\t\tfor(j = 0x%.4X; j <= 0x%.4X; j += 0x%.4X)\n\t", (int)start2, (int)end2, (int)step2); + if (start3 != end3) + { + fprintf(ini_file, "\t\t\t\tfor(k = 0x%.4X; k <= 0x%.4X; k += 0x%.4X)\n\t", (int)start3, (int)end3, (int)step3); + fprintf(ini_file, "\t\t\t\t\tJumpTable[0x%.4X + i + j + k] = &&OP_0x%.4X;\n", (int)base, (int)op); + } + else fprintf(ini_file, "\t\t\t\tJumpTable[0x%.4X + i + j] = &&OP_0x%.4X;\n", (int)base, (int)op); + } + else fprintf(ini_file, "\t\t\tJumpTable[0x%.4X + i] = &&OP_0x%.4X;\n", (int)base, (int)op); + } + else fprintf(ini_file, "\t\tJumpTable[0x%.4X] = &&OP_0x%.4X;\n", (int)base, (int)op); +#endif +#else + if (step1 == 0) step1 = 1; + if (step2 == 0) step2 = 1; + if (step3 == 0) step3 = 1; + + for(i = start1; i <= end1; i += step1) + for(j = start2; j <= end2; j += step2) + for(k = start3; k <= end3; k += step3) + { + u32 temp=(base + i + j + k); + if (temp != op && temp != 0x4E57 && temp != 0x4E5F) + wf_op("case 0x%.4X:\n", base + i + j + k); + } +#endif +} + +static void gen_opjumptable_ext(u32 base, u32 start3, u32 end3, u32 step3, u32 op) +{ + u32 start1, end1, step1, start2, end2, step2; + + start1 = end1 = step1 = 0; + start2 = end2 = step2 = 0; + + if ((current_op->reg_sft != -1) && (current_ea < 7)) + { + if ((current_ea == EA_AINC) || (current_ea == EA_ADEC)) end1 = 6 << current_op->reg_sft; + else end1 = 7 << current_op->reg_sft; + step1 = 1 << current_op->reg_sft; + } + if ((current_op->reg2_sft != -1) && (current_ea2 < 7)) + { + if ((current_ea2 == EA_AINC) || (current_ea2 == EA_ADEC)) end2 = 6 << current_op->reg2_sft; + else end2 = 7 << current_op->reg2_sft; + step2 = 1 << current_op->reg2_sft; + } + + if (start1 != end1) + { + if (start2 != end2) gen_jumptable(base, start1, end1, step1, start2, end2, step2, start3, end3, step3, op); + else gen_jumptable(base, start1, end1, step1, start3, end3, step3, start2, end2, step2, op); + } + else if (start2 != end2) gen_jumptable(base, start2, end2, step2, start3, end3, step3, start1, end1, step1, op); + else gen_jumptable(base, start3, end3, step3, start2, end2, step2, start1, end1, step1, op); +} + +static void gen_opjumptable(u32 op) +{ + gen_opjumptable_ext(op, 0, 0, 0, op); +} + +#define GEN_ADR 1 +#define GEN_RES 2 +#define GEN_SRC 4 +#define GEN_DST 8 +#define GEN_ALL 15 + +static void start_op(u32 op, int v) +{ + current_io_sav = 0; + current_cycle = 0; + + wf_op("\n// %s\n", current_op->op_name); +#ifndef C68K_NO_JUMP_TABLE + wf_op("OP_0x%.4X:\n", op & 0xFFFF); +#else + wf_op("case 0x%.4X:\n", op & 0xFFFF); +#endif + wf_op("{\n"); + if (v & GEN_ADR) wf_op("\tu32 adr;\n"); + if (v & GEN_RES) wf_op("\tu32 res;\n"); + if (v & GEN_DST) wf_op("\tpointer dst;\n"); + if (v & GEN_SRC) wf_op("\tpointer src;\n"); +} + +static void add_CCnt(u32 cycle) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + current_io_sav = 0; + wf_op("\tCCnt -= %d;\n", cycle); +} + +static void adds_CCnt(char *str) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + current_io_sav = 0; + wf_op("\tCCnt -= %s;\n", str); +} + +#if 0 // FIXME: warning removal +static void sub_CCnt(u32 cycle) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + current_io_sav = 0; + wf_op("\tCCnt += %d;\n", cycle); +} + +static void subs_CCnt(char *str) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + current_io_sav = 0; + wf_op("\tCCnt += %s;\n", str); +} + +static void quick_fterminate_op(u32 cycle) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + current_io_sav = 0; + wf_op("\tCCnt -= %d;\n", current_cycle + cycle); + wf_op("\tgoto C68k_Exec_End;\n"); +} +#endif + +static void fterminate_op(u32 cycle) +{ + wf_op("}\n"); + if (current_io_sav) wf_op("POST_IO\n"); + current_io_sav = 0; + wf_op("CCnt -= %d;\n", current_cycle + cycle); + wf_op("goto C68k_Exec_End;\n"); +} + +static void quick_terminate_op(u32 cycle) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + current_io_sav = 0; + wf_op("\tRET(%d)\n", current_cycle + cycle); +} + +static void terminate_op(u32 cycle) +{ + if (current_io_sav) wf_op("\tPOST_IO\n"); + wf_op("}\n"); + current_io_sav = 0; + wf_op("RET(%d)\n", current_cycle + cycle); +} + +static void do_pre_io(void) +{ + if (!current_io_sav) fprintf(opcode_file, "\tPRE_IO\n"); + current_io_sav = 1; +} + +static void mem_op(char* fmt, ...) +{ + va_list args; + + if (opcode_file == NULL) return; + + do_pre_io(); + + va_start(args, fmt); + vfprintf(opcode_file, fmt, args); + va_end(args); +} + +// flag emitter function +///////////////////////// + +static void set_logic_flag(void) +{ + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_V = 0;\n"); + wf_op("\tCPU->flag_notZ = res;\n"); + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = res;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_N = res >> 8;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_logicl_flag(void) +{ + wf_op("\tCPU->flag_C = 0;\n"); + wf_op("\tCPU->flag_V = 0;\n"); + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = res;\n"); + wf_op("\tCPU->flag_notZ = res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_notZ = res & 0xFFFF;\n"); + wf_op("\tCPU->flag_N = res >> 8;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_add_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_V = (src ^ res) & (dst ^ res);\n"); + wf_op("\tCPU->flag_notZ = res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ = res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_X = CPU->flag_C = ((src & dst) | (~res & (src | dst))) >> 23;\n"); + wf_op("\tCPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_addx_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_V = (src ^ res) & (dst ^ res);\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = ((src ^ res) & (dst ^ res)) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ |= res;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_X = CPU->flag_C = ((src & dst) | (~res & (src | dst))) >> 23;\n"); + wf_op("\tCPU->flag_V = ((src ^ res) & (dst ^ res)) >> 24;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_sub_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_V = (src ^ dst) & (res ^ dst);\n"); + wf_op("\tCPU->flag_notZ = res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ = res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res) | (~dst & (src | res))) >> 23;\n"); + wf_op("\tCPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_subx_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_V = (src ^ dst) & (res ^ dst);\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ |= res;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res) | (~dst & (src | res))) >> 23;\n"); + wf_op("\tCPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_cmp_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_N = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_V = (src ^ dst) & (res ^ dst);\n"); + wf_op("\tCPU->flag_notZ = res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ = res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_C = ((src & res) | (~dst & (src | res))) >> 23;\n"); + wf_op("\tCPU->flag_V = ((src ^ dst) & (res ^ dst)) >> 24;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_negx_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_V = res & src;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = (res & src) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ |= res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ |= res;\n"); + wf_op("\tCPU->flag_V = (res & src) >> 24;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res) | (~dst & (src | res))) >> 23;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static void set_neg_flag(void) +{ + switch(current_size) + { + case SIZE_BYTE: + wf_op("\tCPU->flag_V = res & src;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res;\n"); + wf_op("\tCPU->flag_notZ = res & 0xFF;\n"); + break; + + case SIZE_WORD: + wf_op("\tCPU->flag_V = (res & src) >> 8;\n"); + wf_op("\tCPU->flag_N = CPU->flag_X = CPU->flag_C = res >> 8;\n"); + wf_op("\tCPU->flag_notZ = res & 0xFFFF;\n"); + break; + + case SIZE_LONG: + wf_op("\tCPU->flag_notZ = res;\n"); + wf_op("\tCPU->flag_V = (res & src) >> 24;\n"); + wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;\n"); +// wf_op("\tCPU->flag_X = CPU->flag_C = ((src & res) | (~dst & (src | res))) >> 23;\n"); + wf_op("\tCPU->flag_N = res >> 24;\n"); + break; + } +} + +static char* get_cond_as_cond(u32 cond, u32 notvar) +{ + if (notvar) cond ^= 1; + + switch(cond) + { + case COND_TR: + sprintf(current_cond_char, "(1)"); + break; + + case COND_FA: + sprintf(current_cond_char, "(0)"); + break; + + case COND_HI: + sprintf(current_cond_char, "(CPU->flag_notZ && (!(CPU->flag_C & 0x100)))"); + break; + + case COND_LS: + sprintf(current_cond_char, "((!CPU->flag_notZ) || (CPU->flag_C & 0x100))"); + break; + + case COND_CC: + sprintf(current_cond_char, "(!(CPU->flag_C & 0x100))"); + break; + + case COND_CS: + sprintf(current_cond_char, "(CPU->flag_C & 0x100)"); + break; + + case COND_NE: + sprintf(current_cond_char, "(CPU->flag_notZ)"); + break; + + case COND_EQ: + sprintf(current_cond_char, "(!CPU->flag_notZ)"); + break; + + case COND_VC: + sprintf(current_cond_char, "(!(CPU->flag_V & 0x80))"); + break; + + case COND_VS: + sprintf(current_cond_char, "(CPU->flag_V & 0x80)"); + break; + + case COND_PL: + sprintf(current_cond_char, "(!(CPU->flag_N & 0x80))"); + break; + + case COND_MI: + sprintf(current_cond_char, "(CPU->flag_N & 0x80)"); + break; + + case COND_GE: + sprintf(current_cond_char, "(!((CPU->flag_N ^ CPU->flag_V) & 0x80))"); + break; + + case COND_LT: + sprintf(current_cond_char, "((CPU->flag_N ^ CPU->flag_V) & 0x80)"); + break; + + case COND_GT: + sprintf(current_cond_char, "(CPU->flag_notZ && (!((CPU->flag_N ^ CPU->flag_V) & 0x80)))"); + break; + + case COND_LE: + sprintf(current_cond_char, "((!CPU->flag_notZ) || ((CPU->flag_N ^ CPU->flag_V) & 0x80))"); + break; + } + + return current_cond_char; +} + +// effective address related function +////////////////////////////////////// + +static u32 has_ea(u32 ea) +{ + if (ea == EA_AINC7) return (current_op->ea_supported[EA_AINC] == 'o'); + if (ea == EA_ADEC7) return (current_op->ea_supported[EA_ADEC] == 'o'); + if (ea <= EA_IMM) return (current_op->ea_supported[ea] == 'o'); + return 0; +} + +static u32 has_ea2(u32 ea) +{ + if (ea == EA_AINC7) return (current_op->ea2_supported[EA_AINC] == 'o'); + if (ea == EA_ADEC7) return (current_op->ea2_supported[EA_ADEC] == 'o'); + if (ea <= EA_IMM) return (current_op->ea2_supported[ea] == 'o'); + return 0; +} + +#if 0 // FIXME: warning removal +static u32 _eamreg_to_ea(u32 eam, u32 reg) +{ + if ((eam > 7) || (reg > 7)) return EA_ILLEGAL; + if ((eam == 3) && (reg == 7)) return EA_AINC7; + if ((eam == 4) && (reg == 7)) return EA_ADEC7; + if (eam != 7) return eam; + if (reg < 5) return (eam + reg); + return EA_ILLEGAL; +} +#endif + +static u32 _ea_to_eamreg(u32 ea) +{ + if (ea < 7) return (ea << 3) | 0; + if (ea == EA_AINC7) return (EA_AINC << 3) | 7; + if (ea == EA_ADEC7) return (EA_ADEC << 3) | 7; + if (ea <= EA_IMM) return (7 << 3) | (ea - 7); + return (7 << 3) | 7; +} + +static u32 is_ea_memory(u32 ea) +{ + if ((ea > EA_AREG) && (ea != EA_IMM)) return 1; + else return 0; +} + +static void _ea_calc_free(u32 ea, u32 rsft) +{ + u32 step; + + step = 0; + switch (current_size) + { + case SIZE_BYTE: + if ((ea == EA_AINC7) || (ea == EA_ADEC7)) step = 2; + else step = 1; + break; + + case SIZE_WORD: + step = 2; + break; + + case SIZE_LONG: + step = 4; + break; + } + + switch (ea) + { + case EA_DREG: +// wf_op("\tadr = (u32)(&CPU->D[(Opcode >> %d) & 7]);\n", rsft); + break; + + case EA_AREG: +// wf_op("\tadr = (u32)(&CPU->A[(Opcode >> %d) & 7]);\n", rsft); + break; + + case EA_AIND: + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", rsft); + break; + + case EA_AINC: + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", rsft); + wf_op("\tCPU->A[(Opcode >> %d) & 7] += %d;\n", rsft, step); + break; + + case EA_AINC7: + wf_op("\tadr = CPU->A[7];\n"); + wf_op("\tCPU->A[7] += %d;\n", step); + break; + + case EA_ADEC: + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7] - %d;\n", rsft, step); + wf_op("\tCPU->A[(Opcode >> %d) & 7] = adr;\n", rsft); + break; + + case EA_ADEC7: + wf_op("\tadr = CPU->A[7] - %d;\n", step); + wf_op("\tCPU->A[7] = adr;\n"); + break; + + case EA_D16A: + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7] + (s32)(s16)FETCH_WORD;\n", rsft); + wf_op("\tPC += 2;\n"); + break; + + case EA_D8AX: + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", rsft); + wf_op("\tDECODE_EXT_WORD\n"); + break; + + case EA_A16: + wf_op("\tadr = (s32)(s16)FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + break; + + case EA_A32: + wf_op("\tadr = (s32)FETCH_LONG;\n"); + wf_op("\tPC += 4;\n"); + break; + + case EA_D16P: + wf_op("\tadr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + break; + + case EA_D8PX: + wf_op("\tadr = PC - CPU->BasePC;\n"); + wf_op("\tDECODE_EXT_WORD\n"); + break; + } +} + +static void _ea_calc(u32 ea, u32 rsft) +{ + u32 step; + u32 cycle_sft; + + step = 0; + cycle_sft = 0; + switch (current_size) + { + case SIZE_BYTE: + if ((ea == EA_AINC7) || (ea == EA_ADEC7)) step = 2; + else step = 1; + break; + + case SIZE_WORD: + step = 2; + break; + + case SIZE_LONG: + cycle_sft = 1; + step = 4; + break; + } + + switch (ea) + { + case EA_DREG: +// wf_op("\tadr = (u32)(&CPU->D[(Opcode >> %d) & 7]);\n", rsft); + break; + + case EA_AREG: +// wf_op("\tadr = (u32)(&CPU->A[(Opcode >> %d) & 7]);\n", rsft); + break; + + case EA_IMM: + current_cycle += (4 << cycle_sft) + 0; + break; + + case EA_AIND: + current_cycle += (4 << cycle_sft) + 0; + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", rsft); + break; + + case EA_AINC: + current_cycle += (4 << cycle_sft) + 0; + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", rsft); + wf_op("\tCPU->A[(Opcode >> %d) & 7] += %d;\n", rsft, step); + break; + + case EA_AINC7: + current_cycle += (4 << cycle_sft) + 0; + wf_op("\tadr = CPU->A[7];\n"); + wf_op("\tCPU->A[7] += %d;\n", step); + break; + + case EA_ADEC: + current_cycle += (4 << cycle_sft) + 2; + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7] - %d;\n", rsft, step); + wf_op("\tCPU->A[(Opcode >> %d) & 7] = adr;\n", rsft); + break; + + case EA_ADEC7: + current_cycle += (4 << cycle_sft) + 2; + wf_op("\tadr = CPU->A[7] - %d;\n", step); + wf_op("\tCPU->A[7] = adr;\n"); + break; + + case EA_D16A: + current_cycle += (4 << cycle_sft) + 4; + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7] + (s32)(s16)FETCH_WORD;\n", rsft); + wf_op("\tPC += 2;\n"); + break; + + case EA_D8AX: + current_cycle += (4 << cycle_sft) + 6; + wf_op("\tadr = CPU->A[(Opcode >> %d) & 7];\n", rsft); + wf_op("\tDECODE_EXT_WORD\n"); + break; + + case EA_A16: + current_cycle += (4 << cycle_sft) + 4; + wf_op("\tadr = (s32)(s16)FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + break; + + case EA_A32: + current_cycle += (4 << cycle_sft) + 8; + wf_op("\tadr = (s32)FETCH_LONG;\n"); + wf_op("\tPC += 4;\n"); + break; + + case EA_D16P: + current_cycle += (4 << cycle_sft) + 4; + wf_op("\tadr = (PC - CPU->BasePC) + (s32)(s16)FETCH_WORD;\n"); + wf_op("\tPC += 2;\n"); + break; + + case EA_D8PX: + current_cycle += (4 << cycle_sft) + 6; + wf_op("\tadr = PC - CPU->BasePC;\n"); + wf_op("\tDECODE_EXT_WORD\n"); + break; + } +} + +static void _ea_read_(u32 ea, u32 rsft, char dest[4]) +{ + char sz[8]; + + switch (current_size) + { + case SIZE_BYTE: + strcpy(sz, "BYTE"); + break; + + case SIZE_WORD: + strcpy(sz, "WORD"); + break; + + case SIZE_LONG: + strcpy(sz, "LONG"); + break; + } + + switch (ea) + { + case EA_DREG: + wf_op("\t%s = (%s)CPU->D[(Opcode >> %d) & 7];\n", dest, szc, rsft); + break; + + case EA_AREG: + if (current_size == SIZE_BYTE) + { + wf_op("\t// can't read byte from Ax registers !\n"); + wf_op("\tCPU->Status |= C68K_FAULTED;\n"); + wf_op("\tCCnt = 0;\n"); + wf_op("\tgoto C68k_Exec_Really_End;\n"); + } + else wf_op("\t%s = (%s)CPU->A[(Opcode >> %d) & 7];\n", dest, szc, rsft); + break; +/* + case EA_DREG: + case EA_AREG: + wf_op("\t%s = %s(adr);\n", dest, szcf); + break; +*/ + case EA_A32: + case EA_D8AX: + case EA_D8PX: + case EA_D16A: + case EA_D16P: + case EA_A16: + case EA_ADEC: + case EA_ADEC7: + case EA_AIND: + case EA_AINC: + case EA_AINC7: + mem_op("\tREAD_%s_F(adr, %s)\n", sz, dest); + break; + + case EA_IMM: + switch (current_size) + { + case SIZE_BYTE: + wf_op("\t%s = FETCH_BYTE;\n", dest); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_WORD: + wf_op("\t%s = FETCH_WORD;\n", dest); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_LONG: + wf_op("\t%s = FETCH_LONG;\n", dest); + wf_op("\tPC += 4;\n"); + break; + } + break; + } +} + +static void _ea_read(u32 ea, u32 rsft) +{ + _ea_read_(ea, rsft, "res"); +} + +static void _ea_read_src(u32 ea, u32 rsft) +{ + _ea_read_(ea, rsft, "src"); +} + +static void _ea_read_dst(u32 ea, u32 rsft) +{ + _ea_read_(ea, rsft, "dst"); +} + +static void _ea_read_sx_(u32 ea, u32 rsft, char dest[4]) +{ + char sz[8]; + + switch (current_size) + { + case SIZE_BYTE: + strcpy(sz, "BYTE"); + break; + + case SIZE_WORD: + strcpy(sz, "WORD"); + break; + + case SIZE_LONG: + strcpy(sz, "LONG"); + break; + } + + switch (ea) + { + case EA_DREG: + wf_op("\t%s = (s32)(%s)CPU->D[(Opcode >> %d) & 7];\n", dest, szcs, rsft); + break; + + case EA_AREG: + if (current_size == SIZE_BYTE) + { + wf_op("\t// can't read byte from Ax registers !\n"); + wf_op("\tCPU->Status |= C68K_FAULTED;\n"); + wf_op("\tCCnt = 0;\n"); + wf_op("\tgoto C68k_Exec_Really_End;\n"); + } + else wf_op("\t%s = (s32)(%s)CPU->A[(Opcode >> %d) & 7];\n", dest, szcs, rsft); + break; +/* + case EA_DREG: + case EA_AREG: + wf_op("\t%s = (s32)(%s(adr));\n", dest, szcsf); + break; +*/ + case EA_A32: + case EA_D8AX: + case EA_D8PX: + case EA_D16A: + case EA_D16P: + case EA_A16: + case EA_ADEC: + case EA_ADEC7: + case EA_AIND: + case EA_AINC: + case EA_AINC7: + mem_op("\tREADSX_%s_F(adr, %s)\n", sz, dest); + break; + + case EA_IMM: + switch (current_size) + { + case SIZE_BYTE: + wf_op("\t%s = (s32)(%s(PC)));\n", dest, szcsf); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_WORD: + wf_op("\t%s = (s32)(%s)FETCH_WORD;\n", dest, szcs); + wf_op("\tPC += 2;\n"); + break; + + case SIZE_LONG: + wf_op("\t%s = (s32)(%s)FETCH_LONG;\n", dest, szcs); + wf_op("\tPC += 4;\n"); + break; + } + break; + } +} + +static void _ea_read_sx(u32 ea, u32 rsft) +{ + _ea_read_sx_(ea, rsft, "res"); +} + +static void _ea_read_src_sx(u32 ea, u32 rsft) +{ + _ea_read_sx_(ea, rsft, "src"); +} + +static void _ea_write(u32 ea, u32 rsft) +{ + char sz[8]; + + switch (current_size) + { + case SIZE_BYTE: + strcpy(sz, "BYTE"); + break; + + case SIZE_WORD: + strcpy(sz, "WORD"); + break; + + case SIZE_LONG: + strcpy(sz, "LONG"); + break; + } + + switch (ea) + { + case EA_DREG: + wf_op("\t%s(&CPU->D[(Opcode >> %d) & 7])) = res;\n", szcf, +rsft); + break; + + case EA_AREG: + // writes in Ax registers are always 32 bits sized + wf_op("\tCPU->A[(Opcode >> %d) & 7] = res;\n", rsft); + break; +/* + case EA_DREG: + case EA_AREG: + wf_op("\t%s(adr) = res;\n", szcf); + break; +*/ + case EA_A32: + case EA_D8AX: + case EA_D8PX: + case EA_D16A: + case EA_D16P: + case EA_A16: + case EA_ADEC: + case EA_ADEC7: + case EA_AIND: + case EA_AINC: + case EA_AINC7: + mem_op("\tWRITE_%s_F(adr, res)\n", sz); + break; + } +} + +// misc function +///////////////// + +static u32 get_current_opcode_base(void) +{ + u32 base; + + base = current_op->op_base; + if (current_op->eam_sft != -1) base += (current_eam & 7) << current_op->eam_sft; + if (current_op->reg_sft != -1) base += (current_reg & 7) << current_op->reg_sft; + if (current_op->eam2_sft != -1) base += (current_eam2 & 7) << current_op->eam2_sft; + if (current_op->reg2_sft != -1) base += (current_reg2 & 7) << current_op->reg2_sft; + if (current_op->size_type == 1) base += (current_size - 1) << current_op->size_sft; + else if (current_op->size_type == 2) base += (current_size & 3) << current_op->size_sft; + + return base; +} + +static void start_all(int v) +{ + u32 base; + + base = get_current_opcode_base(); + + // generate jump table + gen_opjumptable(base); + + // generate label & declarations + start_op(base, v); +} + +static void set_current_size(u32 sz) +{ + current_size = sz; + switch(current_size) + { + case SIZE_BYTE: + current_bits_mask = 0xFF; + current_sft_mask = 7; + strcpy(szc, "u8"); + strcpy(szcf, "*(BYTE_OFF + (u8*)"); + strcpy(szcs, "s8"); + strcpy(szcsf, "*(BYTE_OFF + (s8*)"); + break; + + case SIZE_WORD: + current_bits_mask = 0xFFFF; + current_sft_mask = 15; + strcpy(szc, "u16"); + strcpy(szcf, "*(WORD_OFF + (u16*)"); + strcpy(szcs, "s16"); + strcpy(szcsf, "*(WORD_OFF + (s16*)"); + break; + + case SIZE_LONG: + current_bits_mask = 0xFFFFFFFF; + current_sft_mask = 31; + strcpy(szc, "u32"); + strcpy(szcf, "*((u32*)"); + strcpy(szcs, "s32"); + strcpy(szcsf, "*((s32*)"); + break; + } +} + +// gen privilege exception (happen when S flag is not set) +static void gen_privilege_exception(char *pre) +{ + // swap A7 and USP (because S not set) + wf_op("%sres = CPU->USP;\n", pre); + wf_op("%sCPU->USP = CPU->A[7];\n", pre); + wf_op("%sCPU->A[7] = res;\n", pre); + + // get vector & add cycle + wf_op("%sres = C68K_PRIVILEGE_VIOLATION_EX;\n", pre); + adds_CCnt("c68k_exception_cycle_table[res]"); + + // we will do some mem/io access + do_pre_io(); + + // push PC and SR + mem_op("%sPUSH_32_F(PC - CPU->BasePC)\n", pre); + mem_op("%sPUSH_16_F(GET_SR)\n", pre); + + // adjust SR + wf_op("%sCPU->flag_S = C68K_SR_S;\n", pre); + + // fetch new PC + mem_op("%sREAD_LONG_F(res * 4, PC)\n", pre); + wf_op("%sSET_PC(PC)\n", pre); +} + +static void gen_exception(char *pre, char* exception) +{ + // swap A7 and USP if needed + wf_op("%sif (!CPU->flag_S)\n", pre); + wf_op("%s{\n", pre); + wf_op("%s\tres = CPU->USP;\n", pre); + wf_op("%s\tCPU->USP = CPU->A[7];\n", pre); + wf_op("%s\tCPU->A[7] = res;\n", pre); + wf_op("%s}\n", pre); + + // get vector & add cycle + wf_op("%sres = %s;\n", pre, exception); + adds_CCnt("c68k_exception_cycle_table[res]"); + + // we will do some mem/io access + do_pre_io(); + + // push PC and SR + mem_op("%sPUSH_32_F(PC - CPU->BasePC)\n", pre); + mem_op("%sPUSH_16_F(GET_SR)\n", pre); + + // adjust SR + wf_op("%sCPU->flag_S = C68K_SR_S;\n", pre); + + // fetch new PC + mem_op("%sREAD_LONG_F(res * 4, PC)\n", pre); + wf_op("%sSET_PC(PC)\n", pre); +} + diff --git a/m68000/m68000.c b/m68000/m68000.c index 3ddb55b..b04dd74 100644 --- a/m68000/m68000.c +++ b/m68000/m68000.c @@ -7,9 +7,12 @@ ******************************************************************************/ #include "m68000.h" -#include "c68k.h" +#include "c68k/c68k.h" #include "../x68k/memory.h" +int m68000_ICountBk; +int ICount; + /****************************************************************************** CPS2暗号化ROM用 ******************************************************************************/ @@ -65,21 +68,29 @@ static UINT16 m68000_read_pcrelative_16(UINT32 offset) /*-------------------------------------------------------- CPU初期化 --------------------------------------------------------*/ +s32 my_irqh_callback(s32 level); void m68000_init(void) { - C68k_Init(&C68K); - C68k_Set_ReadB(&C68K, Memory_ReadB); - C68k_Set_ReadW(&C68K, Memory_ReadW); - C68k_Set_WriteB(&C68K, Memory_WriteB); - C68k_Set_WriteW(&C68K, Memory_WriteW); - C68k_Set_Fetch(&C68K, 0x000000, 0xbfffff, (UINT32)MEM); - C68k_Set_Fetch(&C68K, 0xc00000, 0xc7ffff, (UINT32)GVRAM); - C68k_Set_Fetch(&C68K, 0xe00000, 0xe7ffff, (UINT32)TVRAM); - C68k_Set_Fetch(&C68K, 0xea0000, 0xea1fff, (UINT32)SCSIIPL); - C68k_Set_Fetch(&C68K, 0xed0000, 0xed3fff, (UINT32)SRAM); - C68k_Set_Fetch(&C68K, 0xf00000, 0xfbffff, (UINT32)FONT); - C68k_Set_Fetch(&C68K, 0xfc0000, 0xffffff, (UINT32)IPL); + C68k_Init(&C68K, my_irqh_callback); +#if 0 + C68k_Set_ReadB(&C68K, Memory_ReadB); + C68k_Set_ReadW(&C68K, Memory_ReadW); + C68k_Set_WriteB(&C68K, Memory_WriteB); + C68k_Set_WriteW(&C68K, Memory_WriteW); +#else + C68k_Set_ReadB(&C68K, Memory_ReadB); + C68k_Set_ReadW(&C68K, Memory_ReadW); + C68k_Set_WriteB(&C68K, Memory_WriteB); + C68k_Set_WriteW(&C68K, Memory_WriteW); +#endif + C68k_Set_Fetch(&C68K, 0x000000, 0xbfffff, (pointer)MEM); + C68k_Set_Fetch(&C68K, 0xc00000, 0xc7ffff, (pointer)GVRAM); + C68k_Set_Fetch(&C68K, 0xe00000, 0xe7ffff, (pointer)TVRAM); + C68k_Set_Fetch(&C68K, 0xea0000, 0xea1fff, (pointer)SCSIIPL); + C68k_Set_Fetch(&C68K, 0xed0000, 0xed3fff, (pointer)SRAM); + C68k_Set_Fetch(&C68K, 0xf00000, 0xfbffff, (pointer)FONT); + C68k_Set_Fetch(&C68K, 0xfc0000, 0xffffff, (pointer)IPL); } @@ -123,15 +134,17 @@ void m68000_execute2(UINT32 start, UINT32 break_point) UINT32 pc, old_pc, opcode; c68k_struc C68K_temp; - old_pc = C68k_Get_Reg(&C68K, M68K_PC); + old_pc = C68k_Get_PC(&C68K); memcpy(&C68K_temp, &C68K, sizeof(c68k_struc)); - C68k_Set_Reg(&C68K_temp, C68K_PC, start); +// C68k_Set_Reg(&C68K_temp, C68K_PC, start); + C68k_Set_PC(&C68K_temp, start); C68K_temp.A[5] = 0x108000; C68K_temp.A[7] -= 4 * 8 * 2; - while ((pc = C68k_Get_Reg(&C68K_temp, M68K_PC)) != break_point) +// while ((pc = C68k_Get_Reg(&C68K_temp, M68K_PC)) != break_point) + while ((pc = C68k_Get_PC(&C68K_temp)) != break_point) { opcode = Memory_ReadW(pc); if (opcode == 0x4e75) @@ -159,7 +172,8 @@ void m68000_execute2(UINT32 start, UINT32 break_point) C68k_Exec(&C68K_temp, 1); } - C68k_Set_Reg(&C68K, C68K_PC, old_pc); +// C68k_Set_Reg(&C68K, C68K_PC, old_pc); + C68k_Set_PC(&C68K, old_pc); } #endif @@ -170,10 +184,11 @@ void m68000_execute2(UINT32 start, UINT32 break_point) void m68000_set_irq_line(int irqline, int state) { - if (irqline == IRQ_LINE_NMI) - irqline = 7; +// if (irqline == IRQ_LINE_NMI) +// irqline = 7; - C68k_Set_IRQ(&C68K, irqline, state); +// C68k_Set_IRQ(&C68K, irqline, state); + C68k_Set_IRQ(&C68K, irqline); } @@ -183,7 +198,7 @@ void m68000_set_irq_line(int irqline, int state) void m68000_set_irq_callback(int (*callback)(int line)) { - C68k_Set_IRQ_Callback(&C68K, callback); +// C68k_Set_IRQ_Callback(&C68K, callback); } @@ -195,6 +210,7 @@ UINT32 m68000_get_reg(int regnum) { switch (regnum) { +#if 0 case M68K_PC: return C68k_Get_Reg(&C68K, C68K_PC); case M68K_USP: return C68k_Get_Reg(&C68K, C68K_USP); case M68K_MSP: return C68k_Get_Reg(&C68K, C68K_MSP); @@ -215,6 +231,29 @@ UINT32 m68000_get_reg(int regnum) case M68K_A5: return C68k_Get_Reg(&C68K, C68K_A5); case M68K_A6: return C68k_Get_Reg(&C68K, C68K_A6); case M68K_A7: return C68k_Get_Reg(&C68K, C68K_A7); +#else + case M68K_PC: return C68k_Get_PC(&C68K); + case M68K_USP: return C68k_Get_USP(&C68K); + case M68K_MSP: return C68k_Get_MSP(&C68K); + case M68K_SR: return C68k_Get_SR(&C68K); + case M68K_D0: return C68k_Get_DReg(&C68K, 0); + case M68K_D1: return C68k_Get_DReg(&C68K, 1); + case M68K_D2: return C68k_Get_DReg(&C68K, 2); + case M68K_D3: return C68k_Get_DReg(&C68K, 3); + case M68K_D4: return C68k_Get_DReg(&C68K, 4); + case M68K_D5: return C68k_Get_DReg(&C68K, 5); + case M68K_D6: return C68k_Get_DReg(&C68K, 6); + case M68K_D7: return C68k_Get_DReg(&C68K, 7); + case M68K_A0: return C68k_Get_AReg(&C68K, 0); + case M68K_A1: return C68k_Get_AReg(&C68K, 1); + case M68K_A2: return C68k_Get_AReg(&C68K, 2); + case M68K_A3: return C68k_Get_AReg(&C68K, 3); + case M68K_A4: return C68k_Get_AReg(&C68K, 4); + case M68K_A5: return C68k_Get_AReg(&C68K, 5); + case M68K_A6: return C68k_Get_AReg(&C68K, 6); + case M68K_A7: return C68k_Get_AReg(&C68K, 7); +#endif + default: return 0; } } @@ -228,6 +267,7 @@ void m68000_set_reg(int regnum, UINT32 val) { switch (regnum) { +#if 0 case M68K_PC: C68k_Set_Reg(&C68K, C68K_PC, val); break; case M68K_USP: C68k_Set_Reg(&C68K, C68K_USP, val); break; case M68K_MSP: C68k_Set_Reg(&C68K, C68K_MSP, val); break; @@ -248,6 +288,28 @@ void m68000_set_reg(int regnum, UINT32 val) case M68K_A5: C68k_Set_Reg(&C68K, C68K_A5, val); break; case M68K_A6: C68k_Set_Reg(&C68K, C68K_A6, val); break; case M68K_A7: C68k_Set_Reg(&C68K, C68K_A7, val); break; +#else + case M68K_PC: C68k_Set_PC(&C68K, val); break; + case M68K_USP: C68k_Set_USP(&C68K, val); break; + case M68K_MSP: C68k_Set_MSP(&C68K, val); break; + case M68K_SR: C68k_Set_SR(&C68K, val); break; + case M68K_D0: C68k_Set_DReg(&C68K, 0, val); break; + case M68K_D1: C68k_Set_DReg(&C68K, 1, val); break; + case M68K_D2: C68k_Set_DReg(&C68K, 2, val); break; + case M68K_D3: C68k_Set_DReg(&C68K, 3, val); break; + case M68K_D4: C68k_Set_DReg(&C68K, 4, val); break; + case M68K_D5: C68k_Set_DReg(&C68K, 5, val); break; + case M68K_D6: C68k_Set_DReg(&C68K, 6, val); break; + case M68K_D7: C68k_Set_DReg(&C68K, 7, val); break; + case M68K_A0: C68k_Set_AReg(&C68K, 0, val); break; + case M68K_A1: C68k_Set_AReg(&C68K, 1, val); break; + case M68K_A2: C68k_Set_AReg(&C68K, 2, val); break; + case M68K_A3: C68k_Set_AReg(&C68K, 3, val); break; + case M68K_A4: C68k_Set_AReg(&C68K, 4, val); break; + case M68K_A5: C68k_Set_AReg(&C68K, 5, val); break; + case M68K_A6: C68k_Set_AReg(&C68K, 6, val); break; + case M68K_A7: C68k_Set_AReg(&C68K, 7, val); break; +#endif default: break; } } diff --git a/m68000/m68000.h b/m68000/m68000.h index 2665e9b..99598ee 100644 --- a/m68000/m68000.h +++ b/m68000/m68000.h @@ -9,7 +9,7 @@ #ifndef M68000_H #define M68000_H -#include "c68k.h" +#include "c68k/c68k.h" // MAME互換のレジスタ番号 (一部未対応) enum diff --git a/m68000/old/c68k.c b/m68000/old/c68k.c new file mode 100644 index 0000000..c8fdfd2 --- /dev/null +++ b/m68000/old/c68k.c @@ -0,0 +1,334 @@ +/****************************************************************************** + * + * C68K (68000 CPU emulator) version 0.80 + * Compiled with Dev-C++ + * Copyright 2003-2004 Stephane Dallongeville + * + * (Modified by NJ) + * + *****************************************************************************/ + +#include +#include +#include "c68k.h" + + +/****************************************************************************** + マクロ +******************************************************************************/ + +#include "c68kmacro.h" + + +/****************************************************************************** + グローバル構造体 +******************************************************************************/ + +c68k_struc C68K; +int m68000_ICountBk; +int ICount; + +/****************************************************************************** + ローカル変数 +******************************************************************************/ + +static void *JumpTable[0x10000]; +static UINT8 c68k_bad_address[1 << C68K_FETCH_SFT]; + + +/****************************************************************************** + ローカル関数 +******************************************************************************/ + +/*-------------------------------------------------------- + 割り込みコールバック +--------------------------------------------------------*/ + +static INT32 C68k_InterruptCallback(INT32 line) +{ + return C68K_INTERRUPT_AUTOVECTOR_EX + line; +} + + +/*-------------------------------------------------------- + リセットコールバック +--------------------------------------------------------*/ + +static void C68k_ResetCallback(void) +{ +} + + +/****************************************************************************** + C68Kインタフェース関数 +******************************************************************************/ + +/*-------------------------------------------------------- + CPU初期化 +--------------------------------------------------------*/ + +void C68k_Init(c68k_struc *CPU) +{ + int i; + + memset(CPU, 0, sizeof(c68k_struc)); + + CPU->Interrupt_CallBack = C68k_InterruptCallback; + CPU->Reset_CallBack = C68k_ResetCallback; + + memset(c68k_bad_address, 0xff, sizeof(c68k_bad_address)); + + for (i = 0; i < C68K_FETCH_BANK; i++) + CPU->Fetch[i] = (UINT32)c68k_bad_address; + + C68k_Exec(NULL, 0); +} + + +/*-------------------------------------------------------- + CPUリセット +--------------------------------------------------------*/ + +void C68k_Reset(c68k_struc *CPU) +{ + UINT32 PC; + + memset(CPU, 0, (UINT32)&CPU->BasePC - (UINT32)CPU); + + CPU->flag_I = 7; + CPU->flag_S = C68K_SR_S; + + // SP, PCの初期化はWinX68k_Reset()側で実行する +} + + +/*-------------------------------------------------------- + CPU実行 +--------------------------------------------------------*/ + +extern DWORD BusErrHandling; +extern DWORD BusErrAdr; + +INT32 C68k_Exec(c68k_struc *CPU, INT32 cycles) +{ + if (CPU) + { + UINT32 PC; + UINT32 Opcode; + UINT32 adr; + UINT32 res; + UINT32 src; + UINT32 dst; + + PC = CPU->PC; + CPU->ICount = cycles; + +C68k_Check_Interrupt: + CHECK_INT + if (!CPU->HaltState) + { + +C68k_Exec_Next: + if (CPU->ICount > 0) + { + + if (BusErrHandling) { + printf("BusError occured\n"); + SWAP_SP(); + PUSH_32_F(GET_PC() - 2); + PUSH_16_F(GET_SR()); + CPU->A[7] -= 2; + PUSH_32_F(BusErrAdr); + CPU->A[7] -= 2; + CPU->flag_S = C68K_SR_S; + PC = READ_MEM_32((C68K_BUS_ERROR_EX) << 2); + SET_PC(PC); + BusErrHandling = 0; + } + + + Opcode = READ_IMM_16(); + PC += 2; + goto *JumpTable[Opcode]; + + #include "c68k_op.c" + } + } + + CPU->PC = PC; + + return cycles - CPU->ICount; + } + else + { + #include "c68k_ini.c" + } + + return 0; +} + + +/*-------------------------------------------------------- + 割り込み処理 +--------------------------------------------------------*/ + +void C68k_Set_IRQ(c68k_struc *CPU, INT32 line, INT32 state) +{ + CPU->IRQState = state; + if (state == CLEAR_LINE) + { + CPU->IRQLine = 0; + } + else + { + CPU->IRQLine = line; + CPU->HaltState = 0; + } +} + + +/*-------------------------------------------------------- + レジスタ取得 +--------------------------------------------------------*/ + +UINT32 C68k_Get_Reg(c68k_struc *CPU, INT32 regnum) +{ + switch (regnum) + { + case C68K_PC: return (CPU->PC - CPU->BasePC); + case C68K_USP: return (CPU->flag_S ? CPU->USP : CPU->A[7]); + case C68K_MSP: return (CPU->flag_S ? CPU->A[7] : CPU->USP); + case C68K_SR: return GET_SR(); + case C68K_D0: return CPU->D[0]; + case C68K_D1: return CPU->D[1]; + case C68K_D2: return CPU->D[2]; + case C68K_D3: return CPU->D[3]; + case C68K_D4: return CPU->D[4]; + case C68K_D5: return CPU->D[5]; + case C68K_D6: return CPU->D[6]; + case C68K_D7: return CPU->D[7]; + case C68K_A0: return CPU->A[0]; + case C68K_A1: return CPU->A[1]; + case C68K_A2: return CPU->A[2]; + case C68K_A3: return CPU->A[3]; + case C68K_A4: return CPU->A[4]; + case C68K_A5: return CPU->A[5]; + case C68K_A6: return CPU->A[6]; + case C68K_A7: return CPU->A[7]; + default: return 0; + } +} + + +/*-------------------------------------------------------- + レジスタ設定 +--------------------------------------------------------*/ + +void C68k_Set_Reg(c68k_struc *CPU, INT32 regnum, UINT32 val) +{ + switch (regnum) + { + case C68K_PC: + CPU->BasePC = CPU->Fetch[(val >> C68K_FETCH_SFT) & C68K_FETCH_MASK]; + CPU->BasePC -= val & 0xff000000; + CPU->PC = val + CPU->BasePC; + break; + + case C68K_USP: + if (CPU->flag_S) CPU->USP = val; + else CPU->A[7] = val; + break; + + case C68K_MSP: + if (CPU->flag_S) CPU->A[7] = val; + else CPU->USP = val; + break; + + case C68K_SR: SET_SR(val); break; + case C68K_D0: CPU->D[0] = val; break; + case C68K_D1: CPU->D[1] = val; break; + case C68K_D2: CPU->D[2] = val; break; + case C68K_D3: CPU->D[3] = val; break; + case C68K_D4: CPU->D[4] = val; break; + case C68K_D5: CPU->D[5] = val; break; + case C68K_D6: CPU->D[6] = val; break; + case C68K_D7: CPU->D[7] = val; break; + case C68K_A0: CPU->A[0] = val; break; + case C68K_A1: CPU->A[1] = val; break; + case C68K_A2: CPU->A[2] = val; break; + case C68K_A3: CPU->A[3] = val; break; + case C68K_A4: CPU->A[4] = val; break; + case C68K_A5: CPU->A[5] = val; break; + case C68K_A6: CPU->A[6] = val; break; + case C68K_A7: CPU->A[7] = val; break; + default: break; + } + +} + + +/*-------------------------------------------------------- + フェッチアドレス設定 +--------------------------------------------------------*/ + +void C68k_Set_Fetch(c68k_struc *CPU, UINT32 low_adr, UINT32 high_adr, UINT32 fetch_adr) +{ + UINT32 i, j; + + i = (low_adr >> C68K_FETCH_SFT) & C68K_FETCH_MASK; + j = (high_adr >> C68K_FETCH_SFT) & C68K_FETCH_MASK; + fetch_adr -= i << C68K_FETCH_SFT; + while (i <= j) CPU->Fetch[i++] = fetch_adr; +} + + +/*-------------------------------------------------------- + メモリリード/ライト関数設定 +--------------------------------------------------------*/ + +void C68k_Set_ReadB(c68k_struc *CPU, UINT8 (*Func)(UINT32 address)) +{ + CPU->Read_Byte = Func; + CPU->Read_Byte_PC_Relative = Func; +} + +void C68k_Set_ReadW(c68k_struc *CPU, UINT16 (*Func)(UINT32 address)) +{ + CPU->Read_Word = Func; + CPU->Read_Word_PC_Relative = Func; +} + +void C68k_Set_ReadB_PC_Relative(c68k_struc *CPU, UINT8 (*Func)(UINT32 address)) +{ + CPU->Read_Byte_PC_Relative = Func; +} + +void C68k_Set_ReadW_PC_Relative(c68k_struc *CPU, UINT16 (*Func)(UINT32 address)) +{ + CPU->Read_Word_PC_Relative = Func; +} + +void C68k_Set_WriteB(c68k_struc *CPU, void (*Func)(UINT32 address, UINT8 data)) +{ + CPU->Write_Byte = Func; +} + +void C68k_Set_WriteW(c68k_struc *CPU, void (*Func)(UINT32 address, UINT16 data)) +{ + CPU->Write_Word = Func; +} + + +/*-------------------------------------------------------- + コールバック関数設定 +--------------------------------------------------------*/ + +void C68k_Set_IRQ_Callback(c68k_struc *CPU, INT32 (*Func)(INT32 irqline)) +{ + CPU->Interrupt_CallBack = Func; +} + +void C68k_Set_Reset_Callback(c68k_struc *CPU, void (*Func)(void)) +{ + CPU->Reset_CallBack = Func; +} diff --git a/m68000/old/c68k.h b/m68000/old/c68k.h new file mode 100644 index 0000000..4a807d2 --- /dev/null +++ b/m68000/old/c68k.h @@ -0,0 +1,184 @@ +/****************************************************************************** + * + * C68K (68000 CPU emulator) version 0.80 + * Compiled with Dev-C++ + * Copyright 2003-2004 Stephane Dallongeville + * + * (Modified by NJ) + * + *****************************************************************************/ + +#ifndef C68K_H +#define C68K_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "common.h" + +// setting +/////////// + +//#define C68K_BIG_ENDIAN + +#define C68K_FETCH_BITS 8 // [4-12] default = 8 + +// 68K core types definitions +////////////////////////////// + +#define C68K_ADR_BITS 24 + +#define C68K_FETCH_SFT (C68K_ADR_BITS - C68K_FETCH_BITS) +#define C68K_FETCH_BANK (1 << C68K_FETCH_BITS) +#define C68K_FETCH_MASK (C68K_FETCH_BANK - 1) + +#define C68K_SR_C_SFT 8 +#define C68K_SR_V_SFT 7 +#define C68K_SR_Z_SFT 0 +#define C68K_SR_N_SFT 7 +#define C68K_SR_X_SFT 8 + +#define C68K_SR_S_SFT 13 + +#define C68K_SR_C (1 << C68K_SR_C_SFT) +#define C68K_SR_V (1 << C68K_SR_V_SFT) +#define C68K_SR_Z 0 +#define C68K_SR_N (1 << C68K_SR_N_SFT) +#define C68K_SR_X (1 << C68K_SR_X_SFT) + +#define C68K_SR_S (1 << C68K_SR_S_SFT) + +#define C68K_CCR_MASK 0x1F +#define C68K_SR_MASK (0x2700 | C68K_CCR_MASK) + +// exception defines taken from musashi core +#define C68K_RESET_EX 1 +#define C68K_BUS_ERROR_EX 2 +#define C68K_ADDRESS_ERROR_EX 3 +#define C68K_ILLEGAL_INSTRUCTION_EX 4 +#define C68K_ZERO_DIVIDE_EX 5 +#define C68K_CHK_EX 6 +#define C68K_TRAPV_EX 7 +#define C68K_PRIVILEGE_VIOLATION_EX 8 +#define C68K_TRACE_EX 9 +#define C68K_1010_EX 10 +#define C68K_1111_EX 11 +#define C68K_FORMAT_ERROR_EX 14 +#define C68K_UNINITIALIZED_INTERRUPT_EX 15 +#define C68K_SPURIOUS_INTERRUPT_EX 24 +#define C68K_INTERRUPT_AUTOVECTOR_EX 24 +#define C68K_TRAP_BASE_EX 32 + +#define C68K_INT_ACK_AUTOVECTOR -1 + +#ifndef IRQ_LINE_STATE +#define IRQ_LINE_STATE +#define CLEAR_LINE 0 /* clear (a fired, held or pulsed) line */ +#define ASSERT_LINE 1 /* assert an interrupt immediately */ +#define HOLD_LINE 2 /* hold interrupt line until acknowledged */ +#define PULSE_LINE 3 /* pulse interrupt line for one instruction */ +#define IRQ_LINE_NMI 127 /* IRQ line for NMIs */ +#endif + +enum +{ + C68K_PC = 1, + C68K_USP, + C68K_MSP, + C68K_SR, + C68K_D0, + C68K_D1, + C68K_D2, + C68K_D3, + C68K_D4, + C68K_D5, + C68K_D6, + C68K_D7, + C68K_A0, + C68K_A1, + C68K_A2, + C68K_A3, + C68K_A4, + C68K_A5, + C68K_A6, + C68K_A7 +}; + +typedef struct c68k_t +{ + UINT32 D[8]; + UINT32 A[8]; + + UINT32 flag_C; + UINT32 flag_V; + UINT32 flag_Z; + UINT32 flag_N; + + UINT32 flag_X; + UINT32 flag_I; + UINT32 flag_S; + + UINT32 USP; + UINT32 PC; + + UINT32 HaltState; + INT32 IRQLine; + INT32 IRQState; + INT32 ICount; + + UINT32 BasePC; + UINT32 Fetch[C68K_FETCH_BANK]; + + UINT8 (*Read_Byte)(UINT32 address); + UINT16 (*Read_Word)(UINT32 address); + UINT8 (*Read_Byte_PC_Relative)(UINT32 address); + UINT16 (*Read_Word_PC_Relative)(UINT32 address); + void (*Write_Byte)(UINT32 address, UINT8 data); + void (*Write_Word)(UINT32 address, UINT16 data); + + INT32 (*Interrupt_CallBack)(INT32 irqline); + void (*Reset_CallBack)(void); + +} c68k_struc; + + +// 68K core var declaration +//////////////////////////// + +extern c68k_struc C68K; +extern int m68000_ICountBk; + +// 68K core function declaration +///////////////////////////////// + +void C68k_Init(c68k_struc *cpu); + +void C68k_Reset(c68k_struc *cpu); + +INT32 C68k_Exec(c68k_struc *cpu, INT32 cycle); + +void C68k_Set_IRQ(c68k_struc *cpu, INT32 line, INT32 state); + +UINT32 C68k_Get_Reg(c68k_struc *cpu, INT32 regnum); +void C68k_Set_Reg(c68k_struc *cpu, INT32 regnum, UINT32 val); + +void C68k_Set_Fetch(c68k_struc *cpu, UINT32 low_adr, UINT32 high_adr, UINT32 fetch_adr); + +void C68k_Set_ReadB(c68k_struc *cpu, UINT8 (*Func)(UINT32 address)); +void C68k_Set_ReadW(c68k_struc *cpu, UINT16 (*Func)(UINT32 address)); + +void C68k_Set_ReadB_PC_Relative(c68k_struc *cpu, UINT8 (*Func)(UINT32 address)); +void C68k_Set_ReadW_PC_Relative(c68k_struc *cpu, UINT16 (*Func)(UINT32 address)); + +void C68k_Set_WriteB(c68k_struc *cpu, void (*Func)(UINT32 address, UINT8 data)); +void C68k_Set_WriteW(c68k_struc *cpu, void (*Func)(UINT32 address, UINT16 data)); + +void C68k_Set_IRQ_Callback(c68k_struc *cpu, INT32 (*Func)(INT32 irqline)); +void C68k_Set_Reset_Callback(c68k_struc *cpu, void (*Func)(void)); + +#ifdef __cplusplus +} +#endif + +#endif /* C68K_H */ diff --git a/m68000/old/c68k_ini.c b/m68000/old/c68k_ini.c new file mode 100644 index 0000000..83f3169 --- /dev/null +++ b/m68000/old/c68k_ini.c @@ -0,0 +1,1798 @@ +/****************************************************************************** + + c68k_ini.c + + C68K opcodeジャンプテーブル生成 + +******************************************************************************/ + + typedef struct + { + void *label; /* opcode label */ + UINT16 mask; /* mask on opcode */ + UINT16 match; /* what to match after masking */ + } opcode_struct; + + opcode_struct c68k_opcode_jump_table[] = + { + {&&op_1010 , 0xf000, 0xa000}, + {&&op_1111 , 0xf000, 0xf000}, + {&&op_moveq_32 , 0xf100, 0x7000}, + {&&op_bra_8 , 0xff00, 0x6000}, + {&&op_bsr_8 , 0xff00, 0x6100}, + {&&op_bhi_8 , 0xff00, 0x6200}, + {&&op_bls_8 , 0xff00, 0x6300}, + {&&op_bcc_8 , 0xff00, 0x6400}, + {&&op_bcs_8 , 0xff00, 0x6500}, + {&&op_bne_8 , 0xff00, 0x6600}, + {&&op_beq_8 , 0xff00, 0x6700}, + {&&op_bvc_8 , 0xff00, 0x6800}, + {&&op_bvs_8 , 0xff00, 0x6900}, + {&&op_bpl_8 , 0xff00, 0x6a00}, + {&&op_bmi_8 , 0xff00, 0x6b00}, + {&&op_bge_8 , 0xff00, 0x6c00}, + {&&op_blt_8 , 0xff00, 0x6d00}, + {&&op_bgt_8 , 0xff00, 0x6e00}, + {&&op_ble_8 , 0xff00, 0x6f00}, + {&&op_btst_32_r_d , 0xf1f8, 0x0100}, + {&&op_movep_16_er , 0xf1f8, 0x0108}, + {&&op_btst_8_r_ai , 0xf1f8, 0x0110}, + {&&op_btst_8_r_pi , 0xf1f8, 0x0118}, + {&&op_btst_8_r_pd , 0xf1f8, 0x0120}, + {&&op_btst_8_r_di , 0xf1f8, 0x0128}, + {&&op_btst_8_r_ix , 0xf1f8, 0x0130}, + {&&op_bchg_32_r_d , 0xf1f8, 0x0140}, + {&&op_movep_32_er , 0xf1f8, 0x0148}, + {&&op_bchg_8_r_ai , 0xf1f8, 0x0150}, + {&&op_bchg_8_r_pi , 0xf1f8, 0x0158}, + {&&op_bchg_8_r_pd , 0xf1f8, 0x0160}, + {&&op_bchg_8_r_di , 0xf1f8, 0x0168}, + {&&op_bchg_8_r_ix , 0xf1f8, 0x0170}, + {&&op_bclr_32_r_d , 0xf1f8, 0x0180}, + {&&op_movep_16_re , 0xf1f8, 0x0188}, + {&&op_bclr_8_r_ai , 0xf1f8, 0x0190}, + {&&op_bclr_8_r_pi , 0xf1f8, 0x0198}, + {&&op_bclr_8_r_pd , 0xf1f8, 0x01a0}, + {&&op_bclr_8_r_di , 0xf1f8, 0x01a8}, + {&&op_bclr_8_r_ix , 0xf1f8, 0x01b0}, + {&&op_bset_32_r_d , 0xf1f8, 0x01c0}, + {&&op_movep_32_re , 0xf1f8, 0x01c8}, + {&&op_bset_8_r_ai , 0xf1f8, 0x01d0}, + {&&op_bset_8_r_pi , 0xf1f8, 0x01d8}, + {&&op_bset_8_r_pd , 0xf1f8, 0x01e0}, + {&&op_bset_8_r_di , 0xf1f8, 0x01e8}, + {&&op_bset_8_r_ix , 0xf1f8, 0x01f0}, + {&&op_move_8_d_d , 0xf1f8, 0x1000}, + {&&op_move_8_d_ai , 0xf1f8, 0x1010}, + {&&op_move_8_d_pi , 0xf1f8, 0x1018}, + {&&op_move_8_d_pd , 0xf1f8, 0x1020}, + {&&op_move_8_d_di , 0xf1f8, 0x1028}, + {&&op_move_8_d_ix , 0xf1f8, 0x1030}, + {&&op_move_8_ai_d , 0xf1f8, 0x1080}, + {&&op_move_8_ai_ai , 0xf1f8, 0x1090}, + {&&op_move_8_ai_pi , 0xf1f8, 0x1098}, + {&&op_move_8_ai_pd , 0xf1f8, 0x10a0}, + {&&op_move_8_ai_di , 0xf1f8, 0x10a8}, + {&&op_move_8_ai_ix , 0xf1f8, 0x10b0}, + {&&op_move_8_pi_d , 0xf1f8, 0x10c0}, + {&&op_move_8_pi_ai , 0xf1f8, 0x10d0}, + {&&op_move_8_pi_pi , 0xf1f8, 0x10d8}, + {&&op_move_8_pi_pd , 0xf1f8, 0x10e0}, + {&&op_move_8_pi_di , 0xf1f8, 0x10e8}, + {&&op_move_8_pi_ix , 0xf1f8, 0x10f0}, + {&&op_move_8_pd_d , 0xf1f8, 0x1100}, + {&&op_move_8_pd_ai , 0xf1f8, 0x1110}, + {&&op_move_8_pd_pi , 0xf1f8, 0x1118}, + {&&op_move_8_pd_pd , 0xf1f8, 0x1120}, + {&&op_move_8_pd_di , 0xf1f8, 0x1128}, + {&&op_move_8_pd_ix , 0xf1f8, 0x1130}, + {&&op_move_8_di_d , 0xf1f8, 0x1140}, + {&&op_move_8_di_ai , 0xf1f8, 0x1150}, + {&&op_move_8_di_pi , 0xf1f8, 0x1158}, + {&&op_move_8_di_pd , 0xf1f8, 0x1160}, + {&&op_move_8_di_di , 0xf1f8, 0x1168}, + {&&op_move_8_di_ix , 0xf1f8, 0x1170}, + {&&op_move_8_ix_d , 0xf1f8, 0x1180}, + {&&op_move_8_ix_ai , 0xf1f8, 0x1190}, + {&&op_move_8_ix_pi , 0xf1f8, 0x1198}, + {&&op_move_8_ix_pd , 0xf1f8, 0x11a0}, + {&&op_move_8_ix_di , 0xf1f8, 0x11a8}, + {&&op_move_8_ix_ix , 0xf1f8, 0x11b0}, + {&&op_move_32_d_d , 0xf1f8, 0x2000}, + {&&op_move_32_d_a , 0xf1f8, 0x2008}, + {&&op_move_32_d_ai , 0xf1f8, 0x2010}, + {&&op_move_32_d_pi , 0xf1f8, 0x2018}, + {&&op_move_32_d_pd , 0xf1f8, 0x2020}, + {&&op_move_32_d_di , 0xf1f8, 0x2028}, + {&&op_move_32_d_ix , 0xf1f8, 0x2030}, + {&&op_movea_32_d , 0xf1f8, 0x2040}, + {&&op_movea_32_a , 0xf1f8, 0x2048}, + {&&op_movea_32_ai , 0xf1f8, 0x2050}, + {&&op_movea_32_pi , 0xf1f8, 0x2058}, + {&&op_movea_32_pd , 0xf1f8, 0x2060}, + {&&op_movea_32_di , 0xf1f8, 0x2068}, + {&&op_movea_32_ix , 0xf1f8, 0x2070}, + {&&op_move_32_ai_d , 0xf1f8, 0x2080}, + {&&op_move_32_ai_a , 0xf1f8, 0x2088}, + {&&op_move_32_ai_ai , 0xf1f8, 0x2090}, + {&&op_move_32_ai_pi , 0xf1f8, 0x2098}, + {&&op_move_32_ai_pd , 0xf1f8, 0x20a0}, + {&&op_move_32_ai_di , 0xf1f8, 0x20a8}, + {&&op_move_32_ai_ix , 0xf1f8, 0x20b0}, + {&&op_move_32_pi_d , 0xf1f8, 0x20c0}, + {&&op_move_32_pi_a , 0xf1f8, 0x20c8}, + {&&op_move_32_pi_ai , 0xf1f8, 0x20d0}, + {&&op_move_32_pi_pi , 0xf1f8, 0x20d8}, + {&&op_move_32_pi_pd , 0xf1f8, 0x20e0}, + {&&op_move_32_pi_di , 0xf1f8, 0x20e8}, + {&&op_move_32_pi_ix , 0xf1f8, 0x20f0}, + {&&op_move_32_pd_d , 0xf1f8, 0x2100}, + {&&op_move_32_pd_a , 0xf1f8, 0x2108}, + {&&op_move_32_pd_ai , 0xf1f8, 0x2110}, + {&&op_move_32_pd_pi , 0xf1f8, 0x2118}, + {&&op_move_32_pd_pd , 0xf1f8, 0x2120}, + {&&op_move_32_pd_di , 0xf1f8, 0x2128}, + {&&op_move_32_pd_ix , 0xf1f8, 0x2130}, + {&&op_move_32_di_d , 0xf1f8, 0x2140}, + {&&op_move_32_di_a , 0xf1f8, 0x2148}, + {&&op_move_32_di_ai , 0xf1f8, 0x2150}, + {&&op_move_32_di_pi , 0xf1f8, 0x2158}, + {&&op_move_32_di_pd , 0xf1f8, 0x2160}, + {&&op_move_32_di_di , 0xf1f8, 0x2168}, + {&&op_move_32_di_ix , 0xf1f8, 0x2170}, + {&&op_move_32_ix_d , 0xf1f8, 0x2180}, + {&&op_move_32_ix_a , 0xf1f8, 0x2188}, + {&&op_move_32_ix_ai , 0xf1f8, 0x2190}, + {&&op_move_32_ix_pi , 0xf1f8, 0x2198}, + {&&op_move_32_ix_pd , 0xf1f8, 0x21a0}, + {&&op_move_32_ix_di , 0xf1f8, 0x21a8}, + {&&op_move_32_ix_ix , 0xf1f8, 0x21b0}, + {&&op_move_16_d_d , 0xf1f8, 0x3000}, + {&&op_move_16_d_a , 0xf1f8, 0x3008}, + {&&op_move_16_d_ai , 0xf1f8, 0x3010}, + {&&op_move_16_d_pi , 0xf1f8, 0x3018}, + {&&op_move_16_d_pd , 0xf1f8, 0x3020}, + {&&op_move_16_d_di , 0xf1f8, 0x3028}, + {&&op_move_16_d_ix , 0xf1f8, 0x3030}, + {&&op_movea_16_d , 0xf1f8, 0x3040}, + {&&op_movea_16_a , 0xf1f8, 0x3048}, + {&&op_movea_16_ai , 0xf1f8, 0x3050}, + {&&op_movea_16_pi , 0xf1f8, 0x3058}, + {&&op_movea_16_pd , 0xf1f8, 0x3060}, + {&&op_movea_16_di , 0xf1f8, 0x3068}, + {&&op_movea_16_ix , 0xf1f8, 0x3070}, + {&&op_move_16_ai_d , 0xf1f8, 0x3080}, + {&&op_move_16_ai_a , 0xf1f8, 0x3088}, + {&&op_move_16_ai_ai , 0xf1f8, 0x3090}, + {&&op_move_16_ai_pi , 0xf1f8, 0x3098}, + {&&op_move_16_ai_pd , 0xf1f8, 0x30a0}, + {&&op_move_16_ai_di , 0xf1f8, 0x30a8}, + {&&op_move_16_ai_ix , 0xf1f8, 0x30b0}, + {&&op_move_16_pi_d , 0xf1f8, 0x30c0}, + {&&op_move_16_pi_a , 0xf1f8, 0x30c8}, + {&&op_move_16_pi_ai , 0xf1f8, 0x30d0}, + {&&op_move_16_pi_pi , 0xf1f8, 0x30d8}, + {&&op_move_16_pi_pd , 0xf1f8, 0x30e0}, + {&&op_move_16_pi_di , 0xf1f8, 0x30e8}, + {&&op_move_16_pi_ix , 0xf1f8, 0x30f0}, + {&&op_move_16_pd_d , 0xf1f8, 0x3100}, + {&&op_move_16_pd_a , 0xf1f8, 0x3108}, + {&&op_move_16_pd_ai , 0xf1f8, 0x3110}, + {&&op_move_16_pd_pi , 0xf1f8, 0x3118}, + {&&op_move_16_pd_pd , 0xf1f8, 0x3120}, + {&&op_move_16_pd_di , 0xf1f8, 0x3128}, + {&&op_move_16_pd_ix , 0xf1f8, 0x3130}, + {&&op_move_16_di_d , 0xf1f8, 0x3140}, + {&&op_move_16_di_a , 0xf1f8, 0x3148}, + {&&op_move_16_di_ai , 0xf1f8, 0x3150}, + {&&op_move_16_di_pi , 0xf1f8, 0x3158}, + {&&op_move_16_di_pd , 0xf1f8, 0x3160}, + {&&op_move_16_di_di , 0xf1f8, 0x3168}, + {&&op_move_16_di_ix , 0xf1f8, 0x3170}, + {&&op_move_16_ix_d , 0xf1f8, 0x3180}, + {&&op_move_16_ix_a , 0xf1f8, 0x3188}, + {&&op_move_16_ix_ai , 0xf1f8, 0x3190}, + {&&op_move_16_ix_pi , 0xf1f8, 0x3198}, + {&&op_move_16_ix_pd , 0xf1f8, 0x31a0}, + {&&op_move_16_ix_di , 0xf1f8, 0x31a8}, + {&&op_move_16_ix_ix , 0xf1f8, 0x31b0}, + {&&op_chk_16_d , 0xf1f8, 0x4180}, + {&&op_chk_16_ai , 0xf1f8, 0x4190}, + {&&op_chk_16_pi , 0xf1f8, 0x4198}, + {&&op_chk_16_pd , 0xf1f8, 0x41a0}, + {&&op_chk_16_di , 0xf1f8, 0x41a8}, + {&&op_chk_16_ix , 0xf1f8, 0x41b0}, + {&&op_lea_32_ai , 0xf1f8, 0x41d0}, + {&&op_lea_32_di , 0xf1f8, 0x41e8}, + {&&op_lea_32_ix , 0xf1f8, 0x41f0}, + {&&op_addq_8_d , 0xf1f8, 0x5000}, + {&&op_addq_8_ai , 0xf1f8, 0x5010}, + {&&op_addq_8_pi , 0xf1f8, 0x5018}, + {&&op_addq_8_pd , 0xf1f8, 0x5020}, + {&&op_addq_8_di , 0xf1f8, 0x5028}, + {&&op_addq_8_ix , 0xf1f8, 0x5030}, + {&&op_addq_16_d , 0xf1f8, 0x5040}, + {&&op_addq_16_a , 0xf1f8, 0x5048}, + {&&op_addq_16_ai , 0xf1f8, 0x5050}, + {&&op_addq_16_pi , 0xf1f8, 0x5058}, + {&&op_addq_16_pd , 0xf1f8, 0x5060}, + {&&op_addq_16_di , 0xf1f8, 0x5068}, + {&&op_addq_16_ix , 0xf1f8, 0x5070}, + {&&op_addq_32_d , 0xf1f8, 0x5080}, + {&&op_addq_32_a , 0xf1f8, 0x5088}, + {&&op_addq_32_ai , 0xf1f8, 0x5090}, + {&&op_addq_32_pi , 0xf1f8, 0x5098}, + {&&op_addq_32_pd , 0xf1f8, 0x50a0}, + {&&op_addq_32_di , 0xf1f8, 0x50a8}, + {&&op_addq_32_ix , 0xf1f8, 0x50b0}, + {&&op_subq_8_d , 0xf1f8, 0x5100}, + {&&op_subq_8_ai , 0xf1f8, 0x5110}, + {&&op_subq_8_pi , 0xf1f8, 0x5118}, + {&&op_subq_8_pd , 0xf1f8, 0x5120}, + {&&op_subq_8_di , 0xf1f8, 0x5128}, + {&&op_subq_8_ix , 0xf1f8, 0x5130}, + {&&op_subq_16_d , 0xf1f8, 0x5140}, + {&&op_subq_16_a , 0xf1f8, 0x5148}, + {&&op_subq_16_ai , 0xf1f8, 0x5150}, + {&&op_subq_16_pi , 0xf1f8, 0x5158}, + {&&op_subq_16_pd , 0xf1f8, 0x5160}, + {&&op_subq_16_di , 0xf1f8, 0x5168}, + {&&op_subq_16_ix , 0xf1f8, 0x5170}, + {&&op_subq_32_d , 0xf1f8, 0x5180}, + {&&op_subq_32_a , 0xf1f8, 0x5188}, + {&&op_subq_32_ai , 0xf1f8, 0x5190}, + {&&op_subq_32_pi , 0xf1f8, 0x5198}, + {&&op_subq_32_pd , 0xf1f8, 0x51a0}, + {&&op_subq_32_di , 0xf1f8, 0x51a8}, + {&&op_subq_32_ix , 0xf1f8, 0x51b0}, + {&&op_or_8_er_d , 0xf1f8, 0x8000}, + {&&op_or_8_er_ai , 0xf1f8, 0x8010}, + {&&op_or_8_er_pi , 0xf1f8, 0x8018}, + {&&op_or_8_er_pd , 0xf1f8, 0x8020}, + {&&op_or_8_er_di , 0xf1f8, 0x8028}, + {&&op_or_8_er_ix , 0xf1f8, 0x8030}, + {&&op_or_16_er_d , 0xf1f8, 0x8040}, + {&&op_or_16_er_ai , 0xf1f8, 0x8050}, + {&&op_or_16_er_pi , 0xf1f8, 0x8058}, + {&&op_or_16_er_pd , 0xf1f8, 0x8060}, + {&&op_or_16_er_di , 0xf1f8, 0x8068}, + {&&op_or_16_er_ix , 0xf1f8, 0x8070}, + {&&op_or_32_er_d , 0xf1f8, 0x8080}, + {&&op_or_32_er_ai , 0xf1f8, 0x8090}, + {&&op_or_32_er_pi , 0xf1f8, 0x8098}, + {&&op_or_32_er_pd , 0xf1f8, 0x80a0}, + {&&op_or_32_er_di , 0xf1f8, 0x80a8}, + {&&op_or_32_er_ix , 0xf1f8, 0x80b0}, + {&&op_divu_16_d , 0xf1f8, 0x80c0}, + {&&op_divu_16_ai , 0xf1f8, 0x80d0}, + {&&op_divu_16_pi , 0xf1f8, 0x80d8}, + {&&op_divu_16_pd , 0xf1f8, 0x80e0}, + {&&op_divu_16_di , 0xf1f8, 0x80e8}, + {&&op_divu_16_ix , 0xf1f8, 0x80f0}, + {&&op_sbcd_8_rr , 0xf1f8, 0x8100}, + {&&op_sbcd_8_mm , 0xf1f8, 0x8108}, + {&&op_or_8_re_ai , 0xf1f8, 0x8110}, + {&&op_or_8_re_pi , 0xf1f8, 0x8118}, + {&&op_or_8_re_pd , 0xf1f8, 0x8120}, + {&&op_or_8_re_di , 0xf1f8, 0x8128}, + {&&op_or_8_re_ix , 0xf1f8, 0x8130}, + {&&op_or_16_re_ai , 0xf1f8, 0x8150}, + {&&op_or_16_re_pi , 0xf1f8, 0x8158}, + {&&op_or_16_re_pd , 0xf1f8, 0x8160}, + {&&op_or_16_re_di , 0xf1f8, 0x8168}, + {&&op_or_16_re_ix , 0xf1f8, 0x8170}, + {&&op_or_32_re_ai , 0xf1f8, 0x8190}, + {&&op_or_32_re_pi , 0xf1f8, 0x8198}, + {&&op_or_32_re_pd , 0xf1f8, 0x81a0}, + {&&op_or_32_re_di , 0xf1f8, 0x81a8}, + {&&op_or_32_re_ix , 0xf1f8, 0x81b0}, + {&&op_divs_16_d , 0xf1f8, 0x81c0}, + {&&op_divs_16_ai , 0xf1f8, 0x81d0}, + {&&op_divs_16_pi , 0xf1f8, 0x81d8}, + {&&op_divs_16_pd , 0xf1f8, 0x81e0}, + {&&op_divs_16_di , 0xf1f8, 0x81e8}, + {&&op_divs_16_ix , 0xf1f8, 0x81f0}, + {&&op_sub_8_er_d , 0xf1f8, 0x9000}, + {&&op_sub_8_er_ai , 0xf1f8, 0x9010}, + {&&op_sub_8_er_pi , 0xf1f8, 0x9018}, + {&&op_sub_8_er_pd , 0xf1f8, 0x9020}, + {&&op_sub_8_er_di , 0xf1f8, 0x9028}, + {&&op_sub_8_er_ix , 0xf1f8, 0x9030}, + {&&op_sub_16_er_d , 0xf1f8, 0x9040}, + {&&op_sub_16_er_a , 0xf1f8, 0x9048}, + {&&op_sub_16_er_ai , 0xf1f8, 0x9050}, + {&&op_sub_16_er_pi , 0xf1f8, 0x9058}, + {&&op_sub_16_er_pd , 0xf1f8, 0x9060}, + {&&op_sub_16_er_di , 0xf1f8, 0x9068}, + {&&op_sub_16_er_ix , 0xf1f8, 0x9070}, + {&&op_sub_32_er_d , 0xf1f8, 0x9080}, + {&&op_sub_32_er_a , 0xf1f8, 0x9088}, + {&&op_sub_32_er_ai , 0xf1f8, 0x9090}, + {&&op_sub_32_er_pi , 0xf1f8, 0x9098}, + {&&op_sub_32_er_pd , 0xf1f8, 0x90a0}, + {&&op_sub_32_er_di , 0xf1f8, 0x90a8}, + {&&op_sub_32_er_ix , 0xf1f8, 0x90b0}, + {&&op_suba_16_d , 0xf1f8, 0x90c0}, + {&&op_suba_16_a , 0xf1f8, 0x90c8}, + {&&op_suba_16_ai , 0xf1f8, 0x90d0}, + {&&op_suba_16_pi , 0xf1f8, 0x90d8}, + {&&op_suba_16_pd , 0xf1f8, 0x90e0}, + {&&op_suba_16_di , 0xf1f8, 0x90e8}, + {&&op_suba_16_ix , 0xf1f8, 0x90f0}, + {&&op_subx_8_rr , 0xf1f8, 0x9100}, + {&&op_subx_8_mm , 0xf1f8, 0x9108}, + {&&op_sub_8_re_ai , 0xf1f8, 0x9110}, + {&&op_sub_8_re_pi , 0xf1f8, 0x9118}, + {&&op_sub_8_re_pd , 0xf1f8, 0x9120}, + {&&op_sub_8_re_di , 0xf1f8, 0x9128}, + {&&op_sub_8_re_ix , 0xf1f8, 0x9130}, + {&&op_subx_16_rr , 0xf1f8, 0x9140}, + {&&op_subx_16_mm , 0xf1f8, 0x9148}, + {&&op_sub_16_re_ai , 0xf1f8, 0x9150}, + {&&op_sub_16_re_pi , 0xf1f8, 0x9158}, + {&&op_sub_16_re_pd , 0xf1f8, 0x9160}, + {&&op_sub_16_re_di , 0xf1f8, 0x9168}, + {&&op_sub_16_re_ix , 0xf1f8, 0x9170}, + {&&op_subx_32_rr , 0xf1f8, 0x9180}, + {&&op_subx_32_mm , 0xf1f8, 0x9188}, + {&&op_sub_32_re_ai , 0xf1f8, 0x9190}, + {&&op_sub_32_re_pi , 0xf1f8, 0x9198}, + {&&op_sub_32_re_pd , 0xf1f8, 0x91a0}, + {&&op_sub_32_re_di , 0xf1f8, 0x91a8}, + {&&op_sub_32_re_ix , 0xf1f8, 0x91b0}, + {&&op_suba_32_d , 0xf1f8, 0x91c0}, + {&&op_suba_32_a , 0xf1f8, 0x91c8}, + {&&op_suba_32_ai , 0xf1f8, 0x91d0}, + {&&op_suba_32_pi , 0xf1f8, 0x91d8}, + {&&op_suba_32_pd , 0xf1f8, 0x91e0}, + {&&op_suba_32_di , 0xf1f8, 0x91e8}, + {&&op_suba_32_ix , 0xf1f8, 0x91f0}, + {&&op_cmp_8_d , 0xf1f8, 0xb000}, + {&&op_cmp_8_ai , 0xf1f8, 0xb010}, + {&&op_cmp_8_pi , 0xf1f8, 0xb018}, + {&&op_cmp_8_pd , 0xf1f8, 0xb020}, + {&&op_cmp_8_di , 0xf1f8, 0xb028}, + {&&op_cmp_8_ix , 0xf1f8, 0xb030}, + {&&op_cmp_16_d , 0xf1f8, 0xb040}, + {&&op_cmp_16_a , 0xf1f8, 0xb048}, + {&&op_cmp_16_ai , 0xf1f8, 0xb050}, + {&&op_cmp_16_pi , 0xf1f8, 0xb058}, + {&&op_cmp_16_pd , 0xf1f8, 0xb060}, + {&&op_cmp_16_di , 0xf1f8, 0xb068}, + {&&op_cmp_16_ix , 0xf1f8, 0xb070}, + {&&op_cmp_32_d , 0xf1f8, 0xb080}, + {&&op_cmp_32_a , 0xf1f8, 0xb088}, + {&&op_cmp_32_ai , 0xf1f8, 0xb090}, + {&&op_cmp_32_pi , 0xf1f8, 0xb098}, + {&&op_cmp_32_pd , 0xf1f8, 0xb0a0}, + {&&op_cmp_32_di , 0xf1f8, 0xb0a8}, + {&&op_cmp_32_ix , 0xf1f8, 0xb0b0}, + {&&op_cmpa_16_d , 0xf1f8, 0xb0c0}, + {&&op_cmpa_16_a , 0xf1f8, 0xb0c8}, + {&&op_cmpa_16_ai , 0xf1f8, 0xb0d0}, + {&&op_cmpa_16_pi , 0xf1f8, 0xb0d8}, + {&&op_cmpa_16_pd , 0xf1f8, 0xb0e0}, + {&&op_cmpa_16_di , 0xf1f8, 0xb0e8}, + {&&op_cmpa_16_ix , 0xf1f8, 0xb0f0}, + {&&op_eor_8_d , 0xf1f8, 0xb100}, + {&&op_cmpm_8 , 0xf1f8, 0xb108}, + {&&op_eor_8_ai , 0xf1f8, 0xb110}, + {&&op_eor_8_pi , 0xf1f8, 0xb118}, + {&&op_eor_8_pd , 0xf1f8, 0xb120}, + {&&op_eor_8_di , 0xf1f8, 0xb128}, + {&&op_eor_8_ix , 0xf1f8, 0xb130}, + {&&op_eor_16_d , 0xf1f8, 0xb140}, + {&&op_cmpm_16 , 0xf1f8, 0xb148}, + {&&op_eor_16_ai , 0xf1f8, 0xb150}, + {&&op_eor_16_pi , 0xf1f8, 0xb158}, + {&&op_eor_16_pd , 0xf1f8, 0xb160}, + {&&op_eor_16_di , 0xf1f8, 0xb168}, + {&&op_eor_16_ix , 0xf1f8, 0xb170}, + {&&op_eor_32_d , 0xf1f8, 0xb180}, + {&&op_cmpm_32 , 0xf1f8, 0xb188}, + {&&op_eor_32_ai , 0xf1f8, 0xb190}, + {&&op_eor_32_pi , 0xf1f8, 0xb198}, + {&&op_eor_32_pd , 0xf1f8, 0xb1a0}, + {&&op_eor_32_di , 0xf1f8, 0xb1a8}, + {&&op_eor_32_ix , 0xf1f8, 0xb1b0}, + {&&op_cmpa_32_d , 0xf1f8, 0xb1c0}, + {&&op_cmpa_32_a , 0xf1f8, 0xb1c8}, + {&&op_cmpa_32_ai , 0xf1f8, 0xb1d0}, + {&&op_cmpa_32_pi , 0xf1f8, 0xb1d8}, + {&&op_cmpa_32_pd , 0xf1f8, 0xb1e0}, + {&&op_cmpa_32_di , 0xf1f8, 0xb1e8}, + {&&op_cmpa_32_ix , 0xf1f8, 0xb1f0}, + {&&op_and_8_er_d , 0xf1f8, 0xc000}, + {&&op_and_8_er_ai , 0xf1f8, 0xc010}, + {&&op_and_8_er_pi , 0xf1f8, 0xc018}, + {&&op_and_8_er_pd , 0xf1f8, 0xc020}, + {&&op_and_8_er_di , 0xf1f8, 0xc028}, + {&&op_and_8_er_ix , 0xf1f8, 0xc030}, + {&&op_and_16_er_d , 0xf1f8, 0xc040}, + {&&op_and_16_er_ai , 0xf1f8, 0xc050}, + {&&op_and_16_er_pi , 0xf1f8, 0xc058}, + {&&op_and_16_er_pd , 0xf1f8, 0xc060}, + {&&op_and_16_er_di , 0xf1f8, 0xc068}, + {&&op_and_16_er_ix , 0xf1f8, 0xc070}, + {&&op_and_32_er_d , 0xf1f8, 0xc080}, + {&&op_and_32_er_ai , 0xf1f8, 0xc090}, + {&&op_and_32_er_pi , 0xf1f8, 0xc098}, + {&&op_and_32_er_pd , 0xf1f8, 0xc0a0}, + {&&op_and_32_er_di , 0xf1f8, 0xc0a8}, + {&&op_and_32_er_ix , 0xf1f8, 0xc0b0}, + {&&op_mulu_16_d , 0xf1f8, 0xc0c0}, + {&&op_mulu_16_ai , 0xf1f8, 0xc0d0}, + {&&op_mulu_16_pi , 0xf1f8, 0xc0d8}, + {&&op_mulu_16_pd , 0xf1f8, 0xc0e0}, + {&&op_mulu_16_di , 0xf1f8, 0xc0e8}, + {&&op_mulu_16_ix , 0xf1f8, 0xc0f0}, + {&&op_abcd_8_rr , 0xf1f8, 0xc100}, + {&&op_abcd_8_mm , 0xf1f8, 0xc108}, + {&&op_and_8_re_ai , 0xf1f8, 0xc110}, + {&&op_and_8_re_pi , 0xf1f8, 0xc118}, + {&&op_and_8_re_pd , 0xf1f8, 0xc120}, + {&&op_and_8_re_di , 0xf1f8, 0xc128}, + {&&op_and_8_re_ix , 0xf1f8, 0xc130}, + {&&op_exg_32_dd , 0xf1f8, 0xc140}, + {&&op_exg_32_aa , 0xf1f8, 0xc148}, + {&&op_and_16_re_ai , 0xf1f8, 0xc150}, + {&&op_and_16_re_pi , 0xf1f8, 0xc158}, + {&&op_and_16_re_pd , 0xf1f8, 0xc160}, + {&&op_and_16_re_di , 0xf1f8, 0xc168}, + {&&op_and_16_re_ix , 0xf1f8, 0xc170}, + {&&op_exg_32_da , 0xf1f8, 0xc188}, + {&&op_and_32_re_ai , 0xf1f8, 0xc190}, + {&&op_and_32_re_pi , 0xf1f8, 0xc198}, + {&&op_and_32_re_pd , 0xf1f8, 0xc1a0}, + {&&op_and_32_re_di , 0xf1f8, 0xc1a8}, + {&&op_and_32_re_ix , 0xf1f8, 0xc1b0}, + {&&op_muls_16_d , 0xf1f8, 0xc1c0}, + {&&op_muls_16_ai , 0xf1f8, 0xc1d0}, + {&&op_muls_16_pi , 0xf1f8, 0xc1d8}, + {&&op_muls_16_pd , 0xf1f8, 0xc1e0}, + {&&op_muls_16_di , 0xf1f8, 0xc1e8}, + {&&op_muls_16_ix , 0xf1f8, 0xc1f0}, + {&&op_add_8_er_d , 0xf1f8, 0xd000}, + {&&op_add_8_er_ai , 0xf1f8, 0xd010}, + {&&op_add_8_er_pi , 0xf1f8, 0xd018}, + {&&op_add_8_er_pd , 0xf1f8, 0xd020}, + {&&op_add_8_er_di , 0xf1f8, 0xd028}, + {&&op_add_8_er_ix , 0xf1f8, 0xd030}, + {&&op_add_16_er_d , 0xf1f8, 0xd040}, + {&&op_add_16_er_a , 0xf1f8, 0xd048}, + {&&op_add_16_er_ai , 0xf1f8, 0xd050}, + {&&op_add_16_er_pi , 0xf1f8, 0xd058}, + {&&op_add_16_er_pd , 0xf1f8, 0xd060}, + {&&op_add_16_er_di , 0xf1f8, 0xd068}, + {&&op_add_16_er_ix , 0xf1f8, 0xd070}, + {&&op_add_32_er_d , 0xf1f8, 0xd080}, + {&&op_add_32_er_a , 0xf1f8, 0xd088}, + {&&op_add_32_er_ai , 0xf1f8, 0xd090}, + {&&op_add_32_er_pi , 0xf1f8, 0xd098}, + {&&op_add_32_er_pd , 0xf1f8, 0xd0a0}, + {&&op_add_32_er_di , 0xf1f8, 0xd0a8}, + {&&op_add_32_er_ix , 0xf1f8, 0xd0b0}, + {&&op_adda_16_d , 0xf1f8, 0xd0c0}, + {&&op_adda_16_a , 0xf1f8, 0xd0c8}, + {&&op_adda_16_ai , 0xf1f8, 0xd0d0}, + {&&op_adda_16_pi , 0xf1f8, 0xd0d8}, + {&&op_adda_16_pd , 0xf1f8, 0xd0e0}, + {&&op_adda_16_di , 0xf1f8, 0xd0e8}, + {&&op_adda_16_ix , 0xf1f8, 0xd0f0}, + {&&op_addx_8_rr , 0xf1f8, 0xd100}, + {&&op_addx_8_mm , 0xf1f8, 0xd108}, + {&&op_add_8_re_ai , 0xf1f8, 0xd110}, + {&&op_add_8_re_pi , 0xf1f8, 0xd118}, + {&&op_add_8_re_pd , 0xf1f8, 0xd120}, + {&&op_add_8_re_di , 0xf1f8, 0xd128}, + {&&op_add_8_re_ix , 0xf1f8, 0xd130}, + {&&op_addx_16_rr , 0xf1f8, 0xd140}, + {&&op_addx_16_mm , 0xf1f8, 0xd148}, + {&&op_add_16_re_ai , 0xf1f8, 0xd150}, + {&&op_add_16_re_pi , 0xf1f8, 0xd158}, + {&&op_add_16_re_pd , 0xf1f8, 0xd160}, + {&&op_add_16_re_di , 0xf1f8, 0xd168}, + {&&op_add_16_re_ix , 0xf1f8, 0xd170}, + {&&op_addx_32_rr , 0xf1f8, 0xd180}, + {&&op_addx_32_mm , 0xf1f8, 0xd188}, + {&&op_add_32_re_ai , 0xf1f8, 0xd190}, + {&&op_add_32_re_pi , 0xf1f8, 0xd198}, + {&&op_add_32_re_pd , 0xf1f8, 0xd1a0}, + {&&op_add_32_re_di , 0xf1f8, 0xd1a8}, + {&&op_add_32_re_ix , 0xf1f8, 0xd1b0}, + {&&op_adda_32_d , 0xf1f8, 0xd1c0}, + {&&op_adda_32_a , 0xf1f8, 0xd1c8}, + {&&op_adda_32_ai , 0xf1f8, 0xd1d0}, + {&&op_adda_32_pi , 0xf1f8, 0xd1d8}, + {&&op_adda_32_pd , 0xf1f8, 0xd1e0}, + {&&op_adda_32_di , 0xf1f8, 0xd1e8}, + {&&op_adda_32_ix , 0xf1f8, 0xd1f0}, + {&&op_asr_8_s , 0xf1f8, 0xe000}, + {&&op_lsr_8_s , 0xf1f8, 0xe008}, + {&&op_roxr_8_s , 0xf1f8, 0xe010}, + {&&op_ror_8_s , 0xf1f8, 0xe018}, + {&&op_asr_8_r , 0xf1f8, 0xe020}, + {&&op_lsr_8_r , 0xf1f8, 0xe028}, + {&&op_roxr_8_r , 0xf1f8, 0xe030}, + {&&op_ror_8_r , 0xf1f8, 0xe038}, + {&&op_asr_16_s , 0xf1f8, 0xe040}, + {&&op_lsr_16_s , 0xf1f8, 0xe048}, + {&&op_roxr_16_s , 0xf1f8, 0xe050}, + {&&op_ror_16_s , 0xf1f8, 0xe058}, + {&&op_asr_16_r , 0xf1f8, 0xe060}, + {&&op_lsr_16_r , 0xf1f8, 0xe068}, + {&&op_roxr_16_r , 0xf1f8, 0xe070}, + {&&op_ror_16_r , 0xf1f8, 0xe078}, + {&&op_asr_32_s , 0xf1f8, 0xe080}, + {&&op_lsr_32_s , 0xf1f8, 0xe088}, + {&&op_roxr_32_s , 0xf1f8, 0xe090}, + {&&op_ror_32_s , 0xf1f8, 0xe098}, + {&&op_asr_32_r , 0xf1f8, 0xe0a0}, + {&&op_lsr_32_r , 0xf1f8, 0xe0a8}, + {&&op_roxr_32_r , 0xf1f8, 0xe0b0}, + {&&op_ror_32_r , 0xf1f8, 0xe0b8}, + {&&op_asl_8_s , 0xf1f8, 0xe100}, + {&&op_lsl_8_s , 0xf1f8, 0xe108}, + {&&op_roxl_8_s , 0xf1f8, 0xe110}, + {&&op_rol_8_s , 0xf1f8, 0xe118}, + {&&op_asl_8_r , 0xf1f8, 0xe120}, + {&&op_lsl_8_r , 0xf1f8, 0xe128}, + {&&op_roxl_8_r , 0xf1f8, 0xe130}, + {&&op_rol_8_r , 0xf1f8, 0xe138}, + {&&op_asl_16_s , 0xf1f8, 0xe140}, + {&&op_lsl_16_s , 0xf1f8, 0xe148}, + {&&op_roxl_16_s , 0xf1f8, 0xe150}, + {&&op_rol_16_s , 0xf1f8, 0xe158}, + {&&op_asl_16_r , 0xf1f8, 0xe160}, + {&&op_lsl_16_r , 0xf1f8, 0xe168}, + {&&op_roxl_16_r , 0xf1f8, 0xe170}, + {&&op_rol_16_r , 0xf1f8, 0xe178}, + {&&op_asl_32_s , 0xf1f8, 0xe180}, + {&&op_lsl_32_s , 0xf1f8, 0xe188}, + {&&op_roxl_32_s , 0xf1f8, 0xe190}, + {&&op_rol_32_s , 0xf1f8, 0xe198}, + {&&op_asl_32_r , 0xf1f8, 0xe1a0}, + {&&op_lsl_32_r , 0xf1f8, 0xe1a8}, + {&&op_roxl_32_r , 0xf1f8, 0xe1b0}, + {&&op_rol_32_r , 0xf1f8, 0xe1b8}, + {&&op_trap , 0xfff0, 0x4e40}, + {&&op_btst_8_r_pi7 , 0xf1ff, 0x011f}, + {&&op_btst_8_r_pd7 , 0xf1ff, 0x0127}, + {&&op_btst_8_r_aw , 0xf1ff, 0x0138}, + {&&op_btst_8_r_al , 0xf1ff, 0x0139}, + {&&op_btst_8_r_pcdi , 0xf1ff, 0x013a}, + {&&op_btst_8_r_pcix , 0xf1ff, 0x013b}, + {&&op_btst_8_r_i , 0xf1ff, 0x013c}, + {&&op_bchg_8_r_pi7 , 0xf1ff, 0x015f}, + {&&op_bchg_8_r_pd7 , 0xf1ff, 0x0167}, + {&&op_bchg_8_r_aw , 0xf1ff, 0x0178}, + {&&op_bchg_8_r_al , 0xf1ff, 0x0179}, + {&&op_bclr_8_r_pi7 , 0xf1ff, 0x019f}, + {&&op_bclr_8_r_pd7 , 0xf1ff, 0x01a7}, + {&&op_bclr_8_r_aw , 0xf1ff, 0x01b8}, + {&&op_bclr_8_r_al , 0xf1ff, 0x01b9}, + {&&op_bset_8_r_pi7 , 0xf1ff, 0x01df}, + {&&op_bset_8_r_pd7 , 0xf1ff, 0x01e7}, + {&&op_bset_8_r_aw , 0xf1ff, 0x01f8}, + {&&op_bset_8_r_al , 0xf1ff, 0x01f9}, + {&&op_move_8_d_pi7 , 0xf1ff, 0x101f}, + {&&op_move_8_d_pd7 , 0xf1ff, 0x1027}, + {&&op_move_8_d_aw , 0xf1ff, 0x1038}, + {&&op_move_8_d_al , 0xf1ff, 0x1039}, + {&&op_move_8_d_pcdi , 0xf1ff, 0x103a}, + {&&op_move_8_d_pcix , 0xf1ff, 0x103b}, + {&&op_move_8_d_i , 0xf1ff, 0x103c}, + {&&op_move_8_ai_pi7 , 0xf1ff, 0x109f}, + {&&op_move_8_ai_pd7 , 0xf1ff, 0x10a7}, + {&&op_move_8_ai_aw , 0xf1ff, 0x10b8}, + {&&op_move_8_ai_al , 0xf1ff, 0x10b9}, + {&&op_move_8_ai_pcdi , 0xf1ff, 0x10ba}, + {&&op_move_8_ai_pcix , 0xf1ff, 0x10bb}, + {&&op_move_8_ai_i , 0xf1ff, 0x10bc}, + {&&op_move_8_pi_pi7 , 0xf1ff, 0x10df}, + {&&op_move_8_pi_pd7 , 0xf1ff, 0x10e7}, + {&&op_move_8_pi_aw , 0xf1ff, 0x10f8}, + {&&op_move_8_pi_al , 0xf1ff, 0x10f9}, + {&&op_move_8_pi_pcdi , 0xf1ff, 0x10fa}, + {&&op_move_8_pi_pcix , 0xf1ff, 0x10fb}, + {&&op_move_8_pi_i , 0xf1ff, 0x10fc}, + {&&op_move_8_pd_pi7 , 0xf1ff, 0x111f}, + {&&op_move_8_pd_pd7 , 0xf1ff, 0x1127}, + {&&op_move_8_pd_aw , 0xf1ff, 0x1138}, + {&&op_move_8_pd_al , 0xf1ff, 0x1139}, + {&&op_move_8_pd_pcdi , 0xf1ff, 0x113a}, + {&&op_move_8_pd_pcix , 0xf1ff, 0x113b}, + {&&op_move_8_pd_i , 0xf1ff, 0x113c}, + {&&op_move_8_di_pi7 , 0xf1ff, 0x115f}, + {&&op_move_8_di_pd7 , 0xf1ff, 0x1167}, + {&&op_move_8_di_aw , 0xf1ff, 0x1178}, + {&&op_move_8_di_al , 0xf1ff, 0x1179}, + {&&op_move_8_di_pcdi , 0xf1ff, 0x117a}, + {&&op_move_8_di_pcix , 0xf1ff, 0x117b}, + {&&op_move_8_di_i , 0xf1ff, 0x117c}, + {&&op_move_8_ix_pi7 , 0xf1ff, 0x119f}, + {&&op_move_8_ix_pd7 , 0xf1ff, 0x11a7}, + {&&op_move_8_ix_aw , 0xf1ff, 0x11b8}, + {&&op_move_8_ix_al , 0xf1ff, 0x11b9}, + {&&op_move_8_ix_pcdi , 0xf1ff, 0x11ba}, + {&&op_move_8_ix_pcix , 0xf1ff, 0x11bb}, + {&&op_move_8_ix_i , 0xf1ff, 0x11bc}, + {&&op_move_32_d_aw , 0xf1ff, 0x2038}, + {&&op_move_32_d_al , 0xf1ff, 0x2039}, + {&&op_move_32_d_pcdi , 0xf1ff, 0x203a}, + {&&op_move_32_d_pcix , 0xf1ff, 0x203b}, + {&&op_move_32_d_i , 0xf1ff, 0x203c}, + {&&op_movea_32_aw , 0xf1ff, 0x2078}, + {&&op_movea_32_al , 0xf1ff, 0x2079}, + {&&op_movea_32_pcdi , 0xf1ff, 0x207a}, + {&&op_movea_32_pcix , 0xf1ff, 0x207b}, + {&&op_movea_32_i , 0xf1ff, 0x207c}, + {&&op_move_32_ai_aw , 0xf1ff, 0x20b8}, + {&&op_move_32_ai_al , 0xf1ff, 0x20b9}, + {&&op_move_32_ai_pcdi , 0xf1ff, 0x20ba}, + {&&op_move_32_ai_pcix , 0xf1ff, 0x20bb}, + {&&op_move_32_ai_i , 0xf1ff, 0x20bc}, + {&&op_move_32_pi_aw , 0xf1ff, 0x20f8}, + {&&op_move_32_pi_al , 0xf1ff, 0x20f9}, + {&&op_move_32_pi_pcdi , 0xf1ff, 0x20fa}, + {&&op_move_32_pi_pcix , 0xf1ff, 0x20fb}, + {&&op_move_32_pi_i , 0xf1ff, 0x20fc}, + {&&op_move_32_pd_aw , 0xf1ff, 0x2138}, + {&&op_move_32_pd_al , 0xf1ff, 0x2139}, + {&&op_move_32_pd_pcdi , 0xf1ff, 0x213a}, + {&&op_move_32_pd_pcix , 0xf1ff, 0x213b}, + {&&op_move_32_pd_i , 0xf1ff, 0x213c}, + {&&op_move_32_di_aw , 0xf1ff, 0x2178}, + {&&op_move_32_di_al , 0xf1ff, 0x2179}, + {&&op_move_32_di_pcdi , 0xf1ff, 0x217a}, + {&&op_move_32_di_pcix , 0xf1ff, 0x217b}, + {&&op_move_32_di_i , 0xf1ff, 0x217c}, + {&&op_move_32_ix_aw , 0xf1ff, 0x21b8}, + {&&op_move_32_ix_al , 0xf1ff, 0x21b9}, + {&&op_move_32_ix_pcdi , 0xf1ff, 0x21ba}, + {&&op_move_32_ix_pcix , 0xf1ff, 0x21bb}, + {&&op_move_32_ix_i , 0xf1ff, 0x21bc}, + {&&op_move_16_d_aw , 0xf1ff, 0x3038}, + {&&op_move_16_d_al , 0xf1ff, 0x3039}, + {&&op_move_16_d_pcdi , 0xf1ff, 0x303a}, + {&&op_move_16_d_pcix , 0xf1ff, 0x303b}, + {&&op_move_16_d_i , 0xf1ff, 0x303c}, + {&&op_movea_16_aw , 0xf1ff, 0x3078}, + {&&op_movea_16_al , 0xf1ff, 0x3079}, + {&&op_movea_16_pcdi , 0xf1ff, 0x307a}, + {&&op_movea_16_pcix , 0xf1ff, 0x307b}, + {&&op_movea_16_i , 0xf1ff, 0x307c}, + {&&op_move_16_ai_aw , 0xf1ff, 0x30b8}, + {&&op_move_16_ai_al , 0xf1ff, 0x30b9}, + {&&op_move_16_ai_pcdi , 0xf1ff, 0x30ba}, + {&&op_move_16_ai_pcix , 0xf1ff, 0x30bb}, + {&&op_move_16_ai_i , 0xf1ff, 0x30bc}, + {&&op_move_16_pi_aw , 0xf1ff, 0x30f8}, + {&&op_move_16_pi_al , 0xf1ff, 0x30f9}, + {&&op_move_16_pi_pcdi , 0xf1ff, 0x30fa}, + {&&op_move_16_pi_pcix , 0xf1ff, 0x30fb}, + {&&op_move_16_pi_i , 0xf1ff, 0x30fc}, + {&&op_move_16_pd_aw , 0xf1ff, 0x3138}, + {&&op_move_16_pd_al , 0xf1ff, 0x3139}, + {&&op_move_16_pd_pcdi , 0xf1ff, 0x313a}, + {&&op_move_16_pd_pcix , 0xf1ff, 0x313b}, + {&&op_move_16_pd_i , 0xf1ff, 0x313c}, + {&&op_move_16_di_aw , 0xf1ff, 0x3178}, + {&&op_move_16_di_al , 0xf1ff, 0x3179}, + {&&op_move_16_di_pcdi , 0xf1ff, 0x317a}, + {&&op_move_16_di_pcix , 0xf1ff, 0x317b}, + {&&op_move_16_di_i , 0xf1ff, 0x317c}, + {&&op_move_16_ix_aw , 0xf1ff, 0x31b8}, + {&&op_move_16_ix_al , 0xf1ff, 0x31b9}, + {&&op_move_16_ix_pcdi , 0xf1ff, 0x31ba}, + {&&op_move_16_ix_pcix , 0xf1ff, 0x31bb}, + {&&op_move_16_ix_i , 0xf1ff, 0x31bc}, + {&&op_chk_16_aw , 0xf1ff, 0x41b8}, + {&&op_chk_16_al , 0xf1ff, 0x41b9}, + {&&op_chk_16_pcdi , 0xf1ff, 0x41ba}, + {&&op_chk_16_pcix , 0xf1ff, 0x41bb}, + {&&op_chk_16_i , 0xf1ff, 0x41bc}, + {&&op_lea_32_aw , 0xf1ff, 0x41f8}, + {&&op_lea_32_al , 0xf1ff, 0x41f9}, + {&&op_lea_32_pcdi , 0xf1ff, 0x41fa}, + {&&op_lea_32_pcix , 0xf1ff, 0x41fb}, + {&&op_addq_8_pi7 , 0xf1ff, 0x501f}, + {&&op_addq_8_pd7 , 0xf1ff, 0x5027}, + {&&op_addq_8_aw , 0xf1ff, 0x5038}, + {&&op_addq_8_al , 0xf1ff, 0x5039}, + {&&op_addq_16_aw , 0xf1ff, 0x5078}, + {&&op_addq_16_al , 0xf1ff, 0x5079}, + {&&op_addq_32_aw , 0xf1ff, 0x50b8}, + {&&op_addq_32_al , 0xf1ff, 0x50b9}, + {&&op_subq_8_pi7 , 0xf1ff, 0x511f}, + {&&op_subq_8_pd7 , 0xf1ff, 0x5127}, + {&&op_subq_8_aw , 0xf1ff, 0x5138}, + {&&op_subq_8_al , 0xf1ff, 0x5139}, + {&&op_subq_16_aw , 0xf1ff, 0x5178}, + {&&op_subq_16_al , 0xf1ff, 0x5179}, + {&&op_subq_32_aw , 0xf1ff, 0x51b8}, + {&&op_subq_32_al , 0xf1ff, 0x51b9}, + {&&op_or_8_er_pi7 , 0xf1ff, 0x801f}, + {&&op_or_8_er_pd7 , 0xf1ff, 0x8027}, + {&&op_or_8_er_aw , 0xf1ff, 0x8038}, + {&&op_or_8_er_al , 0xf1ff, 0x8039}, + {&&op_or_8_er_pcdi , 0xf1ff, 0x803a}, + {&&op_or_8_er_pcix , 0xf1ff, 0x803b}, + {&&op_or_8_er_i , 0xf1ff, 0x803c}, + {&&op_or_16_er_aw , 0xf1ff, 0x8078}, + {&&op_or_16_er_al , 0xf1ff, 0x8079}, + {&&op_or_16_er_pcdi , 0xf1ff, 0x807a}, + {&&op_or_16_er_pcix , 0xf1ff, 0x807b}, + {&&op_or_16_er_i , 0xf1ff, 0x807c}, + {&&op_or_32_er_aw , 0xf1ff, 0x80b8}, + {&&op_or_32_er_al , 0xf1ff, 0x80b9}, + {&&op_or_32_er_pcdi , 0xf1ff, 0x80ba}, + {&&op_or_32_er_pcix , 0xf1ff, 0x80bb}, + {&&op_or_32_er_i , 0xf1ff, 0x80bc}, + {&&op_divu_16_aw , 0xf1ff, 0x80f8}, + {&&op_divu_16_al , 0xf1ff, 0x80f9}, + {&&op_divu_16_pcdi , 0xf1ff, 0x80fa}, + {&&op_divu_16_pcix , 0xf1ff, 0x80fb}, + {&&op_divu_16_i , 0xf1ff, 0x80fc}, + {&&op_sbcd_8_mm_ay7 , 0xf1ff, 0x810f}, + {&&op_or_8_re_pi7 , 0xf1ff, 0x811f}, + {&&op_or_8_re_pd7 , 0xf1ff, 0x8127}, + {&&op_or_8_re_aw , 0xf1ff, 0x8138}, + {&&op_or_8_re_al , 0xf1ff, 0x8139}, + {&&op_or_16_re_aw , 0xf1ff, 0x8178}, + {&&op_or_16_re_al , 0xf1ff, 0x8179}, + {&&op_or_32_re_aw , 0xf1ff, 0x81b8}, + {&&op_or_32_re_al , 0xf1ff, 0x81b9}, + {&&op_divs_16_aw , 0xf1ff, 0x81f8}, + {&&op_divs_16_al , 0xf1ff, 0x81f9}, + {&&op_divs_16_pcdi , 0xf1ff, 0x81fa}, + {&&op_divs_16_pcix , 0xf1ff, 0x81fb}, + {&&op_divs_16_i , 0xf1ff, 0x81fc}, + {&&op_sub_8_er_pi7 , 0xf1ff, 0x901f}, + {&&op_sub_8_er_pd7 , 0xf1ff, 0x9027}, + {&&op_sub_8_er_aw , 0xf1ff, 0x9038}, + {&&op_sub_8_er_al , 0xf1ff, 0x9039}, + {&&op_sub_8_er_pcdi , 0xf1ff, 0x903a}, + {&&op_sub_8_er_pcix , 0xf1ff, 0x903b}, + {&&op_sub_8_er_i , 0xf1ff, 0x903c}, + {&&op_sub_16_er_aw , 0xf1ff, 0x9078}, + {&&op_sub_16_er_al , 0xf1ff, 0x9079}, + {&&op_sub_16_er_pcdi , 0xf1ff, 0x907a}, + {&&op_sub_16_er_pcix , 0xf1ff, 0x907b}, + {&&op_sub_16_er_i , 0xf1ff, 0x907c}, + {&&op_sub_32_er_aw , 0xf1ff, 0x90b8}, + {&&op_sub_32_er_al , 0xf1ff, 0x90b9}, + {&&op_sub_32_er_pcdi , 0xf1ff, 0x90ba}, + {&&op_sub_32_er_pcix , 0xf1ff, 0x90bb}, + {&&op_sub_32_er_i , 0xf1ff, 0x90bc}, + {&&op_suba_16_aw , 0xf1ff, 0x90f8}, + {&&op_suba_16_al , 0xf1ff, 0x90f9}, + {&&op_suba_16_pcdi , 0xf1ff, 0x90fa}, + {&&op_suba_16_pcix , 0xf1ff, 0x90fb}, + {&&op_suba_16_i , 0xf1ff, 0x90fc}, + {&&op_subx_8_mm_ay7 , 0xf1ff, 0x910f}, + {&&op_sub_8_re_pi7 , 0xf1ff, 0x911f}, + {&&op_sub_8_re_pd7 , 0xf1ff, 0x9127}, + {&&op_sub_8_re_aw , 0xf1ff, 0x9138}, + {&&op_sub_8_re_al , 0xf1ff, 0x9139}, + {&&op_sub_16_re_aw , 0xf1ff, 0x9178}, + {&&op_sub_16_re_al , 0xf1ff, 0x9179}, + {&&op_sub_32_re_aw , 0xf1ff, 0x91b8}, + {&&op_sub_32_re_al , 0xf1ff, 0x91b9}, + {&&op_suba_32_aw , 0xf1ff, 0x91f8}, + {&&op_suba_32_al , 0xf1ff, 0x91f9}, + {&&op_suba_32_pcdi , 0xf1ff, 0x91fa}, + {&&op_suba_32_pcix , 0xf1ff, 0x91fb}, + {&&op_suba_32_i , 0xf1ff, 0x91fc}, + {&&op_cmp_8_pi7 , 0xf1ff, 0xb01f}, + {&&op_cmp_8_pd7 , 0xf1ff, 0xb027}, + {&&op_cmp_8_aw , 0xf1ff, 0xb038}, + {&&op_cmp_8_al , 0xf1ff, 0xb039}, + {&&op_cmp_8_pcdi , 0xf1ff, 0xb03a}, + {&&op_cmp_8_pcix , 0xf1ff, 0xb03b}, + {&&op_cmp_8_i , 0xf1ff, 0xb03c}, + {&&op_cmp_16_aw , 0xf1ff, 0xb078}, + {&&op_cmp_16_al , 0xf1ff, 0xb079}, + {&&op_cmp_16_pcdi , 0xf1ff, 0xb07a}, + {&&op_cmp_16_pcix , 0xf1ff, 0xb07b}, + {&&op_cmp_16_i , 0xf1ff, 0xb07c}, + {&&op_cmp_32_aw , 0xf1ff, 0xb0b8}, + {&&op_cmp_32_al , 0xf1ff, 0xb0b9}, + {&&op_cmp_32_pcdi , 0xf1ff, 0xb0ba}, + {&&op_cmp_32_pcix , 0xf1ff, 0xb0bb}, + {&&op_cmp_32_i , 0xf1ff, 0xb0bc}, + {&&op_cmpa_16_aw , 0xf1ff, 0xb0f8}, + {&&op_cmpa_16_al , 0xf1ff, 0xb0f9}, + {&&op_cmpa_16_pcdi , 0xf1ff, 0xb0fa}, + {&&op_cmpa_16_pcix , 0xf1ff, 0xb0fb}, + {&&op_cmpa_16_i , 0xf1ff, 0xb0fc}, + {&&op_cmpm_8_ay7 , 0xf1ff, 0xb10f}, + {&&op_eor_8_pi7 , 0xf1ff, 0xb11f}, + {&&op_eor_8_pd7 , 0xf1ff, 0xb127}, + {&&op_eor_8_aw , 0xf1ff, 0xb138}, + {&&op_eor_8_al , 0xf1ff, 0xb139}, + {&&op_eor_16_aw , 0xf1ff, 0xb178}, + {&&op_eor_16_al , 0xf1ff, 0xb179}, + {&&op_eor_32_aw , 0xf1ff, 0xb1b8}, + {&&op_eor_32_al , 0xf1ff, 0xb1b9}, + {&&op_cmpa_32_aw , 0xf1ff, 0xb1f8}, + {&&op_cmpa_32_al , 0xf1ff, 0xb1f9}, + {&&op_cmpa_32_pcdi , 0xf1ff, 0xb1fa}, + {&&op_cmpa_32_pcix , 0xf1ff, 0xb1fb}, + {&&op_cmpa_32_i , 0xf1ff, 0xb1fc}, + {&&op_and_8_er_pi7 , 0xf1ff, 0xc01f}, + {&&op_and_8_er_pd7 , 0xf1ff, 0xc027}, + {&&op_and_8_er_aw , 0xf1ff, 0xc038}, + {&&op_and_8_er_al , 0xf1ff, 0xc039}, + {&&op_and_8_er_pcdi , 0xf1ff, 0xc03a}, + {&&op_and_8_er_pcix , 0xf1ff, 0xc03b}, + {&&op_and_8_er_i , 0xf1ff, 0xc03c}, + {&&op_and_16_er_aw , 0xf1ff, 0xc078}, + {&&op_and_16_er_al , 0xf1ff, 0xc079}, + {&&op_and_16_er_pcdi , 0xf1ff, 0xc07a}, + {&&op_and_16_er_pcix , 0xf1ff, 0xc07b}, + {&&op_and_16_er_i , 0xf1ff, 0xc07c}, + {&&op_and_32_er_aw , 0xf1ff, 0xc0b8}, + {&&op_and_32_er_al , 0xf1ff, 0xc0b9}, + {&&op_and_32_er_pcdi , 0xf1ff, 0xc0ba}, + {&&op_and_32_er_pcix , 0xf1ff, 0xc0bb}, + {&&op_and_32_er_i , 0xf1ff, 0xc0bc}, + {&&op_mulu_16_aw , 0xf1ff, 0xc0f8}, + {&&op_mulu_16_al , 0xf1ff, 0xc0f9}, + {&&op_mulu_16_pcdi , 0xf1ff, 0xc0fa}, + {&&op_mulu_16_pcix , 0xf1ff, 0xc0fb}, + {&&op_mulu_16_i , 0xf1ff, 0xc0fc}, + {&&op_abcd_8_mm_ay7 , 0xf1ff, 0xc10f}, + {&&op_and_8_re_pi7 , 0xf1ff, 0xc11f}, + {&&op_and_8_re_pd7 , 0xf1ff, 0xc127}, + {&&op_and_8_re_aw , 0xf1ff, 0xc138}, + {&&op_and_8_re_al , 0xf1ff, 0xc139}, + {&&op_and_16_re_aw , 0xf1ff, 0xc178}, + {&&op_and_16_re_al , 0xf1ff, 0xc179}, + {&&op_and_32_re_aw , 0xf1ff, 0xc1b8}, + {&&op_and_32_re_al , 0xf1ff, 0xc1b9}, + {&&op_muls_16_aw , 0xf1ff, 0xc1f8}, + {&&op_muls_16_al , 0xf1ff, 0xc1f9}, + {&&op_muls_16_pcdi , 0xf1ff, 0xc1fa}, + {&&op_muls_16_pcix , 0xf1ff, 0xc1fb}, + {&&op_muls_16_i , 0xf1ff, 0xc1fc}, + {&&op_add_8_er_pi7 , 0xf1ff, 0xd01f}, + {&&op_add_8_er_pd7 , 0xf1ff, 0xd027}, + {&&op_add_8_er_aw , 0xf1ff, 0xd038}, + {&&op_add_8_er_al , 0xf1ff, 0xd039}, + {&&op_add_8_er_pcdi , 0xf1ff, 0xd03a}, + {&&op_add_8_er_pcix , 0xf1ff, 0xd03b}, + {&&op_add_8_er_i , 0xf1ff, 0xd03c}, + {&&op_add_16_er_aw , 0xf1ff, 0xd078}, + {&&op_add_16_er_al , 0xf1ff, 0xd079}, + {&&op_add_16_er_pcdi , 0xf1ff, 0xd07a}, + {&&op_add_16_er_pcix , 0xf1ff, 0xd07b}, + {&&op_add_16_er_i , 0xf1ff, 0xd07c}, + {&&op_add_32_er_aw , 0xf1ff, 0xd0b8}, + {&&op_add_32_er_al , 0xf1ff, 0xd0b9}, + {&&op_add_32_er_pcdi , 0xf1ff, 0xd0ba}, + {&&op_add_32_er_pcix , 0xf1ff, 0xd0bb}, + {&&op_add_32_er_i , 0xf1ff, 0xd0bc}, + {&&op_adda_16_aw , 0xf1ff, 0xd0f8}, + {&&op_adda_16_al , 0xf1ff, 0xd0f9}, + {&&op_adda_16_pcdi , 0xf1ff, 0xd0fa}, + {&&op_adda_16_pcix , 0xf1ff, 0xd0fb}, + {&&op_adda_16_i , 0xf1ff, 0xd0fc}, + {&&op_addx_8_mm_ay7 , 0xf1ff, 0xd10f}, + {&&op_add_8_re_pi7 , 0xf1ff, 0xd11f}, + {&&op_add_8_re_pd7 , 0xf1ff, 0xd127}, + {&&op_add_8_re_aw , 0xf1ff, 0xd138}, + {&&op_add_8_re_al , 0xf1ff, 0xd139}, + {&&op_add_16_re_aw , 0xf1ff, 0xd178}, + {&&op_add_16_re_al , 0xf1ff, 0xd179}, + {&&op_add_32_re_aw , 0xf1ff, 0xd1b8}, + {&&op_add_32_re_al , 0xf1ff, 0xd1b9}, + {&&op_adda_32_aw , 0xf1ff, 0xd1f8}, + {&&op_adda_32_al , 0xf1ff, 0xd1f9}, + {&&op_adda_32_pcdi , 0xf1ff, 0xd1fa}, + {&&op_adda_32_pcix , 0xf1ff, 0xd1fb}, + {&&op_adda_32_i , 0xf1ff, 0xd1fc}, + {&&op_ori_8_d , 0xfff8, 0x0000}, + {&&op_ori_8_ai , 0xfff8, 0x0010}, + {&&op_ori_8_pi , 0xfff8, 0x0018}, + {&&op_ori_8_pd , 0xfff8, 0x0020}, + {&&op_ori_8_di , 0xfff8, 0x0028}, + {&&op_ori_8_ix , 0xfff8, 0x0030}, + {&&op_ori_16_d , 0xfff8, 0x0040}, + {&&op_ori_16_ai , 0xfff8, 0x0050}, + {&&op_ori_16_pi , 0xfff8, 0x0058}, + {&&op_ori_16_pd , 0xfff8, 0x0060}, + {&&op_ori_16_di , 0xfff8, 0x0068}, + {&&op_ori_16_ix , 0xfff8, 0x0070}, + {&&op_ori_32_d , 0xfff8, 0x0080}, + {&&op_ori_32_ai , 0xfff8, 0x0090}, + {&&op_ori_32_pi , 0xfff8, 0x0098}, + {&&op_ori_32_pd , 0xfff8, 0x00a0}, + {&&op_ori_32_di , 0xfff8, 0x00a8}, + {&&op_ori_32_ix , 0xfff8, 0x00b0}, + {&&op_andi_8_d , 0xfff8, 0x0200}, + {&&op_andi_8_ai , 0xfff8, 0x0210}, + {&&op_andi_8_pi , 0xfff8, 0x0218}, + {&&op_andi_8_pd , 0xfff8, 0x0220}, + {&&op_andi_8_di , 0xfff8, 0x0228}, + {&&op_andi_8_ix , 0xfff8, 0x0230}, + {&&op_andi_16_d , 0xfff8, 0x0240}, + {&&op_andi_16_ai , 0xfff8, 0x0250}, + {&&op_andi_16_pi , 0xfff8, 0x0258}, + {&&op_andi_16_pd , 0xfff8, 0x0260}, + {&&op_andi_16_di , 0xfff8, 0x0268}, + {&&op_andi_16_ix , 0xfff8, 0x0270}, + {&&op_andi_32_d , 0xfff8, 0x0280}, + {&&op_andi_32_ai , 0xfff8, 0x0290}, + {&&op_andi_32_pi , 0xfff8, 0x0298}, + {&&op_andi_32_pd , 0xfff8, 0x02a0}, + {&&op_andi_32_di , 0xfff8, 0x02a8}, + {&&op_andi_32_ix , 0xfff8, 0x02b0}, + {&&op_subi_8_d , 0xfff8, 0x0400}, + {&&op_subi_8_ai , 0xfff8, 0x0410}, + {&&op_subi_8_pi , 0xfff8, 0x0418}, + {&&op_subi_8_pd , 0xfff8, 0x0420}, + {&&op_subi_8_di , 0xfff8, 0x0428}, + {&&op_subi_8_ix , 0xfff8, 0x0430}, + {&&op_subi_16_d , 0xfff8, 0x0440}, + {&&op_subi_16_ai , 0xfff8, 0x0450}, + {&&op_subi_16_pi , 0xfff8, 0x0458}, + {&&op_subi_16_pd , 0xfff8, 0x0460}, + {&&op_subi_16_di , 0xfff8, 0x0468}, + {&&op_subi_16_ix , 0xfff8, 0x0470}, + {&&op_subi_32_d , 0xfff8, 0x0480}, + {&&op_subi_32_ai , 0xfff8, 0x0490}, + {&&op_subi_32_pi , 0xfff8, 0x0498}, + {&&op_subi_32_pd , 0xfff8, 0x04a0}, + {&&op_subi_32_di , 0xfff8, 0x04a8}, + {&&op_subi_32_ix , 0xfff8, 0x04b0}, + {&&op_addi_8_d , 0xfff8, 0x0600}, + {&&op_addi_8_ai , 0xfff8, 0x0610}, + {&&op_addi_8_pi , 0xfff8, 0x0618}, + {&&op_addi_8_pd , 0xfff8, 0x0620}, + {&&op_addi_8_di , 0xfff8, 0x0628}, + {&&op_addi_8_ix , 0xfff8, 0x0630}, + {&&op_addi_16_d , 0xfff8, 0x0640}, + {&&op_addi_16_ai , 0xfff8, 0x0650}, + {&&op_addi_16_pi , 0xfff8, 0x0658}, + {&&op_addi_16_pd , 0xfff8, 0x0660}, + {&&op_addi_16_di , 0xfff8, 0x0668}, + {&&op_addi_16_ix , 0xfff8, 0x0670}, + {&&op_addi_32_d , 0xfff8, 0x0680}, + {&&op_addi_32_ai , 0xfff8, 0x0690}, + {&&op_addi_32_pi , 0xfff8, 0x0698}, + {&&op_addi_32_pd , 0xfff8, 0x06a0}, + {&&op_addi_32_di , 0xfff8, 0x06a8}, + {&&op_addi_32_ix , 0xfff8, 0x06b0}, + {&&op_btst_32_s_d , 0xfff8, 0x0800}, + {&&op_btst_8_s_ai , 0xfff8, 0x0810}, + {&&op_btst_8_s_pi , 0xfff8, 0x0818}, + {&&op_btst_8_s_pd , 0xfff8, 0x0820}, + {&&op_btst_8_s_di , 0xfff8, 0x0828}, + {&&op_btst_8_s_ix , 0xfff8, 0x0830}, + {&&op_bchg_32_s_d , 0xfff8, 0x0840}, + {&&op_bchg_8_s_ai , 0xfff8, 0x0850}, + {&&op_bchg_8_s_pi , 0xfff8, 0x0858}, + {&&op_bchg_8_s_pd , 0xfff8, 0x0860}, + {&&op_bchg_8_s_di , 0xfff8, 0x0868}, + {&&op_bchg_8_s_ix , 0xfff8, 0x0870}, + {&&op_bclr_32_s_d , 0xfff8, 0x0880}, + {&&op_bclr_8_s_ai , 0xfff8, 0x0890}, + {&&op_bclr_8_s_pi , 0xfff8, 0x0898}, + {&&op_bclr_8_s_pd , 0xfff8, 0x08a0}, + {&&op_bclr_8_s_di , 0xfff8, 0x08a8}, + {&&op_bclr_8_s_ix , 0xfff8, 0x08b0}, + {&&op_bset_32_s_d , 0xfff8, 0x08c0}, + {&&op_bset_8_s_ai , 0xfff8, 0x08d0}, + {&&op_bset_8_s_pi , 0xfff8, 0x08d8}, + {&&op_bset_8_s_pd , 0xfff8, 0x08e0}, + {&&op_bset_8_s_di , 0xfff8, 0x08e8}, + {&&op_bset_8_s_ix , 0xfff8, 0x08f0}, + {&&op_eori_8_d , 0xfff8, 0x0a00}, + {&&op_eori_8_ai , 0xfff8, 0x0a10}, + {&&op_eori_8_pi , 0xfff8, 0x0a18}, + {&&op_eori_8_pd , 0xfff8, 0x0a20}, + {&&op_eori_8_di , 0xfff8, 0x0a28}, + {&&op_eori_8_ix , 0xfff8, 0x0a30}, + {&&op_eori_16_d , 0xfff8, 0x0a40}, + {&&op_eori_16_ai , 0xfff8, 0x0a50}, + {&&op_eori_16_pi , 0xfff8, 0x0a58}, + {&&op_eori_16_pd , 0xfff8, 0x0a60}, + {&&op_eori_16_di , 0xfff8, 0x0a68}, + {&&op_eori_16_ix , 0xfff8, 0x0a70}, + {&&op_eori_32_d , 0xfff8, 0x0a80}, + {&&op_eori_32_ai , 0xfff8, 0x0a90}, + {&&op_eori_32_pi , 0xfff8, 0x0a98}, + {&&op_eori_32_pd , 0xfff8, 0x0aa0}, + {&&op_eori_32_di , 0xfff8, 0x0aa8}, + {&&op_eori_32_ix , 0xfff8, 0x0ab0}, + {&&op_cmpi_8_d , 0xfff8, 0x0c00}, + {&&op_cmpi_8_ai , 0xfff8, 0x0c10}, + {&&op_cmpi_8_pi , 0xfff8, 0x0c18}, + {&&op_cmpi_8_pd , 0xfff8, 0x0c20}, + {&&op_cmpi_8_di , 0xfff8, 0x0c28}, + {&&op_cmpi_8_ix , 0xfff8, 0x0c30}, + {&&op_cmpi_16_d , 0xfff8, 0x0c40}, + {&&op_cmpi_16_ai , 0xfff8, 0x0c50}, + {&&op_cmpi_16_pi , 0xfff8, 0x0c58}, + {&&op_cmpi_16_pd , 0xfff8, 0x0c60}, + {&&op_cmpi_16_di , 0xfff8, 0x0c68}, + {&&op_cmpi_16_ix , 0xfff8, 0x0c70}, + {&&op_cmpi_32_d , 0xfff8, 0x0c80}, + {&&op_cmpi_32_ai , 0xfff8, 0x0c90}, + {&&op_cmpi_32_pi , 0xfff8, 0x0c98}, + {&&op_cmpi_32_pd , 0xfff8, 0x0ca0}, + {&&op_cmpi_32_di , 0xfff8, 0x0ca8}, + {&&op_cmpi_32_ix , 0xfff8, 0x0cb0}, + {&&op_move_8_aw_d , 0xfff8, 0x11c0}, + {&&op_move_8_aw_ai , 0xfff8, 0x11d0}, + {&&op_move_8_aw_pi , 0xfff8, 0x11d8}, + {&&op_move_8_aw_pd , 0xfff8, 0x11e0}, + {&&op_move_8_aw_di , 0xfff8, 0x11e8}, + {&&op_move_8_aw_ix , 0xfff8, 0x11f0}, + {&&op_move_8_al_d , 0xfff8, 0x13c0}, + {&&op_move_8_al_ai , 0xfff8, 0x13d0}, + {&&op_move_8_al_pi , 0xfff8, 0x13d8}, + {&&op_move_8_al_pd , 0xfff8, 0x13e0}, + {&&op_move_8_al_di , 0xfff8, 0x13e8}, + {&&op_move_8_al_ix , 0xfff8, 0x13f0}, + {&&op_move_8_pi7_d , 0xfff8, 0x1ec0}, + {&&op_move_8_pi7_ai , 0xfff8, 0x1ed0}, + {&&op_move_8_pi7_pi , 0xfff8, 0x1ed8}, + {&&op_move_8_pi7_pd , 0xfff8, 0x1ee0}, + {&&op_move_8_pi7_di , 0xfff8, 0x1ee8}, + {&&op_move_8_pi7_ix , 0xfff8, 0x1ef0}, + {&&op_move_8_pd7_d , 0xfff8, 0x1f00}, + {&&op_move_8_pd7_ai , 0xfff8, 0x1f10}, + {&&op_move_8_pd7_pi , 0xfff8, 0x1f18}, + {&&op_move_8_pd7_pd , 0xfff8, 0x1f20}, + {&&op_move_8_pd7_di , 0xfff8, 0x1f28}, + {&&op_move_8_pd7_ix , 0xfff8, 0x1f30}, + {&&op_move_32_aw_d , 0xfff8, 0x21c0}, + {&&op_move_32_aw_a , 0xfff8, 0x21c8}, + {&&op_move_32_aw_ai , 0xfff8, 0x21d0}, + {&&op_move_32_aw_pi , 0xfff8, 0x21d8}, + {&&op_move_32_aw_pd , 0xfff8, 0x21e0}, + {&&op_move_32_aw_di , 0xfff8, 0x21e8}, + {&&op_move_32_aw_ix , 0xfff8, 0x21f0}, + {&&op_move_32_al_d , 0xfff8, 0x23c0}, + {&&op_move_32_al_a , 0xfff8, 0x23c8}, + {&&op_move_32_al_ai , 0xfff8, 0x23d0}, + {&&op_move_32_al_pi , 0xfff8, 0x23d8}, + {&&op_move_32_al_pd , 0xfff8, 0x23e0}, + {&&op_move_32_al_di , 0xfff8, 0x23e8}, + {&&op_move_32_al_ix , 0xfff8, 0x23f0}, + {&&op_move_16_aw_d , 0xfff8, 0x31c0}, + {&&op_move_16_aw_a , 0xfff8, 0x31c8}, + {&&op_move_16_aw_ai , 0xfff8, 0x31d0}, + {&&op_move_16_aw_pi , 0xfff8, 0x31d8}, + {&&op_move_16_aw_pd , 0xfff8, 0x31e0}, + {&&op_move_16_aw_di , 0xfff8, 0x31e8}, + {&&op_move_16_aw_ix , 0xfff8, 0x31f0}, + {&&op_move_16_al_d , 0xfff8, 0x33c0}, + {&&op_move_16_al_a , 0xfff8, 0x33c8}, + {&&op_move_16_al_ai , 0xfff8, 0x33d0}, + {&&op_move_16_al_pi , 0xfff8, 0x33d8}, + {&&op_move_16_al_pd , 0xfff8, 0x33e0}, + {&&op_move_16_al_di , 0xfff8, 0x33e8}, + {&&op_move_16_al_ix , 0xfff8, 0x33f0}, + {&&op_negx_8_d , 0xfff8, 0x4000}, + {&&op_negx_8_ai , 0xfff8, 0x4010}, + {&&op_negx_8_pi , 0xfff8, 0x4018}, + {&&op_negx_8_pd , 0xfff8, 0x4020}, + {&&op_negx_8_di , 0xfff8, 0x4028}, + {&&op_negx_8_ix , 0xfff8, 0x4030}, + {&&op_negx_16_d , 0xfff8, 0x4040}, + {&&op_negx_16_ai , 0xfff8, 0x4050}, + {&&op_negx_16_pi , 0xfff8, 0x4058}, + {&&op_negx_16_pd , 0xfff8, 0x4060}, + {&&op_negx_16_di , 0xfff8, 0x4068}, + {&&op_negx_16_ix , 0xfff8, 0x4070}, + {&&op_negx_32_d , 0xfff8, 0x4080}, + {&&op_negx_32_ai , 0xfff8, 0x4090}, + {&&op_negx_32_pi , 0xfff8, 0x4098}, + {&&op_negx_32_pd , 0xfff8, 0x40a0}, + {&&op_negx_32_di , 0xfff8, 0x40a8}, + {&&op_negx_32_ix , 0xfff8, 0x40b0}, + {&&op_move_16_frs_d , 0xfff8, 0x40c0}, + {&&op_move_16_frs_ai , 0xfff8, 0x40d0}, + {&&op_move_16_frs_pi , 0xfff8, 0x40d8}, + {&&op_move_16_frs_pd , 0xfff8, 0x40e0}, + {&&op_move_16_frs_di , 0xfff8, 0x40e8}, + {&&op_move_16_frs_ix , 0xfff8, 0x40f0}, + {&&op_clr_8_d , 0xfff8, 0x4200}, + {&&op_clr_8_ai , 0xfff8, 0x4210}, + {&&op_clr_8_pi , 0xfff8, 0x4218}, + {&&op_clr_8_pd , 0xfff8, 0x4220}, + {&&op_clr_8_di , 0xfff8, 0x4228}, + {&&op_clr_8_ix , 0xfff8, 0x4230}, + {&&op_clr_16_d , 0xfff8, 0x4240}, + {&&op_clr_16_ai , 0xfff8, 0x4250}, + {&&op_clr_16_pi , 0xfff8, 0x4258}, + {&&op_clr_16_pd , 0xfff8, 0x4260}, + {&&op_clr_16_di , 0xfff8, 0x4268}, + {&&op_clr_16_ix , 0xfff8, 0x4270}, + {&&op_clr_32_d , 0xfff8, 0x4280}, + {&&op_clr_32_ai , 0xfff8, 0x4290}, + {&&op_clr_32_pi , 0xfff8, 0x4298}, + {&&op_clr_32_pd , 0xfff8, 0x42a0}, + {&&op_clr_32_di , 0xfff8, 0x42a8}, + {&&op_clr_32_ix , 0xfff8, 0x42b0}, + {&&op_neg_8_d , 0xfff8, 0x4400}, + {&&op_neg_8_ai , 0xfff8, 0x4410}, + {&&op_neg_8_pi , 0xfff8, 0x4418}, + {&&op_neg_8_pd , 0xfff8, 0x4420}, + {&&op_neg_8_di , 0xfff8, 0x4428}, + {&&op_neg_8_ix , 0xfff8, 0x4430}, + {&&op_neg_16_d , 0xfff8, 0x4440}, + {&&op_neg_16_ai , 0xfff8, 0x4450}, + {&&op_neg_16_pi , 0xfff8, 0x4458}, + {&&op_neg_16_pd , 0xfff8, 0x4460}, + {&&op_neg_16_di , 0xfff8, 0x4468}, + {&&op_neg_16_ix , 0xfff8, 0x4470}, + {&&op_neg_32_d , 0xfff8, 0x4480}, + {&&op_neg_32_ai , 0xfff8, 0x4490}, + {&&op_neg_32_pi , 0xfff8, 0x4498}, + {&&op_neg_32_pd , 0xfff8, 0x44a0}, + {&&op_neg_32_di , 0xfff8, 0x44a8}, + {&&op_neg_32_ix , 0xfff8, 0x44b0}, + {&&op_move_16_toc_d , 0xfff8, 0x44c0}, + {&&op_move_16_toc_ai , 0xfff8, 0x44d0}, + {&&op_move_16_toc_pi , 0xfff8, 0x44d8}, + {&&op_move_16_toc_pd , 0xfff8, 0x44e0}, + {&&op_move_16_toc_di , 0xfff8, 0x44e8}, + {&&op_move_16_toc_ix , 0xfff8, 0x44f0}, + {&&op_not_8_d , 0xfff8, 0x4600}, + {&&op_not_8_ai , 0xfff8, 0x4610}, + {&&op_not_8_pi , 0xfff8, 0x4618}, + {&&op_not_8_pd , 0xfff8, 0x4620}, + {&&op_not_8_di , 0xfff8, 0x4628}, + {&&op_not_8_ix , 0xfff8, 0x4630}, + {&&op_not_16_d , 0xfff8, 0x4640}, + {&&op_not_16_ai , 0xfff8, 0x4650}, + {&&op_not_16_pi , 0xfff8, 0x4658}, + {&&op_not_16_pd , 0xfff8, 0x4660}, + {&&op_not_16_di , 0xfff8, 0x4668}, + {&&op_not_16_ix , 0xfff8, 0x4670}, + {&&op_not_32_d , 0xfff8, 0x4680}, + {&&op_not_32_ai , 0xfff8, 0x4690}, + {&&op_not_32_pi , 0xfff8, 0x4698}, + {&&op_not_32_pd , 0xfff8, 0x46a0}, + {&&op_not_32_di , 0xfff8, 0x46a8}, + {&&op_not_32_ix , 0xfff8, 0x46b0}, + {&&op_move_16_tos_d , 0xfff8, 0x46c0}, + {&&op_move_16_tos_ai , 0xfff8, 0x46d0}, + {&&op_move_16_tos_pi , 0xfff8, 0x46d8}, + {&&op_move_16_tos_pd , 0xfff8, 0x46e0}, + {&&op_move_16_tos_di , 0xfff8, 0x46e8}, + {&&op_move_16_tos_ix , 0xfff8, 0x46f0}, + {&&op_nbcd_8_d , 0xfff8, 0x4800}, + {&&op_nbcd_8_ai , 0xfff8, 0x4810}, + {&&op_nbcd_8_pi , 0xfff8, 0x4818}, + {&&op_nbcd_8_pd , 0xfff8, 0x4820}, + {&&op_nbcd_8_di , 0xfff8, 0x4828}, + {&&op_nbcd_8_ix , 0xfff8, 0x4830}, + {&&op_swap_32 , 0xfff8, 0x4840}, + {&&op_pea_32_ai , 0xfff8, 0x4850}, + {&&op_pea_32_di , 0xfff8, 0x4868}, + {&&op_pea_32_ix , 0xfff8, 0x4870}, + {&&op_ext_16 , 0xfff8, 0x4880}, + {&&op_movem_16_re_ai , 0xfff8, 0x4890}, + {&&op_movem_16_re_pd , 0xfff8, 0x48a0}, + {&&op_movem_16_re_di , 0xfff8, 0x48a8}, + {&&op_movem_16_re_ix , 0xfff8, 0x48b0}, + {&&op_ext_32 , 0xfff8, 0x48c0}, + {&&op_movem_32_re_ai , 0xfff8, 0x48d0}, + {&&op_movem_32_re_pd , 0xfff8, 0x48e0}, + {&&op_movem_32_re_di , 0xfff8, 0x48e8}, + {&&op_movem_32_re_ix , 0xfff8, 0x48f0}, + {&&op_tst_8_d , 0xfff8, 0x4a00}, + {&&op_tst_8_ai , 0xfff8, 0x4a10}, + {&&op_tst_8_pi , 0xfff8, 0x4a18}, + {&&op_tst_8_pd , 0xfff8, 0x4a20}, + {&&op_tst_8_di , 0xfff8, 0x4a28}, + {&&op_tst_8_ix , 0xfff8, 0x4a30}, + {&&op_tst_16_d , 0xfff8, 0x4a40}, + {&&op_tst_16_ai , 0xfff8, 0x4a50}, + {&&op_tst_16_pi , 0xfff8, 0x4a58}, + {&&op_tst_16_pd , 0xfff8, 0x4a60}, + {&&op_tst_16_di , 0xfff8, 0x4a68}, + {&&op_tst_16_ix , 0xfff8, 0x4a70}, + {&&op_tst_32_d , 0xfff8, 0x4a80}, + {&&op_tst_32_ai , 0xfff8, 0x4a90}, + {&&op_tst_32_pi , 0xfff8, 0x4a98}, + {&&op_tst_32_pd , 0xfff8, 0x4aa0}, + {&&op_tst_32_di , 0xfff8, 0x4aa8}, + {&&op_tst_32_ix , 0xfff8, 0x4ab0}, + {&&op_tas_8_d , 0xfff8, 0x4ac0}, + {&&op_tas_8_ai , 0xfff8, 0x4ad0}, + {&&op_tas_8_pi , 0xfff8, 0x4ad8}, + {&&op_tas_8_pd , 0xfff8, 0x4ae0}, + {&&op_tas_8_di , 0xfff8, 0x4ae8}, + {&&op_tas_8_ix , 0xfff8, 0x4af0}, + {&&op_movem_16_er_ai , 0xfff8, 0x4c90}, + {&&op_movem_16_er_pi , 0xfff8, 0x4c98}, + {&&op_movem_16_er_di , 0xfff8, 0x4ca8}, + {&&op_movem_16_er_ix , 0xfff8, 0x4cb0}, + {&&op_movem_32_er_ai , 0xfff8, 0x4cd0}, + {&&op_movem_32_er_pi , 0xfff8, 0x4cd8}, + {&&op_movem_32_er_di , 0xfff8, 0x4ce8}, + {&&op_movem_32_er_ix , 0xfff8, 0x4cf0}, + {&&op_link_16 , 0xfff8, 0x4e50}, + {&&op_unlk_32 , 0xfff8, 0x4e58}, + {&&op_move_32_tou , 0xfff8, 0x4e60}, + {&&op_move_32_fru , 0xfff8, 0x4e68}, + {&&op_jsr_32_ai , 0xfff8, 0x4e90}, + {&&op_jsr_32_di , 0xfff8, 0x4ea8}, + {&&op_jsr_32_ix , 0xfff8, 0x4eb0}, + {&&op_jmp_32_ai , 0xfff8, 0x4ed0}, + {&&op_jmp_32_di , 0xfff8, 0x4ee8}, + {&&op_jmp_32_ix , 0xfff8, 0x4ef0}, + {&&op_st_8_d , 0xfff8, 0x50c0}, + {&&op_dbt_16 , 0xfff8, 0x50c8}, + {&&op_st_8_ai , 0xfff8, 0x50d0}, + {&&op_st_8_pi , 0xfff8, 0x50d8}, + {&&op_st_8_pd , 0xfff8, 0x50e0}, + {&&op_st_8_di , 0xfff8, 0x50e8}, + {&&op_st_8_ix , 0xfff8, 0x50f0}, + {&&op_sf_8_d , 0xfff8, 0x51c0}, + {&&op_dbf_16 , 0xfff8, 0x51c8}, + {&&op_sf_8_ai , 0xfff8, 0x51d0}, + {&&op_sf_8_pi , 0xfff8, 0x51d8}, + {&&op_sf_8_pd , 0xfff8, 0x51e0}, + {&&op_sf_8_di , 0xfff8, 0x51e8}, + {&&op_sf_8_ix , 0xfff8, 0x51f0}, + {&&op_shi_8_d , 0xfff8, 0x52c0}, + {&&op_dbhi_16 , 0xfff8, 0x52c8}, + {&&op_shi_8_ai , 0xfff8, 0x52d0}, + {&&op_shi_8_pi , 0xfff8, 0x52d8}, + {&&op_shi_8_pd , 0xfff8, 0x52e0}, + {&&op_shi_8_di , 0xfff8, 0x52e8}, + {&&op_shi_8_ix , 0xfff8, 0x52f0}, + {&&op_sls_8_d , 0xfff8, 0x53c0}, + {&&op_dbls_16 , 0xfff8, 0x53c8}, + {&&op_sls_8_ai , 0xfff8, 0x53d0}, + {&&op_sls_8_pi , 0xfff8, 0x53d8}, + {&&op_sls_8_pd , 0xfff8, 0x53e0}, + {&&op_sls_8_di , 0xfff8, 0x53e8}, + {&&op_sls_8_ix , 0xfff8, 0x53f0}, + {&&op_scc_8_d , 0xfff8, 0x54c0}, + {&&op_dbcc_16 , 0xfff8, 0x54c8}, + {&&op_scc_8_ai , 0xfff8, 0x54d0}, + {&&op_scc_8_pi , 0xfff8, 0x54d8}, + {&&op_scc_8_pd , 0xfff8, 0x54e0}, + {&&op_scc_8_di , 0xfff8, 0x54e8}, + {&&op_scc_8_ix , 0xfff8, 0x54f0}, + {&&op_scs_8_d , 0xfff8, 0x55c0}, + {&&op_dbcs_16 , 0xfff8, 0x55c8}, + {&&op_scs_8_ai , 0xfff8, 0x55d0}, + {&&op_scs_8_pi , 0xfff8, 0x55d8}, + {&&op_scs_8_pd , 0xfff8, 0x55e0}, + {&&op_scs_8_di , 0xfff8, 0x55e8}, + {&&op_scs_8_ix , 0xfff8, 0x55f0}, + {&&op_sne_8_d , 0xfff8, 0x56c0}, + {&&op_dbne_16 , 0xfff8, 0x56c8}, + {&&op_sne_8_ai , 0xfff8, 0x56d0}, + {&&op_sne_8_pi , 0xfff8, 0x56d8}, + {&&op_sne_8_pd , 0xfff8, 0x56e0}, + {&&op_sne_8_di , 0xfff8, 0x56e8}, + {&&op_sne_8_ix , 0xfff8, 0x56f0}, + {&&op_seq_8_d , 0xfff8, 0x57c0}, + {&&op_dbeq_16 , 0xfff8, 0x57c8}, + {&&op_seq_8_ai , 0xfff8, 0x57d0}, + {&&op_seq_8_pi , 0xfff8, 0x57d8}, + {&&op_seq_8_pd , 0xfff8, 0x57e0}, + {&&op_seq_8_di , 0xfff8, 0x57e8}, + {&&op_seq_8_ix , 0xfff8, 0x57f0}, + {&&op_svc_8_d , 0xfff8, 0x58c0}, + {&&op_dbvc_16 , 0xfff8, 0x58c8}, + {&&op_svc_8_ai , 0xfff8, 0x58d0}, + {&&op_svc_8_pi , 0xfff8, 0x58d8}, + {&&op_svc_8_pd , 0xfff8, 0x58e0}, + {&&op_svc_8_di , 0xfff8, 0x58e8}, + {&&op_svc_8_ix , 0xfff8, 0x58f0}, + {&&op_svs_8_d , 0xfff8, 0x59c0}, + {&&op_dbvs_16 , 0xfff8, 0x59c8}, + {&&op_svs_8_ai , 0xfff8, 0x59d0}, + {&&op_svs_8_pi , 0xfff8, 0x59d8}, + {&&op_svs_8_pd , 0xfff8, 0x59e0}, + {&&op_svs_8_di , 0xfff8, 0x59e8}, + {&&op_svs_8_ix , 0xfff8, 0x59f0}, + {&&op_spl_8_d , 0xfff8, 0x5ac0}, + {&&op_dbpl_16 , 0xfff8, 0x5ac8}, + {&&op_spl_8_ai , 0xfff8, 0x5ad0}, + {&&op_spl_8_pi , 0xfff8, 0x5ad8}, + {&&op_spl_8_pd , 0xfff8, 0x5ae0}, + {&&op_spl_8_di , 0xfff8, 0x5ae8}, + {&&op_spl_8_ix , 0xfff8, 0x5af0}, + {&&op_smi_8_d , 0xfff8, 0x5bc0}, + {&&op_dbmi_16 , 0xfff8, 0x5bc8}, + {&&op_smi_8_ai , 0xfff8, 0x5bd0}, + {&&op_smi_8_pi , 0xfff8, 0x5bd8}, + {&&op_smi_8_pd , 0xfff8, 0x5be0}, + {&&op_smi_8_di , 0xfff8, 0x5be8}, + {&&op_smi_8_ix , 0xfff8, 0x5bf0}, + {&&op_sge_8_d , 0xfff8, 0x5cc0}, + {&&op_dbge_16 , 0xfff8, 0x5cc8}, + {&&op_sge_8_ai , 0xfff8, 0x5cd0}, + {&&op_sge_8_pi , 0xfff8, 0x5cd8}, + {&&op_sge_8_pd , 0xfff8, 0x5ce0}, + {&&op_sge_8_di , 0xfff8, 0x5ce8}, + {&&op_sge_8_ix , 0xfff8, 0x5cf0}, + {&&op_slt_8_d , 0xfff8, 0x5dc0}, + {&&op_dblt_16 , 0xfff8, 0x5dc8}, + {&&op_slt_8_ai , 0xfff8, 0x5dd0}, + {&&op_slt_8_pi , 0xfff8, 0x5dd8}, + {&&op_slt_8_pd , 0xfff8, 0x5de0}, + {&&op_slt_8_di , 0xfff8, 0x5de8}, + {&&op_slt_8_ix , 0xfff8, 0x5df0}, + {&&op_sgt_8_d , 0xfff8, 0x5ec0}, + {&&op_dbgt_16 , 0xfff8, 0x5ec8}, + {&&op_sgt_8_ai , 0xfff8, 0x5ed0}, + {&&op_sgt_8_pi , 0xfff8, 0x5ed8}, + {&&op_sgt_8_pd , 0xfff8, 0x5ee0}, + {&&op_sgt_8_di , 0xfff8, 0x5ee8}, + {&&op_sgt_8_ix , 0xfff8, 0x5ef0}, + {&&op_sle_8_d , 0xfff8, 0x5fc0}, + {&&op_dble_16 , 0xfff8, 0x5fc8}, + {&&op_sle_8_ai , 0xfff8, 0x5fd0}, + {&&op_sle_8_pi , 0xfff8, 0x5fd8}, + {&&op_sle_8_pd , 0xfff8, 0x5fe0}, + {&&op_sle_8_di , 0xfff8, 0x5fe8}, + {&&op_sle_8_ix , 0xfff8, 0x5ff0}, + {&&op_sbcd_8_mm_ax7 , 0xfff8, 0x8f08}, + {&&op_subx_8_mm_ax7 , 0xfff8, 0x9f08}, + {&&op_cmpm_8_ax7 , 0xfff8, 0xbf08}, + {&&op_abcd_8_mm_ax7 , 0xfff8, 0xcf08}, + {&&op_addx_8_mm_ax7 , 0xfff8, 0xdf08}, + {&&op_asr_16_ai , 0xfff8, 0xe0d0}, + {&&op_asr_16_pi , 0xfff8, 0xe0d8}, + {&&op_asr_16_pd , 0xfff8, 0xe0e0}, + {&&op_asr_16_di , 0xfff8, 0xe0e8}, + {&&op_asr_16_ix , 0xfff8, 0xe0f0}, + {&&op_asl_16_ai , 0xfff8, 0xe1d0}, + {&&op_asl_16_pi , 0xfff8, 0xe1d8}, + {&&op_asl_16_pd , 0xfff8, 0xe1e0}, + {&&op_asl_16_di , 0xfff8, 0xe1e8}, + {&&op_asl_16_ix , 0xfff8, 0xe1f0}, + {&&op_lsr_16_ai , 0xfff8, 0xe2d0}, + {&&op_lsr_16_pi , 0xfff8, 0xe2d8}, + {&&op_lsr_16_pd , 0xfff8, 0xe2e0}, + {&&op_lsr_16_di , 0xfff8, 0xe2e8}, + {&&op_lsr_16_ix , 0xfff8, 0xe2f0}, + {&&op_lsl_16_ai , 0xfff8, 0xe3d0}, + {&&op_lsl_16_pi , 0xfff8, 0xe3d8}, + {&&op_lsl_16_pd , 0xfff8, 0xe3e0}, + {&&op_lsl_16_di , 0xfff8, 0xe3e8}, + {&&op_lsl_16_ix , 0xfff8, 0xe3f0}, + {&&op_roxr_16_ai , 0xfff8, 0xe4d0}, + {&&op_roxr_16_pi , 0xfff8, 0xe4d8}, + {&&op_roxr_16_pd , 0xfff8, 0xe4e0}, + {&&op_roxr_16_di , 0xfff8, 0xe4e8}, + {&&op_roxr_16_ix , 0xfff8, 0xe4f0}, + {&&op_roxl_16_ai , 0xfff8, 0xe5d0}, + {&&op_roxl_16_pi , 0xfff8, 0xe5d8}, + {&&op_roxl_16_pd , 0xfff8, 0xe5e0}, + {&&op_roxl_16_di , 0xfff8, 0xe5e8}, + {&&op_roxl_16_ix , 0xfff8, 0xe5f0}, + {&&op_ror_16_ai , 0xfff8, 0xe6d0}, + {&&op_ror_16_pi , 0xfff8, 0xe6d8}, + {&&op_ror_16_pd , 0xfff8, 0xe6e0}, + {&&op_ror_16_di , 0xfff8, 0xe6e8}, + {&&op_ror_16_ix , 0xfff8, 0xe6f0}, + {&&op_rol_16_ai , 0xfff8, 0xe7d0}, + {&&op_rol_16_pi , 0xfff8, 0xe7d8}, + {&&op_rol_16_pd , 0xfff8, 0xe7e0}, + {&&op_rol_16_di , 0xfff8, 0xe7e8}, + {&&op_rol_16_ix , 0xfff8, 0xe7f0}, + {&&op_ori_8_pi7 , 0xffff, 0x001f}, + {&&op_ori_8_pd7 , 0xffff, 0x0027}, + {&&op_ori_8_aw , 0xffff, 0x0038}, + {&&op_ori_8_al , 0xffff, 0x0039}, + {&&op_ori_16_toc , 0xffff, 0x003c}, + {&&op_ori_16_aw , 0xffff, 0x0078}, + {&&op_ori_16_al , 0xffff, 0x0079}, + {&&op_ori_16_tos , 0xffff, 0x007c}, + {&&op_ori_32_aw , 0xffff, 0x00b8}, + {&&op_ori_32_al , 0xffff, 0x00b9}, + {&&op_andi_8_pi7 , 0xffff, 0x021f}, + {&&op_andi_8_pd7 , 0xffff, 0x0227}, + {&&op_andi_8_aw , 0xffff, 0x0238}, + {&&op_andi_8_al , 0xffff, 0x0239}, + {&&op_andi_16_toc , 0xffff, 0x023c}, + {&&op_andi_16_aw , 0xffff, 0x0278}, + {&&op_andi_16_al , 0xffff, 0x0279}, + {&&op_andi_16_tos , 0xffff, 0x027c}, + {&&op_andi_32_aw , 0xffff, 0x02b8}, + {&&op_andi_32_al , 0xffff, 0x02b9}, + {&&op_subi_8_pi7 , 0xffff, 0x041f}, + {&&op_subi_8_pd7 , 0xffff, 0x0427}, + {&&op_subi_8_aw , 0xffff, 0x0438}, + {&&op_subi_8_al , 0xffff, 0x0439}, + {&&op_subi_16_aw , 0xffff, 0x0478}, + {&&op_subi_16_al , 0xffff, 0x0479}, + {&&op_subi_32_aw , 0xffff, 0x04b8}, + {&&op_subi_32_al , 0xffff, 0x04b9}, + {&&op_addi_8_pi7 , 0xffff, 0x061f}, + {&&op_addi_8_pd7 , 0xffff, 0x0627}, + {&&op_addi_8_aw , 0xffff, 0x0638}, + {&&op_addi_8_al , 0xffff, 0x0639}, + {&&op_addi_16_aw , 0xffff, 0x0678}, + {&&op_addi_16_al , 0xffff, 0x0679}, + {&&op_addi_32_aw , 0xffff, 0x06b8}, + {&&op_addi_32_al , 0xffff, 0x06b9}, + {&&op_btst_8_s_pi7 , 0xffff, 0x081f}, + {&&op_btst_8_s_pd7 , 0xffff, 0x0827}, + {&&op_btst_8_s_aw , 0xffff, 0x0838}, + {&&op_btst_8_s_al , 0xffff, 0x0839}, + {&&op_btst_8_s_pcdi , 0xffff, 0x083a}, + {&&op_btst_8_s_pcix , 0xffff, 0x083b}, + {&&op_bchg_8_s_pi7 , 0xffff, 0x085f}, + {&&op_bchg_8_s_pd7 , 0xffff, 0x0867}, + {&&op_bchg_8_s_aw , 0xffff, 0x0878}, + {&&op_bchg_8_s_al , 0xffff, 0x0879}, + {&&op_bclr_8_s_pi7 , 0xffff, 0x089f}, + {&&op_bclr_8_s_pd7 , 0xffff, 0x08a7}, + {&&op_bclr_8_s_aw , 0xffff, 0x08b8}, + {&&op_bclr_8_s_al , 0xffff, 0x08b9}, + {&&op_bset_8_s_pi7 , 0xffff, 0x08df}, + {&&op_bset_8_s_pd7 , 0xffff, 0x08e7}, + {&&op_bset_8_s_aw , 0xffff, 0x08f8}, + {&&op_bset_8_s_al , 0xffff, 0x08f9}, + {&&op_eori_8_pi7 , 0xffff, 0x0a1f}, + {&&op_eori_8_pd7 , 0xffff, 0x0a27}, + {&&op_eori_8_aw , 0xffff, 0x0a38}, + {&&op_eori_8_al , 0xffff, 0x0a39}, + {&&op_eori_16_toc , 0xffff, 0x0a3c}, + {&&op_eori_16_aw , 0xffff, 0x0a78}, + {&&op_eori_16_al , 0xffff, 0x0a79}, + {&&op_eori_16_tos , 0xffff, 0x0a7c}, + {&&op_eori_32_aw , 0xffff, 0x0ab8}, + {&&op_eori_32_al , 0xffff, 0x0ab9}, + {&&op_cmpi_8_pi7 , 0xffff, 0x0c1f}, + {&&op_cmpi_8_pd7 , 0xffff, 0x0c27}, + {&&op_cmpi_8_aw , 0xffff, 0x0c38}, + {&&op_cmpi_8_al , 0xffff, 0x0c39}, + {&&op_cmpi_16_aw , 0xffff, 0x0c78}, + {&&op_cmpi_16_al , 0xffff, 0x0c79}, + {&&op_cmpi_32_aw , 0xffff, 0x0cb8}, + {&&op_cmpi_32_al , 0xffff, 0x0cb9}, + {&&op_move_8_aw_pi7 , 0xffff, 0x11df}, + {&&op_move_8_aw_pd7 , 0xffff, 0x11e7}, + {&&op_move_8_aw_aw , 0xffff, 0x11f8}, + {&&op_move_8_aw_al , 0xffff, 0x11f9}, + {&&op_move_8_aw_pcdi , 0xffff, 0x11fa}, + {&&op_move_8_aw_pcix , 0xffff, 0x11fb}, + {&&op_move_8_aw_i , 0xffff, 0x11fc}, + {&&op_move_8_al_pi7 , 0xffff, 0x13df}, + {&&op_move_8_al_pd7 , 0xffff, 0x13e7}, + {&&op_move_8_al_aw , 0xffff, 0x13f8}, + {&&op_move_8_al_al , 0xffff, 0x13f9}, + {&&op_move_8_al_pcdi , 0xffff, 0x13fa}, + {&&op_move_8_al_pcix , 0xffff, 0x13fb}, + {&&op_move_8_al_i , 0xffff, 0x13fc}, + {&&op_move_8_pi7_pi7 , 0xffff, 0x1edf}, + {&&op_move_8_pi7_pd7 , 0xffff, 0x1ee7}, + {&&op_move_8_pi7_aw , 0xffff, 0x1ef8}, + {&&op_move_8_pi7_al , 0xffff, 0x1ef9}, + {&&op_move_8_pi7_pcdi , 0xffff, 0x1efa}, + {&&op_move_8_pi7_pcix , 0xffff, 0x1efb}, + {&&op_move_8_pi7_i , 0xffff, 0x1efc}, + {&&op_move_8_pd7_pi7 , 0xffff, 0x1f1f}, + {&&op_move_8_pd7_pd7 , 0xffff, 0x1f27}, + {&&op_move_8_pd7_aw , 0xffff, 0x1f38}, + {&&op_move_8_pd7_al , 0xffff, 0x1f39}, + {&&op_move_8_pd7_pcdi , 0xffff, 0x1f3a}, + {&&op_move_8_pd7_pcix , 0xffff, 0x1f3b}, + {&&op_move_8_pd7_i , 0xffff, 0x1f3c}, + {&&op_move_32_aw_aw , 0xffff, 0x21f8}, + {&&op_move_32_aw_al , 0xffff, 0x21f9}, + {&&op_move_32_aw_pcdi , 0xffff, 0x21fa}, + {&&op_move_32_aw_pcix , 0xffff, 0x21fb}, + {&&op_move_32_aw_i , 0xffff, 0x21fc}, + {&&op_move_32_al_aw , 0xffff, 0x23f8}, + {&&op_move_32_al_al , 0xffff, 0x23f9}, + {&&op_move_32_al_pcdi , 0xffff, 0x23fa}, + {&&op_move_32_al_pcix , 0xffff, 0x23fb}, + {&&op_move_32_al_i , 0xffff, 0x23fc}, + {&&op_move_16_aw_aw , 0xffff, 0x31f8}, + {&&op_move_16_aw_al , 0xffff, 0x31f9}, + {&&op_move_16_aw_pcdi , 0xffff, 0x31fa}, + {&&op_move_16_aw_pcix , 0xffff, 0x31fb}, + {&&op_move_16_aw_i , 0xffff, 0x31fc}, + {&&op_move_16_al_aw , 0xffff, 0x33f8}, + {&&op_move_16_al_al , 0xffff, 0x33f9}, + {&&op_move_16_al_pcdi , 0xffff, 0x33fa}, + {&&op_move_16_al_pcix , 0xffff, 0x33fb}, + {&&op_move_16_al_i , 0xffff, 0x33fc}, + {&&op_negx_8_pi7 , 0xffff, 0x401f}, + {&&op_negx_8_pd7 , 0xffff, 0x4027}, + {&&op_negx_8_aw , 0xffff, 0x4038}, + {&&op_negx_8_al , 0xffff, 0x4039}, + {&&op_negx_16_aw , 0xffff, 0x4078}, + {&&op_negx_16_al , 0xffff, 0x4079}, + {&&op_negx_32_aw , 0xffff, 0x40b8}, + {&&op_negx_32_al , 0xffff, 0x40b9}, + {&&op_move_16_frs_aw , 0xffff, 0x40f8}, + {&&op_move_16_frs_al , 0xffff, 0x40f9}, + {&&op_clr_8_pi7 , 0xffff, 0x421f}, + {&&op_clr_8_pd7 , 0xffff, 0x4227}, + {&&op_clr_8_aw , 0xffff, 0x4238}, + {&&op_clr_8_al , 0xffff, 0x4239}, + {&&op_clr_16_aw , 0xffff, 0x4278}, + {&&op_clr_16_al , 0xffff, 0x4279}, + {&&op_clr_32_aw , 0xffff, 0x42b8}, + {&&op_clr_32_al , 0xffff, 0x42b9}, + {&&op_neg_8_pi7 , 0xffff, 0x441f}, + {&&op_neg_8_pd7 , 0xffff, 0x4427}, + {&&op_neg_8_aw , 0xffff, 0x4438}, + {&&op_neg_8_al , 0xffff, 0x4439}, + {&&op_neg_16_aw , 0xffff, 0x4478}, + {&&op_neg_16_al , 0xffff, 0x4479}, + {&&op_neg_32_aw , 0xffff, 0x44b8}, + {&&op_neg_32_al , 0xffff, 0x44b9}, + {&&op_move_16_toc_aw , 0xffff, 0x44f8}, + {&&op_move_16_toc_al , 0xffff, 0x44f9}, + {&&op_move_16_toc_pcdi , 0xffff, 0x44fa}, + {&&op_move_16_toc_pcix , 0xffff, 0x44fb}, + {&&op_move_16_toc_i , 0xffff, 0x44fc}, + {&&op_not_8_pi7 , 0xffff, 0x461f}, + {&&op_not_8_pd7 , 0xffff, 0x4627}, + {&&op_not_8_aw , 0xffff, 0x4638}, + {&&op_not_8_al , 0xffff, 0x4639}, + {&&op_not_16_aw , 0xffff, 0x4678}, + {&&op_not_16_al , 0xffff, 0x4679}, + {&&op_not_32_aw , 0xffff, 0x46b8}, + {&&op_not_32_al , 0xffff, 0x46b9}, + {&&op_move_16_tos_aw , 0xffff, 0x46f8}, + {&&op_move_16_tos_al , 0xffff, 0x46f9}, + {&&op_move_16_tos_pcdi , 0xffff, 0x46fa}, + {&&op_move_16_tos_pcix , 0xffff, 0x46fb}, + {&&op_move_16_tos_i , 0xffff, 0x46fc}, + {&&op_nbcd_8_pi7 , 0xffff, 0x481f}, + {&&op_nbcd_8_pd7 , 0xffff, 0x4827}, + {&&op_nbcd_8_aw , 0xffff, 0x4838}, + {&&op_nbcd_8_al , 0xffff, 0x4839}, + {&&op_pea_32_aw , 0xffff, 0x4878}, + {&&op_pea_32_al , 0xffff, 0x4879}, + {&&op_pea_32_pcdi , 0xffff, 0x487a}, + {&&op_pea_32_pcix , 0xffff, 0x487b}, + {&&op_movem_16_re_aw , 0xffff, 0x48b8}, + {&&op_movem_16_re_al , 0xffff, 0x48b9}, + {&&op_movem_32_re_aw , 0xffff, 0x48f8}, + {&&op_movem_32_re_al , 0xffff, 0x48f9}, + {&&op_tst_8_pi7 , 0xffff, 0x4a1f}, + {&&op_tst_8_pd7 , 0xffff, 0x4a27}, + {&&op_tst_8_aw , 0xffff, 0x4a38}, + {&&op_tst_8_al , 0xffff, 0x4a39}, + {&&op_tst_16_aw , 0xffff, 0x4a78}, + {&&op_tst_16_al , 0xffff, 0x4a79}, + {&&op_tst_32_aw , 0xffff, 0x4ab8}, + {&&op_tst_32_al , 0xffff, 0x4ab9}, + {&&op_tas_8_pi7 , 0xffff, 0x4adf}, + {&&op_tas_8_pd7 , 0xffff, 0x4ae7}, + {&&op_tas_8_aw , 0xffff, 0x4af8}, + {&&op_tas_8_al , 0xffff, 0x4af9}, + {&&op_illegal , 0xffff, 0x4afc}, + {&&op_movem_16_er_aw , 0xffff, 0x4cb8}, + {&&op_movem_16_er_al , 0xffff, 0x4cb9}, + {&&op_movem_16_er_pcdi , 0xffff, 0x4cba}, + {&&op_movem_16_er_pcix , 0xffff, 0x4cbb}, + {&&op_movem_32_er_aw , 0xffff, 0x4cf8}, + {&&op_movem_32_er_al , 0xffff, 0x4cf9}, + {&&op_movem_32_er_pcdi , 0xffff, 0x4cfa}, + {&&op_movem_32_er_pcix , 0xffff, 0x4cfb}, + {&&op_link_16_a7 , 0xffff, 0x4e57}, + {&&op_unlk_32_a7 , 0xffff, 0x4e5f}, + {&&op_reset , 0xffff, 0x4e70}, + {&&op_nop , 0xffff, 0x4e71}, + {&&op_stop , 0xffff, 0x4e72}, + {&&op_rte_32 , 0xffff, 0x4e73}, + {&&op_rts_32 , 0xffff, 0x4e75}, + {&&op_trapv , 0xffff, 0x4e76}, + {&&op_rtr_32 , 0xffff, 0x4e77}, + {&&op_jsr_32_aw , 0xffff, 0x4eb8}, + {&&op_jsr_32_al , 0xffff, 0x4eb9}, + {&&op_jsr_32_pcdi , 0xffff, 0x4eba}, + {&&op_jsr_32_pcix , 0xffff, 0x4ebb}, + {&&op_jmp_32_aw , 0xffff, 0x4ef8}, + {&&op_jmp_32_al , 0xffff, 0x4ef9}, + {&&op_jmp_32_pcdi , 0xffff, 0x4efa}, + {&&op_jmp_32_pcix , 0xffff, 0x4efb}, + {&&op_st_8_pi7 , 0xffff, 0x50df}, + {&&op_st_8_pd7 , 0xffff, 0x50e7}, + {&&op_st_8_aw , 0xffff, 0x50f8}, + {&&op_st_8_al , 0xffff, 0x50f9}, + {&&op_sf_8_pi7 , 0xffff, 0x51df}, + {&&op_sf_8_pd7 , 0xffff, 0x51e7}, + {&&op_sf_8_aw , 0xffff, 0x51f8}, + {&&op_sf_8_al , 0xffff, 0x51f9}, + {&&op_shi_8_pi7 , 0xffff, 0x52df}, + {&&op_shi_8_pd7 , 0xffff, 0x52e7}, + {&&op_shi_8_aw , 0xffff, 0x52f8}, + {&&op_shi_8_al , 0xffff, 0x52f9}, + {&&op_sls_8_pi7 , 0xffff, 0x53df}, + {&&op_sls_8_pd7 , 0xffff, 0x53e7}, + {&&op_sls_8_aw , 0xffff, 0x53f8}, + {&&op_sls_8_al , 0xffff, 0x53f9}, + {&&op_scc_8_pi7 , 0xffff, 0x54df}, + {&&op_scc_8_pd7 , 0xffff, 0x54e7}, + {&&op_scc_8_aw , 0xffff, 0x54f8}, + {&&op_scc_8_al , 0xffff, 0x54f9}, + {&&op_scs_8_pi7 , 0xffff, 0x55df}, + {&&op_scs_8_pd7 , 0xffff, 0x55e7}, + {&&op_scs_8_aw , 0xffff, 0x55f8}, + {&&op_scs_8_al , 0xffff, 0x55f9}, + {&&op_sne_8_pi7 , 0xffff, 0x56df}, + {&&op_sne_8_pd7 , 0xffff, 0x56e7}, + {&&op_sne_8_aw , 0xffff, 0x56f8}, + {&&op_sne_8_al , 0xffff, 0x56f9}, + {&&op_seq_8_pi7 , 0xffff, 0x57df}, + {&&op_seq_8_pd7 , 0xffff, 0x57e7}, + {&&op_seq_8_aw , 0xffff, 0x57f8}, + {&&op_seq_8_al , 0xffff, 0x57f9}, + {&&op_svc_8_pi7 , 0xffff, 0x58df}, + {&&op_svc_8_pd7 , 0xffff, 0x58e7}, + {&&op_svc_8_aw , 0xffff, 0x58f8}, + {&&op_svc_8_al , 0xffff, 0x58f9}, + {&&op_svs_8_pi7 , 0xffff, 0x59df}, + {&&op_svs_8_pd7 , 0xffff, 0x59e7}, + {&&op_svs_8_aw , 0xffff, 0x59f8}, + {&&op_svs_8_al , 0xffff, 0x59f9}, + {&&op_spl_8_pi7 , 0xffff, 0x5adf}, + {&&op_spl_8_pd7 , 0xffff, 0x5ae7}, + {&&op_spl_8_aw , 0xffff, 0x5af8}, + {&&op_spl_8_al , 0xffff, 0x5af9}, + {&&op_smi_8_pi7 , 0xffff, 0x5bdf}, + {&&op_smi_8_pd7 , 0xffff, 0x5be7}, + {&&op_smi_8_aw , 0xffff, 0x5bf8}, + {&&op_smi_8_al , 0xffff, 0x5bf9}, + {&&op_sge_8_pi7 , 0xffff, 0x5cdf}, + {&&op_sge_8_pd7 , 0xffff, 0x5ce7}, + {&&op_sge_8_aw , 0xffff, 0x5cf8}, + {&&op_sge_8_al , 0xffff, 0x5cf9}, + {&&op_slt_8_pi7 , 0xffff, 0x5ddf}, + {&&op_slt_8_pd7 , 0xffff, 0x5de7}, + {&&op_slt_8_aw , 0xffff, 0x5df8}, + {&&op_slt_8_al , 0xffff, 0x5df9}, + {&&op_sgt_8_pi7 , 0xffff, 0x5edf}, + {&&op_sgt_8_pd7 , 0xffff, 0x5ee7}, + {&&op_sgt_8_aw , 0xffff, 0x5ef8}, + {&&op_sgt_8_al , 0xffff, 0x5ef9}, + {&&op_sle_8_pi7 , 0xffff, 0x5fdf}, + {&&op_sle_8_pd7 , 0xffff, 0x5fe7}, + {&&op_sle_8_aw , 0xffff, 0x5ff8}, + {&&op_sle_8_al , 0xffff, 0x5ff9}, + {&&op_bra_16 , 0xffff, 0x6000}, + {&&op_bsr_16 , 0xffff, 0x6100}, + {&&op_bhi_16 , 0xffff, 0x6200}, + {&&op_bls_16 , 0xffff, 0x6300}, + {&&op_bcc_16 , 0xffff, 0x6400}, + {&&op_bcs_16 , 0xffff, 0x6500}, + {&&op_bne_16 , 0xffff, 0x6600}, + {&&op_beq_16 , 0xffff, 0x6700}, + {&&op_bvc_16 , 0xffff, 0x6800}, + {&&op_bvs_16 , 0xffff, 0x6900}, + {&&op_bpl_16 , 0xffff, 0x6a00}, + {&&op_bmi_16 , 0xffff, 0x6b00}, + {&&op_bge_16 , 0xffff, 0x6c00}, + {&&op_blt_16 , 0xffff, 0x6d00}, + {&&op_bgt_16 , 0xffff, 0x6e00}, + {&&op_ble_16 , 0xffff, 0x6f00}, + {&&op_sbcd_8_mm_axy7 , 0xffff, 0x8f0f}, + {&&op_subx_8_mm_axy7 , 0xffff, 0x9f0f}, + {&&op_cmpm_8_axy7 , 0xffff, 0xbf0f}, + {&&op_abcd_8_mm_axy7 , 0xffff, 0xcf0f}, + {&&op_addx_8_mm_axy7 , 0xffff, 0xdf0f}, + {&&op_asr_16_aw , 0xffff, 0xe0f8}, + {&&op_asr_16_al , 0xffff, 0xe0f9}, + {&&op_asl_16_aw , 0xffff, 0xe1f8}, + {&&op_asl_16_al , 0xffff, 0xe1f9}, + {&&op_lsr_16_aw , 0xffff, 0xe2f8}, + {&&op_lsr_16_al , 0xffff, 0xe2f9}, + {&&op_lsl_16_aw , 0xffff, 0xe3f8}, + {&&op_lsl_16_al , 0xffff, 0xe3f9}, + {&&op_roxr_16_aw , 0xffff, 0xe4f8}, + {&&op_roxr_16_al , 0xffff, 0xe4f9}, + {&&op_roxl_16_aw , 0xffff, 0xe5f8}, + {&&op_roxl_16_al , 0xffff, 0xe5f9}, + {&&op_ror_16_aw , 0xffff, 0xe6f8}, + {&&op_ror_16_al , 0xffff, 0xe6f9}, + {&&op_rol_16_aw , 0xffff, 0xe7f8}, + {&&op_rol_16_al , 0xffff, 0xe7f9}, + +#ifdef BUILD_NCDZPSP + {&&op_FAC0 , 0xffff, 0xfac0}, + {&&op_FAC1 , 0xffff, 0xfac1}, + {&&op_FAC2 , 0xffff, 0xfac2}, +#endif /* BUILD_NCDZPSP */ + + {&&op_illegal , 0x0000, 0x0000} + }; + + opcode_struct *ostruct; + int i, j, instr; + + ostruct = c68k_opcode_jump_table; + + while (ostruct->match != 0x4afc) + ostruct++; + + for (i = 0; i < 0x10000; i++) + { + JumpTable[i] = ostruct->label; + } + + ostruct = c68k_opcode_jump_table; + + while (ostruct->mask != 0xff00) + { + for (i = 0; i < 0x10000; i++) + { + if ((i & ostruct->mask) == ostruct->match) + { + JumpTable[i] = ostruct->label; + } + } + ostruct++; + } + + while (ostruct->mask == 0xff00) + { + for (i = 0; i <= 0xff; i++) + { + instr = ostruct->match | i; + JumpTable[instr] = ostruct->label; + } + ostruct++; + } + + while (ostruct->mask == 0xf1f8) + { + for (i = 0; i < 8; i++) + { + for (j = 0; j < 8; j++) + { + instr = ostruct->match | (i << 9) | j; + JumpTable[instr] = ostruct->label; + } + } + ostruct++; + } + + while (ostruct->mask == 0xfff0) + { + for (i = 0; i <= 0x0f; i++) + { + instr = ostruct->match | i; + JumpTable[instr] = ostruct->label; + } + ostruct++; + } + + while (ostruct->mask == 0xf1ff) + { + for (i = 0; i <= 0x07; i++) + { + instr = ostruct->match | (i << 9); + JumpTable[instr] = ostruct->label; + } + ostruct++; + } + + while (ostruct->mask == 0xfff8) + { + for (i = 0; i <= 0x07; i++) + { + instr = ostruct->match | i; + JumpTable[instr] = ostruct->label; + } + ostruct++; + } + + while (ostruct->mask == 0xffff) + { + instr = ostruct->match; + JumpTable[instr] = ostruct->label; + ostruct++; + } diff --git a/m68000/old/c68k_op.c b/m68000/old/c68k_op.c new file mode 100644 index 0000000..b258f59 --- /dev/null +++ b/m68000/old/c68k_op.c @@ -0,0 +1,4620 @@ +/****************************************************************************** + + c68k_op.c + + C68K opcodeマクロ + +******************************************************************************/ + +/****************************************************************************** + OPCODE $0xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + ORI inclusive-OR Immediate +-----------------------------------------------------------------------------*/ + +OP(ori_8_d) { ORI(8, D, D) } // 0000 +OP(ori_8_ai) { ORI(8, M, AI) } // 0010 +OP(ori_8_pi) { ORI(8, M, PI) } // 0018 +OP(ori_8_pd) { ORI(8, M, PD) } // 0020 +OP(ori_8_di) { ORI(8, M, DI) } // 0028 +OP(ori_8_ix) { ORI(8, M, IX) } // 0030 +OP(ori_8_aw) { ORI(8, M, AW) } // 0038 +OP(ori_8_al) { ORI(8, M, AL) } // 0039 +OP(ori_8_pi7) { ORI(8, M, PI7) } // 001f +OP(ori_8_pd7) { ORI(8, M, PD7) } // 0027 + +OP(ori_16_d) { ORI(16, D, D) } // 0040 +OP(ori_16_ai) { ORI(16, M, AI) } // 0050 +OP(ori_16_pi) { ORI(16, M, PI) } // 0058 +OP(ori_16_pd) { ORI(16, M, PD) } // 0060 +OP(ori_16_di) { ORI(16, M, DI) } // 0068 +OP(ori_16_ix) { ORI(16, M, IX) } // 0070 +OP(ori_16_aw) { ORI(16, M, AW) } // 0078 +OP(ori_16_al) { ORI(16, M, AL) } // 0079 + +OP(ori_32_d) { ORI(32, D, D) } // 0080 +OP(ori_32_ai) { ORI(32, M, AI) } // 0090 +OP(ori_32_pi) { ORI(32, M, PI) } // 0098 +OP(ori_32_pd) { ORI(32, M, PD) } // 00a0 +OP(ori_32_di) { ORI(32, M, DI) } // 00a8 +OP(ori_32_ix) { ORI(32, M, IX) } // 00b0 +OP(ori_32_aw) { ORI(32, M, AW) } // 00b8 +OP(ori_32_al) { ORI(32, M, AL) } // 00b9 + +OP(ori_16_toc) { LOGOP_TOC(|=) } // 003c +OP(ori_16_tos) { LOGOP_TOS(|=) } // 007c + +/*----------------------------------------------------------------------------- + ANDI And Immediate +-----------------------------------------------------------------------------*/ + +OP(andi_8_d) { ANDI(8, D, D) } // 0200 +OP(andi_8_ai) { ANDI(8, M, AI) } // 0210 +OP(andi_8_pi) { ANDI(8, M, PI) } // 0218 +OP(andi_8_pd) { ANDI(8, M, PD) } // 0220 +OP(andi_8_di) { ANDI(8, M, DI) } // 0228 +OP(andi_8_ix) { ANDI(8, M, IX) } // 0230 +OP(andi_8_aw) { ANDI(8, M, AW) } // 0238 +OP(andi_8_al) { ANDI(8, M, AL) } // 0239 +OP(andi_8_pi7) { ANDI(8, M, PI7) } // 021f +OP(andi_8_pd7) { ANDI(8, M, PD7) } // 0227 + +OP(andi_16_d) { ANDI(16, D, D) } // 0240 +OP(andi_16_ai) { ANDI(16, M, AI) } // 0250 +OP(andi_16_pi) { ANDI(16, M, PI) } // 0258 +OP(andi_16_pd) { ANDI(16, M, PD) } // 0260 +OP(andi_16_di) { ANDI(16, M, DI) } // 0268 +OP(andi_16_ix) { ANDI(16, M, IX) } // 0270 +OP(andi_16_aw) { ANDI(16, M, AW) } // 0278 +OP(andi_16_al) { ANDI(16, M, AL) } // 0279 + +OP(andi_32_d) { ANDI(32, D, D) } // 0280 +OP(andi_32_ai) { ANDI(32, M, AI) } // 0290 +OP(andi_32_pi) { ANDI(32, M, PI) } // 0298 +OP(andi_32_pd) { ANDI(32, M, PD) } // 02a0 +OP(andi_32_di) { ANDI(32, M, DI) } // 02a8 +OP(andi_32_ix) { ANDI(32, M, IX) } // 02b0 +OP(andi_32_aw) { ANDI(32, M, AW) } // 02b8 +OP(andi_32_al) { ANDI(32, M, AL) } // 02b9 + +OP(andi_16_toc) { LOGOP_TOC(&=) } // 023c +OP(andi_16_tos) { LOGOP_TOS(&=) } // 027c + +/*----------------------------------------------------------------------------- + EORI Exclusive-OR Immediate +-----------------------------------------------------------------------------*/ + +OP(eori_8_d) { EORI(8, D, D) } // 0a00 +OP(eori_8_ai) { EORI(8, M, AI) } // 0a10 +OP(eori_8_pi) { EORI(8, M, PI) } // 0a18 +OP(eori_8_pd) { EORI(8, M, PD) } // 0a20 +OP(eori_8_di) { EORI(8, M, DI) } // 0a28 +OP(eori_8_ix) { EORI(8, M, IX) } // 0a30 +OP(eori_8_aw) { EORI(8, M, AW) } // 0a38 +OP(eori_8_al) { EORI(8, M, AL) } // 0a39 +OP(eori_8_pi7) { EORI(8, M, PI7) } // 0a1f +OP(eori_8_pd7) { EORI(8, M, PD7) } // 0a27 + +OP(eori_16_d) { EORI(16, D, D) } // 0a40 +OP(eori_16_ai) { EORI(16, M, AI) } // 0a50 +OP(eori_16_pi) { EORI(16, M, PI) } // 0a58 +OP(eori_16_pd) { EORI(16, M, PD) } // 0a60 +OP(eori_16_di) { EORI(16, M, DI) } // 0a68 +OP(eori_16_ix) { EORI(16, M, IX) } // 0a70 +OP(eori_16_aw) { EORI(16, M, AW) } // 0a78 +OP(eori_16_al) { EORI(16, M, AL) } // 0a79 + +OP(eori_32_d) { EORI(32, D, D) } // 0a80 +OP(eori_32_ai) { EORI(32, M, AI) } // 0a90 +OP(eori_32_pi) { EORI(32, M, PI) } // 0a98 +OP(eori_32_pd) { EORI(32, M, PD) } // 0aa0 +OP(eori_32_di) { EORI(32, M, DI) } // 0aa8 +OP(eori_32_ix) { EORI(32, M, IX) } // 0ab0 +OP(eori_32_aw) { EORI(32, M, AW) } // 0ab8 +OP(eori_32_al) { EORI(32, M, AL) } // 0ab9 + +OP(eori_16_toc) { LOGOP_TOC(^=) } // 0a3c +OP(eori_16_tos) { LOGOP_TOS(^=) } // 0a7c + +/*----------------------------------------------------------------------------- + SUBI Subtract Immediate +-----------------------------------------------------------------------------*/ + +OP(subi_8_d) { SUBI(8, D, D) } // 0400 +OP(subi_8_ai) { SUBI(8, M, AI) } // 0410 +OP(subi_8_pi) { SUBI(8, M, PI) } // 0418 +OP(subi_8_pd) { SUBI(8, M, PD) } // 0420 +OP(subi_8_di) { SUBI(8, M, DI) } // 0428 +OP(subi_8_ix) { SUBI(8, M, IX) } // 0430 +OP(subi_8_aw) { SUBI(8, M, AW) } // 0438 +OP(subi_8_al) { SUBI(8, M, AL) } // 0439 +OP(subi_8_pi7) { SUBI(8, M, PI7) } // 041f +OP(subi_8_pd7) { SUBI(8, M, PD7) } // 0427 + +OP(subi_16_d) { SUBI(16, D, D) } // 0440 +OP(subi_16_ai) { SUBI(16, M, AI) } // 0450 +OP(subi_16_pi) { SUBI(16, M, PI) } // 0458 +OP(subi_16_pd) { SUBI(16, M, PD) } // 0460 +OP(subi_16_di) { SUBI(16, M, DI) } // 0468 +OP(subi_16_ix) { SUBI(16, M, IX) } // 0470 +OP(subi_16_aw) { SUBI(16, M, AW) } // 0478 +OP(subi_16_al) { SUBI(16, M, AL) } // 0479 + +OP(subi_32_d) { SUBI(32, D, D) } // 0480 +OP(subi_32_ai) { SUBI(32, M, AI) } // 0490 +OP(subi_32_pi) { SUBI(32, M, PI) } // 0498 +OP(subi_32_pd) { SUBI(32, M, PD) } // 04a0 +OP(subi_32_di) { SUBI(32, M, DI) } // 04a8 +OP(subi_32_ix) { SUBI(32, M, IX) } // 04b0 +OP(subi_32_aw) { SUBI(32, M, AW) } // 04b8 +OP(subi_32_al) { SUBI(32, M, AL) } // 04b9 + +/*----------------------------------------------------------------------------- + ADDI Add Immediate +-----------------------------------------------------------------------------*/ + +OP(addi_8_d) { ADDI(8, D, D) } // 0600 +OP(addi_8_ai) { ADDI(8, M, AI) } // 0610 +OP(addi_8_pi) { ADDI(8, M, PI) } // 0618 +OP(addi_8_pd) { ADDI(8, M, PD) } // 0620 +OP(addi_8_di) { ADDI(8, M, DI) } // 0628 +OP(addi_8_ix) { ADDI(8, M, IX) } // 0630 +OP(addi_8_aw) { ADDI(8, M, AW) } // 0638 +OP(addi_8_al) { ADDI(8, M, AL) } // 0639 +OP(addi_8_pi7) { ADDI(8, M, PI7) } // 061f +OP(addi_8_pd7) { ADDI(8, M, PD7) } // 0627 + +OP(addi_16_d) { ADDI(16, D, D) } // 0640 +OP(addi_16_ai) { ADDI(16, M, AI) } // 0650 +OP(addi_16_pi) { ADDI(16, M, PI) } // 0658 +OP(addi_16_pd) { ADDI(16, M, PD) } // 0660 +OP(addi_16_di) { ADDI(16, M, DI) } // 0668 +OP(addi_16_ix) { ADDI(16, M, IX) } // 0670 +OP(addi_16_aw) { ADDI(16, M, AW) } // 0678 +OP(addi_16_al) { ADDI(16, M, AL) } // 0679 + +OP(addi_32_d) { ADDI(32, D, D) } // 0680 +OP(addi_32_ai) { ADDI(32, M, AI) } // 0690 +OP(addi_32_pi) { ADDI(32, M, PI) } // 0698 +OP(addi_32_pd) { ADDI(32, M, PD) } // 06a0 +OP(addi_32_di) { ADDI(32, M, DI) } // 06a8 +OP(addi_32_ix) { ADDI(32, M, IX) } // 06b0 +OP(addi_32_aw) { ADDI(32, M, AW) } // 06b8 +OP(addi_32_al) { ADDI(32, M, AL) } // 06b9 + +/*----------------------------------------------------------------------------- + CMPI Compare Immediate +-----------------------------------------------------------------------------*/ + +OP(cmpi_8_d) { CMPI(8, D, D) } // 0c00 +OP(cmpi_8_ai) { CMPI(8, M, AI) } // 0c10 +OP(cmpi_8_pi) { CMPI(8, M, PI) } // 0c18 +OP(cmpi_8_pd) { CMPI(8, M, PD) } // 0c20 +OP(cmpi_8_di) { CMPI(8, M, DI) } // 0c28 +OP(cmpi_8_ix) { CMPI(8, M, IX) } // 0c30 +OP(cmpi_8_aw) { CMPI(8, M, AW) } // 0c38 +OP(cmpi_8_al) { CMPI(8, M, AL) } // 0c39 +OP(cmpi_8_pi7) { CMPI(8, M, PI7) } // 0c1f +OP(cmpi_8_pd7) { CMPI(8, M, PD7) } // 0c27 + +OP(cmpi_16_d) { CMPI(16, D, D) } // 0c40 +OP(cmpi_16_ai) { CMPI(16, M, AI) } // 0c50 +OP(cmpi_16_pi) { CMPI(16, M, PI) } // 0c58 +OP(cmpi_16_pd) { CMPI(16, M, PD) } // 0c60 +OP(cmpi_16_di) { CMPI(16, M, DI) } // 0c68 +OP(cmpi_16_ix) { CMPI(16, M, IX) } // 0c70 +OP(cmpi_16_aw) { CMPI(16, M, AW) } // 0c78 +OP(cmpi_16_al) { CMPI(16, M, AL) } // 0c79 + +OP(cmpi_32_d) { CMPI(32, D, D) } // 0c80 +OP(cmpi_32_ai) { CMPI(32, M, AI) } // 0c90 +OP(cmpi_32_pi) { CMPI(32, M, PI) } // 0c98 +OP(cmpi_32_pd) { CMPI(32, M, PD) } // 0ca0 +OP(cmpi_32_di) { CMPI(32, M, DI) } // 0ca8 +OP(cmpi_32_ix) { CMPI(32, M, IX) } // 0cb0 +OP(cmpi_32_aw) { CMPI(32, M, AW) } // 0cb8 +OP(cmpi_32_al) { CMPI(32, M, AL) } // 0cb9 + +/*----------------------------------------------------------------------------- + BTST Test a Bit + BCHG Test a Bit and Change + BCLR Test a Bit and Clear + BSET Test a Bit and Set +-----------------------------------------------------------------------------*/ + +OP(btst_32_s_d) { BITOP_STATIC(TST, 32, D) } // 0800 +OP(btst_8_s_ai) { BITOP_STATIC(TST, 8, AI) } // 0810 +OP(btst_8_s_pi) { BITOP_STATIC(TST, 8, PI) } // 0818 +OP(btst_8_s_pd) { BITOP_STATIC(TST, 8, PD) } // 0820 +OP(btst_8_s_di) { BITOP_STATIC(TST, 8, DI) } // 0828 +OP(btst_8_s_ix) { BITOP_STATIC(TST, 8, IX) } // 0830 +OP(btst_8_s_aw) { BITOP_STATIC(TST, 8, AW) } // 0838 +OP(btst_8_s_al) { BITOP_STATIC(TST, 8, AL) } // 0839 +OP(btst_8_s_pcdi) { BITOP_STATIC(TST, 8, PCDI) } // 083a +OP(btst_8_s_pcix) { BITOP_STATIC(TST, 8, PCIX) } // 083b +OP(btst_8_s_pi7) { BITOP_STATIC(TST, 8, PI7) } // 081f +OP(btst_8_s_pd7) { BITOP_STATIC(TST, 8, PD7) } // 0827 + +OP(bchg_32_s_d) { BITOP_STATIC(CHG, 32, D) } // 0840 +OP(bchg_8_s_ai) { BITOP_STATIC(CHG, 8, AI) } // 0850 +OP(bchg_8_s_pi) { BITOP_STATIC(CHG, 8, PI) } // 0858 +OP(bchg_8_s_pd) { BITOP_STATIC(CHG, 8, PD) } // 0860 +OP(bchg_8_s_di) { BITOP_STATIC(CHG, 8, DI) } // 0868 +OP(bchg_8_s_ix) { BITOP_STATIC(CHG, 8, IX) } // 0870 +OP(bchg_8_s_aw) { BITOP_STATIC(CHG, 8, AW) } // 0878 +OP(bchg_8_s_al) { BITOP_STATIC(CHG, 8, AL) } // 0879 +OP(bchg_8_s_pi7) { BITOP_STATIC(CHG, 8, PI7) } // 085f +OP(bchg_8_s_pd7) { BITOP_STATIC(CHG, 8, PD7) } // 0867 + +OP(bclr_32_s_d) { BITOP_STATIC(CLR, 32, D) } // 0880 +OP(bclr_8_s_ai) { BITOP_STATIC(CLR, 8, AI) } // 0890 +OP(bclr_8_s_pi) { BITOP_STATIC(CLR, 8, PI) } // 0898 +OP(bclr_8_s_pd) { BITOP_STATIC(CLR, 8, PD) } // 08a0 +OP(bclr_8_s_di) { BITOP_STATIC(CLR, 8, DI) } // 08a8 +OP(bclr_8_s_ix) { BITOP_STATIC(CLR, 8, IX) } // 08b0 +OP(bclr_8_s_aw) { BITOP_STATIC(CLR, 8, AW) } // 08b8 +OP(bclr_8_s_al) { BITOP_STATIC(CLR, 8, AL) } // 08b9 +OP(bclr_8_s_pi7) { BITOP_STATIC(CLR, 8, PI7) } // 089f +OP(bclr_8_s_pd7) { BITOP_STATIC(CLR, 8, PD7) } // 08a7 + +OP(bset_32_s_d) { BITOP_STATIC(SET, 32, D) } // 08c0 +OP(bset_8_s_ai) { BITOP_STATIC(SET, 8, AI) } // 08d0 +OP(bset_8_s_pi) { BITOP_STATIC(SET, 8, PI) } // 08d8 +OP(bset_8_s_pd) { BITOP_STATIC(SET, 8, PD) } // 08e0 +OP(bset_8_s_di) { BITOP_STATIC(SET, 8, DI) } // 08e8 +OP(bset_8_s_ix) { BITOP_STATIC(SET, 8, IX) } // 08f0 +OP(bset_8_s_aw) { BITOP_STATIC(SET, 8, AW) } // 08f8 +OP(bset_8_s_al) { BITOP_STATIC(SET, 8, AL) } // 08f9 +OP(bset_8_s_pi7) { BITOP_STATIC(SET, 8, PI7) } // 08df +OP(bset_8_s_pd7) { BITOP_STATIC(SET, 8, PD7) } // 08e7 + +OP(btst_32_r_d) { BITOP_DYNAMIC(TST, 32, D) } // 0100 +OP(btst_8_r_ai) { BITOP_DYNAMIC(TST, 8, AI) } // 0110 +OP(btst_8_r_pi) { BITOP_DYNAMIC(TST, 8, PI) } // 0118 +OP(btst_8_r_pd) { BITOP_DYNAMIC(TST, 8, PD) } // 0120 +OP(btst_8_r_di) { BITOP_DYNAMIC(TST, 8, DI) } // 0128 +OP(btst_8_r_ix) { BITOP_DYNAMIC(TST, 8, IX) } // 0130 +OP(btst_8_r_aw) { BITOP_DYNAMIC(TST, 8, AW) } // 0138 +OP(btst_8_r_al) { BITOP_DYNAMIC(TST, 8, AL) } // 0139 +OP(btst_8_r_pcdi) { BITOP_DYNAMIC(TST, 8, PCDI) } // 013a +OP(btst_8_r_pcix) { BITOP_DYNAMIC(TST, 8, PCIX) } // 013b +OP(btst_8_r_i) { BITOP_DYNAMIC(TST, 8, I) } // 013c +OP(btst_8_r_pi7) { BITOP_DYNAMIC(TST, 8, PI7) } // 011f +OP(btst_8_r_pd7) { BITOP_DYNAMIC(TST, 8, PD7) } // 0127 + +OP(bchg_32_r_d) { BITOP_DYNAMIC(CHG, 32, D) } // 0140 +OP(bchg_8_r_ai) { BITOP_DYNAMIC(CHG, 8, AI) } // 0150 +OP(bchg_8_r_pi) { BITOP_DYNAMIC(CHG, 8, PI) } // 0158 +OP(bchg_8_r_pd) { BITOP_DYNAMIC(CHG, 8, PD) } // 0160 +OP(bchg_8_r_di) { BITOP_DYNAMIC(CHG, 8, DI) } // 0168 +OP(bchg_8_r_ix) { BITOP_DYNAMIC(CHG, 8, IX) } // 0170 +OP(bchg_8_r_aw) { BITOP_DYNAMIC(CHG, 8, AW) } // 0178 +OP(bchg_8_r_al) { BITOP_DYNAMIC(CHG, 8, AL) } // 0179 +OP(bchg_8_r_pi7) { BITOP_DYNAMIC(CHG, 8, PI7) } // 015f +OP(bchg_8_r_pd7) { BITOP_DYNAMIC(CHG, 8, PD7) } // 0167 + +OP(bclr_32_r_d) { BITOP_DYNAMIC(CLR, 32, D) } // 0180 +OP(bclr_8_r_ai) { BITOP_DYNAMIC(CLR, 8, AI) } // 0190 +OP(bclr_8_r_pi) { BITOP_DYNAMIC(CLR, 8, PI) } // 0198 +OP(bclr_8_r_pd) { BITOP_DYNAMIC(CLR, 8, PD) } // 01a0 +OP(bclr_8_r_di) { BITOP_DYNAMIC(CLR, 8, DI) } // 01a8 +OP(bclr_8_r_ix) { BITOP_DYNAMIC(CLR, 8, IX) } // 01b0 +OP(bclr_8_r_aw) { BITOP_DYNAMIC(CLR, 8, AW) } // 01b8 +OP(bclr_8_r_al) { BITOP_DYNAMIC(CLR, 8, AL) } // 01b9 +OP(bclr_8_r_pi7) { BITOP_DYNAMIC(CLR, 8, PI7) } // 019f +OP(bclr_8_r_pd7) { BITOP_DYNAMIC(CLR, 8, PD7) } // 01a7 + +OP(bset_32_r_d) { BITOP_DYNAMIC(SET, 32, D) } // 01c0 +OP(bset_8_r_ai) { BITOP_DYNAMIC(SET, 8, AI) } // 01d0 +OP(bset_8_r_pi) { BITOP_DYNAMIC(SET, 8, PI) } // 01d8 +OP(bset_8_r_pd) { BITOP_DYNAMIC(SET, 8, PD) } // 01e0 +OP(bset_8_r_di) { BITOP_DYNAMIC(SET, 8, DI) } // 01e8 +OP(bset_8_r_ix) { BITOP_DYNAMIC(SET, 8, IX) } // 01f0 +OP(bset_8_r_aw) { BITOP_DYNAMIC(SET, 8, AW) } // 01f8 +OP(bset_8_r_al) { BITOP_DYNAMIC(SET, 8, AL) } // 01f9 +OP(bset_8_r_pi7) { BITOP_DYNAMIC(SET, 8, PI7) } // 01df +OP(bset_8_r_pd7) { BITOP_DYNAMIC(SET, 8, PD7) } // 01e7 + +/*----------------------------------------------------------------------------- + MOVEP Move Peripheral Data +-----------------------------------------------------------------------------*/ + +// 0108 +OP(movep_16_er) +{ + EA_DI(NA, Y) + res = READ_MEM_8(adr + 0); + res <<= 8; + res |= READ_MEM_8(adr + 2); + EA_WRITE_RESULT(16, D, X) + RET(16) +} + +// 0148 +OP(movep_32_er) +{ + EA_DI(NA, Y) + res = READ_MEM_8(adr + 0); + res <<= 8; + res |= READ_MEM_8(adr + 2); + res <<= 8; + res |= READ_MEM_8(adr + 4); + res <<= 8; + res |= READ_MEM_8(adr + 6); + EA_WRITE_RESULT(32, D, X) + RET(24) +} + +// 0188 +OP(movep_16_re) +{ + EA_READ_D(16, X, res) + EA_DI(NA, Y) + WRITE_MEM_8(adr + 2, res); + res >>= 8; + WRITE_MEM_8(adr + 0, res); + RET(16) +} + +// 01c8 +OP(movep_32_re) +{ + EA_READ_D(32, X, res) + EA_DI(NA, Y) + WRITE_MEM_8(adr + 6, res); + res >>= 8; + WRITE_MEM_8(adr + 4, res); + res >>= 8; + WRITE_MEM_8(adr + 2, res); + res >>= 8; + WRITE_MEM_8(adr + 0, res); + RET(24) +} + +/****************************************************************************** + OPCODE $1xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + MOVE Move Data from Source to Destination +-----------------------------------------------------------------------------*/ + +OP(move_8_d_d) { MOVE(8, D, D) } // 1000 +OP(move_8_ai_d) { MOVE(8, AI, D) } // 1080 +OP(move_8_pi_d) { MOVE(8, PI, D) } // 10c0 +OP(move_8_pd_d) { MOVE(8, PD, D) } // 1100 +OP(move_8_di_d) { MOVE(8, DI, D) } // 1140 +OP(move_8_ix_d) { MOVE(8, IX, D) } // 1180 +OP(move_8_aw_d) { MOVE(8, AW, D) } // 11c0 +OP(move_8_al_d) { MOVE(8, AL, D) } // 13c0 +OP(move_8_pi7_d) { MOVE(8, PI7, D) } // 1ec0 +OP(move_8_pd7_d) { MOVE(8, PD7, D) } // 1f00 + +OP(move_8_d_ai) { MOVE(8, D, AI) } // 1010 +OP(move_8_ai_ai) { MOVE(8, AI, AI) } // 1090 +OP(move_8_pi_ai) { MOVE(8, PI, AI) } // 10d0 +OP(move_8_pd_ai) { MOVE(8, PD, AI) } // 1110 +OP(move_8_di_ai) { MOVE(8, DI, AI) } // 1150 +OP(move_8_ix_ai) { MOVE(8, IX, AI) } // 1190 +OP(move_8_aw_ai) { MOVE(8, AW, AI) } // 11d0 +OP(move_8_al_ai) { MOVE(8, AL, AI) } // 13d0 +OP(move_8_pi7_ai) { MOVE(8, PI7, AI) } // 1ed0 +OP(move_8_pd7_ai) { MOVE(8, PD7, AI) } // 1f10 + +OP(move_8_d_pi) { MOVE(8, D, PI) } // 1018 +OP(move_8_ai_pi) { MOVE(8, AI, PI) } // 1098 +OP(move_8_pi_pi) { MOVE(8, PI, PI) } // 10d8 +OP(move_8_pd_pi) { MOVE(8, PD, PI) } // 1118 +OP(move_8_di_pi) { MOVE(8, DI, PI) } // 1158 +OP(move_8_ix_pi) { MOVE(8, IX, PI) } // 1198 +OP(move_8_aw_pi) { MOVE(8, AW, PI) } // 11d8 +OP(move_8_al_pi) { MOVE(8, AL, PI) } // 13d8 +OP(move_8_pi7_pi) { MOVE(8, PI7, PI) } // 1ed8 +OP(move_8_pd7_pi) { MOVE(8, PD7, PI) } // 1f18 + +OP(move_8_d_pd) { MOVE(8, D, PD) } // 1020 +OP(move_8_ai_pd) { MOVE(8, AI, PD) } // 10a0 +OP(move_8_pi_pd) { MOVE(8, PI, PD) } // 10e0 +OP(move_8_pd_pd) { MOVE(8, PD, PD) } // 1120 +OP(move_8_di_pd) { MOVE(8, DI, PD) } // 1160 +OP(move_8_ix_pd) { MOVE(8, IX, PD) } // 11a0 +OP(move_8_aw_pd) { MOVE(8, AW, PD) } // 11e0 +OP(move_8_al_pd) { MOVE(8, AL, PD) } // 13e0 +OP(move_8_pi7_pd) { MOVE(8, PI7, PD) } // 1ee0 +OP(move_8_pd7_pd) { MOVE(8, PD7, PD) } // 1f20 + +OP(move_8_d_di) { MOVE(8, D, DI) } // 1028 +OP(move_8_ai_di) { MOVE(8, AI, DI) } // 10a8 +OP(move_8_pi_di) { MOVE(8, PI, DI) } // 10e8 +OP(move_8_pd_di) { MOVE(8, PD, DI) } // 1128 +OP(move_8_di_di) { MOVE(8, DI, DI) } // 1168 +OP(move_8_ix_di) { MOVE(8, IX, DI) } // 11a8 +OP(move_8_aw_di) { MOVE(8, AW, DI) } // 11e8 +OP(move_8_al_di) { MOVE(8, AL, DI) } // 13e8 +OP(move_8_pi7_di) { MOVE(8, PI7, DI) } // 1ee8 +OP(move_8_pd7_di) { MOVE(8, PD7, DI) } // 1f28 + +OP(move_8_d_ix) { MOVE(8, D, IX) } // 1030 +OP(move_8_ai_ix) { MOVE(8, AI, IX) } // 10b0 +OP(move_8_pi_ix) { MOVE(8, PI, IX) } // 10f0 +OP(move_8_pd_ix) { MOVE(8, PD, IX) } // 1130 +OP(move_8_di_ix) { MOVE(8, DI, IX) } // 1170 +OP(move_8_ix_ix) { MOVE(8, IX, IX) } // 11b0 +OP(move_8_aw_ix) { MOVE(8, AW, IX) } // 11f0 +OP(move_8_al_ix) { MOVE(8, AL, IX) } // 13f0 +OP(move_8_pi7_ix) { MOVE(8, PI7, IX) } // 1ef0 +OP(move_8_pd7_ix) { MOVE(8, PD7, IX) } // 1f30 + +OP(move_8_d_aw) { MOVE(8, D, AW) } // 1038 +OP(move_8_ai_aw) { MOVE(8, AI, AW) } // 10b8 +OP(move_8_pi_aw) { MOVE(8, PI, AW) } // 10f8 +OP(move_8_pd_aw) { MOVE(8, PD, AW) } // 1138 +OP(move_8_di_aw) { MOVE(8, DI, AW) } // 1178 +OP(move_8_ix_aw) { MOVE(8, IX, AW) } // 11b8 +OP(move_8_aw_aw) { MOVE(8, AW, AW) } // 11f8 +OP(move_8_al_aw) { MOVE(8, AL, AW) } // 13f8 +OP(move_8_pi7_aw) { MOVE(8, PI7, AW) } // 1ef8 +OP(move_8_pd7_aw) { MOVE(8, PD7, AW) } // 1f38 + +OP(move_8_d_al) { MOVE(8, D, AL) } // 1039 +OP(move_8_ai_al) { MOVE(8, AI, AL) } // 10b9 +OP(move_8_pi_al) { MOVE(8, PI, AL) } // 10f9 +OP(move_8_pd_al) { MOVE(8, PD, AL) } // 1139 +OP(move_8_di_al) { MOVE(8, DI, AL) } // 1179 +OP(move_8_ix_al) { MOVE(8, IX, AL) } // 11b9 +OP(move_8_aw_al) { MOVE(8, AW, AL) } // 11f9 +OP(move_8_al_al) { MOVE(8, AL, AL) } // 13f9 +OP(move_8_pi7_al) { MOVE(8, PI7, AL) } // 1ef9 +OP(move_8_pd7_al) { MOVE(8, PD7, AL) } // 1f39 + +OP(move_8_d_pcdi) { MOVE(8, D, PCDI) } // 103a +OP(move_8_ai_pcdi) { MOVE(8, AI, PCDI) } // 10ba +OP(move_8_pi_pcdi) { MOVE(8, PI, PCDI) } // 10fa +OP(move_8_pd_pcdi) { MOVE(8, PD, PCDI) } // 113a +OP(move_8_di_pcdi) { MOVE(8, DI, PCDI) } // 117a +OP(move_8_ix_pcdi) { MOVE(8, IX, PCDI) } // 11ba +OP(move_8_aw_pcdi) { MOVE(8, AW, PCDI) } // 11fa +OP(move_8_al_pcdi) { MOVE(8, AL, PCDI) } // 13fa +OP(move_8_pi7_pcdi) { MOVE(8, PI7, PCDI) } // 1efa +OP(move_8_pd7_pcdi) { MOVE(8, PD7, PCDI) } // 1f3a + +OP(move_8_d_pcix) { MOVE(8, D, PCIX) } // 103b +OP(move_8_ai_pcix) { MOVE(8, AI, PCIX) } // 10bb +OP(move_8_pi_pcix) { MOVE(8, PI, PCIX) } // 10fb +OP(move_8_pd_pcix) { MOVE(8, PD, PCIX) } // 113b +OP(move_8_di_pcix) { MOVE(8, DI, PCIX) } // 117b +OP(move_8_ix_pcix) { MOVE(8, IX, PCIX) } // 11bb +OP(move_8_aw_pcix) { MOVE(8, AW, PCIX) } // 11fb +OP(move_8_al_pcix) { MOVE(8, AL, PCIX) } // 13fb +OP(move_8_pi7_pcix) { MOVE(8, PI7, PCIX) } // 1efb +OP(move_8_pd7_pcix) { MOVE(8, PD7, PCIX) } // 1f3b + +OP(move_8_d_i) { MOVE(8, D, I) } // 103c +OP(move_8_ai_i) { MOVE(8, AI, I) } // 10bc +OP(move_8_pi_i) { MOVE(8, PI, I) } // 10fc +OP(move_8_pd_i) { MOVE(8, PD, I) } // 113c +OP(move_8_di_i) { MOVE(8, DI, I) } // 117c +OP(move_8_ix_i) { MOVE(8, IX, I) } // 11bc +OP(move_8_aw_i) { MOVE(8, AW, I) } // 11fc +OP(move_8_al_i) { MOVE(8, AL, I) } // 13fc +OP(move_8_pi7_i) { MOVE(8, PI7, I) } // 1efc +OP(move_8_pd7_i) { MOVE(8, PD7, I) } // 1f3c + +OP(move_8_d_pi7) { MOVE(8, D, PI7) } // 101f +OP(move_8_ai_pi7) { MOVE(8, AI, PI7) } // 109f +OP(move_8_pi_pi7) { MOVE(8, PI, PI7) } // 10df +OP(move_8_pd_pi7) { MOVE(8, PD, PI7) } // 111f +OP(move_8_di_pi7) { MOVE(8, DI, PI7) } // 115f +OP(move_8_ix_pi7) { MOVE(8, IX, PI7) } // 119f +OP(move_8_aw_pi7) { MOVE(8, AW, PI7) } // 11df +OP(move_8_al_pi7) { MOVE(8, AL, PI7) } // 13df +OP(move_8_pi7_pi7) { MOVE(8, PI7, PI7) } // 1edf +OP(move_8_pd7_pi7) { MOVE(8, PD7, PI7) } // 1f1f + +OP(move_8_d_pd7) { MOVE(8, D, PD7) } // 1027 +OP(move_8_ai_pd7) { MOVE(8, AI, PD7) } // 10a7 +OP(move_8_pi_pd7) { MOVE(8, PI, PD7) } // 10e7 +OP(move_8_pd_pd7) { MOVE(8, PD, PD7) } // 1127 +OP(move_8_di_pd7) { MOVE(8, DI, PD7) } // 1167 +OP(move_8_ix_pd7) { MOVE(8, IX, PD7) } // 11a7 +OP(move_8_aw_pd7) { MOVE(8, AW, PD7) } // 11e7 +OP(move_8_al_pd7) { MOVE(8, AL, PD7) } // 13e7 +OP(move_8_pi7_pd7) { MOVE(8, PI7, PD7) } // 1ee7 +OP(move_8_pd7_pd7) { MOVE(8, PD7, PD7) } // 1f27 + +/****************************************************************************** + OPCODE $2xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + MOVE Move Data from Source to Destination +-----------------------------------------------------------------------------*/ + +OP(move_32_d_d) { MOVE(32, D, D) } // 2000 +OP(move_32_ai_d) { MOVE(32, AI, D) } // 2080 +OP(move_32_pi_d) { MOVE(32, PI, D) } // 20c0 +OP(move_32_pd_d) { MOVE(32, PD, D) } // 2100 +OP(move_32_di_d) { MOVE(32, DI, D) } // 2140 +OP(move_32_ix_d) { MOVE(32, IX, D) } // 2180 +OP(move_32_aw_d) { MOVE(32, AW, D) } // 21c0 +OP(move_32_al_d) { MOVE(32, AL, D) } // 23c0 + +OP(move_32_d_a) { MOVE(32, D, A) } // 2008 +OP(move_32_ai_a) { MOVE(32, AI, A) } // 2088 +OP(move_32_pi_a) { MOVE(32, PI, A) } // 20c8 +OP(move_32_pd_a) { MOVE(32, PD, A) } // 2108 +OP(move_32_di_a) { MOVE(32, DI, A) } // 2148 +OP(move_32_ix_a) { MOVE(32, IX, A) } // 2188 +OP(move_32_aw_a) { MOVE(32, AW, A) } // 21c8 +OP(move_32_al_a) { MOVE(32, AL, A) } // 23c8 + +OP(move_32_d_ai) { MOVE(32, D, AI) } // 2010 +OP(move_32_ai_ai) { MOVE(32, AI, AI) } // 2090 +OP(move_32_pi_ai) { MOVE(32, PI, AI) } // 20d0 +OP(move_32_pd_ai) { MOVE(32, PD, AI) } // 2110 +OP(move_32_di_ai) { MOVE(32, DI, AI) } // 2150 +OP(move_32_ix_ai) { MOVE(32, IX, AI) } // 2190 +OP(move_32_aw_ai) { MOVE(32, AW, AI) } // 21d0 +OP(move_32_al_ai) { MOVE(32, AL, AI) } // 23d0 + +OP(move_32_d_pi) { MOVE(32, D, PI) } // 2018 +OP(move_32_ai_pi) { MOVE(32, AI, PI) } // 2098 +OP(move_32_pi_pi) { MOVE(32, PI, PI) } // 20d8 +OP(move_32_pd_pi) { MOVE(32, PD, PI) } // 2118 +OP(move_32_di_pi) { MOVE(32, DI, PI) } // 2158 +OP(move_32_ix_pi) { MOVE(32, IX, PI) } // 2198 +OP(move_32_aw_pi) { MOVE(32, AW, PI) } // 21d8 +OP(move_32_al_pi) { MOVE(32, AL, PI) } // 23d8 + +OP(move_32_d_pd) { MOVE(32, D, PD) } // 2020 +OP(move_32_ai_pd) { MOVE(32, AI, PD) } // 20a0 +OP(move_32_pi_pd) { MOVE(32, PI, PD) } // 20e0 +OP(move_32_pd_pd) { MOVE(32, PD, PD) } // 2120 +OP(move_32_di_pd) { MOVE(32, DI, PD) } // 2160 +OP(move_32_ix_pd) { MOVE(32, IX, PD) } // 21a0 +OP(move_32_aw_pd) { MOVE(32, AW, PD) } // 21e0 +OP(move_32_al_pd) { MOVE(32, AL, PD) } // 23e0 + +OP(move_32_d_di) { MOVE(32, D, DI) } // 2028 +OP(move_32_ai_di) { MOVE(32, AI, DI) } // 20a8 +OP(move_32_pi_di) { MOVE(32, PI, DI) } // 20e8 +OP(move_32_pd_di) { MOVE(32, PD, DI) } // 2128 +OP(move_32_di_di) { MOVE(32, DI, DI) } // 2168 +OP(move_32_ix_di) { MOVE(32, IX, DI) } // 21a8 +OP(move_32_aw_di) { MOVE(32, AW, DI) } // 21e8 +OP(move_32_al_di) { MOVE(32, AL, DI) } // 23e8 + +OP(move_32_d_ix) { MOVE(32, D, IX) } // 2030 +OP(move_32_ai_ix) { MOVE(32, AI, IX) } // 20b0 +OP(move_32_pi_ix) { MOVE(32, PI, IX) } // 20f0 +OP(move_32_pd_ix) { MOVE(32, PD, IX) } // 2130 +OP(move_32_di_ix) { MOVE(32, DI, IX) } // 2170 +OP(move_32_ix_ix) { MOVE(32, IX, IX) } // 21b0 +OP(move_32_aw_ix) { MOVE(32, AW, IX) } // 21f0 +OP(move_32_al_ix) { MOVE(32, AL, IX) } // 23f0 + +OP(move_32_d_aw) { MOVE(32, D, AW) } // 2038 +OP(move_32_ai_aw) { MOVE(32, AI, AW) } // 20b8 +OP(move_32_pi_aw) { MOVE(32, PI, AW) } // 20f8 +OP(move_32_pd_aw) { MOVE(32, PD, AW) } // 2138 +OP(move_32_di_aw) { MOVE(32, DI, AW) } // 2178 +OP(move_32_ix_aw) { MOVE(32, IX, AW) } // 21b8 +OP(move_32_aw_aw) { MOVE(32, AW, AW) } // 21f8 +OP(move_32_al_aw) { MOVE(32, AL, AW) } // 23f8 + +OP(move_32_d_al) { MOVE(32, D, AL) } // 2039 +OP(move_32_ai_al) { MOVE(32, AI, AL) } // 20b9 +OP(move_32_pi_al) { MOVE(32, PI, AL) } // 20f9 +OP(move_32_pd_al) { MOVE(32, PD, AL) } // 2139 +OP(move_32_di_al) { MOVE(32, DI, AL) } // 2179 +OP(move_32_ix_al) { MOVE(32, IX, AL) } // 21b9 +OP(move_32_aw_al) { MOVE(32, AW, AL) } // 21f9 +OP(move_32_al_al) { MOVE(32, AL, AL) } // 23f9 + +OP(move_32_d_pcdi) { MOVE(32, D, PCDI) } // 203a +OP(move_32_ai_pcdi) { MOVE(32, AI, PCDI) } // 20ba +OP(move_32_pi_pcdi) { MOVE(32, PI, PCDI) } // 20fa +OP(move_32_pd_pcdi) { MOVE(32, PD, PCDI) } // 213a +OP(move_32_di_pcdi) { MOVE(32, DI, PCDI) } // 217a +OP(move_32_ix_pcdi) { MOVE(32, IX, PCDI) } // 21ba +OP(move_32_aw_pcdi) { MOVE(32, AW, PCDI) } // 21fa +OP(move_32_al_pcdi) { MOVE(32, AL, PCDI) } // 23fa + +OP(move_32_d_pcix) { MOVE(32, D, PCIX) } // 203b +OP(move_32_ai_pcix) { MOVE(32, AI, PCIX) } // 20bb +OP(move_32_pi_pcix) { MOVE(32, PI, PCIX) } // 20fb +OP(move_32_pd_pcix) { MOVE(32, PD, PCIX) } // 213b +OP(move_32_di_pcix) { MOVE(32, DI, PCIX) } // 217b +OP(move_32_ix_pcix) { MOVE(32, IX, PCIX) } // 21bb +OP(move_32_aw_pcix) { MOVE(32, AW, PCIX) } // 21fb +OP(move_32_al_pcix) { MOVE(32, AL, PCIX) } // 23fb + +OP(move_32_d_i) { MOVE(32, D, I) } // 203c +OP(move_32_ai_i) { MOVE(32, AI, I) } // 20bc +OP(move_32_pi_i) { MOVE(32, PI, I) } // 20fc +OP(move_32_pd_i) { MOVE(32, PD, I) } // 213c +OP(move_32_di_i) { MOVE(32, DI, I) } // 217c +OP(move_32_ix_i) { MOVE(32, IX, I) } // 21bc +OP(move_32_aw_i) { MOVE(32, AW, I) } // 21fc +OP(move_32_al_i) { MOVE(32, AL, I) } // 23fc + +/*----------------------------------------------------------------------------- + MOVEA Move Address +-----------------------------------------------------------------------------*/ + +OP(movea_32_d) { MOVEA(32, D) } // 2040 +OP(movea_32_a) { MOVEA(32, A) } // 2048 +OP(movea_32_ai) { MOVEA(32, AI) } // 2050 +OP(movea_32_pi) { MOVEA(32, PI) } // 2058 +OP(movea_32_pd) { MOVEA(32, PD) } // 2060 +OP(movea_32_di) { MOVEA(32, DI) } // 2068 +OP(movea_32_ix) { MOVEA(32, IX) } // 2070 +OP(movea_32_aw) { MOVEA(32, AW) } // 2078 +OP(movea_32_al) { MOVEA(32, AL) } // 2079 +OP(movea_32_pcdi) { MOVEA(32, PCDI) } // 207a +OP(movea_32_pcix) { MOVEA(32, PCIX) } // 207b +OP(movea_32_i) { MOVEA(32, I) } // 207c + +/****************************************************************************** + OPCODE $3xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + MOVE Move Data from Source to Destination +-----------------------------------------------------------------------------*/ + +OP(move_16_d_d) { MOVE(16, D, D) } // 3000 +OP(move_16_ai_d) { MOVE(16, AI, D) } // 3080 +OP(move_16_pi_d) { MOVE(16, PI, D) } // 30c0 +OP(move_16_pd_d) { MOVE(16, PD, D) } // 3100 +OP(move_16_di_d) { MOVE(16, DI, D) } // 3140 +OP(move_16_ix_d) { MOVE(16, IX, D) } // 3180 +OP(move_16_aw_d) { MOVE(16, AW, D) } // 31c0 +OP(move_16_al_d) { MOVE(16, AL, D) } // 33c0 + +OP(move_16_d_a) { MOVE(16, D, A) } // 3008 +OP(move_16_ai_a) { MOVE(16, AI, A) } // 3088 +OP(move_16_pi_a) { MOVE(16, PI, A) } // 30c8 +OP(move_16_pd_a) { MOVE(16, PD, A) } // 3108 +OP(move_16_di_a) { MOVE(16, DI, A) } // 3148 +OP(move_16_ix_a) { MOVE(16, IX, A) } // 3188 +OP(move_16_aw_a) { MOVE(16, AW, A) } // 31c8 +OP(move_16_al_a) { MOVE(16, AL, A) } // 33c8 + +OP(move_16_d_ai) { MOVE(16, D, AI) } // 3010 +OP(move_16_ai_ai) { MOVE(16, AI, AI) } // 3090 +OP(move_16_pi_ai) { MOVE(16, PI, AI) } // 30d0 +OP(move_16_pd_ai) { MOVE(16, PD, AI) } // 3110 +OP(move_16_di_ai) { MOVE(16, DI, AI) } // 3150 +OP(move_16_ix_ai) { MOVE(16, IX, AI) } // 3190 +OP(move_16_aw_ai) { MOVE(16, AW, AI) } // 31d0 +OP(move_16_al_ai) { MOVE(16, AL, AI) } // 33d0 + +OP(move_16_d_pi) { MOVE(16, D, PI) } // 3018 +OP(move_16_ai_pi) { MOVE(16, AI, PI) } // 3098 +OP(move_16_pi_pi) { MOVE(16, PI, PI) } // 30d8 +OP(move_16_pd_pi) { MOVE(16, PD, PI) } // 3118 +OP(move_16_di_pi) { MOVE(16, DI, PI) } // 3158 +OP(move_16_ix_pi) { MOVE(16, IX, PI) } // 3198 +OP(move_16_aw_pi) { MOVE(16, AW, PI) } // 31d8 +OP(move_16_al_pi) { MOVE(16, AL, PI) } // 33d8 + +OP(move_16_d_pd) { MOVE(16, D, PD) } // 3020 +OP(move_16_ai_pd) { MOVE(16, AI, PD) } // 30a0 +OP(move_16_pi_pd) { MOVE(16, PI, PD) } // 30e0 +OP(move_16_pd_pd) { MOVE(16, PD, PD) } // 3120 +OP(move_16_di_pd) { MOVE(16, DI, PD) } // 3160 +OP(move_16_ix_pd) { MOVE(16, IX, PD) } // 31a0 +OP(move_16_aw_pd) { MOVE(16, AW, PD) } // 31e0 +OP(move_16_al_pd) { MOVE(16, AL, PD) } // 33e0 + +OP(move_16_d_di) { MOVE(16, D, DI) } // 3028 +OP(move_16_ai_di) { MOVE(16, AI, DI) } // 30a8 +OP(move_16_pi_di) { MOVE(16, PI, DI) } // 30e8 +OP(move_16_pd_di) { MOVE(16, PD, DI) } // 3128 +OP(move_16_di_di) { MOVE(16, DI, DI) } // 3168 +OP(move_16_ix_di) { MOVE(16, IX, DI) } // 31a8 +OP(move_16_aw_di) { MOVE(16, AW, DI) } // 31e8 +OP(move_16_al_di) { MOVE(16, AL, DI) } // 33e8 + +OP(move_16_d_ix) { MOVE(16, D, IX) } // 3030 +OP(move_16_ai_ix) { MOVE(16, AI, IX) } // 30b0 +OP(move_16_pi_ix) { MOVE(16, PI, IX) } // 30f0 +OP(move_16_pd_ix) { MOVE(16, PD, IX) } // 3130 +OP(move_16_di_ix) { MOVE(16, DI, IX) } // 3170 +OP(move_16_ix_ix) { MOVE(16, IX, IX) } // 31b0 +OP(move_16_aw_ix) { MOVE(16, AW, IX) } // 31f0 +OP(move_16_al_ix) { MOVE(16, AL, IX) } // 33f0 + +OP(move_16_d_aw) { MOVE(16, D, AW) } // 3038 +OP(move_16_ai_aw) { MOVE(16, AI, AW) } // 30b8 +OP(move_16_pi_aw) { MOVE(16, PI, AW) } // 30f8 +OP(move_16_pd_aw) { MOVE(16, PD, AW) } // 3138 +OP(move_16_di_aw) { MOVE(16, DI, AW) } // 3178 +OP(move_16_ix_aw) { MOVE(16, IX, AW) } // 31b8 +OP(move_16_aw_aw) { MOVE(16, AW, AW) } // 31f8 +OP(move_16_al_aw) { MOVE(16, AL, AW) } // 33f8 + +OP(move_16_d_al) { MOVE(16, D, AL) } // 3039 +OP(move_16_ai_al) { MOVE(16, AI, AL) } // 30b9 +OP(move_16_pi_al) { MOVE(16, PI, AL) } // 30f9 +OP(move_16_pd_al) { MOVE(16, PD, AL) } // 3139 +OP(move_16_di_al) { MOVE(16, DI, AL) } // 3179 +OP(move_16_ix_al) { MOVE(16, IX, AL) } // 31b9 +OP(move_16_aw_al) { MOVE(16, AW, AL) } // 31f9 +OP(move_16_al_al) { MOVE(16, AL, AL) } // 33f9 + +OP(move_16_d_pcdi) { MOVE(16, D, PCDI) } // 303a +OP(move_16_ai_pcdi) { MOVE(16, AI, PCDI) } // 30ba +OP(move_16_pi_pcdi) { MOVE(16, PI, PCDI) } // 30fa +OP(move_16_pd_pcdi) { MOVE(16, PD, PCDI) } // 313a +OP(move_16_di_pcdi) { MOVE(16, DI, PCDI) } // 317a +OP(move_16_ix_pcdi) { MOVE(16, IX, PCDI) } // 31ba +OP(move_16_aw_pcdi) { MOVE(16, AW, PCDI) } // 31fa +OP(move_16_al_pcdi) { MOVE(16, AL, PCDI) } // 33fa + +OP(move_16_d_pcix) { MOVE(16, D, PCIX) } // 303b +OP(move_16_ai_pcix) { MOVE(16, AI, PCIX) } // 30bb +OP(move_16_pi_pcix) { MOVE(16, PI, PCIX) } // 30fb +OP(move_16_pd_pcix) { MOVE(16, PD, PCIX) } // 313b +OP(move_16_di_pcix) { MOVE(16, DI, PCIX) } // 317b +OP(move_16_ix_pcix) { MOVE(16, IX, PCIX) } // 31bb +OP(move_16_aw_pcix) { MOVE(16, AW, PCIX) } // 31fb +OP(move_16_al_pcix) { MOVE(16, AL, PCIX) } // 33fb + +OP(move_16_d_i) { MOVE(16, D, I) } // 303c +OP(move_16_ai_i) { MOVE(16, AI, I) } // 30bc +OP(move_16_pi_i) { MOVE(16, PI, I) } // 30fc +OP(move_16_pd_i) { MOVE(16, PD, I) } // 313c +OP(move_16_di_i) { MOVE(16, DI, I) } // 317c +OP(move_16_ix_i) { MOVE(16, IX, I) } // 31bc +OP(move_16_aw_i) { MOVE(16, AW, I) } // 31fc +OP(move_16_al_i) { MOVE(16, AL, I) } // 33fc + +/*----------------------------------------------------------------------------- + MOVEA Move Address +-----------------------------------------------------------------------------*/ + +OP(movea_16_d) { MOVEA(16, D) } // 3040 +OP(movea_16_a) { MOVEA(16, A) } // 3048 +OP(movea_16_ai) { MOVEA(16, AI) } // 3050 +OP(movea_16_pi) { MOVEA(16, PI) } // 3058 +OP(movea_16_pd) { MOVEA(16, PD) } // 3060 +OP(movea_16_di) { MOVEA(16, DI) } // 3068 +OP(movea_16_ix) { MOVEA(16, IX) } // 3070 +OP(movea_16_aw) { MOVEA(16, AW) } // 3078 +OP(movea_16_al) { MOVEA(16, AL) } // 3079 +OP(movea_16_pcdi) { MOVEA(16, PCDI) } // 307a +OP(movea_16_pcix) { MOVEA(16, PCIX) } // 307b +OP(movea_16_i) { MOVEA(16, I) } // 307c + +/****************************************************************************** + OPCODE $4xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + NEGX Negate with Extend +-----------------------------------------------------------------------------*/ + +OP(negx_8_d) { NEGX(8, D, D) } // 4000 +OP(negx_8_ai) { NEGX(8, M, AI) } // 4010 +OP(negx_8_pi) { NEGX(8, M, PI) } // 4018 +OP(negx_8_pd) { NEGX(8, M, PD) } // 4020 +OP(negx_8_di) { NEGX(8, M, DI) } // 4028 +OP(negx_8_ix) { NEGX(8, M, IX) } // 4030 +OP(negx_8_aw) { NEGX(8, M, AW) } // 4038 +OP(negx_8_al) { NEGX(8, M, AL) } // 4039 +OP(negx_8_pi7) { NEGX(8, M, PI7) } // 401f +OP(negx_8_pd7) { NEGX(8, M, PD7) } // 4027 + +OP(negx_16_d) { NEGX(16, D, D) } // 4040 +OP(negx_16_ai) { NEGX(16, M, AI) } // 4050 +OP(negx_16_pi) { NEGX(16, M, PI) } // 4058 +OP(negx_16_pd) { NEGX(16, M, PD) } // 4060 +OP(negx_16_di) { NEGX(16, M, DI) } // 4068 +OP(negx_16_ix) { NEGX(16, M, IX) } // 4070 +OP(negx_16_aw) { NEGX(16, M, AW) } // 4078 +OP(negx_16_al) { NEGX(16, M, AL) } // 4079 + +OP(negx_32_d) { NEGX(32, D, D) } // 4080 +OP(negx_32_ai) { NEGX(32, M, AI) } // 4090 +OP(negx_32_pi) { NEGX(32, M, PI) } // 4098 +OP(negx_32_pd) { NEGX(32, M, PD) } // 40a0 +OP(negx_32_di) { NEGX(32, M, DI) } // 40a8 +OP(negx_32_ix) { NEGX(32, M, IX) } // 40b0 +OP(negx_32_aw) { NEGX(32, M, AW) } // 40b8 +OP(negx_32_al) { NEGX(32, M, AL) } // 40b9 + +/*----------------------------------------------------------------------------- + CLR Clear an Operand +-----------------------------------------------------------------------------*/ + +OP(clr_8_d) { CLR(8, D, D) } // 4200 +OP(clr_8_ai) { CLR(8, M, AI) } // 4210 +OP(clr_8_pi) { CLR(8, M, PI) } // 4218 +OP(clr_8_pd) { CLR(8, M, PD) } // 4220 +OP(clr_8_di) { CLR(8, M, DI) } // 4228 +OP(clr_8_ix) { CLR(8, M, IX) } // 4230 +OP(clr_8_aw) { CLR(8, M, AW) } // 4238 +OP(clr_8_al) { CLR(8, M, AL) } // 4239 +OP(clr_8_pi7) { CLR(8, M, PI7) } // 421f +OP(clr_8_pd7) { CLR(8, M, PD7) } // 4227 + +OP(clr_16_d) { CLR(16, D, D) } // 4240 +OP(clr_16_ai) { CLR(16, M, AI) } // 4250 +OP(clr_16_pi) { CLR(16, M, PI) } // 4258 +OP(clr_16_pd) { CLR(16, M, PD) } // 4260 +OP(clr_16_di) { CLR(16, M, DI) } // 4268 +OP(clr_16_ix) { CLR(16, M, IX) } // 4270 +OP(clr_16_aw) { CLR(16, M, AW) } // 4278 +OP(clr_16_al) { CLR(16, M, AL) } // 4279 + +OP(clr_32_d) { CLR(32, D, D) } // 4280 +OP(clr_32_ai) { CLR(32, M, AI) } // 4290 +OP(clr_32_pi) { CLR(32, M, PI) } // 4298 +OP(clr_32_pd) { CLR(32, M, PD) } // 42a0 +OP(clr_32_di) { CLR(32, M, DI) } // 42a8 +OP(clr_32_ix) { CLR(32, M, IX) } // 42b0 +OP(clr_32_aw) { CLR(32, M, AW) } // 42b8 +OP(clr_32_al) { CLR(32, M, AL) } // 42b9 + +/*----------------------------------------------------------------------------- + NEG Negate +-----------------------------------------------------------------------------*/ + +OP(neg_8_d) { NEG(8, D, D) } // 4400 +OP(neg_8_ai) { NEG(8, M, AI) } // 4410 +OP(neg_8_pi) { NEG(8, M, PI) } // 4418 +OP(neg_8_pd) { NEG(8, M, PD) } // 4420 +OP(neg_8_di) { NEG(8, M, DI) } // 4428 +OP(neg_8_ix) { NEG(8, M, IX) } // 4430 +OP(neg_8_aw) { NEG(8, M, AW) } // 4438 +OP(neg_8_al) { NEG(8, M, AL) } // 4439 +OP(neg_8_pi7) { NEG(8, M, PI7) } // 441f +OP(neg_8_pd7) { NEG(8, M, PD7) } // 4427 + +OP(neg_16_d) { NEG(16, D, D) } // 4440 +OP(neg_16_ai) { NEG(16, M, AI) } // 4450 +OP(neg_16_pi) { NEG(16, M, PI) } // 4458 +OP(neg_16_pd) { NEG(16, M, PD) } // 4460 +OP(neg_16_di) { NEG(16, M, DI) } // 4468 +OP(neg_16_ix) { NEG(16, M, IX) } // 4470 +OP(neg_16_aw) { NEG(16, M, AW) } // 4478 +OP(neg_16_al) { NEG(16, M, AL) } // 4479 + +OP(neg_32_d) { NEG(32, D, D) } // 4480 +OP(neg_32_ai) { NEG(32, M, AI) } // 4490 +OP(neg_32_pi) { NEG(32, M, PI) } // 4498 +OP(neg_32_pd) { NEG(32, M, PD) } // 44a0 +OP(neg_32_di) { NEG(32, M, DI) } // 44a8 +OP(neg_32_ix) { NEG(32, M, IX) } // 44b0 +OP(neg_32_aw) { NEG(32, M, AW) } // 44b8 +OP(neg_32_al) { NEG(32, M, AL) } // 44b9 + +/*----------------------------------------------------------------------------- + NOT Logical Complement +-----------------------------------------------------------------------------*/ + +OP(not_8_d) { NOT(8, D, D) } // 4600 +OP(not_8_ai) { NOT(8, M, AI) } // 4610 +OP(not_8_pi) { NOT(8, M, PI) } // 4618 +OP(not_8_pd) { NOT(8, M, PD) } // 4620 +OP(not_8_di) { NOT(8, M, DI) } // 4628 +OP(not_8_ix) { NOT(8, M, IX) } // 4630 +OP(not_8_aw) { NOT(8, M, AW) } // 4638 +OP(not_8_al) { NOT(8, M, AL) } // 4639 +OP(not_8_pi7) { NOT(8, M, PI7) } // 461f +OP(not_8_pd7) { NOT(8, M, PD7) } // 4627 + +OP(not_16_d) { NOT(16, D, D) } // 4640 +OP(not_16_ai) { NOT(16, M, AI) } // 4650 +OP(not_16_pi) { NOT(16, M, PI) } // 4658 +OP(not_16_pd) { NOT(16, M, PD) } // 4660 +OP(not_16_di) { NOT(16, M, DI) } // 4668 +OP(not_16_ix) { NOT(16, M, IX) } // 4670 +OP(not_16_aw) { NOT(16, M, AW) } // 4678 +OP(not_16_al) { NOT(16, M, AL) } // 4679 + +OP(not_32_d) { NOT(32, D, D) } // 4680 +OP(not_32_ai) { NOT(32, M, AI) } // 4690 +OP(not_32_pi) { NOT(32, M, PI) } // 4698 +OP(not_32_pd) { NOT(32, M, PD) } // 46a0 +OP(not_32_di) { NOT(32, M, DI) } // 46a8 +OP(not_32_ix) { NOT(32, M, IX) } // 46b0 +OP(not_32_aw) { NOT(32, M, AW) } // 46b8 +OP(not_32_al) { NOT(32, M, AL) } // 46b9 + +/*----------------------------------------------------------------------------- + MOVE from SR Move from the Status Register +-----------------------------------------------------------------------------*/ + +OP(move_16_frs_d) { MOVE_FRS(D, D) } // 40c0 +OP(move_16_frs_ai) { MOVE_FRS(M, AI) } // 40d0 +OP(move_16_frs_pi) { MOVE_FRS(M, PI) } // 40d8 +OP(move_16_frs_pd) { MOVE_FRS(M, PD) } // 40e0 +OP(move_16_frs_di) { MOVE_FRS(M, DI) } // 40e8 +OP(move_16_frs_ix) { MOVE_FRS(M, IX) } // 40f0 +OP(move_16_frs_aw) { MOVE_FRS(M, AW) } // 40f8 +OP(move_16_frs_al) { MOVE_FRS(M, AL) } // 40f9 + +/*----------------------------------------------------------------------------- + MOVE to CCR Move to Condition Code Register +-----------------------------------------------------------------------------*/ + +OP(move_16_toc_d) { MOVE_TOC(D) } // 44c0 +OP(move_16_toc_ai) { MOVE_TOC(AI) } // 44d0 +OP(move_16_toc_pi) { MOVE_TOC(PI) } // 44d8 +OP(move_16_toc_pd) { MOVE_TOC(PD) } // 44e0 +OP(move_16_toc_di) { MOVE_TOC(DI) } // 44e8 +OP(move_16_toc_ix) { MOVE_TOC(IX) } // 44f0 +OP(move_16_toc_aw) { MOVE_TOC(AW) } // 44f8 +OP(move_16_toc_al) { MOVE_TOC(AL) } // 44f9 +OP(move_16_toc_pcdi) { MOVE_TOC(PCDI) } // 44fa +OP(move_16_toc_pcix) { MOVE_TOC(PCIX) } // 44fb +OP(move_16_toc_i) { MOVE_TOC(I) } // 44fc + +/*----------------------------------------------------------------------------- + MOVE to SR Move to the Status Register +-----------------------------------------------------------------------------*/ + +OP(move_16_tos_d) { MOVE_TOS(D) } // 46c0 +OP(move_16_tos_ai) { MOVE_TOS(AI) } // 46d0 +OP(move_16_tos_pi) { MOVE_TOS(PI) } // 46d8 +OP(move_16_tos_pd) { MOVE_TOS(PD) } // 46e0 +OP(move_16_tos_di) { MOVE_TOS(DI) } // 46e8 +OP(move_16_tos_ix) { MOVE_TOS(IX) } // 46f0 +OP(move_16_tos_aw) { MOVE_TOS(AW) } // 46f8 +OP(move_16_tos_al) { MOVE_TOS(AL) } // 46f9 +OP(move_16_tos_pcdi) { MOVE_TOS(PCDI) } // 46fa +OP(move_16_tos_pcix) { MOVE_TOS(PCIX) } // 46fb +OP(move_16_tos_i) { MOVE_TOS(I) } // 46fc + +/*----------------------------------------------------------------------------- + NBCD Negate Decimal with Extend +-----------------------------------------------------------------------------*/ + +OP(nbcd_8_d) { NBCD(D, D) } // 4800 +OP(nbcd_8_ai) { NBCD(M, AI) } // 4810 +OP(nbcd_8_pi) { NBCD(M, PI) } // 4818 +OP(nbcd_8_pd) { NBCD(M, PD) } // 4820 +OP(nbcd_8_di) { NBCD(M, DI) } // 4828 +OP(nbcd_8_ix) { NBCD(M, IX) } // 4830 +OP(nbcd_8_aw) { NBCD(M, AW) } // 4838 +OP(nbcd_8_al) { NBCD(M, AL) } // 4839 +OP(nbcd_8_pi7) { NBCD(M, PI7) } // 481f +OP(nbcd_8_pd7) { NBCD(M, PD7) } // 4827 + +/*----------------------------------------------------------------------------- + PEA Push Effective Address +-----------------------------------------------------------------------------*/ + +OP(pea_32_ai) { PEA(AI) } // 4850 +OP(pea_32_di) { PEA(DI) } // 4868 +OP(pea_32_ix) { PEA(IX) } // 4870 +OP(pea_32_aw) { PEA(AW) } // 4878 +OP(pea_32_al) { PEA(AL) } // 4879 +OP(pea_32_pcdi) { PEA(PCDI) } // 487a +OP(pea_32_pcix) { PEA(PCIX) } // 487b + +/*----------------------------------------------------------------------------- + SWAP Swap Register Halves +-----------------------------------------------------------------------------*/ + +// 4840 +OP(swap_32) +{ + EA_READ_D(32, Y, res); + res = (res >> 16) | (res << 16); + FLAGS(32) + EA_WRITE_RESULT(32, D, Y) + RET(4) +} + +/*----------------------------------------------------------------------------- + MOVEM Move from Multiple Registers +-----------------------------------------------------------------------------*/ + +OP(movem_16_re_ai) { MOVEM_RE(16, AI) } // 4890 +OP(movem_16_re_pd) { MOVEM_RE_PD(16, Y) } // 48a0 +OP(movem_16_re_di) { MOVEM_RE(16, DI) } // 48a8 +OP(movem_16_re_ix) { MOVEM_RE(16, IX) } // 48b0 +OP(movem_16_re_aw) { MOVEM_RE(16, AW) } // 48b8 +OP(movem_16_re_al) { MOVEM_RE(16, AL) } // 48b9 + +OP(movem_32_re_ai) { MOVEM_RE(32, AI) } // 48d0 +OP(movem_32_re_pd) { MOVEM_RE_PD(32, Y) } // 48e0 +OP(movem_32_re_di) { MOVEM_RE(32, DI) } // 48e8 +OP(movem_32_re_ix) { MOVEM_RE(32, IX) } // 48f0 +OP(movem_32_re_aw) { MOVEM_RE(32, AW) } // 48f8 +OP(movem_32_re_al) { MOVEM_RE(32, AL) } // 48f9 + +/*----------------------------------------------------------------------------- + EXT Sign-Extend +-----------------------------------------------------------------------------*/ + +OP(ext_16) { EXT(8, 16) } // 4880 +OP(ext_32) { EXT(16, 32) } // 48c0 + +/*----------------------------------------------------------------------------- + TST Test an Operand +-----------------------------------------------------------------------------*/ + +OP(tst_8_d) { TST(8, D) } // 4a00 +OP(tst_8_ai) { TST(8, AI) } // 4a10 +OP(tst_8_pi) { TST(8, PI) } // 4a18 +OP(tst_8_pd) { TST(8, PD) } // 4a20 +OP(tst_8_di) { TST(8, DI) } // 4a28 +OP(tst_8_ix) { TST(8, IX) } // 4a30 +OP(tst_8_aw) { TST(8, AW) } // 4a38 +OP(tst_8_al) { TST(8, AL) } // 4a39 +OP(tst_8_pi7) { TST(8, PI7) } // 4a1f +OP(tst_8_pd7) { TST(8, PD7) } // 4a27 + +OP(tst_16_d) { TST(16, D) } // 4a40 +OP(tst_16_ai) { TST(16, AI) } // 4a50 +OP(tst_16_pi) { TST(16, PI) } // 4a58 +OP(tst_16_pd) { TST(16, PD) } // 4a60 +OP(tst_16_di) { TST(16, DI) } // 4a68 +OP(tst_16_ix) { TST(16, IX) } // 4a70 +OP(tst_16_aw) { TST(16, AW) } // 4a78 +OP(tst_16_al) { TST(16, AL) } // 4a79 + +OP(tst_32_d) { TST(32, D) } // 4a80 +OP(tst_32_ai) { TST(32, AI) } // 4a90 +OP(tst_32_pi) { TST(32, PI) } // 4a98 +OP(tst_32_pd) { TST(32, PD) } // 4aa0 +OP(tst_32_di) { TST(32, DI) } // 4aa8 +OP(tst_32_ix) { TST(32, IX) } // 4ab0 +OP(tst_32_aw) { TST(32, AW) } // 4ab8 +OP(tst_32_al) { TST(32, AL) } // 4ab9 + +/*----------------------------------------------------------------------------- + TAS Test and Set an Operand +-----------------------------------------------------------------------------*/ + +OP(tas_8_d) { TAS(D, D) } // 4ac0 +OP(tas_8_ai) { TAS(M, AI) } // 4ad0 +OP(tas_8_pi) { TAS(M, PI) } // 4ad8 +OP(tas_8_pd) { TAS(M, PD) } // 4ae0 +OP(tas_8_di) { TAS(M, DI) } // 4ae8 +OP(tas_8_ix) { TAS(M, IX) } // 4af0 +OP(tas_8_aw) { TAS(M, AW) } // 4af8 +OP(tas_8_al) { TAS(M, AL) } // 4af9 +OP(tas_8_pi7) { TAS(M, PI7) } // 4adf +OP(tas_8_pd7) { TAS(M, PD7) } // 4ae7 + +/*----------------------------------------------------------------------------- + ILLEGAL Take Illegal Instruction Trap +-----------------------------------------------------------------------------*/ + +// 4afc +OP(illegal) +{ + SWAP_SP() + PC -= 2; + EXCEPTION(C68K_ILLEGAL_INSTRUCTION_EX) + RET(34) +} + +/*----------------------------------------------------------------------------- + MOVEM Move to Multiple Registers +-----------------------------------------------------------------------------*/ + +OP(movem_16_er_ai) { MOVEM_ER(16, AI) } // 4c90 +OP(movem_16_er_pi) { MOVEM_ER_PI(16, Y) } // 4c98 +OP(movem_16_er_di) { MOVEM_ER(16, DI) } // 4ca8 +OP(movem_16_er_ix) { MOVEM_ER(16, IX) } // 4cb0 +OP(movem_16_er_aw) { MOVEM_ER(16, AW) } // 4cb8 +OP(movem_16_er_al) { MOVEM_ER(16, AL) } // 4cb9 +OP(movem_16_er_pcdi) { MOVEM_ER(16, PCDI) } // 4cba +OP(movem_16_er_pcix) { MOVEM_ER(16, PCIX) } // 4cbb + +OP(movem_32_er_ai) { MOVEM_ER(32, AI) } // 4cd0 +OP(movem_32_er_pi) { MOVEM_ER_PI(32, Y) } // 4cd8 +OP(movem_32_er_di) { MOVEM_ER(32, DI) } // 4ce8 +OP(movem_32_er_ix) { MOVEM_ER(32, IX) } // 4cf0 +OP(movem_32_er_aw) { MOVEM_ER(32, AW) } // 4cf8 +OP(movem_32_er_al) { MOVEM_ER(32, AL) } // 4cf9 +OP(movem_32_er_pcdi) { MOVEM_ER(32, PCDI) } // 4cfa +OP(movem_32_er_pcix) { MOVEM_ER(32, PCIX) } // 4cfb + +/*----------------------------------------------------------------------------- + TRAP Take Illegal Instruction Trap +-----------------------------------------------------------------------------*/ + +// 4e40 +OP(trap) +{ + SWAP_SP() + res = C68K_TRAP_BASE_EX + (Opcode & 0x0f); + EXCEPTION(res) + RET(34) +} + +/*----------------------------------------------------------------------------- + LINK Link and Allocate +-----------------------------------------------------------------------------*/ + +// 4e50 +OP(link_16) +{ + EA_AI(32, Y) + PUSH_32_F(adr) + AY = A7; + A7 += READSX_I(16, NA); + RET(16) +} + +// 4e57 +OP(link_16_a7) +{ + A7 -= 4; + WRITE_MEM_32PD(A7, A7); + A7 += READSX_I(16, NA); + RET(16) +} + +/*----------------------------------------------------------------------------- + UNLK Unlink +-----------------------------------------------------------------------------*/ + +// 4e58 +OP(unlk_32) +{ + EA_AI(32, Y) + A7 = adr + 4; + AY = READ_MEM_32(adr); + RET(12) +} + +// 4e5f +OP(unlk_32_a7) +{ + A7 = READ_MEM_32(A7); + RET(12) +} + +/*----------------------------------------------------------------------------- + MOVE USP Move User Stack Pointer +-----------------------------------------------------------------------------*/ + +OP(move_32_tou) { MOVEUSP(CPU->USP, AY) } // 4e60 +OP(move_32_fru) { MOVEUSP(AY, CPU->USP) } // 4e68 + +/*----------------------------------------------------------------------------- + RESET Reset External Devices +-----------------------------------------------------------------------------*/ + +// 4e70 +OP(reset) +{ + if (FLAG_S) + { + CPU->Reset_CallBack(); + RET(132) + } + SWAP_SP_NOCHECK() + EXCEPTION(C68K_PRIVILEGE_VIOLATION_EX) + RET(40) +} + +/*----------------------------------------------------------------------------- + NOP No Operation +-----------------------------------------------------------------------------*/ + +OP(nop) { RET(4) } // 4e71 + +/*----------------------------------------------------------------------------- + STOP Load Status Register and Stop +-----------------------------------------------------------------------------*/ + +// 4e72 +OP(stop) +{ + if (FLAG_S) + { + EA_READ_I(16, NA, res) + res &= C68K_SR_MASK; + SET_SR(res) + SWAP_SP() + RET_HALT() + } + PC += 2; + SWAP_SP_NOCHECK() + EXCEPTION(C68K_PRIVILEGE_VIOLATION_EX) + RET(40) +} + +/*----------------------------------------------------------------------------- + RTE Return from Exception +-----------------------------------------------------------------------------*/ + +// 4e73 +OP(rte_32) +{ + if (FLAG_S) + { + POP_16_F(res) + SET_SR(res) + POP_32_F(res) + SET_PC(res) + SWAP_SP() + RET_INT(20) + } + SWAP_SP_NOCHECK() + EXCEPTION(C68K_PRIVILEGE_VIOLATION_EX) + RET(34) +} + +/*----------------------------------------------------------------------------- + RTS Return from Subroutine +-----------------------------------------------------------------------------*/ + +// 4e75 +OP(rts_32) +{ + POP_32_F(res) + SET_PC(res) + RET(16) +} + +/*----------------------------------------------------------------------------- + TRAPV Trap on Overflow +-----------------------------------------------------------------------------*/ + +// 4e76 +OP(trapv) +{ + if (COND_VS()) + { + SWAP_SP() + EXCEPTION(C68K_TRAPV_EX); + RET(34) + } + RET(4) +} + +/*----------------------------------------------------------------------------- + RTR Return and Restore Condition Codes +-----------------------------------------------------------------------------*/ + +// 4e77 +OP(rtr_32) +{ + POP_16_F(res) + SET_CCR(res) + POP_32_F(res) + SET_PC(res) + RET(20) +} + +/*----------------------------------------------------------------------------- + JSR Jump to Subroutine +-----------------------------------------------------------------------------*/ + +OP(jsr_32_ai) { JSR(AI) } // 4e90 +OP(jsr_32_di) { JSR(DI) } // 4ea8 +OP(jsr_32_ix) { JSR(IX) } // 4eb0 +OP(jsr_32_aw) { JSR(AW) } // 4eb8 +OP(jsr_32_al) { JSR(AL) } // 4eb9 +OP(jsr_32_pcdi) { JSR(PCDI) } // 4eba +OP(jsr_32_pcix) { JSR(PCIX) } // 4ebb + +/*----------------------------------------------------------------------------- + JMP Jump +-----------------------------------------------------------------------------*/ + +OP(jmp_32_ai) { JMP(AI) } // 4ed0 +OP(jmp_32_di) { JMP(DI) } // 4ee8 +OP(jmp_32_ix) { JMP(IX) } // 4ef0 +OP(jmp_32_aw) { JMP(AW) } // 4ef8 +OP(jmp_32_al) { JMP(AL) } // 4ef9 +OP(jmp_32_pcdi) { JMP(PCDI) } // 4efa +OP(jmp_32_pcix) { JMP(PCIX) } // 4efb + +/*----------------------------------------------------------------------------- + CHK Check Register Against Bounds +-----------------------------------------------------------------------------*/ + +OP(chk_16_d) { CHK(D) } // 4180 +OP(chk_16_ai) { CHK(AI) } // 4190 +OP(chk_16_pi) { CHK(PI) } // 4198 +OP(chk_16_pd) { CHK(PD) } // 41a0 +OP(chk_16_di) { CHK(DI) } // 41a8 +OP(chk_16_ix) { CHK(IX) } // 41b0 +OP(chk_16_aw) { CHK(AW) } // 41b8 +OP(chk_16_al) { CHK(AL) } // 41b9 +OP(chk_16_pcdi) { CHK(PCDI) } // 41ba +OP(chk_16_pcix) { CHK(PCIX) } // 41bb +OP(chk_16_i) { CHK(I) } // 41bc + +/*----------------------------------------------------------------------------- + LEA Load Effective Address +-----------------------------------------------------------------------------*/ + +OP(lea_32_ai) { LEA(AI) } // 41d0 +OP(lea_32_di) { LEA(DI) } // 41e8 +OP(lea_32_ix) { LEA(IX) } // 41f0 +OP(lea_32_aw) { LEA(AW) } // 41f8 +OP(lea_32_al) { LEA(AL) } // 41f9 +OP(lea_32_pcdi) { LEA(PCDI) } // 41fa +OP(lea_32_pcix) { LEA(PCIX) } // 41fb + +/****************************************************************************** + OPCODE $5xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + Scc Set According to Condition +-----------------------------------------------------------------------------*/ + +OP(st_8_d) { ST_D() } // 50c0 +OP(sf_8_d) { SF_D() } // 51c0 +OP(shi_8_d) { Scc_D(HI) } // 52c0 +OP(sls_8_d) { Scc_D(LS) } // 53c0 +OP(scc_8_d) { Scc_D(CC) } // 54c0 +OP(scs_8_d) { Scc_D(CS) } // 55c0 +OP(sne_8_d) { Scc_D(NE) } // 56c0 +OP(seq_8_d) { Scc_D(EQ) } // 57c0 +OP(svc_8_d) { Scc_D(VC) } // 58c0 +OP(svs_8_d) { Scc_D(VS) } // 59c0 +OP(spl_8_d) { Scc_D(PL) } // 5ac0 +OP(smi_8_d) { Scc_D(MI) } // 5bc0 +OP(sge_8_d) { Scc_D(GE) } // 5cc0 +OP(slt_8_d) { Scc_D(LT) } // 5dc0 +OP(sgt_8_d) { Scc_D(GT) } // 5ec0 +OP(sle_8_d) { Scc_D(LE) } // 5fc0 + +OP(st_8_ai) { ST(AI) } // 50d0 +OP(sf_8_ai) { SF(AI) } // 51d0 +OP(shi_8_ai) { Scc(AI, HI) } // 52d0 +OP(sls_8_ai) { Scc(AI, LS) } // 53d0 +OP(scc_8_ai) { Scc(AI, CC) } // 54d0 +OP(scs_8_ai) { Scc(AI, CS) } // 55d0 +OP(sne_8_ai) { Scc(AI, NE) } // 56d0 +OP(seq_8_ai) { Scc(AI, EQ) } // 57d0 +OP(svc_8_ai) { Scc(AI, VC) } // 58d0 +OP(svs_8_ai) { Scc(AI, VS) } // 59d0 +OP(spl_8_ai) { Scc(AI, PL) } // 5ad0 +OP(smi_8_ai) { Scc(AI, MI) } // 5bd0 +OP(sge_8_ai) { Scc(AI, GE) } // 5cd0 +OP(slt_8_ai) { Scc(AI, LT) } // 5dd0 +OP(sgt_8_ai) { Scc(AI, GT) } // 5ed0 +OP(sle_8_ai) { Scc(AI, LE) } // 5fd0 + +OP(st_8_pi) { ST(PI) } // 50d8 +OP(sf_8_pi) { SF(PI) } // 51d8 +OP(shi_8_pi) { Scc(PI, HI) } // 52d8 +OP(sls_8_pi) { Scc(PI, LS) } // 53d8 +OP(scc_8_pi) { Scc(PI, CC) } // 54d8 +OP(scs_8_pi) { Scc(PI, CS) } // 55d8 +OP(sne_8_pi) { Scc(PI, NE) } // 56d8 +OP(seq_8_pi) { Scc(PI, EQ) } // 57d8 +OP(svc_8_pi) { Scc(PI, VC) } // 58d8 +OP(svs_8_pi) { Scc(PI, VS) } // 59d8 +OP(spl_8_pi) { Scc(PI, PL) } // 5ad8 +OP(smi_8_pi) { Scc(PI, MI) } // 5bd8 +OP(sge_8_pi) { Scc(PI, GE) } // 5cd8 +OP(slt_8_pi) { Scc(PI, LT) } // 5dd8 +OP(sgt_8_pi) { Scc(PI, GT) } // 5ed8 +OP(sle_8_pi) { Scc(PI, LE) } // 5fd8 + +OP(st_8_pd) { ST(PD) } // 50e0 +OP(sf_8_pd) { SF(PD) } // 51e0 +OP(shi_8_pd) { Scc(PD, HI) } // 52e0 +OP(sls_8_pd) { Scc(PD, LS) } // 53e0 +OP(scc_8_pd) { Scc(PD, CC) } // 54e0 +OP(scs_8_pd) { Scc(PD, CS) } // 55e0 +OP(sne_8_pd) { Scc(PD, NE) } // 56e0 +OP(seq_8_pd) { Scc(PD, EQ) } // 57e0 +OP(svc_8_pd) { Scc(PD, VC) } // 58e0 +OP(svs_8_pd) { Scc(PD, VS) } // 59e0 +OP(spl_8_pd) { Scc(PD, PL) } // 5ae0 +OP(smi_8_pd) { Scc(PD, MI) } // 5be0 +OP(sge_8_pd) { Scc(PD, GE) } // 5ce0 +OP(slt_8_pd) { Scc(PD, LT) } // 5de0 +OP(sgt_8_pd) { Scc(PD, GT) } // 5ee0 +OP(sle_8_pd) { Scc(PD, LE) } // 5fe0 + +OP(st_8_di) { ST(DI) } // 50e8 +OP(sf_8_di) { SF(DI) } // 51e8 +OP(shi_8_di) { Scc(DI, HI) } // 52e8 +OP(sls_8_di) { Scc(DI, LS) } // 53e8 +OP(scc_8_di) { Scc(DI, CC) } // 54e8 +OP(scs_8_di) { Scc(DI, CS) } // 55e8 +OP(sne_8_di) { Scc(DI, NE) } // 56e8 +OP(seq_8_di) { Scc(DI, EQ) } // 57e8 +OP(svc_8_di) { Scc(DI, VC) } // 58e8 +OP(svs_8_di) { Scc(DI, VS) } // 59e8 +OP(spl_8_di) { Scc(DI, PL) } // 5ae8 +OP(smi_8_di) { Scc(DI, MI) } // 5be8 +OP(sge_8_di) { Scc(DI, GE) } // 5ce8 +OP(slt_8_di) { Scc(DI, LT) } // 5de8 +OP(sgt_8_di) { Scc(DI, GT) } // 5ee8 +OP(sle_8_di) { Scc(DI, LE) } // 5fe8 + +OP(st_8_ix) { ST(IX) } // 50f0 +OP(sf_8_ix) { SF(IX) } // 51f0 +OP(shi_8_ix) { Scc(IX, HI) } // 52f0 +OP(sls_8_ix) { Scc(IX, LS) } // 53f0 +OP(scc_8_ix) { Scc(IX, CC) } // 54f0 +OP(scs_8_ix) { Scc(IX, CS) } // 55f0 +OP(sne_8_ix) { Scc(IX, NE) } // 56f0 +OP(seq_8_ix) { Scc(IX, EQ) } // 57f0 +OP(svc_8_ix) { Scc(IX, VC) } // 58f0 +OP(svs_8_ix) { Scc(IX, VS) } // 59f0 +OP(spl_8_ix) { Scc(IX, PL) } // 5af0 +OP(smi_8_ix) { Scc(IX, MI) } // 5bf0 +OP(sge_8_ix) { Scc(IX, GE) } // 5cf0 +OP(slt_8_ix) { Scc(IX, LT) } // 5df0 +OP(sgt_8_ix) { Scc(IX, GT) } // 5ef0 +OP(sle_8_ix) { Scc(IX, LE) } // 5ff0 + +OP(st_8_aw) { ST(AW) } // 50f8 +OP(sf_8_aw) { SF(AW) } // 51f8 +OP(shi_8_aw) { Scc(AW, HI) } // 52f8 +OP(sls_8_aw) { Scc(AW, LS) } // 53f8 +OP(scc_8_aw) { Scc(AW, CC) } // 54f8 +OP(scs_8_aw) { Scc(AW, CS) } // 55f8 +OP(sne_8_aw) { Scc(AW, NE) } // 56f8 +OP(seq_8_aw) { Scc(AW, EQ) } // 57f8 +OP(svc_8_aw) { Scc(AW, VC) } // 58f8 +OP(svs_8_aw) { Scc(AW, VS) } // 59f8 +OP(spl_8_aw) { Scc(AW, PL) } // 5af8 +OP(smi_8_aw) { Scc(AW, MI) } // 5bf8 +OP(sge_8_aw) { Scc(AW, GE) } // 5cf8 +OP(slt_8_aw) { Scc(AW, LT) } // 5df8 +OP(sgt_8_aw) { Scc(AW, GT) } // 5ef8 +OP(sle_8_aw) { Scc(AW, LE) } // 5ff8 + +OP(st_8_al) { ST(AL) } // 50f9 +OP(sf_8_al) { SF(AL) } // 51f9 +OP(shi_8_al) { Scc(AL, HI) } // 52f9 +OP(sls_8_al) { Scc(AL, LS) } // 53f9 +OP(scc_8_al) { Scc(AL, CC) } // 54f9 +OP(scs_8_al) { Scc(AL, CS) } // 55f9 +OP(sne_8_al) { Scc(AL, NE) } // 56f9 +OP(seq_8_al) { Scc(AL, EQ) } // 57f9 +OP(svc_8_al) { Scc(AL, VC) } // 58f9 +OP(svs_8_al) { Scc(AL, VS) } // 59f9 +OP(spl_8_al) { Scc(AL, PL) } // 5af9 +OP(smi_8_al) { Scc(AL, MI) } // 5bf9 +OP(sge_8_al) { Scc(AL, GE) } // 5cf9 +OP(slt_8_al) { Scc(AL, LT) } // 5df9 +OP(sgt_8_al) { Scc(AL, GT) } // 5ef9 +OP(sle_8_al) { Scc(AL, LE) } // 5ff9 + +OP(st_8_pi7) { ST(PI7) } // 50df +OP(sf_8_pi7) { SF(PI7) } // 51df +OP(shi_8_pi7) { Scc(PI7, HI) } // 52df +OP(sls_8_pi7) { Scc(PI7, LS) } // 53df +OP(scc_8_pi7) { Scc(PI7, CC) } // 54df +OP(scs_8_pi7) { Scc(PI7, CS) } // 55df +OP(sne_8_pi7) { Scc(PI7, NE) } // 56df +OP(seq_8_pi7) { Scc(PI7, EQ) } // 57df +OP(svc_8_pi7) { Scc(PI7, VC) } // 58df +OP(svs_8_pi7) { Scc(PI7, VS) } // 59df +OP(spl_8_pi7) { Scc(PI7, PL) } // 5adf +OP(smi_8_pi7) { Scc(PI7, MI) } // 5bdf +OP(sge_8_pi7) { Scc(PI7, GE) } // 5cdf +OP(slt_8_pi7) { Scc(PI7, LT) } // 5ddf +OP(sgt_8_pi7) { Scc(PI7, GT) } // 5edf +OP(sle_8_pi7) { Scc(PI7, LE) } // 5fdf + +OP(st_8_pd7) { ST(PD7) } // 50e7 +OP(sf_8_pd7) { SF(PD7) } // 51e7 +OP(shi_8_pd7) { Scc(PD7, HI) } // 52e7 +OP(sls_8_pd7) { Scc(PD7, LS) } // 53e7 +OP(scc_8_pd7) { Scc(PD7, CC) } // 54e7 +OP(scs_8_pd7) { Scc(PD7, CS) } // 55e7 +OP(sne_8_pd7) { Scc(PD7, NE) } // 56e7 +OP(seq_8_pd7) { Scc(PD7, EQ) } // 57e7 +OP(svc_8_pd7) { Scc(PD7, VC) } // 58e7 +OP(svs_8_pd7) { Scc(PD7, VS) } // 59e7 +OP(spl_8_pd7) { Scc(PD7, PL) } // 5ae7 +OP(smi_8_pd7) { Scc(PD7, MI) } // 5be7 +OP(sge_8_pd7) { Scc(PD7, GE) } // 5ce7 +OP(slt_8_pd7) { Scc(PD7, LT) } // 5de7 +OP(sgt_8_pd7) { Scc(PD7, GT) } // 5ee7 +OP(sle_8_pd7) { Scc(PD7, LE) } // 5fe7 + +/*----------------------------------------------------------------------------- + DBcc Test Condition, Decrement, and Branch +-----------------------------------------------------------------------------*/ + +OP(dbt_16) { DBT() } // 50c8 +OP(dbf_16) { DBF() } // 51c8 +OP(dbhi_16) { DBcc(HI) } // 52c8 +OP(dbls_16) { DBcc(LS) } // 53c8 +OP(dbcc_16) { DBcc(CC) } // 54c8 +OP(dbcs_16) { DBcc(CS) } // 55c8 +OP(dbne_16) { DBcc(NE) } // 56c8 +OP(dbeq_16) { DBcc(EQ) } // 57c8 +OP(dbvc_16) { DBcc(VC) } // 58c8 +OP(dbvs_16) { DBcc(VS) } // 59c8 +OP(dbpl_16) { DBcc(PL) } // 5ac8 +OP(dbmi_16) { DBcc(MI) } // 5bc8 +OP(dbge_16) { DBcc(GE) } // 5cc8 +OP(dblt_16) { DBcc(LT) } // 5dc8 +OP(dbgt_16) { DBcc(GT) } // 5ec8 +OP(dble_16) { DBcc(LE) } // 5fc8 + +/*----------------------------------------------------------------------------- + ADDQ Add Quick +-----------------------------------------------------------------------------*/ + +OP(addq_8_d) { ADDQ(8, D, D) } // 5000 +OP(addq_8_ai) { ADDQ(8, M, AI) } // 5010 +OP(addq_8_pi) { ADDQ(8, M, PI) } // 5018 +OP(addq_8_pd) { ADDQ(8, M, PD) } // 5020 +OP(addq_8_di) { ADDQ(8, M, DI) } // 5028 +OP(addq_8_ix) { ADDQ(8, M, IX) } // 5030 +OP(addq_8_aw) { ADDQ(8, M, AW) } // 5038 +OP(addq_8_al) { ADDQ(8, M, AL) } // 5039 +OP(addq_8_pi7) { ADDQ(8, M, PI7) } // 501f +OP(addq_8_pd7) { ADDQ(8, M, PD7) } // 5027 + +OP(addq_16_d) { ADDQ(16, D, D) } // 5040 +OP(addq_16_a) { ADDQ_A(16) } // 5048 +OP(addq_16_ai) { ADDQ(16, M, AI) } // 5050 +OP(addq_16_pi) { ADDQ(16, M, PI) } // 5058 +OP(addq_16_pd) { ADDQ(16, M, PD) } // 5060 +OP(addq_16_di) { ADDQ(16, M, DI) } // 5068 +OP(addq_16_ix) { ADDQ(16, M, IX) } // 5070 +OP(addq_16_aw) { ADDQ(16, M, AW) } // 5078 +OP(addq_16_al) { ADDQ(16, M, AL) } // 5079 + +OP(addq_32_d) { ADDQ(32, D, D) } // 5080 +OP(addq_32_a) { ADDQ_A(32) } // 5088 +OP(addq_32_ai) { ADDQ(32, M, AI) } // 5090 +OP(addq_32_pi) { ADDQ(32, M, PI) } // 5098 +OP(addq_32_pd) { ADDQ(32, M, PD) } // 50a0 +OP(addq_32_di) { ADDQ(32, M, DI) } // 50a8 +OP(addq_32_ix) { ADDQ(32, M, IX) } // 50b0 +OP(addq_32_aw) { ADDQ(32, M, AW) } // 50b8 +OP(addq_32_al) { ADDQ(32, M, AL) } // 50b9 + +/*----------------------------------------------------------------------------- + SUBQ Subtract Quick +-----------------------------------------------------------------------------*/ + +OP(subq_8_d) { SUBQ(8, D, D) } // 5100 +OP(subq_8_ai) { SUBQ(8, M, AI) } // 5110 +OP(subq_8_pi) { SUBQ(8, M, PI) } // 5118 +OP(subq_8_pd) { SUBQ(8, M, PD) } // 5120 +OP(subq_8_di) { SUBQ(8, M, DI) } // 5128 +OP(subq_8_ix) { SUBQ(8, M, IX) } // 5130 +OP(subq_8_aw) { SUBQ(8, M, AW) } // 5138 +OP(subq_8_al) { SUBQ(8, M, AL) } // 5139 +OP(subq_8_pi7) { SUBQ(8, M, PI7) } // 511f +OP(subq_8_pd7) { SUBQ(8, M, PD7) } // 5127 + +OP(subq_16_d) { SUBQ(16, D, D) } // 5140 +OP(subq_16_a) { SUBQ_A(16) } // 5148 +OP(subq_16_ai) { SUBQ(16, M, AI) } // 5150 +OP(subq_16_pi) { SUBQ(16, M, PI) } // 5158 +OP(subq_16_pd) { SUBQ(16, M, PD) } // 5160 +OP(subq_16_di) { SUBQ(16, M, DI) } // 5168 +OP(subq_16_ix) { SUBQ(16, M, IX) } // 5170 +OP(subq_16_aw) { SUBQ(16, M, AW) } // 5178 +OP(subq_16_al) { SUBQ(16, M, AL) } // 5179 + +OP(subq_32_d) { SUBQ(32, D, D) } // 5180 +OP(subq_32_a) { SUBQ_A(32) } // 5188 +OP(subq_32_ai) { SUBQ(32, M, AI) } // 5190 +OP(subq_32_pi) { SUBQ(32, M, PI) } // 5198 +OP(subq_32_pd) { SUBQ(32, M, PD) } // 51a0 +OP(subq_32_di) { SUBQ(32, M, DI) } // 51a8 +OP(subq_32_ix) { SUBQ(32, M, IX) } // 51b0 +OP(subq_32_aw) { SUBQ(32, M, AW) } // 51b8 +OP(subq_32_al) { SUBQ(32, M, AL) } // 51b9 + +/****************************************************************************** + OPCODE $6xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + Bcc Branch Conditionally +-----------------------------------------------------------------------------*/ + +OP(bhi_8) { Bcc_8(HI) } // 6201 +OP(bls_8) { Bcc_8(LS) } // 6301 +OP(bcc_8) { Bcc_8(CC) } // 6401 +OP(bcs_8) { Bcc_8(CS) } // 6501 +OP(bne_8) { Bcc_8(NE) } // 6601 +OP(beq_8) { Bcc_8(EQ) } // 6701 +OP(bvc_8) { Bcc_8(VC) } // 6801 +OP(bvs_8) { Bcc_8(VS) } // 6901 +OP(bpl_8) { Bcc_8(PL) } // 6a01 +OP(bmi_8) { Bcc_8(MI) } // 6b01 +OP(bge_8) { Bcc_8(GE) } // 6c01 +OP(blt_8) { Bcc_8(LT) } // 6d01 +OP(bgt_8) { Bcc_8(GT) } // 6e01 +OP(ble_8) { Bcc_8(LE) } // 6f01 + +OP(bhi_16) { Bcc_16(HI) } // 6200 +OP(bls_16) { Bcc_16(LS) } // 6300 +OP(bcc_16) { Bcc_16(CC) } // 6400 +OP(bcs_16) { Bcc_16(CS) } // 6500 +OP(bne_16) { Bcc_16(NE) } // 6600 +OP(beq_16) { Bcc_16(EQ) } // 6700 +OP(bvc_16) { Bcc_16(VC) } // 6800 +OP(bvs_16) { Bcc_16(VS) } // 6900 +OP(bpl_16) { Bcc_16(PL) } // 6a00 +OP(bmi_16) { Bcc_16(MI) } // 6b00 +OP(bge_16) { Bcc_16(GE) } // 6c00 +OP(blt_16) { Bcc_16(LT) } // 6d00 +OP(bgt_16) { Bcc_16(GT) } // 6e00 +OP(ble_16) { Bcc_16(LE) } // 6f00 + +/*----------------------------------------------------------------------------- + BRA Branch Always +-----------------------------------------------------------------------------*/ + +// 6001 +OP(bra_8) +{ + PC += (INT32)(INT8)Opcode; + RET(10) +} + +// 6000 +OP(bra_16) +{ + PC += READSX_IMM_16(); + ADJUST_PC() + SET_PC(PC) + RET(10) +} + +/*----------------------------------------------------------------------------- + BSR Branch to Subroutine +-----------------------------------------------------------------------------*/ + +// 6101 +OP(bsr_8) +{ + res = GET_PC(); + PUSH_32_F(res) + PC += MAKE_INT_8(Opcode); + RET(18) +} + +// 6100 +OP(bsr_16) +{ + res = READSX_IMM_16(); + ADJUST_PC() + PUSH_32_F(PC + 2) + PC += res; + SET_PC(PC) + RET(18) +} + +/****************************************************************************** + OPCODE $7xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + MOVEQ Move Quick +-----------------------------------------------------------------------------*/ + +// 7000 +OP(moveq_32) +{ + res = MAKE_INT_8(Opcode); + FLAG_C = CFLAG_CLEAR; + FLAG_V = VFLAG_CLEAR; + FLAG_N = res; + FLAG_Z = res; + EA_WRITE_RESULT(32, D, X) + RET(4) +} + +/****************************************************************************** + OPCODE $8xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + OR inclusive-OR logical +-----------------------------------------------------------------------------*/ + +OP(or_8_er_d) { OR_ER(8, D) } // 8000 +OP(or_8_er_ai) { OR_ER(8, AI) } // 8010 +OP(or_8_er_pi) { OR_ER(8, PI) } // 8018 +OP(or_8_er_pd) { OR_ER(8, PD) } // 8020 +OP(or_8_er_di) { OR_ER(8, DI) } // 8028 +OP(or_8_er_ix) { OR_ER(8, IX) } // 8030 +OP(or_8_er_aw) { OR_ER(8, AW) } // 8038 +OP(or_8_er_al) { OR_ER(8, AL) } // 8039 +OP(or_8_er_pcdi) { OR_ER(8, PCDI) } // 803a +OP(or_8_er_pcix) { OR_ER(8, PCIX) } // 803b +OP(or_8_er_i) { OR_ER(8, I) } // 803c +OP(or_8_er_pi7) { OR_ER(8, PI7) } // 801f +OP(or_8_er_pd7) { OR_ER(8, PD7) } // 8027 + +OP(or_16_er_d) { OR_ER(16, D) } // 8040 +OP(or_16_er_ai) { OR_ER(16, AI) } // 8050 +OP(or_16_er_pi) { OR_ER(16, PI) } // 8058 +OP(or_16_er_pd) { OR_ER(16, PD) } // 8060 +OP(or_16_er_di) { OR_ER(16, DI) } // 8068 +OP(or_16_er_ix) { OR_ER(16, IX) } // 8070 +OP(or_16_er_aw) { OR_ER(16, AW) } // 8078 +OP(or_16_er_al) { OR_ER(16, AL) } // 8079 +OP(or_16_er_pcdi) { OR_ER(16, PCDI) } // 807a +OP(or_16_er_pcix) { OR_ER(16, PCIX) } // 807b +OP(or_16_er_i) { OR_ER(16, I) } // 807c + +OP(or_32_er_d) { OR_ER_RI32(D) } // 8080 +OP(or_32_er_ai) { OR_ER_RI32(AI) } // 8090 +OP(or_32_er_pi) { OR_ER(32, PI) } // 8098 +OP(or_32_er_pd) { OR_ER(32, PD) } // 80a0 +OP(or_32_er_di) { OR_ER(32, DI) } // 80a8 +OP(or_32_er_ix) { OR_ER(32, IX) } // 80b0 +OP(or_32_er_aw) { OR_ER(32, AW) } // 80b8 +OP(or_32_er_al) { OR_ER(32, AL) } // 80b9 +OP(or_32_er_pcdi) { OR_ER(32, PCDI) } // 80ba +OP(or_32_er_pcix) { OR_ER(32, PCIX) } // 80bb +OP(or_32_er_i) { OR_ER_RI32(I) } // 80bc + +OP(or_8_re_ai) { OR_RE(8, AI) } // 8110 +OP(or_8_re_pi) { OR_RE(8, PI) } // 8118 +OP(or_8_re_pd) { OR_RE(8, PD) } // 8120 +OP(or_8_re_di) { OR_RE(8, DI) } // 8128 +OP(or_8_re_ix) { OR_RE(8, IX) } // 8130 +OP(or_8_re_aw) { OR_RE(8, AW) } // 8138 +OP(or_8_re_al) { OR_RE(8, AL) } // 8139 +OP(or_8_re_pi7) { OR_RE(8, PI7) } // 811f +OP(or_8_re_pd7) { OR_RE(8, PD7) } // 8127 + +OP(or_16_re_ai) { OR_RE(16, AI) } // 8150 +OP(or_16_re_pi) { OR_RE(16, PI) } // 8158 +OP(or_16_re_pd) { OR_RE(16, PD) } // 8160 +OP(or_16_re_di) { OR_RE(16, DI) } // 8168 +OP(or_16_re_ix) { OR_RE(16, IX) } // 8170 +OP(or_16_re_aw) { OR_RE(16, AW) } // 8178 +OP(or_16_re_al) { OR_RE(16, AL) } // 8179 + +OP(or_32_re_ai) { OR_RE(32, AI) } // 8190 +OP(or_32_re_pi) { OR_RE(32, PI) } // 8198 +OP(or_32_re_pd) { OR_RE(32, PD) } // 81a0 +OP(or_32_re_di) { OR_RE(32, DI) } // 81a8 +OP(or_32_re_ix) { OR_RE(32, IX) } // 81b0 +OP(or_32_re_aw) { OR_RE(32, AW) } // 81b8 +OP(or_32_re_al) { OR_RE(32, AL) } // 81b9 + +/*----------------------------------------------------------------------------- + SBCD Subtract Decimal with Extend +-----------------------------------------------------------------------------*/ + +OP(sbcd_8_rr) { SBCD(D, D, D) } // 8100 +OP(sbcd_8_mm) { SBCD(M, PD, PD) } // 8108 +OP(sbcd_8_mm_ay7) { SBCD(M, PD, PD7) } // 810f +OP(sbcd_8_mm_ax7) { SBCD(M, PD7, PD) } // 8f08 +OP(sbcd_8_mm_axy7) { SBCD(M, PD7, PD7) } // 8f0f + +/*----------------------------------------------------------------------------- + DIVU Unsigned Divide +-----------------------------------------------------------------------------*/ + +OP(divu_16_d) { DIVU(D) } // 80c0 +OP(divu_16_ai) { DIVU(AI) } // 80d0 +OP(divu_16_pi) { DIVU(PI) } // 80d8 +OP(divu_16_pd) { DIVU(PD) } // 80e0 +OP(divu_16_di) { DIVU(DI) } // 80e8 +OP(divu_16_ix) { DIVU(IX) } // 80f0 +OP(divu_16_aw) { DIVU(AW) } // 80f8 +OP(divu_16_al) { DIVU(AL) } // 80f9 +OP(divu_16_pcdi) { DIVU(PCDI) } // 80fa +OP(divu_16_pcix) { DIVU(PCIX) } // 80fb +OP(divu_16_i) { DIVU(I) } // 80fc + +/*----------------------------------------------------------------------------- + DIVS Signed Divide +-----------------------------------------------------------------------------*/ + +OP(divs_16_d) { DIVS(D) } // 81c0 +OP(divs_16_ai) { DIVS(AI) } // 81d0 +OP(divs_16_pi) { DIVS(PI) } // 81d8 +OP(divs_16_pd) { DIVS(PD) } // 81e0 +OP(divs_16_di) { DIVS(DI) } // 81e8 +OP(divs_16_ix) { DIVS(IX) } // 81f0 +OP(divs_16_aw) { DIVS(AW) } // 81f8 +OP(divs_16_al) { DIVS(AL) } // 81f9 +OP(divs_16_pcdi) { DIVS(PCDI) } // 81fa +OP(divs_16_pcix) { DIVS(PCIX) } // 81fb +OP(divs_16_i) { DIVS(I) } // 81fc + +/****************************************************************************** + OPCODE $9xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + SUB Subtract +-----------------------------------------------------------------------------*/ + +OP(sub_8_er_d) { SUB_ER(8, D) } // 9000 +OP(sub_8_er_ai) { SUB_ER(8, AI) } // 9010 +OP(sub_8_er_pi) { SUB_ER(8, PI) } // 9018 +OP(sub_8_er_pd) { SUB_ER(8, PD) } // 9020 +OP(sub_8_er_di) { SUB_ER(8, DI) } // 9028 +OP(sub_8_er_ix) { SUB_ER(8, IX) } // 9030 +OP(sub_8_er_aw) { SUB_ER(8, AW) } // 9038 +OP(sub_8_er_al) { SUB_ER(8, AL) } // 9039 +OP(sub_8_er_pcdi) { SUB_ER(8, PCDI) } // 903a +OP(sub_8_er_pcix) { SUB_ER(8, PCIX) } // 903b +OP(sub_8_er_i) { SUB_ER(8, I) } // 903c +OP(sub_8_er_pi7) { SUB_ER(8, PI7) } // 901f +OP(sub_8_er_pd7) { SUB_ER(8, PD7) } // 9027 + +OP(sub_16_er_d) { SUB_ER(16, D) } // 9040 +OP(sub_16_er_a) { SUB_ER(16, A) } // 9048 +OP(sub_16_er_ai) { SUB_ER(16, AI) } // 9050 +OP(sub_16_er_pi) { SUB_ER(16, PI) } // 9058 +OP(sub_16_er_pd) { SUB_ER(16, PD) } // 9060 +OP(sub_16_er_di) { SUB_ER(16, DI) } // 9068 +OP(sub_16_er_ix) { SUB_ER(16, IX) } // 9070 +OP(sub_16_er_aw) { SUB_ER(16, AW) } // 9078 +OP(sub_16_er_al) { SUB_ER(16, AL) } // 9079 +OP(sub_16_er_pcdi) { SUB_ER(16, PCDI) } // 907a +OP(sub_16_er_pcix) { SUB_ER(16, PCIX) } // 907b +OP(sub_16_er_i) { SUB_ER(16, I) } // 907c + +OP(sub_32_er_d) { SUB_ER_RI32(D) } // 9080 +OP(sub_32_er_a) { SUB_ER_RI32(A) } // 9088 +OP(sub_32_er_ai) { SUB_ER(32, AI) } // 9090 +OP(sub_32_er_pi) { SUB_ER(32, PI) } // 9098 +OP(sub_32_er_pd) { SUB_ER(32, PD) } // 90a0 +OP(sub_32_er_di) { SUB_ER(32, DI) } // 90a8 +OP(sub_32_er_ix) { SUB_ER(32, IX) } // 90b0 +OP(sub_32_er_aw) { SUB_ER(32, AW) } // 90b8 +OP(sub_32_er_al) { SUB_ER(32, AL) } // 90b9 +OP(sub_32_er_pcdi) { SUB_ER(32, PCDI) } // 90ba +OP(sub_32_er_pcix) { SUB_ER(32, PCIX) } // 90bb +OP(sub_32_er_i) { SUB_ER_RI32(I) } // 90bc + +OP(sub_8_re_ai) { SUB_RE(8, AI) } // 9110 +OP(sub_8_re_pi) { SUB_RE(8, PI) } // 9118 +OP(sub_8_re_pd) { SUB_RE(8, PD) } // 9120 +OP(sub_8_re_di) { SUB_RE(8, DI) } // 9128 +OP(sub_8_re_ix) { SUB_RE(8, IX) } // 9130 +OP(sub_8_re_aw) { SUB_RE(8, AW) } // 9138 +OP(sub_8_re_al) { SUB_RE(8, AL) } // 9139 +OP(sub_8_re_pi7) { SUB_RE(8, PI7) } // 911f +OP(sub_8_re_pd7) { SUB_RE(8, PD7) } // 9127 + +OP(sub_16_re_ai) { SUB_RE(16, AI) } // 9150 +OP(sub_16_re_pi) { SUB_RE(16, PI) } // 9158 +OP(sub_16_re_pd) { SUB_RE(16, PD) } // 9160 +OP(sub_16_re_di) { SUB_RE(16, DI) } // 9168 +OP(sub_16_re_ix) { SUB_RE(16, IX) } // 9170 +OP(sub_16_re_aw) { SUB_RE(16, AW) } // 9178 +OP(sub_16_re_al) { SUB_RE(16, AL) } // 9179 + +OP(sub_32_re_ai) { SUB_RE(32, AI) } // 9190 +OP(sub_32_re_pi) { SUB_RE(32, PI) } // 9198 +OP(sub_32_re_pd) { SUB_RE(32, PD) } // 91a0 +OP(sub_32_re_di) { SUB_RE(32, DI) } // 91a8 +OP(sub_32_re_ix) { SUB_RE(32, IX) } // 91b0 +OP(sub_32_re_aw) { SUB_RE(32, AW) } // 91b8 +OP(sub_32_re_al) { SUB_RE(32, AL) } // 91b9 + +/*----------------------------------------------------------------------------- + SUBX Subtract with Extend +-----------------------------------------------------------------------------*/ + +OP(subx_8_rr) { SUBX(8, D, D, D) } // 9100 +OP(subx_16_rr) { SUBX(16, D, D, D) } // 9140 +OP(subx_32_rr) { SUBX(32, D, D, D) } // 9180 + +OP(subx_8_mm) { SUBX(8, M, PD, PD) } // 9108 +OP(subx_16_mm) { SUBX(16, M, PD, PD) } // 9148 +OP(subx_32_mm) { SUBX(32, M, PD, PD) } // 9188 + +OP(subx_8_mm_ay7) { SUBX(8, M, PD, PD7) } // 910f +OP(subx_8_mm_ax7) { SUBX(8, M, PD7, PD) } // 9f08 +OP(subx_8_mm_axy7) { SUBX(8, M, PD7, PD7) } // 9f0f + +/*----------------------------------------------------------------------------- + SUBA Subtract Address +-----------------------------------------------------------------------------*/ + +OP(suba_16_d) { SUBA(16, D) } // 0440 +OP(suba_16_a) { SUBA(16, A) } // 0448 +OP(suba_16_ai) { SUBA(16, AI) } // 0450 +OP(suba_16_pi) { SUBA(16, PI) } // 0458 +OP(suba_16_pd) { SUBA(16, PD) } // 0460 +OP(suba_16_di) { SUBA(16, DI) } // 0468 +OP(suba_16_ix) { SUBA(16, IX) } // 0470 +OP(suba_16_aw) { SUBA(16, AW) } // 0478 +OP(suba_16_al) { SUBA(16, AL) } // 0479 +OP(suba_16_pcdi) { SUBA(16, PCDI) } // 047a +OP(suba_16_pcix) { SUBA(16, PCIX) } // 047b +OP(suba_16_i) { SUBA(16, I) } // 047c + +OP(suba_32_d) { SUBA_RI32(D) } // 0480 +OP(suba_32_a) { SUBA_RI32(A) } // 0488 +OP(suba_32_ai) { SUBA(32, AI) } // 0490 +OP(suba_32_pi) { SUBA(32, PI) } // 0498 +OP(suba_32_pd) { SUBA(32, PD) } // 04a0 +OP(suba_32_di) { SUBA(32, DI) } // 04a8 +OP(suba_32_ix) { SUBA(32, IX) } // 04b0 +OP(suba_32_aw) { SUBA(32, AW) } // 04b8 +OP(suba_32_al) { SUBA(32, AL) } // 04b9 +OP(suba_32_pcdi) { SUBA(32, PCDI) } // 04ba +OP(suba_32_pcix) { SUBA(32, PCIX) } // 04bb +OP(suba_32_i) { SUBA_RI32(I) } // 04bc + +/****************************************************************************** + OPCODE $Axxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + Line-A +-----------------------------------------------------------------------------*/ + +// a000 +OP(1010) +{ + SWAP_SP() + PC -= 2; + EXCEPTION(C68K_1010_EX) + RET(34) +} + +/****************************************************************************** + OPCODE $Bxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + CMP Compare +-----------------------------------------------------------------------------*/ + +OP(cmp_8_d) { CMP(8, D) } // b000 +OP(cmp_8_ai) { CMP(8, AI) } // b010 +OP(cmp_8_pi) { CMP(8, PI) } // b018 +OP(cmp_8_pd) { CMP(8, PD) } // b020 +OP(cmp_8_di) { CMP(8, DI) } // b028 +OP(cmp_8_ix) { CMP(8, IX) } // b030 +OP(cmp_8_aw) { CMP(8, AW) } // b038 +OP(cmp_8_al) { CMP(8, AL) } // b039 +OP(cmp_8_pcdi) { CMP(8, PCDI) } // b03a +OP(cmp_8_pcix) { CMP(8, PCIX) } // b03b +OP(cmp_8_i) { CMP(8, I) } // b03c +OP(cmp_8_pi7) { CMP(8, PI7) } // b01f +OP(cmp_8_pd7) { CMP(8, PD7) } // b027 + +OP(cmp_16_d) { CMP(16, D) } // b040 +OP(cmp_16_a) { CMP(16, A) } // b048 +OP(cmp_16_ai) { CMP(16, AI) } // b050 +OP(cmp_16_pi) { CMP(16, PI) } // b058 +OP(cmp_16_pd) { CMP(16, PD) } // b060 +OP(cmp_16_di) { CMP(16, DI) } // b068 +OP(cmp_16_ix) { CMP(16, IX) } // b070 +OP(cmp_16_aw) { CMP(16, AW) } // b078 +OP(cmp_16_al) { CMP(16, AL) } // b079 +OP(cmp_16_pcdi) { CMP(16, PCDI) } // b07a +OP(cmp_16_pcix) { CMP(16, PCIX) } // b07b +OP(cmp_16_i) { CMP(16, I) } // b07c + +OP(cmp_32_d) { CMP(32, D) } // b080 +OP(cmp_32_a) { CMP(32, A) } // b088 +OP(cmp_32_ai) { CMP(32, AI) } // b090 +OP(cmp_32_pi) { CMP(32, PI) } // b098 +OP(cmp_32_pd) { CMP(32, PD) } // b0a0 +OP(cmp_32_di) { CMP(32, DI) } // b0a8 +OP(cmp_32_ix) { CMP(32, IX) } // b0b0 +OP(cmp_32_aw) { CMP(32, AW) } // b0b8 +OP(cmp_32_al) { CMP(32, AL) } // b0b9 +OP(cmp_32_pcdi) { CMP(32, PCDI) } // b0ba +OP(cmp_32_pcix) { CMP(32, PCIX) } // b0bb +OP(cmp_32_i) { CMP(32, I) } // b0bc + +/*----------------------------------------------------------------------------- + CMPM Compare Memory +-----------------------------------------------------------------------------*/ + +OP(cmpm_8) { CMPM(8, PI, PI) } // b108 +OP(cmpm_16) { CMPM(16, PI, PI) } // b148 +OP(cmpm_32) { CMPM(32, PI, PI) } // b188 + +OP(cmpm_8_ay7) { CMPM(8, PI, PI7) } // b10f +OP(cmpm_8_ax7) { CMPM(8, PI7, PI) } // bf08 +OP(cmpm_8_axy7) { CMPM(8, PI7, PI7) } // bf0f + +/*----------------------------------------------------------------------------- + EOR Exclusive-OR logical +-----------------------------------------------------------------------------*/ + +OP(eor_8_d) { EOR(8, D, D) } // b100 +OP(eor_8_ai) { EOR(8, M, AI) } // b110 +OP(eor_8_pi) { EOR(8, M, PI) } // b118 +OP(eor_8_pd) { EOR(8, M, PD) } // b120 +OP(eor_8_di) { EOR(8, M, DI) } // b128 +OP(eor_8_ix) { EOR(8, M, IX) } // b130 +OP(eor_8_aw) { EOR(8, M, AW) } // b138 +OP(eor_8_al) { EOR(8, M, AL) } // b139 +OP(eor_8_pi7) { EOR(8, M, PI7) } // b11f +OP(eor_8_pd7) { EOR(8, M, PD7) } // b127 + +OP(eor_16_d) { EOR(16, D, D) } // b140 +OP(eor_16_ai) { EOR(16, M, AI) } // b150 +OP(eor_16_pi) { EOR(16, M, PI) } // b158 +OP(eor_16_pd) { EOR(16, M, PD) } // b160 +OP(eor_16_di) { EOR(16, M, DI) } // b168 +OP(eor_16_ix) { EOR(16, M, IX) } // b170 +OP(eor_16_aw) { EOR(16, M, AW) } // b178 +OP(eor_16_al) { EOR(16, M, AL) } // b179 + +OP(eor_32_d) { EOR(32, D, D) } // b180 +OP(eor_32_ai) { EOR(32, M, AI) } // b190 +OP(eor_32_pi) { EOR(32, M, PI) } // b198 +OP(eor_32_pd) { EOR(32, M, PD) } // b1a0 +OP(eor_32_di) { EOR(32, M, DI) } // b1a8 +OP(eor_32_ix) { EOR(32, M, IX) } // b1b0 +OP(eor_32_aw) { EOR(32, M, AW) } // b1b8 +OP(eor_32_al) { EOR(32, M, AL) } // b1b9 + +/*----------------------------------------------------------------------------- + CMPA Compare +-----------------------------------------------------------------------------*/ + +OP(cmpa_16_d) { CMPA(16, D) } // b0c0 +OP(cmpa_16_a) { CMPA(16, A) } // b0c8 +OP(cmpa_16_ai) { CMPA(16, AI) } // b0d0 +OP(cmpa_16_pi) { CMPA(16, PI) } // b0d8 +OP(cmpa_16_pd) { CMPA(16, PD) } // b0e0 +OP(cmpa_16_di) { CMPA(16, DI) } // b0e8 +OP(cmpa_16_ix) { CMPA(16, IX) } // b0f0 +OP(cmpa_16_aw) { CMPA(16, AW) } // b0f8 +OP(cmpa_16_al) { CMPA(16, AL) } // b0f9 +OP(cmpa_16_pcdi) { CMPA(16, PCDI) } // b0fa +OP(cmpa_16_pcix) { CMPA(16, PCIX) } // b0fb +OP(cmpa_16_i) { CMPA(16, I) } // b0fc + +OP(cmpa_32_d) { CMPA(32, D) } // b1c0 +OP(cmpa_32_a) { CMPA(32, A) } // b1c8 +OP(cmpa_32_ai) { CMPA(32, AI) } // b1d0 +OP(cmpa_32_pi) { CMPA(32, PI) } // b1d8 +OP(cmpa_32_pd) { CMPA(32, PD) } // b1e0 +OP(cmpa_32_di) { CMPA(32, DI) } // b1e8 +OP(cmpa_32_ix) { CMPA(32, IX) } // b1f0 +OP(cmpa_32_aw) { CMPA(32, AW) } // b1f8 +OP(cmpa_32_al) { CMPA(32, AL) } // b1f9 +OP(cmpa_32_pcdi) { CMPA(32, PCDI) } // b1fa +OP(cmpa_32_pcix) { CMPA(32, PCIX) } // b1fb +OP(cmpa_32_i) { CMPA(32, I) } // b1fc + +/****************************************************************************** + OPCODE $Cxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + AND AND logical +-----------------------------------------------------------------------------*/ + +OP(and_8_er_d) { AND_ER(8, D) } // c000 +OP(and_8_er_ai) { AND_ER(8, AI) } // c010 +OP(and_8_er_pi) { AND_ER(8, PI) } // c018 +OP(and_8_er_pd) { AND_ER(8, PD) } // c020 +OP(and_8_er_di) { AND_ER(8, DI) } // c028 +OP(and_8_er_ix) { AND_ER(8, IX) } // c030 +OP(and_8_er_aw) { AND_ER(8, AW) } // c038 +OP(and_8_er_al) { AND_ER(8, AL) } // c039 +OP(and_8_er_pcdi) { AND_ER(8, PCDI) } // c03a +OP(and_8_er_pcix) { AND_ER(8, PCIX) } // c03b +OP(and_8_er_i) { AND_ER(8, I) } // c03c +OP(and_8_er_pi7) { AND_ER(8, PI7) } // c01f +OP(and_8_er_pd7) { AND_ER(8, PD7) } // c027 + +OP(and_16_er_d) { AND_ER(16, D) } // c040 +OP(and_16_er_ai) { AND_ER(16, AI) } // c050 +OP(and_16_er_pi) { AND_ER(16, PI) } // c058 +OP(and_16_er_pd) { AND_ER(16, PD) } // c060 +OP(and_16_er_di) { AND_ER(16, DI) } // c068 +OP(and_16_er_ix) { AND_ER(16, IX) } // c070 +OP(and_16_er_aw) { AND_ER(16, AW) } // c078 +OP(and_16_er_al) { AND_ER(16, AL) } // c079 +OP(and_16_er_pcdi) { AND_ER(16, PCDI) } // c07a +OP(and_16_er_pcix) { AND_ER(16, PCIX) } // c07b +OP(and_16_er_i) { AND_ER(16, I) } // c07c + +OP(and_32_er_d) { AND_ER_RI32(D) } // c080 +OP(and_32_er_ai) { AND_ER(32, AI) } // c090 +OP(and_32_er_pi) { AND_ER(32, PI) } // c098 +OP(and_32_er_pd) { AND_ER(32, PD) } // c0a0 +OP(and_32_er_di) { AND_ER(32, DI) } // c0a8 +OP(and_32_er_ix) { AND_ER(32, IX) } // c0b0 +OP(and_32_er_aw) { AND_ER(32, AW) } // c0b8 +OP(and_32_er_al) { AND_ER(32, AL) } // c0b9 +OP(and_32_er_pcdi) { AND_ER(32, PCDI) } // c0ba +OP(and_32_er_pcix) { AND_ER(32, PCIX) } // c0bb +OP(and_32_er_i) { AND_ER_RI32(I) } // c0bc + +OP(and_8_re_ai) { AND_RE(8, AI) } // c110 +OP(and_8_re_pi) { AND_RE(8, PI) } // c118 +OP(and_8_re_pd) { AND_RE(8, PD) } // c120 +OP(and_8_re_di) { AND_RE(8, DI) } // c128 +OP(and_8_re_ix) { AND_RE(8, IX) } // c130 +OP(and_8_re_aw) { AND_RE(8, AW) } // c138 +OP(and_8_re_al) { AND_RE(8, AL) } // c139 +OP(and_8_re_pi7) { AND_RE(8, PI7) } // c11f +OP(and_8_re_pd7) { AND_RE(8, PD7) } // c127 + +OP(and_16_re_ai) { AND_RE(16, AI) } // c150 +OP(and_16_re_pi) { AND_RE(16, PI) } // c158 +OP(and_16_re_pd) { AND_RE(16, PD) } // c160 +OP(and_16_re_di) { AND_RE(16, DI) } // c168 +OP(and_16_re_ix) { AND_RE(16, IX) } // c170 +OP(and_16_re_aw) { AND_RE(16, AW) } // c178 +OP(and_16_re_al) { AND_RE(16, AL) } // c179 + +OP(and_32_re_ai) { AND_RE(32, AI) } // c190 +OP(and_32_re_pi) { AND_RE(32, PI) } // c198 +OP(and_32_re_pd) { AND_RE(32, PD) } // c1a0 +OP(and_32_re_di) { AND_RE(32, DI) } // c1a8 +OP(and_32_re_ix) { AND_RE(32, IX) } // c1b0 +OP(and_32_re_aw) { AND_RE(32, AW) } // c1b8 +OP(and_32_re_al) { AND_RE(32, AL) } // c1b9 + +/*----------------------------------------------------------------------------- + ABCD Add Decimal with Extend +-----------------------------------------------------------------------------*/ + +OP(abcd_8_rr) { ABCD(D, D, D) } // c100 +OP(abcd_8_mm) { ABCD(M, PD, PD) } // c108 +OP(abcd_8_mm_ay7) { ABCD(M, PD, PD7) } // c10f +OP(abcd_8_mm_ax7) { ABCD(M, PD7, PD) } // cf08 +OP(abcd_8_mm_axy7) { ABCD(M, PD7, PD7) } // cf0f + +/*----------------------------------------------------------------------------- + MULU Unsigned Multiply +-----------------------------------------------------------------------------*/ + +OP(mulu_16_d) { MULU(D) } // c0c0 +OP(mulu_16_ai) { MULU(AI) } // c0d0 +OP(mulu_16_pi) { MULU(PI) } // c0d8 +OP(mulu_16_pd) { MULU(PD) } // c0e0 +OP(mulu_16_di) { MULU(DI) } // c0e8 +OP(mulu_16_ix) { MULU(IX) } // c0f0 +OP(mulu_16_aw) { MULU(AW) } // c0f8 +OP(mulu_16_al) { MULU(AL) } // c0f9 +OP(mulu_16_pcdi) { MULU(PCDI) } // c0fa +OP(mulu_16_pcix) { MULU(PCIX) } // c0fb +OP(mulu_16_i) { MULU(I) } // c0fc + +/*----------------------------------------------------------------------------- + MULS Signed Multiply +-----------------------------------------------------------------------------*/ + +OP(muls_16_d) { MULS(D) } // c1c0 +OP(muls_16_ai) { MULS(AI) } // c1d0 +OP(muls_16_pi) { MULS(PI) } // c1d8 +OP(muls_16_pd) { MULS(PD) } // c1e0 +OP(muls_16_di) { MULS(DI) } // c1e8 +OP(muls_16_ix) { MULS(IX) } // c1f0 +OP(muls_16_aw) { MULS(AW) } // c1f8 +OP(muls_16_al) { MULS(AL) } // c1f9 +OP(muls_16_pcdi) { MULS(PCDI) } // c1fa +OP(muls_16_pcix) { MULS(PCIX) } // c1fb +OP(muls_16_i) { MULS(I) } // c1fc + +/*----------------------------------------------------------------------------- + EXG Exchange Registers +-----------------------------------------------------------------------------*/ + +OP(exg_32_dd) { EXG(D, D) } // c140 +OP(exg_32_aa) { EXG(A, A) } // c148 +OP(exg_32_da) { EXG(D, A) } // c188 + +/****************************************************************************** + OPCODE $Dxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + ADD Add +-----------------------------------------------------------------------------*/ + +OP(add_8_er_d) { ADD_ER(8, D) } // d000 +OP(add_8_er_ai) { ADD_ER(8, AI) } // d010 +OP(add_8_er_pi) { ADD_ER(8, PI) } // d018 +OP(add_8_er_pd) { ADD_ER(8, PD) } // d020 +OP(add_8_er_di) { ADD_ER(8, DI) } // d028 +OP(add_8_er_ix) { ADD_ER(8, IX) } // d030 +OP(add_8_er_aw) { ADD_ER(8, AW) } // d038 +OP(add_8_er_al) { ADD_ER(8, AL) } // d039 +OP(add_8_er_pcdi) { ADD_ER(8, PCDI) } // d03a +OP(add_8_er_pcix) { ADD_ER(8, PCIX) } // d03b +OP(add_8_er_i) { ADD_ER(8, I) } // d03c +OP(add_8_er_pi7) { ADD_ER(8, PI7) } // d01f +OP(add_8_er_pd7) { ADD_ER(8, PD7) } // d027 + +OP(add_16_er_d) { ADD_ER(16, D) } // d040 +OP(add_16_er_a) { ADD_ER(16, A) } // d048 +OP(add_16_er_ai) { ADD_ER(16, AI) } // d050 +OP(add_16_er_pi) { ADD_ER(16, PI) } // d058 +OP(add_16_er_pd) { ADD_ER(16, PD) } // d060 +OP(add_16_er_di) { ADD_ER(16, DI) } // d068 +OP(add_16_er_ix) { ADD_ER(16, IX) } // d070 +OP(add_16_er_aw) { ADD_ER(16, AW) } // d078 +OP(add_16_er_al) { ADD_ER(16, AL) } // d079 +OP(add_16_er_pcdi) { ADD_ER(16, PCDI) } // d07a +OP(add_16_er_pcix) { ADD_ER(16, PCIX) } // d07b +OP(add_16_er_i) { ADD_ER(16, I) } // d07c + +OP(add_32_er_d) { ADD_ER_RI32(D) } // d080 +OP(add_32_er_a) { ADD_ER_RI32(A) } // d088 +OP(add_32_er_ai) { ADD_ER(32, AI) } // d090 +OP(add_32_er_pi) { ADD_ER(32, PI) } // d098 +OP(add_32_er_pd) { ADD_ER(32, PD) } // d0a0 +OP(add_32_er_di) { ADD_ER(32, DI) } // d0a8 +OP(add_32_er_ix) { ADD_ER(32, IX) } // d0b0 +OP(add_32_er_aw) { ADD_ER(32, AW) } // d0b8 +OP(add_32_er_al) { ADD_ER(32, AL) } // d0b9 +OP(add_32_er_pcdi) { ADD_ER(32, PCDI) } // d0ba +OP(add_32_er_pcix) { ADD_ER(32, PCIX) } // d0bb +OP(add_32_er_i) { ADD_ER_RI32(I) } // d0bc + +OP(add_8_re_ai) { ADD_RE(8, AI) } // d110 +OP(add_8_re_pi) { ADD_RE(8, PI) } // d118 +OP(add_8_re_pd) { ADD_RE(8, PD) } // d120 +OP(add_8_re_di) { ADD_RE(8, DI) } // d128 +OP(add_8_re_ix) { ADD_RE(8, IX) } // d130 +OP(add_8_re_aw) { ADD_RE(8, AW) } // d138 +OP(add_8_re_al) { ADD_RE(8, AL) } // d139 +OP(add_8_re_pi7) { ADD_RE(8, PI7) } // d11f +OP(add_8_re_pd7) { ADD_RE(8, PD7) } // d127 + +OP(add_16_re_ai) { ADD_RE(16, AI) } // d150 +OP(add_16_re_pi) { ADD_RE(16, PI) } // d158 +OP(add_16_re_pd) { ADD_RE(16, PD) } // d160 +OP(add_16_re_di) { ADD_RE(16, DI) } // d168 +OP(add_16_re_ix) { ADD_RE(16, IX) } // d170 +OP(add_16_re_aw) { ADD_RE(16, AW) } // d178 +OP(add_16_re_al) { ADD_RE(16, AL) } // d179 + +OP(add_32_re_ai) { ADD_RE(32, AI) } // d190 +OP(add_32_re_pi) { ADD_RE(32, PI) } // d198 +OP(add_32_re_pd) { ADD_RE(32, PD) } // d1a0 +OP(add_32_re_di) { ADD_RE(32, DI) } // d1a8 +OP(add_32_re_ix) { ADD_RE(32, IX) } // d1b0 +OP(add_32_re_aw) { ADD_RE(32, AW) } // d1b8 +OP(add_32_re_al) { ADD_RE(32, AL) } // d1b9 + +/*----------------------------------------------------------------------------- + ADDX Subtract with Extend +-----------------------------------------------------------------------------*/ + +OP(addx_8_rr) { ADDX(8, D, D, D) } // d100 +OP(addx_16_rr) { ADDX(16, D, D, D) } // d140 +OP(addx_32_rr) { ADDX(32, D, D, D) } // d180 + +OP(addx_8_mm) { ADDX(8, M, PD, PD) } // d108 +OP(addx_16_mm) { ADDX(16, M, PD, PD) } // d148 +OP(addx_32_mm) { ADDX(32, M, PD, PD) } // d188 + +OP(addx_8_mm_ay7) { ADDX(8, M, PD, PD7) } // d10f +OP(addx_8_mm_ax7) { ADDX(8, M, PD7, PD) } // df08 +OP(addx_8_mm_axy7) { ADDX(8, M, PD7, PD7) } // df0f + +/*----------------------------------------------------------------------------- + ADDA Add Address +-----------------------------------------------------------------------------*/ + +OP(adda_16_d) { ADDA(16, D) } // 0440 +OP(adda_16_a) { ADDA(16, A) } // 0448 +OP(adda_16_ai) { ADDA(16, AI) } // 0450 +OP(adda_16_pi) { ADDA(16, PI) } // 0458 +OP(adda_16_pd) { ADDA(16, PD) } // 0460 +OP(adda_16_di) { ADDA(16, DI) } // 0468 +OP(adda_16_ix) { ADDA(16, IX) } // 0470 +OP(adda_16_aw) { ADDA(16, AW) } // 0478 +OP(adda_16_al) { ADDA(16, AL) } // 0479 +OP(adda_16_pcdi) { ADDA(16, PCDI) } // 047a +OP(adda_16_pcix) { ADDA(16, PCIX) } // 047b +OP(adda_16_i) { ADDA(16, I) } // 047c + +OP(adda_32_d) { ADDA_RI32(D) } // 0480 +OP(adda_32_a) { ADDA_RI32(A) } // 0488 +OP(adda_32_ai) { ADDA(32, AI) } // 0490 +OP(adda_32_pi) { ADDA(32, PI) } // 0498 +OP(adda_32_pd) { ADDA(32, PD) } // 04a0 +OP(adda_32_di) { ADDA(32, DI) } // 04a8 +OP(adda_32_ix) { ADDA(32, IX) } // 04b0 +OP(adda_32_aw) { ADDA(32, AW) } // 04b8 +OP(adda_32_al) { ADDA(32, AL) } // 04b9 +OP(adda_32_pcdi) { ADDA(32, PCDI) } // 04ba +OP(adda_32_pcix) { ADDA(32, PCIX) } // 04bb +OP(adda_32_i) { ADDA_RI32(I) } // 04bc + +/****************************************************************************** + OPCODE $Exxx +******************************************************************************/ + +// e000 +OP(asr_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = (INT32)(INT8)DY; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((INT32)src) >> sft; + CPU->flag_N = res >> 0; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e040 +OP(asr_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = (INT32)(INT16)DY; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((INT32)src) >> sft; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e080 +OP(asr_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = (INT32)DY; + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((INT32)src) >> sft; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e008 +OP(lsr_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e048 +OP(lsr_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e088 +OP(lsr_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e010 +OP(roxr_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src >> sft) | (src << (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e050 +OP(roxr_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src >> sft) | (src << (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e090 +OP(roxr_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + if (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))); + else res = (src >> sft) | (src << (33 - sft)) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + sft))); + CPU->flag_X = CPU->flag_C; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e018 +OP(ror_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + CPU->flag_V = 0; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = (src >> sft) | (src << (8 - sft)); + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e058 +OP(ror_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + CPU->flag_V = 0; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = (src >> sft) | (src << (16 - sft)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e098 +OP(ror_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_V = 0; + CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = (src >> sft) | (src << (32 - sft)); + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e100 +OP(asl_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + if (sft < 8) + { + CPU->flag_X = CPU->flag_C = src << (0 + sft); + res = src << sft; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + CPU->flag_V = 0; + if ((sft > 7) && (src)) CPU->flag_V = C68K_SR_V; + else + { + UINT32 msk = (((INT32)0x80000000) >> (sft + 24)) & 0xff; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) + } + + if (src) CPU->flag_V = C68K_SR_V; + else CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = 0; + *(UINT8 *)(&DY) = res; + CPU->flag_N = 0; + CPU->flag_Z = 0; + RET(6) +} + +// e140 +OP(asl_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + CPU->flag_X = CPU->flag_C = src >> (8 - sft); + res = src << sft; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + CPU->flag_V = 0; + { + UINT32 msk = (((INT32)0x80000000) >> (sft + 16)) & 0xffff; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) +} + +// e180 +OP(asl_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_X = CPU->flag_C = src >> (24 - sft); + res = src << sft; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + CPU->flag_V = 0; + { + UINT32 msk = (((INT32)0x80000000) >> (sft + 0)); + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(8) +} + +// e108 +OP(lsl_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << (0 + sft); + res = src << sft; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e148 +OP(lsl_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> (8 - sft); + res = src << sft; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e188 +OP(lsl_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> (24 - sft); + res = src << sft; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e110 +OP(roxl_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src << sft) | (src >> (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e150 +OP(roxl_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src << sft) | (src >> (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e190 +OP(roxl_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_C = src >> ((32 - C68K_SR_C_SFT) - sft); + if (sft == 1) res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - 1)); + else res = (src << sft) | (src >> (33 - sft)) | ((CPU->flag_X & C68K_SR_X) >> ((C68K_SR_X_SFT + 1) - sft)); + CPU->flag_X = CPU->flag_C; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e118 +OP(rol_8_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_8(DY); + CPU->flag_V = 0; + CPU->flag_C = src << (0 + sft); + res = (src << sft) | (src >> (8 - sft)); + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) +} + +// e158 +OP(rol_16_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_16(DY); + CPU->flag_V = 0; + CPU->flag_C = src >> (8 - sft); + res = (src << sft) | (src >> (16 - sft)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) +} + +// e198 +OP(rol_32_s) +{ + UINT32 sft; + + sft = (((Opcode >> 9) - 1) & 7) + 1; + USE_CYCLES(sft << 1) + src = READ_REG_32(DY); + CPU->flag_V = 0; + CPU->flag_C = src >> (24 - sft); + res = (src << sft) | (src >> (32 - sft)); + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) +} + +// e020 +OP(asr_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = (INT32)(INT8)DY; + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 8) + { + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = ((INT32)src) >> sft; + CPU->flag_N = res >> 0; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + RET(6) + } + + if (src & (1 << 7)) + { + CPU->flag_N = C68K_SR_N; + CPU->flag_Z = 1; + CPU->flag_V = 0; + CPU->flag_C = C68K_SR_C; + CPU->flag_X = C68K_SR_X; + res = 0xff; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_X = 0; + res = 0; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e060 +OP(asr_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = (INT32)(INT16)DY; + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 16) + { + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = ((INT32)src) >> sft; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + RET(6) + } + + if (src & (1 << 15)) + { + CPU->flag_N = C68K_SR_N; + CPU->flag_Z = 1; + CPU->flag_V = 0; + CPU->flag_C = C68K_SR_C; + CPU->flag_X = C68K_SR_X; + res = 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_X = 0; + res = 0; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e0a0 +OP(asr_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = (INT32)DY; + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 32) + { + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = ((INT32)src) >> sft; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + if (src & (1 << 31)) + { + CPU->flag_N = C68K_SR_N; + CPU->flag_Z = 1; + CPU->flag_V = 0; + CPU->flag_C = C68K_SR_C; + CPU->flag_X = C68K_SR_X; + res = 0xffffffff; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_X = 0; + res = 0; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e028 +OP(lsr_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft <= 8) + { + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << ((C68K_SR_C_SFT + 1) - sft); + res = src >> sft; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + res = 0; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e068 +OP(lsr_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft <= 16) + { + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = src >> sft; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + res = 0; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e0a8 +OP(lsr_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 32) + { + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = (src >> (sft - 1)) << C68K_SR_C_SFT; + res = src >> sft; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + if (sft == 32) CPU->flag_C = src >> (31 - C68K_SR_C_SFT); + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + res = 0; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e030 +OP(roxr_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft %= 9; + + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src >> sft) | (src << (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e070 +OP(roxr_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft %= 17; + + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src >> sft) | (src << (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e0b0 +OP(roxr_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft %= 33; + + if (sft != 0) + { + if (sft == 1) res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))); + else res = (src >> sft) | (src << (33 - sft)) | (((CPU->flag_X & C68K_SR_X) << (32 - (C68K_SR_X_SFT + 1))) >> (sft - 1)); + CPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT; + } + else res = src; + CPU->flag_C = CPU->flag_X; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e038 +OP(ror_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft &= 0x07; + + CPU->flag_C = src << (C68K_SR_C_SFT - ((sft - 1) & 7)); + res = (src >> sft) | (src << (8 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e078 +OP(ror_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft &= 0x0f; + + CPU->flag_C = (src >> ((sft - 1) & 15)) << C68K_SR_C_SFT; + res = (src >> sft) | (src << (16 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e0b8 +OP(ror_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft &= 0x1f; + + CPU->flag_C = (src >> ((sft - 1) & 31)) << C68K_SR_C_SFT; + res = (src >> sft) | (src << (32 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e120 +OP(asl_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 8) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 0; + res = (src << sft) & 0xff; + CPU->flag_N = res >> 0; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + CPU->flag_V = 0; + { + UINT32 msk = (((INT32)0x80000000) >> (sft + 24)) & 0xff; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) + } + + if (sft == 256) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_V = (src) ? C68K_SR_V : 0; + *(UINT8 *)(&DY) = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e160 +OP(asl_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 16) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 8; + res = (src << sft) & 0xffff; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + CPU->flag_V = 0; + { + UINT32 msk = (((INT32)0x80000000) >> (sft + 16)) & 0xffff; + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(6) + } + + if (sft == 65536) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_V = (src) ? C68K_SR_V : 0; + *(UINT16 *)(&DY) = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e1a0 +OP(asl_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 32) + { + CPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT; + res = src << sft; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + CPU->flag_V = 0; + { + UINT32 msk = (((INT32)0x80000000) >> (sft + 0)); + src &= msk; + if ((src) && (src != msk)) CPU->flag_V = C68K_SR_V; + } + RET(8) + } + + if (sft == 0) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_V = (src) ? C68K_SR_V : 0; + *(UINT32 *)(&DY) = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e128 +OP(lsl_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft <= 8) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 0; + res = (src << sft) & 0xff; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + *(UINT8 *)(&DY) = 0; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e168 +OP(lsl_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft <= 16) + { + CPU->flag_X = CPU->flag_C = (src << sft) >> 8; + res = (src << sft) & 0xffff; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_X = CPU->flag_C = 0; + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + *(UINT16 *)(&DY) = 0; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e1a8 +OP(lsl_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft < 32) + { + CPU->flag_X = CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT; + res = src << sft; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + if (sft == 32) CPU->flag_C = src << C68K_SR_C_SFT; + else CPU->flag_C = 0; + CPU->flag_X = CPU->flag_C; + CPU->flag_N = 0; + CPU->flag_Z = 0; + CPU->flag_V = 0; + *(UINT32 *)(&DY) = 0; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e130 +OP(roxl_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft %= 9; + + src |= (CPU->flag_X & C68K_SR_X) << 0; + res = (src << sft) | (src >> (9 - sft)); + CPU->flag_X = CPU->flag_C = res >> 0; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res & 0xff; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e170 +OP(roxl_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft %= 17; + + src |= (CPU->flag_X & C68K_SR_X) << 8; + res = (src << sft) | (src >> (17 - sft)); + CPU->flag_X = CPU->flag_C = res >> 8; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e1b0 +OP(roxl_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + sft %= 33; + + if (sft != 0) + { + if (sft == 1) res = (src << 1) | ((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1); + else res = (src << sft) | (src >> (33 - sft)) | (((CPU->flag_X >> ((C68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1)); + CPU->flag_X = (src >> (32 - sft)) << C68K_SR_X_SFT; + } + else res = src; + CPU->flag_C = CPU->flag_X; + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = CPU->flag_X; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +// e138 +OP(rol_8_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_8(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft &= 0x07) + { + CPU->flag_C = (src << sft) >> 0; + res = ((src << sft) | (src >> (8 - sft))) & 0xff; + CPU->flag_V = 0; + CPU->flag_N = res >> 0; + CPU->flag_Z = res; + *(UINT8 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 0; + CPU->flag_Z = src; + RET(6) +} + +// e178 +OP(rol_16_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_16(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft &= 0x0f) + { + CPU->flag_C = (src << sft) >> 8; + res = ((src << sft) | (src >> (16 - sft))) & 0xffff; + CPU->flag_V = 0; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + *(UINT16 *)(&DY) = res; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 8; + CPU->flag_Z = src; + RET(6) +} + +// e1b8 +OP(rol_32_r) +{ + UINT32 sft; + + sft = DX & 0x3f; + src = READ_REG_32(DY); + if (sft) + { + USE_CYCLES(sft << 1) + if (sft &= 0x1f) + { + CPU->flag_C = (src >> (32 - sft)) << C68K_SR_C_SFT; + res = (src << sft) | (src >> (32 - sft)); + CPU->flag_V = 0; + CPU->flag_N = res >> 24; + CPU->flag_Z = res; + *(UINT32 *)(&DY) = res; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) + } + + CPU->flag_V = 0; + CPU->flag_C = 0; + CPU->flag_N = src >> 24; + CPU->flag_Z = src; + RET(8) +} + +#if 0 + +/*----------------------------------------------------------------------------- + ASR (EA) Arithmetic Shift Right +-----------------------------------------------------------------------------*/ + +OP(asr_16_ai) { ASR_EA(AI) } // e0d0 +OP(asr_16_pi) { ASR_EA(PI) } // e0d8 +OP(asr_16_pd) { ASR_EA(PD) } // e0e0 +OP(asr_16_di) { ASR_EA(DI) } // e0e8 +OP(asr_16_ix) { ASR_EA(IX) } // e0f0 +OP(asr_16_aw) { ASR_EA(AW) } // e0f8 +OP(asr_16_al) { ASR_EA(AL) } // e0f9 + +/*----------------------------------------------------------------------------- + LSR (EA) Logical Shift Right +-----------------------------------------------------------------------------*/ + +OP(lsr_16_ai) { LSR_EA(AI) } // e2d0 +OP(lsr_16_pi) { LSR_EA(PI) } // e2d8 +OP(lsr_16_pd) { LSR_EA(PD) } // e2e0 +OP(lsr_16_di) { LSR_EA(DI) } // e2e8 +OP(lsr_16_ix) { LSR_EA(IX) } // e2f0 +OP(lsr_16_aw) { LSR_EA(AW) } // e2f8 +OP(lsr_16_al) { LSR_EA(AL) } // e2f9 + +/*----------------------------------------------------------------------------- + ROXR (EA) Rotate Right with Extend +-----------------------------------------------------------------------------*/ + +OP(roxr_16_ai) { ROXR_EA(AI) } // e4d0 +OP(roxr_16_pi) { ROXR_EA(PI) } // e4d8 +OP(roxr_16_pd) { ROXR_EA(PD) } // e4e0 +OP(roxr_16_di) { ROXR_EA(DI) } // e4e8 +OP(roxr_16_ix) { ROXR_EA(IX) } // e4f0 +OP(roxr_16_aw) { ROXR_EA(AW) } // e4f8 +OP(roxr_16_al) { ROXR_EA(AL) } // e4f9 + +/*----------------------------------------------------------------------------- + ROR (EA) Rotate Right +-----------------------------------------------------------------------------*/ + +OP(ror_16_ai) { ROR_EA(AI) } // e6d0 +OP(ror_16_pi) { ROR_EA(PI) } // e6d8 +OP(ror_16_pd) { ROR_EA(PD) } // e6e0 +OP(ror_16_di) { ROR_EA(DI) } // e6e8 +OP(ror_16_ix) { ROR_EA(IX) } // e6f0 +OP(ror_16_aw) { ROR_EA(AW) } // e6f8 +OP(ror_16_al) { ROR_EA(AL) } // e6f9 + +/*----------------------------------------------------------------------------- + ASL (EA) Arithmetic Shift Left +-----------------------------------------------------------------------------*/ + +OP(asl_16_ai) { ASL_EA(AI) } // e1d0 +OP(asl_16_pi) { ASL_EA(PI) } // e1d8 +OP(asl_16_pd) { ASL_EA(PD) } // e1e0 +OP(asl_16_di) { ASL_EA(DI) } // e1e8 +OP(asl_16_ix) { ASL_EA(IX) } // e1f0 +OP(asl_16_aw) { ASL_EA(AW) } // e1f8 +OP(asl_16_al) { ASL_EA(AL) } // e1f9 + +/*----------------------------------------------------------------------------- + LSL (EA) Logical Shift Left +-----------------------------------------------------------------------------*/ + +OP(lsl_16_ai) { LSL_EA(AI) } // e3d0 +OP(lsl_16_pi) { LSL_EA(PI) } // e3d8 +OP(lsl_16_pd) { LSL_EA(PD) } // e3e0 +OP(lsl_16_di) { LSL_EA(DI) } // e3e8 +OP(lsl_16_ix) { LSL_EA(IX) } // e3f0 +OP(lsl_16_aw) { LSL_EA(AW) } // e3f8 +OP(lsl_16_al) { LSL_EA(AL) } // e3f9 + +/*----------------------------------------------------------------------------- + ROXL (EA) Rotate Right with Extend +-----------------------------------------------------------------------------*/ + +OP(roxl_16_ai) { ROXL_EA(AI) } // e5d0 +OP(roxl_16_pi) { ROXL_EA(PI) } // e5d8 +OP(roxl_16_pd) { ROXL_EA(PD) } // e5e0 +OP(roxl_16_di) { ROXL_EA(DI) } // e5e8 +OP(roxl_16_ix) { ROXL_EA(IX) } // e5f0 +OP(roxl_16_aw) { ROXL_EA(AW) } // e5f8 +OP(roxl_16_al) { ROXL_EA(AL) } // e5f9 + +/*----------------------------------------------------------------------------- + ROL (EA) Rotate Left +-----------------------------------------------------------------------------*/ + +OP(rol_16_ai) { ROL_EA(AI) } // e7d0 +OP(rol_16_pi) { ROL_EA(PI) } // e7d8 +OP(rol_16_pd) { ROL_EA(PD) } // e7e0 +OP(rol_16_di) { ROL_EA(DI) } // e7e8 +OP(rol_16_ix) { ROL_EA(IX) } // e7f0 +OP(rol_16_aw) { ROL_EA(AW) } // e7f8 +OP(rol_16_al) { ROL_EA(AL) } // e7f9 + +#else + +// e0d0 +OP(asr_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e0d8 +OP(asr_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e0e0 +OP(asr_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e0e8 +OP(asr_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e0f0 +OP(asr_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e0f8 +OP(asr_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e0f9 +OP(asr_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src & (1 << 15)); + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e2d0 +OP(lsr_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e2d8 +OP(lsr_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e2e0 +OP(lsr_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e2e8 +OP(lsr_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e2f0 +OP(lsr_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e2f8 +OP(lsr_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e2f9 +OP(lsr_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_N = CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src << C68K_SR_C_SFT; + res = src >> 1; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e4d0 +OP(roxr_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e4d8 +OP(roxr_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e4e0 +OP(roxr_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e4e8 +OP(roxr_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e4f0 +OP(roxr_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e4f8 +OP(roxr_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e4f9 +OP(roxr_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src >> 1) | ((CPU->flag_X & C68K_SR_X) << 7); + CPU->flag_C = CPU->flag_X = src << C68K_SR_C_SFT; + CPU->flag_N = res >> 8; + CPU->flag_Z = res; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e6d0 +OP(ror_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e6d8 +OP(ror_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e6e0 +OP(ror_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e6e8 +OP(ror_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e6f0 +OP(ror_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e6f8 +OP(ror_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e6f9 +OP(ror_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src << C68K_SR_C_SFT; + res = (src >> 1) | (src << 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e1d0 +OP(asl_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e1d8 +OP(asl_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e1e0 +OP(asl_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e1e8 +OP(asl_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e1f0 +OP(asl_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e1f8 +OP(asl_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e1f9 +OP(asl_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_V = (src ^ res) >> 8; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e3d0 +OP(lsl_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e3d8 +OP(lsl_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e3e0 +OP(lsl_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e3e8 +OP(lsl_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e3f0 +OP(lsl_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e3f8 +OP(lsl_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e3f9 +OP(lsl_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_X = CPU->flag_C = src >> 7; + res = src << 1; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e5d0 +OP(roxl_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e5d8 +OP(roxl_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e5e0 +OP(roxl_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e5e8 +OP(roxl_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e5f0 +OP(roxl_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e5f8 +OP(roxl_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e5f9 +OP(roxl_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + res = (src << 1) | ((CPU->flag_X & C68K_SR_X) >> 8); + CPU->flag_X = CPU->flag_C = src >> 7; + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(20) +} + +// e7d0 +OP(rol_16_ai) +{ + adr = AY; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e7d8 +OP(rol_16_pi) +{ + adr = AY; + AY += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(12) +} + +// e7e0 +OP(rol_16_pd) +{ + adr = AY - 2; + AY = adr; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(14) +} + +// e7e8 +OP(rol_16_di) +{ + adr = AY + READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e7f0 +OP(rol_16_ix) +{ + adr = AY; + DECODE_EXT_WORD + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(18) +} + +// e7f8 +OP(rol_16_aw) +{ + adr = READSX_IMM_16(); + PC += 2; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(16) +} + +// e7f9 +OP(rol_16_al) +{ + adr = READSX_IMM_32(); + PC += 4; + src = READ_MEM_16(adr); + CPU->flag_V = 0; + CPU->flag_C = src >> 7; + res = (src << 1) | (src >> 15); + CPU->flag_N = res >> 8; + CPU->flag_Z = res & 0xffff; + WRITE_MEM_16(adr, res); + RET(20) +} + +#endif + +/****************************************************************************** + OPCODE $Fxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + Line-F +-----------------------------------------------------------------------------*/ + +// f000 +OP(1111) +{ + SWAP_SP() + PC -= 2; + EXCEPTION(C68K_1111_EX) + RET(34) +} + +#ifdef BUILD_NCDZPSP + +OP(FAC0) +{ + extern void cdrom_load_files(void); + + cdrom_load_files(); + RET(400) +} + +OP(FAC1) +{ + extern void neogeo_cdda_control(void); + + neogeo_cdda_control(); + RET(200) +} + +OP(FAC2) +{ + extern void neogeo_bios_exit(void); + + neogeo_bios_exit(); + RET(200) +} + +#endif /* BUILD_NCDZPSP */ diff --git a/m68000/old/c68kmacro.h b/m68000/old/c68kmacro.h new file mode 100644 index 0000000..7e5afff --- /dev/null +++ b/m68000/old/c68kmacro.h @@ -0,0 +1,2137 @@ +/****************************************************************************** + + c68kmacro.h + + C68K 各種マクロ + +******************************************************************************/ + +/*------------------------------- core macros -------------------------------*/ + +#define AY CPU->A[Opcode & 7] +#define AX CPU->A[(Opcode >> 9) & 7] +#define A7 CPU->A[7] + +#define DY CPU->D[Opcode & 7] +#define DX CPU->D[(Opcode >> 9) & 7] +#define D0 CPU->D[0] + +#define FLAG_X CPU->flag_X +#define FLAG_C CPU->flag_C +#define FLAG_V CPU->flag_V +#define FLAG_N CPU->flag_N +#define FLAG_Z CPU->flag_Z + +#define FLAG_S CPU->flag_S +#define FLAG_I CPU->flag_I + +#define OP(name) op_##name: + +#define MAKE_INT_8(A) (INT32)(INT8)(A) +#define MAKE_INT_16(A) (INT32)(INT16)(A) +#define MAKE_INT_32(A) (INT32)(A) + +#define MAKE_UINT_8(A) (UINT8)(A) +#define MAKE_UINT_16(A) (UINT16)(A) +#define MAKE_UINT_32(A) (UINT32)(A) + +#define LOW_NIBBLE(A) ((A) & 0x0f) +#define HIGH_NIBBLE(A) ((A) & 0xf0) + +#define USE_CYCLES(A) CPU->ICount -= (A); +#define RELEASE_CYCLES() CPU->ICount = 0; + +#define READ_REG_8(A) MAKE_UINT_8(A) +#define READ_REG_16(A) MAKE_UINT_16(A) +#define READ_REG_32(A) MAKE_UINT_32(A) + +#define READSX_REG_8(A) MAKE_INT_8(A) +#define READSX_REG_16(A) MAKE_INT_16(A) +#define READSX_REG_32(A) MAKE_INT_32(A) + +#define WRITE_REG_8(A, D) *(UINT8 *)(&A) = D +#define WRITE_REG_16(A, D) *(UINT16 *)(&A) = D +#define WRITE_REG_32(A, D) A = D + +#define READ_IMM_8() (*(UINT8 *)PC) +#define READ_IMM_16() (*(UINT16 *)PC) +#ifdef C68K_BIG_ENDIAN +#define READ_IMM_32() (*(UINT32 *)PC) +#else +#define READ_IMM_32() (((*(UINT16 *)PC) << 16) | (*(UINT16 *)(PC + 2))) +#endif + +#define READSX_IMM_8() (INT32)(*(INT8 *)PC) +#define READSX_IMM_16() (INT32)(*(INT16 *)PC) +#define READSX_IMM_32() MAKE_INT_32(READ_IMM_32()) + +#define READ_MEM_8(A) CPU->Read_Byte(A) +#define READ_MEM_16(A) CPU->Read_Word(A) +#ifdef C68K_BIG_ENDIAN +#define READ_MEM_32(A) (READ_MEM_16(A) | (READ_MEM_16((A) + 2) << 16)) +#else +#define READ_MEM_32(A) ((READ_MEM_16(A) << 16) | READ_MEM_16((A) + 2)) +#endif + +#define READSX_MEM_8(A) MAKE_INT_8(READ_MEM_8(A)) +#define READSX_MEM_16(A) MAKE_INT_16(READ_MEM_16(A)) +#define READSX_MEM_32(A) MAKE_INT_32(READ_MEM_32(A)) + +#define READ_PCREL_8(A) CPU->Read_Byte_PC_Relative(A) +#define READ_PCREL_16(A) CPU->Read_Word_PC_Relative(A) +#ifdef C68K_BIG_ENDIAN +#define READ_PCREL_32(A) (READ_PCREL_16(A) | (READ_PCREL_16((A) + 2) << 16)) +#else +#define READ_PCREL_32(A) ((READ_PCREL_16(A) << 16) | READ_PCREL_16((A) + 2)) +#endif + +#define READSX_PCREL_8(A) MAKE_INT_8(READ_PCREL_8(A)) +#define READSX_PCREL_16(A) MAKE_INT_16(READ_PCREL_16(A)) +#define READSX_PCREL_32(A) MAKE_INT_32(READ_PCREL_32(A)) + +#define WRITE_MEM_8(A, D) CPU->Write_Byte(A, D) +#define WRITE_MEM_16(A, D) CPU->Write_Word(A, D) +#ifdef C68K_BIG_ENDIAN +#define WRITE_MEM_32(A, D) WRITE_MEM_16((A), (D)); WRITE_MEM_16((A) + 2, (D) >> 16) +#else +#define WRITE_MEM_32(A, D) WRITE_MEM_16((A), (D) >> 16); WRITE_MEM_16((A) + 2, (D)) +#endif + +#define WRITE_MEM_16PD(A, D) WRITE_MEM_16(A, D) +#ifdef C68K_BIG_ENDIAN +#define WRITE_MEM_32PD(A, D) WRITE_MEM_16((A) + 2, (D) >> 16); WRITE_MEM_16((A), (D)) +#else +#define WRITE_MEM_32PD(A, D) WRITE_MEM_16((A) + 2, (D)); WRITE_MEM_16((A), (D) >> 16) +#endif + +#define GET_QUICK() (((Opcode >> 9) - 1) & 7) + 1 + +#define PUSH_16_F(D) A7 -= 2; WRITE_MEM_16(A7, D); +#define POP_16_F(D) D = READ_MEM_16(A7); A7 += 2; + +#define PUSH_32_F(D) A7 -= 4; WRITE_MEM_32PD(A7, D); +#define POP_32_F(D) D = READ_MEM_32(A7); A7 += 4; + +#define DECODE_EXT_WORD \ +{ \ + UINT32 ext = READ_IMM_16(); \ + PC += 2; \ + \ + adr += MAKE_INT_8(ext); \ + if (ext & 0x0800) adr += MAKE_INT_32(CPU->D[ext >> 12]); \ + else adr += MAKE_INT_16(CPU->D[ext >> 12]); \ +} + +#define RET(A) \ + USE_CYCLES(A) \ + goto C68k_Exec_Next; + +#define RET_INT(A) \ + USE_CYCLES(A) \ + goto C68k_Check_Interrupt; + +#define RET_HALT() \ + CPU->HaltState = 1; \ + RELEASE_CYCLES(); \ + goto C68k_Check_Interrupt; + +#define GET_PC() (PC - CPU->BasePC) + +#define SET_PC(A) \ + CPU->BasePC = CPU->Fetch[((A) >> C68K_FETCH_SFT) & C68K_FETCH_MASK]; \ + CPU->BasePC -= (A) & 0xff000000; \ + PC = (A) + CPU->BasePC; + +#define ADJUST_PC() PC -= CPU->BasePC; + +#define GET_CCR() \ + (((CPU->flag_C >> (C68K_SR_C_SFT - 0)) & 1) | \ + ((CPU->flag_V >> (C68K_SR_V_SFT - 1)) & 2) | \ + (((!CPU->flag_Z) & 1) << 2) | \ + ((CPU->flag_N >> (C68K_SR_N_SFT - 3)) & 8) | \ + ((CPU->flag_X >> (C68K_SR_X_SFT - 4)) & 0x10)) + +#define GET_SR() \ + ((CPU->flag_S << 0) | \ + (CPU->flag_I << 8) | \ + GET_CCR()) + +#define SET_CCR(A) \ + CPU->flag_C = (A) << (C68K_SR_C_SFT - 0); \ + CPU->flag_V = (A) << (C68K_SR_V_SFT - 1); \ + CPU->flag_Z = ~(A) & 4; \ + CPU->flag_N = (A) << (C68K_SR_N_SFT - 3); \ + CPU->flag_X = (A) << (C68K_SR_X_SFT - 4); + +#define SET_SR(A) \ + SET_CCR(A) \ + CPU->flag_I = ((A) >> 8) & 7; \ + CPU->flag_S = (A) & C68K_SR_S; + +#define SWAP_SP() \ + if (!CPU->flag_S) \ + { \ + res = CPU->USP; \ + CPU->USP = A7; \ + A7 = res; \ + } + +#define SWAP_SP_NOCHECK() \ + res = CPU->USP; \ + CPU->USP = A7; \ + A7 = res; + +#define EXCEPTION(number) \ + PUSH_32_F(GET_PC()) \ + PUSH_16_F(GET_SR()) \ + CPU->flag_S = C68K_SR_S; \ + PC = READ_MEM_32((number) << 2); \ + SET_PC(PC) + +#define CHECK_INT \ + adr = CPU->IRQLine; \ + if ((adr == 7) || (adr > CPU->flag_I)) \ + { \ + if (CPU->IRQState == HOLD_LINE) \ + CPU->IRQState = CLEAR_LINE; \ + CPU->IRQLine = 0; \ + SWAP_SP() \ + res = CPU->Interrupt_CallBack(adr); \ + if (res < 0) { \ + res = adr + 24; \ + } \ + EXCEPTION(res) \ + CPU->flag_I = adr; \ + USE_CYCLES(44) \ + } + +/****************************************************************************** + c68k_op用マクロ +******************************************************************************/ + +/*------------------------------- opcode macros -----------------------------*/ + +#define CFLAG_8(A) (A) +#define CFLAG_16(A) ((A) >> 8) + +#define CFLAG_ADD_32(S, D, R) (((S & D & 1) + (S >> 1) + (D >> 1)) >> 23) +#define CFLAG_ADDX_32(S, D, F) (((((S & 1) + (D & 1) + (F & 1)) >> 1) + (S >> 1) + (D >> 1)) >> 23) +#define CFLAG_SUB_32(S, D, R) (((S & R & 1) + (S >> 1) + (R >> 1)) >> 23) +#define CFLAG_SUBX_32(S, R, F) (((((S & 1) + (R & 1) + (F & 1)) >> 1) + (S >> 1) + (R >> 1)) >> 23) + +#define VFLAG_ADD_8(S, D, R) ((S ^ R) & (D ^ R)) +#define VFLAG_ADD_16(S, D, R) (((S ^ R) & (D ^ R)) >> 8) +#define VFLAG_ADD_32(S, D, R) (((S ^ R) & (D ^ R)) >> 24) + +#define VFLAG_SUB_8(S, D, R) ((S ^ D) & (R ^ D)) +#define VFLAG_SUB_16(S, D, R) (((S ^ D) & (R ^ D)) >> 8) +#define VFLAG_SUB_32(S, D, R) (((S ^ D) & (R ^ D)) >> 24) + +#define NFLAG_8(A) (A) +#define NFLAG_16(A) ((A) >> 8) +#define NFLAG_32(A) ((A) >> 24) + +#define ZFLAG_8(A) MAKE_UINT_8(A) +#define ZFLAG_16(A) MAKE_UINT_16(A) +#define ZFLAG_32(A) MAKE_UINT_32(A) + +#define CFLAG_SET 0x100 +#define CFLAG_CLEAR 0 +#define XFLAG_SET 0x100 +#define XFLAG_CLEAR 0 +#define VFLAG_SET 0x80 +#define VFLAG_CLEAR 0 +#define NFLAG_SET 0x80 +#define NFLAG_CLEAR 0 +#define ZFLAG_SET 0 +#define ZFLAG_CLEAR 1 + +#define XFLAG_AS_1() ((FLAG_X >> 8) & 1) +#define NFLAG_AS_1() ((FLAG_N >> 7) & 1) +#define VFLAG_AS_1() ((FLAG_V >> 7) & 1) +#define ZFLAG_AS_1() (!FLAG_Z) +#define CFLAG_AS_1() ((FLAG_C >> 8) & 1) + +#define COND_CS() (FLAG_C & 0x100) +#define COND_CC() (!COND_CS()) +#define COND_VS() (FLAG_V & 0x80) +#define COND_VC() (!COND_VS()) +#define COND_NE() FLAG_Z +#define COND_EQ() (!COND_NE()) +#define COND_MI() (FLAG_N & 0x80) +#define COND_PL() (!COND_MI()) +#define COND_LT() ((FLAG_N ^ FLAG_V) & 0x80) +#define COND_GE() (!COND_LT()) +#define COND_HI() (COND_CC() && COND_NE()) +#define COND_LS() (COND_CS() || COND_EQ()) +#define COND_GT() (COND_GE() && COND_NE()) +#define COND_LE() (COND_LT() || COND_EQ()) + +#define COND_NOT_CS() COND_CC() +#define COND_NOT_CC() COND_CS() +#define COND_NOT_VS() COND_VC() +#define COND_NOT_VC() COND_VS() +#define COND_NOT_NE() COND_EQ() +#define COND_NOT_EQ() COND_NE() +#define COND_NOT_MI() COND_PL() +#define COND_NOT_PL() COND_MI() +#define COND_NOT_LT() COND_GE() +#define COND_NOT_GE() COND_LT() +#define COND_NOT_HI() COND_LS() +#define COND_NOT_LS() COND_HI() +#define COND_NOT_GT() COND_LE() +#define COND_NOT_LE() COND_GT() + +/*--------------------------------- clocks ----------------------------------*/ + +#define EA_CLOCKS_D_8 0 +#define EA_CLOCKS_AI_8 4 +#define EA_CLOCKS_PI_8 4 +#define EA_CLOCKS_PD_8 6 +#define EA_CLOCKS_DI_8 8 +#define EA_CLOCKS_IX_8 10 +#define EA_CLOCKS_AW_8 8 +#define EA_CLOCKS_AL_8 12 +#define EA_CLOCKS_PCDI_8 8 +#define EA_CLOCKS_PCIX_8 10 +#define EA_CLOCKS_I_8 4 +#define EA_CLOCKS_PI7_8 4 +#define EA_CLOCKS_PD7_8 6 + +#define EA_CLOCKS_D_16 0 +#define EA_CLOCKS_A_16 0 +#define EA_CLOCKS_AI_16 4 +#define EA_CLOCKS_PI_16 4 +#define EA_CLOCKS_PD_16 6 +#define EA_CLOCKS_DI_16 8 +#define EA_CLOCKS_IX_16 10 +#define EA_CLOCKS_AW_16 8 +#define EA_CLOCKS_AL_16 12 +#define EA_CLOCKS_PCDI_16 8 +#define EA_CLOCKS_PCIX_16 10 +#define EA_CLOCKS_I_16 4 +#define EA_CLOCKS_PI7_16 4 +#define EA_CLOCKS_PD7_16 6 + +#define EA_CLOCKS_D_32 0 +#define EA_CLOCKS_A_32 0 +#define EA_CLOCKS_AI_32 8 +#define EA_CLOCKS_PI_32 8 +#define EA_CLOCKS_PD_32 10 +#define EA_CLOCKS_DI_32 12 +#define EA_CLOCKS_IX_32 14 +#define EA_CLOCKS_AW_32 12 +#define EA_CLOCKS_AL_32 16 +#define EA_CLOCKS_PCDI_32 12 +#define EA_CLOCKS_PCIX_32 14 +#define EA_CLOCKS_I_32 8 +#define EA_CLOCKS_PI7_32 8 +#define EA_CLOCKS_PD7_32 10 + +/*----------------------------- Effective Address ---------------------------*/ + +#define PI7_8() A7; A7 += 2 +#define PI7_16() A7; A7 += 2 +#define PI7_32() A7; A7 += 4 + +#define PD7_8() A7 - 2; A7 = adr +#define PD7_16() A7 - 2; A7 = adr +#define PD7_32() A7 - 4; A7 = adr + +#define ADD_PC_8() PC += 2 +#define ADD_PC_16() PC += 2 +#define ADD_PC_32() PC += 4 + +#define READ_D(size, xy) READ_REG_##size(D##xy) +#define READ_A(size, xy) READ_REG_##size(A##xy) +#define READ_AI(size, xy) READ_MEM_##size(adr) +#define READ_PI(size, xy) READ_MEM_##size(adr) +#define READ_PD(size, xy) READ_MEM_##size(adr) +#define READ_DI(size, xy) READ_MEM_##size(adr) +#define READ_IX(size, xy) READ_MEM_##size(adr) +#define READ_AW(size, xy) READ_MEM_##size(adr) +#define READ_AL(size, xy) READ_MEM_##size(adr) +#define READ_PCDI(size, xy) READ_PCREL_##size(adr) +#define READ_PCIX(size, xy) READ_PCREL_##size(adr) +#define READ_I(size, xy) READ_IMM_##size(); ADD_PC_##size() +#define READ_PI7(size, xy) READ_MEM_##size(adr) +#define READ_PD7(size, xy) READ_MEM_##size(adr) + +#define READSX_D(size, xy) READSX_REG_##size(D##xy) +#define READSX_A(size, xy) READSX_REG_##size(A##xy) +#define READSX_AI(size, xy) READSX_MEM_##size(adr) +#define READSX_PI(size, xy) READSX_MEM_##size(adr) +#define READSX_PD(size, xy) READSX_MEM_##size(adr) +#define READSX_DI(size, xy) READSX_MEM_##size(adr) +#define READSX_IX(size, xy) READSX_MEM_##size(adr) +#define READSX_AW(size, xy) READSX_MEM_##size(adr) +#define READSX_AL(size, xy) READSX_MEM_##size(adr) +#define READSX_PCDI(size, xy) READSX_PCREL_##size(adr) +#define READSX_PCIX(size, xy) READSX_PCREL_##size(adr) +#define READSX_I(size, xy) READSX_IMM_##size(); ADD_PC_##size() +#define READSX_PI7(size, xy) READSX_MEM_##size(adr) +#define READSX_PD7(size, xy) READSX_MEM_##size(adr) + +#define WRITE_D(size, xy, v) WRITE_REG_##size(D##xy, v) +#define WRITE_A(size, xy, v) WRITE_REG_32(A##xy, v) +#define WRITE_AI(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_PI(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_PD(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_DI(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_IX(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_AW(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_AL(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_PCDI(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_PCIX(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_PI7(size, xy, v) WRITE_MEM_##size(adr, v) +#define WRITE_PD7(size, xy, v) WRITE_MEM_##size(adr, v) + +#define WRITE_EA(size, mode, xy) WRITE_##mode(size, xy, res) + +#define EA_D(size, xy) +#define EA_A(size, xy) +#define EA_AI(size, xy) { adr = A##xy; } +#define EA_PI(size, xy) { adr = A##xy; A##xy += (size / 8); } +#define EA_PD(size, xy) { adr = A##xy - (size / 8); A##xy = adr; } +#define EA_DI(size, xy) { adr = A##xy + READSX_I(16, NA); } +#define EA_IX(size, xy) { adr = A##xy; DECODE_EXT_WORD } +#define EA_AW(size, xy) { adr = READSX_I(16, NA); } +#define EA_AL(size, xy) { adr = READSX_I(32, NA); } +#define EA_PCDI(size, xy) { adr = GET_PC() + READSX_I(16, NA); } +#define EA_PCIX(size, xy) { adr = GET_PC(); DECODE_EXT_WORD } +#define EA_I(size, xy) +#define EA_PI7(size, xy) { adr = PI7_##size(); } +#define EA_PD7(size, xy) { adr = PD7_##size(); } + +#define EA_READ_D(s, xy, v) { v = READ_D(s, xy); } +#define EA_READ_A(s, xy, v) { v = READ_A(s, xy); } +#define EA_READ_AI(s, xy, v) { EA_AI(s, xy) v = READ_AI(s, xy); } +#define EA_READ_PI(s, xy, v) { EA_PI(s, xy) v = READ_PI(s, xy); } +#define EA_READ_PD(s, xy, v) { EA_PD(s, xy) v = READ_PD(s, xy); } +#define EA_READ_DI(s, xy, v) { EA_DI(s, xy) v = READ_DI(s, xy); } +#define EA_READ_IX(s, xy, v) { EA_IX(s, xy) v = READ_IX(s, xy); } +#define EA_READ_AW(s, xy, v) { EA_AW(s, xy) v = READ_AW(s, xy); } +#define EA_READ_AL(s, xy, v) { EA_AL(s, xy) v = READ_AL(s, xy); } +#define EA_READ_PCDI(s, xy, v) { EA_PCDI(s, xy) v = READ_PCDI(s, xy); } +#define EA_READ_PCIX(s, xy, v) { EA_PCIX(s, xy) v = READ_PCIX(s, xy); } +#define EA_READ_I(s, xy, v) { v = READ_I(s, xy); } +#define EA_READ_PI7(s, xy, v) { EA_PI7(s, xy) v = READ_PI7(s, xy); } +#define EA_READ_PD7(s, xy, v) { EA_PD7(s, xy) v = READ_PD7(s, xy); } + +#define EA_READSX_D(s, xy, v) { v = READSX_D(s, xy); } +#define EA_READSX_A(s, xy, v) { v = READSX_A(s, xy); } +#define EA_READSX_AI(s, xy, v) { EA_AI(s, xy) v = READSX_AI(s, xy); } +#define EA_READSX_PI(s, xy, v) { EA_PI(s, xy) v = READSX_PI(s, xy); } +#define EA_READSX_PD(s, xy, v) { EA_PD(s, xy) v = READSX_PD(s, xy); } +#define EA_READSX_DI(s, xy, v) { EA_DI(s, xy) v = READSX_DI(s, xy); } +#define EA_READSX_IX(s, xy, v) { EA_IX(s, xy) v = READSX_IX(s, xy); } +#define EA_READSX_AW(s, xy, v) { EA_AW(s, xy) v = READSX_AW(s, xy); } +#define EA_READSX_AL(s, xy, v) { EA_AL(s, xy) v = READSX_AL(s, xy); } +#define EA_READSX_PCDI(s, xy, v) { EA_PCDI(s, xy) v = READSX_PCDI(s, xy); } +#define EA_READSX_PCIX(s, xy, v) { EA_PCIX(s, xy) v = READSX_PCIX(s, xy); } +#define EA_READSX_I(s, xy, v) { v = READSX_I(s, xy); } +#define EA_READSX_PI7(s, xy, v) { EA_PI7(s, xy) v = READSX_PI7(s, xy); } +#define EA_READSX_PD7(s, xy, v) { EA_PD7(s, xy) v = READSX_PD7(s, xy); } + +#define EA_WRITE_D(s, xy, v) { WRITE_D(s, xy, v); } +#define EA_WRITE_A(s, xy, v) { WRITE_A(s, xy, v); } +#define EA_WRITE_AI(s, xy, v) { EA_AI(s, xy) WRITE_AI(s, xy, v); } +#define EA_WRITE_PI(s, xy, v) { EA_PI(s, xy) WRITE_PI(s, xy, v); } +#define EA_WRITE_PD(s, xy, v) { EA_PD(s, xy) WRITE_PD(s, xy, v); } +#define EA_WRITE_DI(s, xy, v) { EA_DI(s, xy) WRITE_DI(s, xy, v); } +#define EA_WRITE_IX(s, xy, v) { EA_IX(s, xy) WRITE_IX(s, xy, v); } +#define EA_WRITE_AW(s, xy, v) { EA_AW(s, xy) WRITE_AW(s, xy, v); } +#define EA_WRITE_AL(s, xy, v) { EA_AL(s, xy) WRITE_AL(s, xy, v); } +#define EA_WRITE_PCDI(s, xy, v) { EA_PCDI(s, xy) WRITE_PCDI(s, xy, v); } +#define EA_WRITE_PCIX(s, xy, v) { EA_PCIX(s, xy) WRITE_PCIX(s, xy, v); } +#define EA_WRITE_PI7(s, xy, v) { EA_PI7(s, xy) WRITE_PI7(s, xy, v); } +#define EA_WRITE_PD7(s, xy, v) { EA_PD7(s, xy) WRITE_PD7(s, xy, v); } + +#define EA_WRITE_RESULT(s, mode, xy) WRITE_EA(s, mode, xy); + +/*----------------------------- operation flags -----------------------------*/ + +#define FLAGS(size) \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_Z = res; \ + FLAG_N = NFLAG_##size(res); + +#define FLAGS_ADD_8() \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_8(res); \ + FLAG_V = VFLAG_ADD_8(src, dst, res); \ + FLAG_Z = ZFLAG_8(res); + +#define FLAGS_ADD_16() \ + FLAG_V = VFLAG_ADD_16(src, dst, res); \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); + +#define FLAGS_ADD_32() \ + FLAG_Z = ZFLAG_32(res); \ + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); \ + FLAG_V = VFLAG_ADD_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +#define FLAGS_ADDX_8() \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_8(res); \ + FLAG_V = VFLAG_ADD_8(src, dst, res); \ + FLAG_Z |= ZFLAG_8(res); + +#define FLAGS_ADDX_16() \ + FLAG_V = VFLAG_ADD_16(src, dst, res); \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_16(res); \ + FLAG_Z |= ZFLAG_16(res); + +#define FLAGS_ADDX_32() \ + FLAG_Z |= ZFLAG_32(res); \ + FLAG_X = FLAG_C = CFLAG_ADDX_32(src, dst, XFLAG_AS_1()); \ + FLAG_V = VFLAG_ADD_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +#define FLAGS_SUB_8() \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_8(res); \ + FLAG_V = VFLAG_SUB_8(src, dst, res); \ + FLAG_Z = ZFLAG_8(res); + +#define FLAGS_SUB_16() \ + FLAG_V = VFLAG_SUB_16(src, dst, res); \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); + +#define FLAGS_SUB_32() \ + FLAG_Z = ZFLAG_32(res); \ + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); \ + FLAG_V = VFLAG_SUB_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +#define FLAGS_SUBX_8() \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_8(res); \ + FLAG_V = VFLAG_SUB_8(src, dst, res); \ + FLAG_Z |= ZFLAG_8(res); + +#define FLAGS_SUBX_16() \ + FLAG_V = VFLAG_SUB_16(src, dst, res); \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_16(res); \ + FLAG_Z |= ZFLAG_16(res); + +#define FLAGS_SUBX_32() \ + FLAG_Z |= ZFLAG_32(res); \ + FLAG_X = FLAG_C = CFLAG_SUBX_32(src, res, XFLAG_AS_1()); \ + FLAG_V = VFLAG_SUB_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +#define FLAGS_CMP_8() \ + FLAG_N = FLAG_C = CFLAG_8(res); \ + FLAG_V = VFLAG_SUB_8(src, dst, res); \ + FLAG_Z = ZFLAG_8(res); + +#define FLAGS_CMP_16() \ + FLAG_V = VFLAG_SUB_16(src, dst, res); \ + FLAG_N = FLAG_C = CFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); + +#define FLAGS_CMP_32() \ + FLAG_Z = ZFLAG_32(res); \ + FLAG_C = CFLAG_SUB_32(src, dst, res); \ + FLAG_V = VFLAG_SUB_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +#define FLAGS_NEGX_8() \ + FLAG_V = res & src; \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_8(res); \ + FLAG_Z |= ZFLAG_8(res); + +#define FLAGS_NEGX_16() \ + FLAG_V = (res & src) >> 8; \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_16(res); \ + FLAG_Z |= ZFLAG_16(res); + +#define FLAGS_NEGX_32() \ + FLAG_Z |= ZFLAG_32(res); \ + FLAG_V = (res & src) >> 24; \ + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +#define FLAGS_NEG_8() \ + FLAG_V = res & src; \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_8(res); \ + FLAG_Z = ZFLAG_8(res); + +#define FLAGS_NEG_16() \ + FLAG_V = (res & src) >> 8; \ + FLAG_N = FLAG_X = FLAG_C = CFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); + +#define FLAGS_NEG_32() \ + FLAG_Z = ZFLAG_32(res); \ + FLAG_V = (res & src) >> 24; \ + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); \ + FLAG_N = NFLAG_32(res); + +/*--------------------------------- operation -------------------------------*/ + +#define OP_OR(size) \ + res |= src; \ + FLAGS(size) + +#define OP_AND(size) \ + res &= src; \ + FLAGS(size) + +#define OP_EOR(size) \ + res ^= src; \ + FLAGS(size) + +#define OP_ADD(size) \ + res = dst + src; \ + FLAGS_ADD_##size() + +#define OP_SUB(size) \ + res = dst - src; \ + FLAGS_SUB_##size() + +#define OP_CMP(size) \ + res = dst - src; \ + FLAGS_CMP_##size() + +/****************************************************************************** + OPCODE $0xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + ORI inclusive-OR Immediate +-----------------------------------------------------------------------------*/ + +#define ORI_CLOCKS_D_8 8 +#define ORI_CLOCKS_D_16 8 +#define ORI_CLOCKS_D_32 16 + +#define ORI_CLOCKS_M_8 12 +#define ORI_CLOCKS_M_16 12 +#define ORI_CLOCKS_M_32 20 + +#define ORI(size, clk, mode) \ +{ \ + EA_READ_I(size, NA, src) \ + EA_READ_##mode(size, Y, res) \ + OP_OR(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(ORI_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + ANDI And Immediate +-----------------------------------------------------------------------------*/ + +#define ANDI_CLOCKS_D_8 8 +#define ANDI_CLOCKS_D_16 8 +#define ANDI_CLOCKS_D_32 14 + +#define ANDI_CLOCKS_M_8 12 +#define ANDI_CLOCKS_M_16 12 +#define ANDI_CLOCKS_M_32 20 + +#define ANDI(size, clk, mode) \ +{ \ + EA_READ_I(size, NA, src) \ + EA_READ_##mode(size, Y, res) \ + OP_AND(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(ANDI_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + EORI Exclusive-OR Immediate +-----------------------------------------------------------------------------*/ + +#define EORI_CLOCKS_D_8 8 +#define EORI_CLOCKS_D_16 8 +#define EORI_CLOCKS_D_32 16 + +#define EORI_CLOCKS_M_8 12 +#define EORI_CLOCKS_M_16 12 +#define EORI_CLOCKS_M_32 20 + +#define EORI(size, clk, mode) \ +{ \ + EA_READ_I(size, NA, src) \ + EA_READ_##mode(size, Y, res) \ + OP_EOR(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(EORI_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + ORI to CCR inclusive-OR Immidiate to the Condition Code Register + ANDI to CCR And Immisiate to Condition the Code Register + EORI to CCR Exclusive-OR Immediate to the Condition Code Register +-----------------------------------------------------------------------------*/ + +#define LOGOP_TOC(operation) \ +{ \ + EA_READ_I(8, NA, res) \ + res &= C68K_CCR_MASK; \ + res operation GET_CCR(); \ + SET_CCR(res) \ + RET(20) \ +} + +/*----------------------------------------------------------------------------- + ORI to SR inclusive-OR Immidiate to the Stats Register + ANDI to SR AND Immisiate to the Status Register + EORI to SR Exclusive-OR Immediate to the Status Register +-----------------------------------------------------------------------------*/ + +#define LOGOP_TOS(operation) \ +{ \ + if (FLAG_S) \ + { \ + EA_READ_I(16, NA, res) \ + res &= C68K_SR_MASK; \ + res operation GET_SR(); \ + SET_SR(res) \ + SWAP_SP() \ + RET_INT(20) \ + } \ + SWAP_SP_NOCHECK() \ + EXCEPTION(C68K_PRIVILEGE_VIOLATION_EX) \ + RET(34) \ +} + +/*----------------------------------------------------------------------------- + SUBI Subtract Immediate +-----------------------------------------------------------------------------*/ + +#define SUBI_CLOCKS_D_8 8 +#define SUBI_CLOCKS_D_16 8 +#define SUBI_CLOCKS_D_32 16 + +#define SUBI_CLOCKS_M_8 12 +#define SUBI_CLOCKS_M_16 12 +#define SUBI_CLOCKS_M_32 20 + +#define SUBI(size, clk, mode) \ +{ \ + EA_READ_I(size, NA, src) \ + EA_READ_##mode(size, Y, dst) \ + OP_SUB(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(SUBI_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + ADDI Add Immediate +-----------------------------------------------------------------------------*/ + +#define ADDI_CLOCKS_D_8 8 +#define ADDI_CLOCKS_D_16 8 +#define ADDI_CLOCKS_D_32 16 + +#define ADDI_CLOCKS_M_8 12 +#define ADDI_CLOCKS_M_16 12 +#define ADDI_CLOCKS_M_32 20 + +#define ADDI(size, clk, mode) \ +{ \ + EA_READ_I(size, NA, src) \ + EA_READ_##mode(size, Y, dst) \ + OP_ADD(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(ADDI_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + CMPI Compare Immediate +-----------------------------------------------------------------------------*/ + +#define CMPI_CLOCKS_D_8 8 +#define CMPI_CLOCKS_D_16 8 +#define CMPI_CLOCKS_D_32 14 + +#define CMPI_CLOCKS_M_8 8 +#define CMPI_CLOCKS_M_16 8 +#define CMPI_CLOCKS_M_32 12 + +#define CMPI(size, clk, mode) \ +{ \ + EA_READ_I(size, NA, src) \ + EA_READ_##mode(size, Y, dst) \ + OP_CMP(size) \ + RET(CMPI_CLOCKS_M_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + BTST Test a Bit + BCHG Test a Bit and Change + BCLR Test a Bit and Clear + BSET Test a Bit and Set +-----------------------------------------------------------------------------*/ + +#define BTST_CLOCKS_D_8 4 +#define BTST_CLOCKS_D_32 6 +#define BTST_CLOCKS_S_8 8 +#define BTST_CLOCKS_S_32 10 + +#define BCHG_CLOCKS_D_8 8 +#define BCHG_CLOCKS_D_32 8 +#define BCHG_CLOCKS_S_8 12 +#define BCHG_CLOCKS_S_32 12 + +#define BCLR_CLOCKS_D_8 8 +#define BCLR_CLOCKS_D_32 10 +#define BCLR_CLOCKS_S_8 12 +#define BCLR_CLOCKS_S_32 14 + +#define BSET_CLOCKS_D_8 8 +#define BSET_CLOCKS_D_32 8 +#define BSET_CLOCKS_S_8 12 +#define BSET_CLOCKS_S_32 12 + +#define BTST_WRITE(size, mode, xy) +#define BCHG_WRITE(size, mode, xy) res ^= src; EA_WRITE_RESULT(size, mode, xy) +#define BCLR_WRITE(size, mode, xy) res &= ~src; EA_WRITE_RESULT(size, mode, xy) +#define BSET_WRITE(size, mode, xy) res |= src; EA_WRITE_RESULT(size, mode, xy) + +#define BITOP_DYNAMIC(op, size, mode) \ +{ \ + EA_READ_D(size, X, src) \ + src = 1 << (src & (size - 1)); \ + EA_READ_##mode(size, Y, res) \ + FLAG_Z = res & src; \ + B##op##_WRITE(size, mode, Y) \ + RET(B##op##_CLOCKS_D_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define BITOP_STATIC(op, size, mode) \ +{ \ + EA_READ_I(8, NA, src) \ + src = 1 << (src & (size - 1)); \ + EA_READ_##mode(size, Y, res) \ + FLAG_Z = res & src; \ + B##op##_WRITE(size, mode, Y) \ + RET(B##op##_CLOCKS_S_##size + EA_CLOCKS_##mode##_##size) \ +} + +/****************************************************************************** + OPCODE $1xxx - #3xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + MOVE Move Data from Source to Destination +-----------------------------------------------------------------------------*/ + +#define MOVE_CLOCKS_D_8 4 +#define MOVE_CLOCKS_A_8 4 +#define MOVE_CLOCKS_AI_8 8 +#define MOVE_CLOCKS_PI_8 8 +#define MOVE_CLOCKS_PD_8 8 +#define MOVE_CLOCKS_DI_8 12 +#define MOVE_CLOCKS_IX_8 14 +#define MOVE_CLOCKS_AW_8 12 +#define MOVE_CLOCKS_AL_8 16 +#define MOVE_CLOCKS_PI7_8 8 +#define MOVE_CLOCKS_PD7_8 8 + +#define MOVE_CLOCKS_D_16 4 +#define MOVE_CLOCKS_A_16 4 +#define MOVE_CLOCKS_AI_16 8 +#define MOVE_CLOCKS_PI_16 8 +#define MOVE_CLOCKS_PD_16 8 +#define MOVE_CLOCKS_DI_16 12 +#define MOVE_CLOCKS_IX_16 14 +#define MOVE_CLOCKS_AW_16 12 +#define MOVE_CLOCKS_AL_16 16 +#define MOVE_CLOCKS_PI7_16 8 +#define MOVE_CLOCKS_PD7_16 8 + +#define MOVE_CLOCKS_D_32 4 +#define MOVE_CLOCKS_A_32 4 +#define MOVE_CLOCKS_AI_32 12 +#define MOVE_CLOCKS_PI_32 12 +#define MOVE_CLOCKS_PD_32 12 +#define MOVE_CLOCKS_DI_32 18 +#define MOVE_CLOCKS_IX_32 18 +#define MOVE_CLOCKS_AW_32 16 +#define MOVE_CLOCKS_AL_32 20 +#define MOVE_CLOCKS_PI7_32 12 +#define MOVE_CLOCKS_PD7_32 12 + +#define MOVE(size, modex, modey) \ +{ \ + EA_READ_##modey(size, Y, res) \ + FLAGS(size) \ + EA_WRITE_##modex(size, X, res) \ + RET(MOVE_CLOCKS_##modex##_##size + EA_CLOCKS_##modey##_##size) \ +} + +/*----------------------------------------------------------------------------- + MOVEA Move Address +-----------------------------------------------------------------------------*/ + +#define MOVEA(size, mode) \ +{ \ + EA_READSX_##mode(size, Y, AX) \ + RET(4 + EA_CLOCKS_##mode##_##size) \ +} + +/****************************************************************************** + OPCODE $4xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + NEGX Negate with Extend +-----------------------------------------------------------------------------*/ + +#define NEGX_CLOCKS_D_8 4 +#define NEGX_CLOCKS_D_16 4 +#define NEGX_CLOCKS_D_32 6 + +#define NEGX_CLOCKS_M_8 8 +#define NEGX_CLOCKS_M_16 8 +#define NEGX_CLOCKS_M_32 12 + +#define NEGX(size, clk, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + res = -src - XFLAG_AS_1(); \ + FLAGS_NEGX_##size() \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(NEGX_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + CLR Clear an Operand +-----------------------------------------------------------------------------*/ + +#define CLR_CLOCKS_D_8 4 +#define CLR_CLOCKS_D_16 4 +#define CLR_CLOCKS_D_32 6 + +#define CLR_CLOCKS_M_8 8 +#define CLR_CLOCKS_M_16 8 +#define CLR_CLOCKS_M_32 12 + +#define CLR(size, clk, mode) \ +{ \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_CLEAR; \ + FLAG_Z = ZFLAG_SET; \ + EA_WRITE_##mode(size, Y, 0) \ + RET(CLR_CLOCKS_M_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + NEG Negate +-----------------------------------------------------------------------------*/ + +#define NEG_CLOCKS_D_8 4 +#define NEG_CLOCKS_D_16 4 +#define NEG_CLOCKS_D_32 6 + +#define NEG_CLOCKS_M_8 8 +#define NEG_CLOCKS_M_16 8 +#define NEG_CLOCKS_M_32 12 + +#define NEG(size, clk, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + res = -src; \ + FLAGS_NEG_##size() \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(NEG_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + NOT Logical Complement +-----------------------------------------------------------------------------*/ + +#define NOT_CLOCKS_D_8 4 +#define NOT_CLOCKS_D_16 4 +#define NOT_CLOCKS_D_32 6 + +#define NOT_CLOCKS_M_8 8 +#define NOT_CLOCKS_M_16 8 +#define NOT_CLOCKS_M_32 12 + +#define NOT(size, clk, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + res = ~src; \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_##size(res); \ + FLAG_Z = ZFLAG_##size(res); \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(NOT_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + MOVE from SR Move from the Status Register +-----------------------------------------------------------------------------*/ + +#define MOVE_FRS_CLOCKS_D 6 +#define MOVE_FRS_CLOCKS_M 8 + +#define MOVE_FRS(clk, mode) \ +{ \ + res = GET_SR(); \ + EA_WRITE_##mode(16, Y, res) \ + RET(MOVE_FRS_CLOCKS_##clk + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + MOVE to CCR Move to Condition Code Register +-----------------------------------------------------------------------------*/ + +#define MOVE_TOC(mode) \ +{ \ + EA_READ_##mode(16, Y, res) \ + SET_CCR(res) \ + RET(12 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + MOVE to SR Move to the Status Register +-----------------------------------------------------------------------------*/ + +#define MOVE_TOS(mode) \ +{ \ + if (FLAG_S) \ + { \ + EA_READ_##mode(16, Y, res) \ + SET_SR(res) \ + SWAP_SP() \ + RET_INT(12 + EA_CLOCKS_##mode##_16) \ + } \ + SWAP_SP_NOCHECK() \ + EXCEPTION(C68K_PRIVILEGE_VIOLATION_EX) \ + RET(34 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + NBCD Negate Decimal with Extend +-----------------------------------------------------------------------------*/ + +#define NBCD_CLOCKS_D 6 +#define NBCD_CLOCKS_M 8 + +#define NBCD(clk, mode) \ +{ \ + EA_READ_##mode(8, Y, res) \ + res = 0x9a - res - XFLAG_AS_1(); \ + if (res != 0x9a) \ + { \ + FLAG_V = ~res; \ + if (LOW_NIBBLE(res) == 0x0a) res = HIGH_NIBBLE(res) + 0x10; \ + res &= 0xff; \ + FLAG_V &= res; \ + EA_WRITE_RESULT(8, mode, Y) \ + FLAG_X = XFLAG_SET; \ + FLAG_C = CFLAG_SET; \ + FLAG_Z |= res; \ + } \ + else \ + { \ + FLAG_X = XFLAG_CLEAR; \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + } \ + FLAG_N = res; \ + RET(NBCD_CLOCKS_##clk + EA_CLOCKS_##mode##_8) \ +} + +/*----------------------------------------------------------------------------- + PEA Push Effective Address +-----------------------------------------------------------------------------*/ + +#define PEA_CLOCKS_AI 12 +#define PEA_CLOCKS_DI 16 +#define PEA_CLOCKS_IX 20 +#define PEA_CLOCKS_AW 16 +#define PEA_CLOCKS_AL 20 +#define PEA_CLOCKS_PCDI 16 +#define PEA_CLOCKS_PCIX 20 + +#define PEA(mode) \ +{ \ + EA_##mode(NA, Y) \ + PUSH_32_F(adr) \ + RET(PEA_CLOCKS_##mode) \ +} + +/*----------------------------------------------------------------------------- + MOVEM Move Multiple Registers +-----------------------------------------------------------------------------*/ + +#define MOVEM_CLOCKS_RE_AI 8 +#define MOVEM_CLOCKS_RE_PD 8 +#define MOVEM_CLOCKS_RE_DI 12 +#define MOVEM_CLOCKS_RE_IX 14 +#define MOVEM_CLOCKS_RE_AW 12 +#define MOVEM_CLOCKS_RE_AL 14 + +#define MOVEM_CLOCKS_ER_AI 12 +#define MOVEM_CLOCKS_ER_PI 12 +#define MOVEM_CLOCKS_ER_DI 16 +#define MOVEM_CLOCKS_ER_IX 18 +#define MOVEM_CLOCKS_ER_AW 16 +#define MOVEM_CLOCKS_ER_AL 20 +#define MOVEM_CLOCKS_ER_PCDI 16 +#define MOVEM_CLOCKS_ER_PCIX 18 + +#define MOVEM_RE(size, mode) \ +{ \ + EA_READ_I(16, NA, res) \ + EA_##mode(NA, Y) \ + src = (UINT32)(&D0); \ + dst = adr; \ + do \ + { \ + if (res & 1) \ + { \ + WRITE_MEM_##size(adr, *(UINT##size *)src); \ + adr += (size / 8); \ + } \ + src += 4; \ + } while (res >>= 1); \ + RET(MOVEM_CLOCKS_RE_##mode + ((adr - dst) << 1)) \ +} + +#define MOVEM_RE_PD(size, y) \ +{ \ + EA_READ_I(16, NA, res) \ + adr = A##y; \ + src = (UINT32)(&A7); \ + dst = adr; \ + do \ + { \ + if (res & 1) \ + { \ + adr -= (size / 8); \ + WRITE_MEM_##size##PD(adr, *(UINT##size *)src); \ + } \ + src -= 4; \ + } while (res >>= 1); \ + A##y = adr; \ + RET(MOVEM_CLOCKS_RE_PD + ((dst - adr) << 1)) \ +} + +#define MOVEM_ER(size, mode) \ +{ \ + EA_READ_I(16, NA, res) \ + EA_##mode(NA, Y) \ + src = (UINT32)(&D0); \ + dst = adr; \ + do \ + { \ + if (res & 1) \ + { \ + *(INT32 *)src = READSX_##mode(size, NA); \ + adr += (size / 8); \ + } \ + src += 4; \ + } while (res >>= 1); \ + RET(MOVEM_CLOCKS_ER_##mode + ((adr - dst) << 1)) \ +} + +#define MOVEM_ER_PI(size, y) \ +{ \ + EA_READ_I(16, NA, res) \ + adr = A##y; \ + src = (UINT32)(&D0); \ + dst = adr; \ + do \ + { \ + if (res & 1) \ + { \ + *(INT32 *)src = READSX_MEM_##size(adr); \ + adr += (size / 8); \ + } \ + src += 4; \ + } while (res >>= 1); \ + A##y = adr; \ + RET(MOVEM_CLOCKS_ER_PI + ((adr - dst) << 1)) \ +} + +/*----------------------------------------------------------------------------- + EXT Sign-Extend +-----------------------------------------------------------------------------*/ + +#define EXT(size1, size2) \ +{ \ + EA_READSX_D(size1, Y, res) \ + FLAGS(size1) \ + EA_WRITE_RESULT(size2, D, Y) \ + RET(4) \ +} + +/*----------------------------------------------------------------------------- + TST Test an Operand +-----------------------------------------------------------------------------*/ + +#define TST(size, mode) \ +{ \ + EA_READ_##mode(size, Y, res) \ + FLAGS(size) \ + RET(4 + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + TAS Test and Set an Operand +-----------------------------------------------------------------------------*/ + +#define TAS_CLOCKS_D 4 +#define TAS_CLOCKS_M 14 + +#define TAS(clk, mode) \ +{ \ + EA_READ_##mode(8, Y, res) \ + FLAGS(8) \ + res |= 0x80; \ + EA_WRITE_RESULT(8, mode, Y) \ + RET(TAS_CLOCKS_##clk + EA_CLOCKS_##mode##_8) \ +} + +/*----------------------------------------------------------------------------- + MOVE USP Move User Stack Pointer +-----------------------------------------------------------------------------*/ + +#define MOVEUSP(d, s) \ +{ \ + if (FLAG_S) \ + { \ + d = s; \ + RET(4) \ + } \ + SWAP_SP_NOCHECK() \ + EXCEPTION(C68K_PRIVILEGE_VIOLATION_EX) \ + RET(34) \ +} + +/*----------------------------------------------------------------------------- + JSR Jump to Subroutine +-----------------------------------------------------------------------------*/ + +#define JSR_CLOCKS_AI 16 +#define JSR_CLOCKS_DI 18 +#define JSR_CLOCKS_IX 22 +#define JSR_CLOCKS_AW 18 +#define JSR_CLOCKS_AL 20 +#define JSR_CLOCKS_PCDI 18 +#define JSR_CLOCKS_PCIX 22 + +#define JSR(mode) \ +{ \ + EA_##mode(NA, Y) \ + PUSH_32_F(GET_PC()) \ + SET_PC(adr) \ + RET(JSR_CLOCKS_##mode) \ +} + +/*----------------------------------------------------------------------------- + JMP Jump +-----------------------------------------------------------------------------*/ + +#define JMP_CLOCKS_AI 8 +#define JMP_CLOCKS_DI 10 +#define JMP_CLOCKS_IX 14 +#define JMP_CLOCKS_AW 10 +#define JMP_CLOCKS_AL 12 +#define JMP_CLOCKS_PCDI 10 +#define JMP_CLOCKS_PCIX 14 + +#define JMP(mode) \ +{ \ + EA_##mode(NA, Y) \ + SET_PC(adr) \ + RET(JMP_CLOCKS_##mode) \ +} + +/*----------------------------------------------------------------------------- + CHK Check Register Against Bounds +-----------------------------------------------------------------------------*/ + +#define CHK(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + EA_READ_D(16, X, res) \ + if (((INT32)res < 0) || (res > src)) \ + { \ + FLAG_N = NFLAG_16(res); \ + SWAP_SP() \ + EXCEPTION(C68K_CHK_EX) \ + RET(40 + EA_CLOCKS_##mode##_16) \ + } \ + RET(10 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + LEA Load Effective Address +-----------------------------------------------------------------------------*/ + +#define LEA_CLOCKS_AI 4 +#define LEA_CLOCKS_DI 8 +#define LEA_CLOCKS_IX 12 +#define LEA_CLOCKS_AW 8 +#define LEA_CLOCKS_AL 12 +#define LEA_CLOCKS_PCDI 8 +#define LEA_CLOCKS_PCIX 12 + +#define LEA(mode) \ +{ \ + EA_##mode(NA, Y) \ + AX = adr; \ + RET(LEA_CLOCKS_##mode) \ +} + +/****************************************************************************** + OPCODE $5xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + Scc Set According to Condition +-----------------------------------------------------------------------------*/ + +#define ST_D() \ +{ \ + EA_WRITE_D(8, Y, 0xff) \ + RET(6) \ +} + +#define SF_D() \ +{ \ + EA_WRITE_D(8, Y, 0) \ + RET(4) \ +} + +#define Scc_D(cond) \ +{ \ + if (COND_##cond()) ST_D() \ + SF_D() \ +} + +#define ST(mode) \ +{ \ + EA_WRITE_##mode(8, Y, 0xff) \ + RET(8 + EA_CLOCKS_##mode##_8) \ +} + +#define SF(mode) \ +{ \ + EA_WRITE_##mode(8, Y, 0) \ + RET(8 + EA_CLOCKS_##mode##_8) \ +} + +#define Scc(mode, cond) \ +{ \ + EA_##mode(8, Y) \ + if (COND_##cond()) \ + { \ + WRITE_MEM_8(adr, 0xff); \ + RET(8 + EA_CLOCKS_##mode##_8) \ + } \ + WRITE_MEM_8(adr, 0); \ + RET(8 + EA_CLOCKS_##mode##_8) \ +} + +/*----------------------------------------------------------------------------- + DBcc Test Condition, Decrement, and Branch +-----------------------------------------------------------------------------*/ + +#define DBT() \ +{ \ + PC += 2; \ + RET(12) \ +} + +#define DBF() \ +{ \ + EA_READ_D(16, Y, res) \ + res--; \ + EA_WRITE_RESULT(16, D, Y) \ + if ((INT32)res != -1) \ + { \ + PC += READSX_IMM_16(); \ + ADJUST_PC() \ + SET_PC(PC) \ + RET(10) \ + } \ + PC += 2; \ + RET(14) \ +} + +#define DBcc(cond) \ +{ \ + if (COND_NOT_##cond()) DBF() \ + DBT() \ +} + +/*----------------------------------------------------------------------------- + ADDQ Add Quick +-----------------------------------------------------------------------------*/ + +#define ADDQ_CLOCKS_D_8 4 +#define ADDQ_CLOCKS_D_16 4 +#define ADDQ_CLOCKS_D_32 8 + +#define ADDQ_CLOCKS_M_8 8 +#define ADDQ_CLOCKS_M_16 8 +#define ADDQ_CLOCKS_M_32 12 + +#define ADDQ(size, clk, mode) \ +{ \ + src = GET_QUICK(); \ + EA_READ_##mode(size, Y, dst) \ + OP_ADD(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(ADDQ_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define ADDQ_A(size) \ +{ \ + src = GET_QUICK(); \ + AY += src; \ + RET(8) \ +} + +/*----------------------------------------------------------------------------- + SUBQ Subtract Quick +-----------------------------------------------------------------------------*/ + +#define SUBQ_CLOCKS_D_8 4 +#define SUBQ_CLOCKS_D_16 4 +#define SUBQ_CLOCKS_D_32 8 + +#define SUBQ_CLOCKS_M_8 8 +#define SUBQ_CLOCKS_M_16 8 +#define SUBQ_CLOCKS_M_32 12 + +#define SUBQ(size, clk, mode) \ +{ \ + src = GET_QUICK(); \ + EA_READ_##mode(size, Y, dst) \ + OP_SUB(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(SUBQ_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define SUBQ_A(size) \ +{ \ + src = GET_QUICK(); \ + AY -= src; \ + RET(8) \ +} + +/****************************************************************************** + OPCODE $6xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + Bcc Branch Conditionally +-----------------------------------------------------------------------------*/ + +#define Bcc_8(cond) \ +{ \ + if (COND_##cond()) \ + { \ + PC += MAKE_INT_8(Opcode); \ + RET(10) \ + } \ + RET(8) \ +} + +#define Bcc_16(cond) \ +{ \ + if (COND_##cond()) \ + { \ + PC += READSX_IMM_16(); \ + ADJUST_PC() \ + SET_PC(PC) \ + RET(10) \ + } \ + PC += 2; \ + RET(12) \ +} + +/****************************************************************************** + OPCODE $8xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + OR inclusive-OR logical +-----------------------------------------------------------------------------*/ + +/* + (*) The base time of six clock periods is increased to eight if the + effective address mode is register direct or immediate (effective + address time should also be added). +*/ + +#define OR_CLOCKS_ER_8 4 +#define OR_CLOCKS_ER_16 4 +#define OR_CLOCKS_ER_32 6 // * + +#define OR_CLOCKS_RE_8 8 +#define OR_CLOCKS_RE_16 8 +#define OR_CLOCKS_RE_32 12 + +#define OR_ER_RI32(mode) \ +{ \ + EA_READ_##mode(32, Y, src) \ + EA_READ_D(32, X, res) \ + OP_OR(32) \ + EA_WRITE_RESULT(32, D, X) \ + RET(8 + EA_CLOCKS_##mode##_32) \ +} + +#define OR_ER(size, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + EA_READ_D(size, X, res) \ + OP_OR(size) \ + EA_WRITE_RESULT(size, D, X) \ + RET(OR_CLOCKS_ER_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define OR_RE(size, mode) \ +{ \ + EA_READ_D(size, X, src) \ + EA_READ_##mode(size, Y, res) \ + OP_OR(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(OR_CLOCKS_RE_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + SBCD Subtract Decimal with Extend +-----------------------------------------------------------------------------*/ + +#define SBCD_CLOCKS_D 6 +#define SBCD_CLOCKS_M 18 + +#define SBCD(clk, modex, modey) \ +{ \ + EA_READ_##modey(8, Y, src) \ + EA_READ_##modex(8, X, dst) \ + FLAG_V = VFLAG_CLEAR; \ + res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1(); \ + if (res > 9) res -= 6; \ + res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src); \ + if (res > 0x99) \ + { \ + res += 0xa0; \ + FLAG_X = XFLAG_SET; \ + FLAG_C = CFLAG_SET; \ + FLAG_N = NFLAG_SET; \ + } \ + else \ + { \ + FLAG_X = XFLAG_CLEAR; \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_N = NFLAG_CLEAR; \ + } \ + FLAG_Z |= ZFLAG_8(res); \ + EA_WRITE_RESULT(8, modex, X) \ + RET(SBCD_CLOCKS_##clk) \ +} + +/*----------------------------------------------------------------------------- + DIVU Unsigned Divide +-----------------------------------------------------------------------------*/ + +#define DIVU(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + if (src) \ + { \ + EA_READ_D(32, X, dst) \ + res = dst / src; \ + if (res & 0xffff0000) /* overflow */ \ + { \ + FLAG_V = VFLAG_SET; \ + RET(70 + EA_CLOCKS_##mode##_16) \ + } \ + res &= 0x0000ffff; \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = res; \ + res |= (dst % src) << 16; \ + EA_WRITE_RESULT(32, D, X) \ + RET(90 + EA_CLOCKS_##mode##_16) \ + } \ + SWAP_SP() \ + EXCEPTION(C68K_ZERO_DIVIDE_EX) \ + RET(38 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + DIVS Signed Divide +-----------------------------------------------------------------------------*/ + +#define DIVS(mode) \ +{ \ + EA_READSX_##mode(16, Y, src) \ + if (src) \ + { \ + EA_READ_D(32, X, dst) \ + if (((UINT32)dst == 0x80000000) && ((INT32)src == -1)) \ + { \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_CLEAR; \ + FLAG_Z = ZFLAG_SET; \ + WRITE_REG_32(DX, 0); \ + RET(50 + EA_CLOCKS_##mode##_16) \ + } \ + else \ + { \ + INT32 quotient = (INT32)dst / (INT32)src; \ + if (quotient > 0x7fff || quotient < -0x8000) \ + { \ + FLAG_V = VFLAG_SET; \ + RET(80 + EA_CLOCKS_##mode##_16) \ + } \ + else \ + { \ + INT32 remainder = (INT32)dst % (INT32)src; \ + quotient &= 0x0000ffff; \ + FLAG_C = CFLAG_CLEAR; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(quotient); \ + FLAG_Z = quotient; \ + res = quotient | (remainder << 16); \ + EA_WRITE_RESULT(32, D, X) \ + RET(108 + EA_CLOCKS_##mode##_16) \ + } \ + } \ + } \ + SWAP_SP() \ + EXCEPTION(C68K_ZERO_DIVIDE_EX) \ + RET(38 + EA_CLOCKS_##mode##_16) \ +} + +/****************************************************************************** + OPCODE $9xxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + SUB Subtract +-----------------------------------------------------------------------------*/ + +/* + (*) The base time of six clock periods is increased to eight if the + effective address mode is register direct or immediate (effective + address time should also be added). +*/ + +#define SUB_CLOCKS_ER_8 4 +#define SUB_CLOCKS_ER_16 4 +#define SUB_CLOCKS_ER_32 6 // * + +#define SUB_CLOCKS_RE_8 8 +#define SUB_CLOCKS_RE_16 8 +#define SUB_CLOCKS_RE_32 12 + +#define SUB_ER_RI32(mode) \ +{ \ + EA_READ_##mode(32, Y, src) \ + EA_READ_D(32, X, dst) \ + OP_SUB(32) \ + EA_WRITE_RESULT(32, D, X) \ + RET(8 + EA_CLOCKS_##mode##_32) \ +} + +#define SUB_ER(size, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + EA_READ_D(size, X, dst) \ + OP_SUB(size) \ + EA_WRITE_RESULT(size, D, X) \ + RET(SUB_CLOCKS_ER_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define SUB_RE(size, mode) \ +{ \ + EA_READ_D(size, X, src) \ + EA_READ_##mode(size, Y, dst) \ + OP_SUB(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(SUB_CLOCKS_RE_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + SUBX Subtract with Extend +-----------------------------------------------------------------------------*/ + +#define SUBX_CLOCKS_D_8 4 +#define SUBX_CLOCKS_D_16 4 +#define SUBX_CLOCKS_D_32 8 + +#define SUBX_CLOCKS_M_8 18 +#define SUBX_CLOCKS_M_16 18 +#define SUBX_CLOCKS_M_32 30 + +#define SUBX(size, clk, modex, modey) \ +{ \ + EA_READ_##modey(size, Y, src) \ + EA_READ_##modex(size, X, dst) \ + res = dst - src - XFLAG_AS_1(); \ + FLAGS_SUBX_##size() \ + EA_WRITE_RESULT(size, modex, X) \ + RET(SUBX_CLOCKS_##clk##_##size) \ +} + +/*----------------------------------------------------------------------------- + SUBA Subtract Address +-----------------------------------------------------------------------------*/ + +/* + (*) The base time of six clock periods is increased to eight if the + effective address mode is register direct or immediate (effective + address time should also be added). +*/ + +#define SUBA_CLOCKS_16 8 +#define SUBA_CLOCKS_32 6 // * + +#define SUBA_RI32(mode) \ +{ \ + EA_READSX_##mode(32, Y, src) \ + AX -= src; \ + RET(8 + EA_CLOCKS_##mode##_32) \ +} + +#define SUBA(size, mode) \ +{ \ + EA_READSX_##mode(size, Y, src) \ + AX -= src; \ + RET(SUBA_CLOCKS_##size + EA_CLOCKS_##mode##_##size) \ +} + +/****************************************************************************** + OPCODE $Bxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + CMP Compare +-----------------------------------------------------------------------------*/ + +#define CMP_CLOCKS_8 4 +#define CMP_CLOCKS_16 4 +#define CMP_CLOCKS_32 6 + +#define CMP(size, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + EA_READ_D(size, X, dst) \ + OP_CMP(size) \ + RET(CMP_CLOCKS_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + CMPM Compare Memory +-----------------------------------------------------------------------------*/ + +#define CMPM_CLOCKS_8 12 +#define CMPM_CLOCKS_16 12 +#define CMPM_CLOCKS_32 20 + +#define CMPM(size, modex, modey) \ +{ \ + EA_READ_##modey(size, Y, src) \ + EA_READ_##modex(size, X, dst) \ + OP_CMP(size) \ + RET(CMPM_CLOCKS_##size) \ +} + +/*----------------------------------------------------------------------------- + EOR Exclusive-OR logical +-----------------------------------------------------------------------------*/ + +#define EOR_CLOCKS_D_8 4 +#define EOR_CLOCKS_D_16 4 +#define EOR_CLOCKS_D_32 8 + +#define EOR_CLOCKS_M_8 8 +#define EOR_CLOCKS_M_16 8 +#define EOR_CLOCKS_M_32 12 + +#define EOR(size, clk, mode) \ +{ \ + EA_READ_D(size, X, src) \ + EA_READ_##mode(size, Y, res) \ + OP_EOR(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(EOR_CLOCKS_##clk##_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + CMPA Compare +-----------------------------------------------------------------------------*/ + +#define CMPA(size, mode) \ +{ \ + EA_READSX_##mode(size, Y, src) \ + EA_READ_A(32, X, dst) \ + OP_CMP(32) \ + RET(6 + EA_CLOCKS_##mode##_##size) \ +} + +/****************************************************************************** + OPCODE $Cxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + AND AND logical +-----------------------------------------------------------------------------*/ + +/* + (*) The base time of six clock periods is increased to eight if the + effective address mode is register direct or immediate (effective + address time should also be added). +*/ + +#define AND_CLOCKS_ER_8 4 +#define AND_CLOCKS_ER_16 4 +#define AND_CLOCKS_ER_32 6 // * + +#define AND_CLOCKS_RE_8 8 +#define AND_CLOCKS_RE_16 8 +#define AND_CLOCKS_RE_32 12 + +#define AND_ER_RI32(mode) \ +{ \ + EA_READ_##mode(32, Y, src) \ + EA_READ_D(32, X, res) \ + OP_AND(32) \ + EA_WRITE_RESULT(32, D, X) \ + RET(8 + EA_CLOCKS_##mode##_32) \ +} + +#define AND_ER(size, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + EA_READ_D(size, X, res) \ + OP_AND(size) \ + EA_WRITE_RESULT(size, D, X) \ + RET(AND_CLOCKS_ER_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define AND_RE(size, mode) \ +{ \ + EA_READ_D(size, X, src) \ + EA_READ_##mode(size, Y, res) \ + OP_AND(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(AND_CLOCKS_RE_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + ABCD Add Decimal with Extend +-----------------------------------------------------------------------------*/ + +#define ABCD_CLOCKS_D 6 +#define ABCD_CLOCKS_M 18 + +#define ABCD(clk, modex, modey) \ +{ \ + EA_READ_##modey(8, Y, src) \ + EA_READ_##modex(8, X, dst) \ + res = LOW_NIBBLE(dst) + LOW_NIBBLE(src) + XFLAG_AS_1(); \ + FLAG_V = ~res; \ + if (res > 9) res += 6; \ + res += HIGH_NIBBLE(dst) + HIGH_NIBBLE(src); \ + if (res > 0x99) \ + { \ + res -= 0xa0; \ + FLAG_X = XFLAG_SET; \ + FLAG_C = CFLAG_SET; \ + } \ + else \ + { \ + FLAG_X = XFLAG_CLEAR; \ + FLAG_C = CFLAG_CLEAR; \ + } \ + FLAG_V &= res; \ + FLAG_N = res; \ + FLAG_Z |= ZFLAG_8(res); \ + EA_WRITE_RESULT(8, modex, X) \ + RET(ABCD_CLOCKS_##clk) \ +} + +/*----------------------------------------------------------------------------- + MULU Unsigned Multiply +-----------------------------------------------------------------------------*/ + +#define MULU(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + EA_READ_D(16, X, res) \ + res = res * src; \ + FLAGS(32) \ + EA_WRITE_RESULT(32, D, X) \ + RET(50 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + MULS Signed Multiply +-----------------------------------------------------------------------------*/ + +#define MULS(mode) \ +{ \ + EA_READSX_##mode(16, Y, src) \ + EA_READSX_D(16, X, res) \ + res = (INT32)res * (INT32)src; \ + FLAGS(32) \ + EA_WRITE_RESULT(32, D, X) \ + RET(50 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + EXG Exchange Registers +-----------------------------------------------------------------------------*/ + +#define EXG(regx, regy) \ +{ \ + res = regy##Y; \ + regy##Y = regx##X; \ + regx##X = res; \ + RET(6) \ +} + +/****************************************************************************** + OPCODE $Dxxx +******************************************************************************/ + +/*----------------------------------------------------------------------------- + ADD Add +-----------------------------------------------------------------------------*/ + +/* + (*) The base time of six clock periods is increased to eight if the + effective address mode is register direct or immediate (effective + address time should also be added). +*/ + +#define ADD_CLOCKS_ER_8 4 +#define ADD_CLOCKS_ER_16 4 +#define ADD_CLOCKS_ER_32 6 // * + +#define ADD_CLOCKS_RE_8 8 +#define ADD_CLOCKS_RE_16 8 +#define ADD_CLOCKS_RE_32 12 + +#define ADD_ER_RI32(mode) \ +{ \ + EA_READ_##mode(32, Y, src) \ + EA_READ_D(32, X, dst) \ + OP_ADD(32) \ + EA_WRITE_RESULT(32, D, X) \ + RET(8 + EA_CLOCKS_##mode##_32) \ +} + +#define ADD_ER(size, mode) \ +{ \ + EA_READ_##mode(size, Y, src) \ + EA_READ_D(size, X, dst) \ + OP_ADD(size) \ + EA_WRITE_RESULT(size, D, X) \ + RET(ADD_CLOCKS_ER_##size + EA_CLOCKS_##mode##_##size) \ +} + +#define ADD_RE(size, mode) \ +{ \ + EA_READ_D(size, X, src) \ + EA_READ_##mode(size, Y, dst) \ + OP_ADD(size) \ + EA_WRITE_RESULT(size, mode, Y) \ + RET(ADD_CLOCKS_RE_##size + EA_CLOCKS_##mode##_##size) \ +} + +/*----------------------------------------------------------------------------- + ADDX Subtract with Extend +-----------------------------------------------------------------------------*/ + +#define ADDX_CLOCKS_D_8 4 +#define ADDX_CLOCKS_D_16 4 +#define ADDX_CLOCKS_D_32 8 + +#define ADDX_CLOCKS_M_8 18 +#define ADDX_CLOCKS_M_16 18 +#define ADDX_CLOCKS_M_32 30 + +#define ADDX(size, clk, modex, modey) \ +{ \ + EA_READ_##modey(size, Y, src) \ + EA_READ_##modex(size, X, dst) \ + res = dst + src + XFLAG_AS_1(); \ + FLAGS_ADDX_##size() \ + EA_WRITE_RESULT(size, modex, X) \ + RET(ADDX_CLOCKS_##clk##_##size) \ +} + +/*----------------------------------------------------------------------------- + ADDA Add Address +-----------------------------------------------------------------------------*/ + +/* + (*) The base time of six clock periods is increased to eight if the + effective address mode is register direct or immediate (effective + address time should also be added). +*/ + +#define ADDA_CLOCKS_16 8 +#define ADDA_CLOCKS_32 6 // * + +#define ADDA_RI32(mode) \ +{ \ + EA_READSX_##mode(32, Y, src) \ + AX += src; \ + RET(8 + EA_CLOCKS_##mode##_32) \ +} + +#define ADDA(size, mode) \ +{ \ + EA_READSX_##mode(size, Y, src) \ + AX += src; \ + RET(ADDA_CLOCKS_##size + EA_CLOCKS_##mode##_##size) \ +} + +/****************************************************************************** + OPCODE $Exxx +******************************************************************************/ + +#define SHIFT_ROTATE_CLOCKS_8 6 +#define SHIFT_ROTATE_CLOCKS_16 6 +#define SHIFT_ROTATE_CLOCKS_32 8 + +/*----------------------------------------------------------------------------- + ASR Arithmetic Shift Right +-----------------------------------------------------------------------------*/ + +#define ASR_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = (src >> 1) | (src & (1 << 15)); \ + FLAG_X = FLAG_C = src << 8; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = res; \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + LSR Logical Shift Right +-----------------------------------------------------------------------------*/ + +#define LSR_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = src >> 1; \ + FLAG_X = FLAG_C = src << 8; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_CLEAR; \ + FLAG_Z = res; \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + ROXR Rotate Right with Extend +-----------------------------------------------------------------------------*/ + +#define ROXR_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = (src >> 1) | (XFLAG_AS_1() << 15); \ + FLAG_X = FLAG_C = src << 8; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = res; \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + ROR Rotate Right +-----------------------------------------------------------------------------*/ + +#define ROR_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = (src >> 1) | (src << 15); \ + FLAG_C = src << 8; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + ASL Arithmetic Shift Left +-----------------------------------------------------------------------------*/ + +#define ASL_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = src << 1; \ + FLAG_X = FLAG_C = src >> 7; \ + FLAG_V = (src ^ res) >> 8; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + LSL Logical Shift Left +-----------------------------------------------------------------------------*/ + +#define LSL_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = src << 1; \ + FLAG_X = FLAG_C = src >> 7; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + ROXL Rotate Right with Extend +-----------------------------------------------------------------------------*/ + +#define ROXL_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = (src << 1) | XFLAG_AS_1(); \ + FLAG_X = FLAG_C = src >> 7; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} + +/*----------------------------------------------------------------------------- + ROL Rotate Left +-----------------------------------------------------------------------------*/ + +#define ROL_EA(mode) \ +{ \ + EA_READ_##mode(16, Y, src) \ + res = (src << 1) | (src >> 15); \ + FLAG_C = src >> 7; \ + FLAG_V = VFLAG_CLEAR; \ + FLAG_N = NFLAG_16(res); \ + FLAG_Z = ZFLAG_16(res); \ + EA_WRITE_RESULT(16, mode, Y) \ + RET(8 + EA_CLOCKS_##mode##_16) \ +} diff --git a/m68000/old/m68000.c b/m68000/old/m68000.c new file mode 100644 index 0000000..3ddb55b --- /dev/null +++ b/m68000/old/m68000.c @@ -0,0 +1,312 @@ +/****************************************************************************** + + m68000.c + + M68000 CPUインタフェース関数 + +******************************************************************************/ + +#include "m68000.h" +#include "c68k.h" +#include "../x68k/memory.h" + +/****************************************************************************** + CPS2暗号化ROM用 +******************************************************************************/ + +#if (EMU_SYSTEM == CPS2) +static UINT32 m68k_encrypt_start; +static UINT32 m68k_encrypt_end; +static UINT8 *m68k_decrypted_rom; + +/*-------------------------------------------------------- + 暗号化ROM範囲設定 +--------------------------------------------------------*/ + +void m68000_set_encrypted_range(UINT32 start, UINT32 end, void *decrypted_rom) +{ + m68k_encrypt_start = start; + m68k_encrypt_end = end; + m68k_decrypted_rom = (UINT8 *)decrypted_rom; +} + + +/*-------------------------------------------------------- + PC依存メモリリード (byte) +--------------------------------------------------------*/ + +static UINT8 m68000_read_pcrelative_8(UINT32 offset) +{ + if (offset >= m68k_encrypt_start && offset <= m68k_encrypt_end) + return m68k_decrypted_rom[offset ^ 1]; + else + return Memory_ReadB(offset); +} + + +/*-------------------------------------------------------- + PC依存メモリリード (word) +--------------------------------------------------------*/ + +static UINT16 m68000_read_pcrelative_16(UINT32 offset) +{ + if (offset >= m68k_encrypt_start && offset <= m68k_encrypt_end) + return *(UINT16 *)&m68k_decrypted_rom[offset]; + else + return Memory_ReadW(offset); +} +#endif + + +/****************************************************************************** + M68000インタフェース関数 +******************************************************************************/ + +/*-------------------------------------------------------- + CPU初期化 +--------------------------------------------------------*/ + +void m68000_init(void) +{ + C68k_Init(&C68K); + C68k_Set_ReadB(&C68K, Memory_ReadB); + C68k_Set_ReadW(&C68K, Memory_ReadW); + C68k_Set_WriteB(&C68K, Memory_WriteB); + C68k_Set_WriteW(&C68K, Memory_WriteW); + C68k_Set_Fetch(&C68K, 0x000000, 0xbfffff, (UINT32)MEM); + C68k_Set_Fetch(&C68K, 0xc00000, 0xc7ffff, (UINT32)GVRAM); + C68k_Set_Fetch(&C68K, 0xe00000, 0xe7ffff, (UINT32)TVRAM); + C68k_Set_Fetch(&C68K, 0xea0000, 0xea1fff, (UINT32)SCSIIPL); + C68k_Set_Fetch(&C68K, 0xed0000, 0xed3fff, (UINT32)SRAM); + C68k_Set_Fetch(&C68K, 0xf00000, 0xfbffff, (UINT32)FONT); + C68k_Set_Fetch(&C68K, 0xfc0000, 0xffffff, (UINT32)IPL); +} + + +/*-------------------------------------------------------- + CPUリセット +--------------------------------------------------------*/ + +void m68000_reset(void) +{ + C68k_Reset(&C68K); +} + + +/*-------------------------------------------------------- + CPU停止 +--------------------------------------------------------*/ + +void m68000_exit(void) +{ +} + + +/*-------------------------------------------------------- + CPU実行 +--------------------------------------------------------*/ + +int m68000_execute(int cycles) +{ + return C68k_Exec(&C68K, cycles); +} + + +/*-------------------------------------------------------- + CPU実行 (NEOGEO CDZ専用: ロード画面用) +--------------------------------------------------------*/ + +#if (EMU_SYSTEM == NCDZ) +void m68000_execute2(UINT32 start, UINT32 break_point) +{ + int nest_counter = 0; + UINT32 pc, old_pc, opcode; + c68k_struc C68K_temp; + + old_pc = C68k_Get_Reg(&C68K, M68K_PC); + + memcpy(&C68K_temp, &C68K, sizeof(c68k_struc)); + + C68k_Set_Reg(&C68K_temp, C68K_PC, start); + C68K_temp.A[5] = 0x108000; + C68K_temp.A[7] -= 4 * 8 * 2; + + while ((pc = C68k_Get_Reg(&C68K_temp, M68K_PC)) != break_point) + { + opcode = Memory_ReadW(pc); + if (opcode == 0x4e75) + { + // rts + nest_counter--; + if (nest_counter < 0) break; + } + else if (opcode == 0x6100) + { + // bsr 16 + nest_counter++; + } + else if ((opcode & 0xff00) == 0x6100) + { + // bsr 8 + nest_counter++; + } + else if ((opcode & 0xffc0) == 0x4e80) + { + // jsr + nest_counter++; + } + + C68k_Exec(&C68K_temp, 1); + } + + C68k_Set_Reg(&C68K, C68K_PC, old_pc); +} +#endif + + +/*-------------------------------------------------------- + 割り込み処理 +--------------------------------------------------------*/ + +void m68000_set_irq_line(int irqline, int state) +{ + if (irqline == IRQ_LINE_NMI) + irqline = 7; + + C68k_Set_IRQ(&C68K, irqline, state); +} + + +/*-------------------------------------------------------- + 割り込みコールバック関数設定 +--------------------------------------------------------*/ + +void m68000_set_irq_callback(int (*callback)(int line)) +{ + C68k_Set_IRQ_Callback(&C68K, callback); +} + + +/*-------------------------------------------------------- + レジスタ取得 +--------------------------------------------------------*/ + +UINT32 m68000_get_reg(int regnum) +{ + switch (regnum) + { + case M68K_PC: return C68k_Get_Reg(&C68K, C68K_PC); + case M68K_USP: return C68k_Get_Reg(&C68K, C68K_USP); + case M68K_MSP: return C68k_Get_Reg(&C68K, C68K_MSP); + case M68K_SR: return C68k_Get_Reg(&C68K, C68K_SR); + case M68K_D0: return C68k_Get_Reg(&C68K, C68K_D0); + case M68K_D1: return C68k_Get_Reg(&C68K, C68K_D1); + case M68K_D2: return C68k_Get_Reg(&C68K, C68K_D2); + case M68K_D3: return C68k_Get_Reg(&C68K, C68K_D3); + case M68K_D4: return C68k_Get_Reg(&C68K, C68K_D4); + case M68K_D5: return C68k_Get_Reg(&C68K, C68K_D5); + case M68K_D6: return C68k_Get_Reg(&C68K, C68K_D6); + case M68K_D7: return C68k_Get_Reg(&C68K, C68K_D7); + case M68K_A0: return C68k_Get_Reg(&C68K, C68K_A0); + case M68K_A1: return C68k_Get_Reg(&C68K, C68K_A1); + case M68K_A2: return C68k_Get_Reg(&C68K, C68K_A2); + case M68K_A3: return C68k_Get_Reg(&C68K, C68K_A3); + case M68K_A4: return C68k_Get_Reg(&C68K, C68K_A4); + case M68K_A5: return C68k_Get_Reg(&C68K, C68K_A5); + case M68K_A6: return C68k_Get_Reg(&C68K, C68K_A6); + case M68K_A7: return C68k_Get_Reg(&C68K, C68K_A7); + default: return 0; + } +} + + +/*-------------------------------------------------------- + レジスタ設定 +--------------------------------------------------------*/ + +void m68000_set_reg(int regnum, UINT32 val) +{ + switch (regnum) + { + case M68K_PC: C68k_Set_Reg(&C68K, C68K_PC, val); break; + case M68K_USP: C68k_Set_Reg(&C68K, C68K_USP, val); break; + case M68K_MSP: C68k_Set_Reg(&C68K, C68K_MSP, val); break; + case M68K_SR: C68k_Set_Reg(&C68K, C68K_SR, val); break; + case M68K_D0: C68k_Set_Reg(&C68K, C68K_D0, val); break; + case M68K_D1: C68k_Set_Reg(&C68K, C68K_D1, val); break; + case M68K_D2: C68k_Set_Reg(&C68K, C68K_D2, val); break; + case M68K_D3: C68k_Set_Reg(&C68K, C68K_D3, val); break; + case M68K_D4: C68k_Set_Reg(&C68K, C68K_D4, val); break; + case M68K_D5: C68k_Set_Reg(&C68K, C68K_D5, val); break; + case M68K_D6: C68k_Set_Reg(&C68K, C68K_D6, val); break; + case M68K_D7: C68k_Set_Reg(&C68K, C68K_D7, val); break; + case M68K_A0: C68k_Set_Reg(&C68K, C68K_A0, val); break; + case M68K_A1: C68k_Set_Reg(&C68K, C68K_A1, val); break; + case M68K_A2: C68k_Set_Reg(&C68K, C68K_A2, val); break; + case M68K_A3: C68k_Set_Reg(&C68K, C68K_A3, val); break; + case M68K_A4: C68k_Set_Reg(&C68K, C68K_A4, val); break; + case M68K_A5: C68k_Set_Reg(&C68K, C68K_A5, val); break; + case M68K_A6: C68k_Set_Reg(&C68K, C68K_A6, val); break; + case M68K_A7: C68k_Set_Reg(&C68K, C68K_A7, val); break; + default: break; + } +} + + +/*------------------------------------------------------ + セーブ/ロード ステート +------------------------------------------------------*/ + +#ifdef SAVE_STATE + +STATE_SAVE( m68000 ) +{ + int i; + UINT32 pc = C68k_Get_Reg(&C68K, C68K_PC); + + for (i = 0; i < 8; i++) + state_save_long(&C68K.D[i], 1); + for (i = 0; i < 8; i++) + state_save_long(&C68K.A[i], 1); + + state_save_long(&C68K.flag_C, 1); + state_save_long(&C68K.flag_V, 1); + state_save_long(&C68K.flag_Z, 1); + state_save_long(&C68K.flag_N, 1); + state_save_long(&C68K.flag_X, 1); + state_save_long(&C68K.flag_I, 1); + state_save_long(&C68K.flag_S, 1); + state_save_long(&C68K.USP, 1); + state_save_long(&pc, 1); + state_save_long(&C68K.HaltState, 1); + state_save_long(&C68K.IRQLine, 1); + state_save_long(&C68K.IRQState, 1); +} + +STATE_LOAD( m68000 ) +{ + int i; + UINT32 pc; + + for (i = 0; i < 8; i++) + state_load_long(&C68K.D[i], 1); + for (i = 0; i < 8; i++) + state_load_long(&C68K.A[i], 1); + + state_load_long(&C68K.flag_C, 1); + state_load_long(&C68K.flag_V, 1); + state_load_long(&C68K.flag_Z, 1); + state_load_long(&C68K.flag_N, 1); + state_load_long(&C68K.flag_X, 1); + state_load_long(&C68K.flag_I, 1); + state_load_long(&C68K.flag_S, 1); + state_load_long(&C68K.USP, 1); + state_load_long(&pc, 1); + state_load_long(&C68K.HaltState, 1); + state_load_long(&C68K.IRQLine, 1); + state_load_long(&C68K.IRQState, 1); + + C68k_Set_Reg(&C68K, C68K_PC, pc); +} + +#endif /* SAVE_STATE */ diff --git a/m68000/old/m68000.h b/m68000/old/m68000.h new file mode 100644 index 0000000..2665e9b --- /dev/null +++ b/m68000/old/m68000.h @@ -0,0 +1,45 @@ +/****************************************************************************** + + m68000.c + + M68000 CPUインタフェース関数 + +******************************************************************************/ + +#ifndef M68000_H +#define M68000_H + +#include "c68k.h" + +// MAME互換のレジスタ番号 (一部未対応) +enum +{ + /* NOTE: M68K_SP fetches the current SP, be it USP, ISP, or MSP */ + M68K_PC=1, M68K_SP, M68K_ISP, M68K_USP, M68K_MSP, M68K_SR, M68K_VBR, + M68K_SFC, M68K_DFC, M68K_CACR, M68K_CAAR, M68K_PREF_ADDR, M68K_PREF_DATA, + M68K_D0, M68K_D1, M68K_D2, M68K_D3, M68K_D4, M68K_D5, M68K_D6, M68K_D7, + M68K_A0, M68K_A1, M68K_A2, M68K_A3, M68K_A4, M68K_A5, M68K_A6, M68K_A7 +}; + +void m68000_init(void); +void m68000_reset(void); +void m68000_exit(void); +int m68000_execute(int cycles); +#if (EMU_SYSTEM == NCDZ) +void m68000_execute2(UINT32 start_pc, UINT32 break_point); +#endif +void m68000_set_irq_line(int irqline, int state); +void m68000_set_irq_callback(int (*callback)(int irqline)); +UINT32 m68000_get_reg(int regnum); +void m68000_set_reg(int regnum, UINT32 val); + +#if (EMU_SYSTEM == CPS2) +void m68000_set_encrypted_range(UINT32 start, UINT32 end, void *decrypted_rom); +#endif + +#ifdef SAVE_STATE +STATE_SAVE( m68000 ); +STATE_LOAD( m68000 ); +#endif + +#endif /* M68000_H */ diff --git a/win32api/dosio.c b/win32api/dosio.c index 4db2f1a..a5b1a6a 100644 --- a/win32api/dosio.c +++ b/win32api/dosio.c @@ -35,6 +35,10 @@ #include "dosio.h" +#ifdef __LIBRETRO__ +extern char slash; +#endif + static char curpath[MAX_PATH+32] = ""; static LPSTR curfilep = curpath; @@ -260,7 +264,7 @@ getFileName(LPSTR filename) LPSTR p, q; for (p = q = filename; *p != '\0'; p++) - if (*p == '/') + if (*p == slash/*'/'*/) q = p + 1; return q; } @@ -271,7 +275,7 @@ cutFileName(LPSTR filename) LPSTR p, q; for (p = filename, q = NULL; *p != '\0'; p++) - if (*p == '/') + if (*p == slash/*'/'*/) q = p + 1; if (q != NULL) *q = '\0'; @@ -375,7 +379,7 @@ cutyen(LPSTR str) { int pos = strlen(str) - 1; - if ((pos > 0) && (str[pos] == '/')) + if ((pos > 0) && (str[pos] == slash/*'/'*/)) str[pos] = '\0'; } @@ -385,12 +389,12 @@ plusyen(LPSTR str, int len) int pos = strlen(str); if (pos) { - if (str[pos-1] == '/') + if (str[pos-1] == slash/*'/'*/) return; } if ((pos + 2) >= len) return; - str[pos++] = '/'; + str[pos++] = slash/*'/'*/; str[pos] = '\0'; } @@ -404,7 +408,7 @@ fname_mix(LPSTR str, LPSTR mix, int size) char check; cutFileName(str); - if (mix[0] == '/') + if (mix[0] == slash/*'/'*/) str[0] = '\0'; len = strlen(str); @@ -417,12 +421,12 @@ fname_mix(LPSTR str, LPSTR mix, int size) if (c == check) { /* current dir */ - if (mix[0] == '/') { + if (mix[0] == slash/*'/'*/) { mix++; continue; } /* parent dir */ - if (mix[0] == '.' && mix[1] == '/') { + if (mix[0] == '.' && mix[1] == slash/*'/'*/) { mix += 2; cutyen(str); cutFileName(str); @@ -431,7 +435,7 @@ fname_mix(LPSTR str, LPSTR mix, int size) continue; } } - if (c == '/') + if (c == slash/*'/'*/) check = '.'; else check = 0; diff --git a/win32api/dosio.h b/win32api/dosio.h index d8a7dd3..4206486 100644 --- a/win32api/dosio.h +++ b/win32api/dosio.h @@ -157,6 +157,9 @@ void fname_mix(LPSTR str, LPSTR mix, int size); #define DD_YEAR_MASK 0xFE00 /* year - 1980 */ #define DD_YEAR_SHIFT 9 +#ifdef _WIN32 +typedef unsigned int u_int; +#endif void unix2dostime(time_t t, unsigned short *ddp, unsigned short *dtp, unsigned char *dhp); void dos2unixtime(u_int dd, u_int dt, u_int dh, time_t *tp); diff --git a/win32api/fake.c b/win32api/fake.c index 3ae4b4e..c3e82b1 100644 --- a/win32api/fake.c +++ b/win32api/fake.c @@ -60,14 +60,14 @@ PostQuitMessage(int m) exit(m); } - +#ifndef _WIN32 DWORD WINAPI GetLastError(VOID) { return NO_ERROR; } - +#endif BOOL WINAPI SetEndOfFile(HANDLE hFile) { diff --git a/win32api/peace.c b/win32api/peace.c index 4d48fe0..180f4fc 100644 --- a/win32api/peace.c +++ b/win32api/peace.c @@ -69,7 +69,10 @@ enum { HTYPE_CONSOLE, HTYPE_KEY, }; - +#ifdef _WIN32 +typedef unsigned int u_int; +#define bzero(s,d) memset(s,1,d) +#endif struct internal_handle { void *p; u_int flags; @@ -107,7 +110,7 @@ struct internal_file { #define DPRF(arg) #endif /* DEBUG */ - +#ifndef _WIN32 DWORD WINAPI GetTickCount(void) { @@ -116,7 +119,7 @@ GetTickCount(void) gettimeofday(&tv, 0); return tv.tv_usec / 1000 + tv.tv_sec * 1000; } - +#endif BOOL WINAPI ReadFile(HANDLE h, PVOID buf, DWORD len, PDWORD lp, LPOVERLAPPED lpov) { @@ -213,7 +216,7 @@ SetFilePointer(HANDLE h, LONG pos, PLONG newposh, DWORD whence) newpos = lseek(fd, pos, whence); return newpos; } - +#ifndef _WIN32 BOOL WINAPI CloseHandle(HANDLE h) { @@ -233,7 +236,7 @@ CloseHandle(HANDLE h) LocalFree(h); return TRUE; } - +#endif DWORD WINAPI GetFileAttributes(LPCSTR path) { diff --git a/x11/mouse.c b/x11/mouse.c index 4499a4a..d4c7b6e 100644 --- a/x11/mouse.c +++ b/x11/mouse.c @@ -59,7 +59,7 @@ void Mouse_Init(void) // ---------------------------------- void Mouse_Event(int param, float dx, float dy) { - printf("ME(): %f %f\n", dx, dy); + //printf("ME(): %f %f\n", dx, dy); if (MouseSW) { switch (param) { diff --git a/x11/prop.c b/x11/prop.c index 471036a..e6486ce 100644 --- a/x11/prop.c +++ b/x11/prop.c @@ -131,6 +131,12 @@ static BYTE solveBOOL(char *str) { return(0); } +#ifdef __LIBRETRO__ +extern char retro_system_conf[512]; +extern char slash; + +#endif + int set_modulepath(char *path, size_t len) { @@ -191,14 +197,23 @@ set_dir: sprintf(winx68k_ini, "/var/mobile/px68k/config"); return 0; #endif - +#ifdef __LIBRETRO__ + puts("Libretro..."); + sprintf(path,retro_system_conf); + sprintf(winx68k_ini, "%s%cconfig",retro_system_conf,slash); + return 0; +#endif homepath = getenv("HOME"); if (homepath == 0) homepath = "."; snprintf(path, len, "%s/%s", homepath, ".keropi"); if (stat(path, &sb) < 0) { +#ifdef _WIN32 + if (mkdir(path) < 0) { +#else if (mkdir(path, 0700) < 0) { +#endif perror(path); return 1; } diff --git a/x11/windraw.c b/x11/windraw.c index 65be05d..9a13635 100644 --- a/x11/windraw.c +++ b/x11/windraw.c @@ -47,7 +47,10 @@ #include "tvram.h" #include "joystick.h" #include "keyboard.h" - +#ifdef __LIBRETRO__ +extern uint16_t *videoBuffer; +extern SDL_Surface *mysdl_surface; +#endif #if 0 #include "../icons/keropi.xpm" #endif @@ -64,11 +67,11 @@ WORD *ScrBuf = 0; WORD *menu_buffer; WORD *kbd_buffer; #endif - +#ifndef __LIBRETRO__ #ifdef USE_SDLGFX SDL_Surface *sdl_rgbsurface; #endif - +#endif int Draw_Opaque; int FullScreenFlag = 0; extern BYTE Draw_RedrawAllFlag; @@ -401,7 +404,7 @@ int WinDraw_Init(void) draw_kbd_to_tex(); #else - +#ifndef __LIBRETRO__ #ifdef USE_SDLGFX sdl_rgbsurface = SDL_CreateRGBSurface(SDL_SWSURFACE, 800, 600, 16, WinDraw_Pal16R, WinDraw_Pal16G, WinDraw_Pal16B, 0); @@ -412,6 +415,8 @@ int WinDraw_Init(void) ScrBuf = sdl_rgbsurface->pixels; printf("drawbuf: 0x%x, ScrBuf: 0x%x\n", sdl_surface->pixels, ScrBuf); + printf("drawbuf: 0x%x, ScrBuf: 0x%x\n", mysdl_surface->pixels); +#endif #else ScrBuf = malloc(800 * 600 * 2); #endif @@ -476,7 +481,7 @@ void draw_all_buttons(GLfloat *tex, GLfloat *ver, GLfloat scale, int is_menu) } } #endif // USE_OGLES11 - +extern int retrow,retroh,CHANGEAV; void FASTCALL WinDraw_Draw(void) { @@ -486,12 +491,17 @@ WinDraw_Draw(void) if (oldtextx != TextDotX) { oldtextx = TextDotX; p6logd("TextDotX: %d\n", TextDotX); +CHANGEAV=1; } if (oldtexty != TextDotY) { oldtexty = TextDotY; p6logd("TextDotY: %d\n", TextDotY); +CHANGEAV=1; } - +if(CHANGEAV==1){ +retrow=TextDotX; +retroh=TextDotY; +} #if defined(USE_OGLES11) GLfloat texture_coordinates[8]; GLfloat vertices[8]; @@ -651,13 +661,16 @@ WinDraw_Draw(void) sceGuSwapBuffers(); #else // OpenGL ES 未使用 - +#ifndef __LIBRETRO__ #if SDL_VERSION_ATLEAST(2, 0, 0) sdl_surface = SDL_GetWindowSurface(sdl_window); #else sdl_surface = SDL_GetVideoSurface(); #endif - +#else +sdl_surface = mysdl_surface; +#endif +#ifndef __LIBRETRO__ #ifdef USE_SDLGFX SDL_Surface *roto_surface = NULL; int ret; @@ -667,10 +680,11 @@ WinDraw_Draw(void) return; } - if (TextDotX <= 512) { + if(0){//if (TextDotX <= 512) { roto_surface = rotozoomSurfaceXY(sdl_rgbsurface, 0.0, 512.0*1.33333/TextDotX, 512.0/TextDotY, 0); } - if (roto_surface) { + + if(0){//if (roto_surface) { ret = SDL_BlitSurface(roto_surface, NULL, sdl_surface, NULL); SDL_FreeSurface(roto_surface); } else { @@ -679,6 +693,7 @@ WinDraw_Draw(void) if (ret < 0) { printf("SDL_BlitSurface() failed %d\n", ret); } +//#endif #else int x, y, Bpp; // WORD c, *p, *p2, dummy, *dst16; @@ -735,11 +750,15 @@ WinDraw_Draw(void) } } #endif - +#endif #if SDL_VERSION_ATLEAST(2, 0, 0) SDL_UpdateWindowSurface(sdl_window); +#else +#ifdef __LIBRETRO__ +videoBuffer=(unsigned short int *)ScrBuf;//sdl_surface->pixels; #else SDL_UpdateRect(sdl_surface, 0, 0, FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT); +#endif //libretro #endif #endif @@ -1935,9 +1954,13 @@ void WinDraw_DrawMenu(int menu_state, int mkey_pos, int mkey_y, int *mval_y) sdl_surface = SDL_GetWindowSurface(sdl_window); SDL_BlitSurface(menu_surface, NULL, sdl_surface, NULL); SDL_UpdateWindowSurface(sdl_window); +#else +#ifdef __LIBRETRO__ +videoBuffer=(unsigned short int *)menu_surface->pixels;//sdl_surface->pixels; #else SDL_UpdateRect(menu_surface, 0, 0, FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT); #endif +#endif #endif } @@ -1991,9 +2014,13 @@ void WinDraw_DrawMenufile(struct menu_flist *mfl) sdl_surface = SDL_GetWindowSurface(sdl_window); SDL_BlitSurface(menu_surface, NULL, sdl_surface, NULL); SDL_UpdateWindowSurface(sdl_window); +#else +#ifdef __LIBRETRO__ +videoBuffer=(unsigned short int *)menu_surface->pixels;//sdl_surface->pixels; #else SDL_UpdateRect(menu_surface, 0, 0, FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT); #endif +#endif #endif } diff --git a/x11/winui.c b/x11/winui.c index a43c8e4..3dd6d65 100644 --- a/x11/winui.c +++ b/x11/winui.c @@ -88,7 +88,7 @@ extern short timertrace; char filepath[MAX_PATH] = "."; int fddblink = 0; int fddblinkcount = 0; - int hddtrace = 0; + int hddtrace = 1;//0; extern int dmatrace; DWORD LastClock[4] = {0, 0, 0, 0}; @@ -241,7 +241,17 @@ WinUI_Init(void) #elif TARGET_OS_IPHONE && TARGET_IPHONE_SIMULATOR == 0 #define CUR_DIR_STR "/var/mobile/px68k/" #else + +#ifdef __LIBRETRO__ +#ifdef _WIN32 +#define CUR_DIR_STR "c:\\" +#else +#define CUR_DIR_STR "/" +#endif +#else #define CUR_DIR_STR "./" +#endif + #endif strcpy(cur_dir_str, CUR_DIR_STR); @@ -511,6 +521,9 @@ static void menu_joykey(int v) Config.JoyKey = v; } +#ifdef __LIBRETRO__ +extern char slash; +#endif // ex. ./hoge/.. -> ./ // ( ./ ---down hoge dir--> ./hoge ---up hoge dir--> ./hoge/.. ) static void shortcut_dir(int drv) @@ -522,17 +535,24 @@ static void shortcut_dir(int drv) len = strlen(mfl.dir[drv]); p = mfl.dir[drv] + len - 2; for (i = len - 2; i >= 0; i--) { - if (*p == '/') { + if (*p == slash/*'/'*/) { found = 1; break; } p--; } - +#ifdef _WIN32 + if (found && strcmp(p, "\\..\\")) { +#else if (found && strcmp(p, "/../")) { +#endif *(p + 1) = '\0'; } else { +#ifdef _WIN32 + strcat(mfl.dir[drv], "..\\"); +#else strcat(mfl.dir[drv], "../"); +#endif } } @@ -724,7 +744,11 @@ int WinUI_Menu(int first) shortcut_dir(drv); } else { strcat(mfl.dir[drv], mfl.name[y]); +#ifdef _WIN32 + strcat(mfl.dir[drv], "\\"); +#else strcat(mfl.dir[drv], "/"); +#endif } menu_func[mkey_y].func(0); mfile_redraw = 1; diff --git a/x11/winx68k-retro.cpp b/x11/winx68k-retro.cpp new file mode 100644 index 0000000..8e6b35e --- /dev/null +++ b/x11/winx68k-retro.cpp @@ -0,0 +1,1319 @@ +#ifdef __cplusplus +extern "C" { +#endif + +#include +#ifdef USE_OGLES11 +#include +#endif +#include "common.h" +#include "fileio.h" +#include "timer.h" +#include "keyboard.h" +#include "prop.h" +#include "status.h" +#include "joystick.h" +#include "mkcgrom.h" +#include "winx68k.h" +#include "windraw.h" +#include "winui.h" +#include "../x68k/m68000.h" // xxx 続狸尊狸辿俗谷尊 +#include "../m68000/m68000.h" +#include "../x68k/memory.h" +#include "mfp.h" +#include "opm.h" +#include "bg.h" +#include "adpcm.h" +#include "mercury.h" +#include "crtc.h" +#include "mfp.h" +#include "fdc.h" +#include "fdd.h" +#include "dmac.h" +#include "irqh.h" +#include "ioc.h" +#include "rtc.h" +#include "sasi.h" +#include "scsi.h" +#include "sysport.h" +#include "bg.h" +#include "palette.h" +#include "crtc.h" +#include "pia.h" +#include "scc.h" +#include "midi.h" +#include "sram.h" +#include "gvram.h" +#include "tvram.h" +#include "mouse.h" + +#include "dswin.h" +#include "fmg_wrap.h" + +#ifdef RFMDRV +int rfd_sock; +#endif + + //#define WIN68DEBUG + +#ifdef WIN68DEBUG +#include "d68k.h" +#endif + +//#include "../icons/keropi_mono.xbm" + +#define APPNAME "Keropi" + +extern WORD BG_CHREND; +extern WORD BG_BGTOP; +extern WORD BG_BGEND; +extern BYTE BG_CHRSIZE; + +#if defined(ANDROID) || TARGET_OS_IPHONE +extern SDL_TouchID touchId; +#endif + +const BYTE PrgName[] = "Keropi"; +const BYTE PrgTitle[] = APPNAME; + +char winx68k_dir[MAX_PATH]; +char winx68k_ini[MAX_PATH]; + +WORD VLINE_TOTAL = 567; +DWORD VLINE = 0; +DWORD vline = 0; + +extern int SplashFlag; + +BYTE DispFrame = 0; +DWORD SoundSampleRate; + +unsigned int hTimerID = 0; +DWORD TimerICount = 0; +extern DWORD timertick; +BYTE traceflag = 0; + +BYTE ForceDebugMode = 0; +DWORD skippedframes = 0; + +static int ClkUsed = 0; +static int FrameSkipCount = 0; +static int FrameSkipQueue = 0; + +#ifdef __cplusplus +}; +#endif + +#if SDL_VERSION_ATLEAST(2, 0, 0) +SDL_Window *sdl_window; +int realdisp_w, realdisp_h; +#endif + +void +WinX68k_SCSICheck(void) +{ + static const BYTE SCSIIMG[] = { + 0x00, 0xfc, 0x00, 0x14, // $fc0000 SCSI袖俗属ﾂヅ‖ッ蛎ッ促棚促蔵促促狸促孫 + 0x00, 0xfc, 0x00, 0x16, // $fc0004 IOCS促促俗促多棚ﾂヅ‖ッ蛎ッ促棚促蔵促促狸促孫(測尊"Human"8促促促属) + 0x00, 0x00, 0x00, 0x00, // $fc0008 ? + 0x48, 0x75, 0x6d, 0x61, // $fc000c 蔵足 + 0x6e, 0x36, 0x38, 0x6b, // $fc0010 ID "Human68k" (測尊袖俗属促邸促坦促促棚促促促坦促ﾃ展属) + 0x4e, 0x75, // $fc0014 "rts" (袖俗属促邸促坦促促棚促促促坦促) + 0x23, 0xfc, 0x00, 0xfc, 0x00, 0x2a, // $fc0016 蔵足 (IOCS促促俗促多棚促邸促坦促促棚促促促坦促) + 0x00, 0x00, 0x07, 0xd4, // $fc001c "move.l #$fc002a, $7d4.l" + 0x74, 0xff, // $fc0020 "moveq #-1, d2" + 0x4e, 0x75, // $fc0022 "rts" +// 0x53, 0x43, 0x53, 0x49, 0x49, 0x4e, // $fc0024 ID "SCSIIN" +// 但蔵SCSI嘆ON孫谷臓蔵SASI束属捉OFF達辿揃臓 +// 竪臓蔵ID昤促促揃竪揃捉俗臓 + 0x44, 0x55, 0x4d, 0x4d, 0x59, 0x20, // $fc0024 ID "DUMMY " + 0x70, 0xff, // $fc002a "moveq #-1, d0" (SCSI IOCS促続臓促谷促邸促坦促促棚促促促坦促) + 0x4e, 0x75, // $fc002c "rts" + }; + +#if 0 + DWORD *p; +#endif + WORD *p1, *p2; + int scsi; + int i; + + scsi = 0; + for (i = 0x30600; i < 0x30c00; i += 2) { +#if 0 // 4ﾃ多担其旦多担促蔵促促狸促孫束辿4促促促孫促蔵促俗促損促孫MIPS袖箪 + p = (DWORD *)(&IPL[i]); + if (*p == 0x0000fc00) + scsi = 1; +#else + p1 = (WORD *)(&IPL[i]); + p2 = p1 + 1; + // xxx: works only for little endian guys + if (*p1 == 0xfc00 && *p2 == 0x0000) { + scsi = 1; + break; + } +#endif + } + + // SCSI促但促促谷足 + if (scsi) { + ZeroMemory(IPL, 0x2000); // 8kb + memset(&IPL[0x2000], 0xff, 0x1e000); // 損棚0xff + memcpy(IPL, SCSIIMG, sizeof(SCSIIMG)); // 促促坦促促足SCSI BIOS +// Memory_SetSCSIMode(); + } else { + // SASI促但促促谷IPL測転束邸谷 + memcpy(IPL, &IPL[0x20000], 0x20000); + } +} + +int +WinX68k_LoadROMs(void) +{ + static const char *BIOSFILE[] = { + "iplrom.dat", "iplrom30.dat", "iplromco.dat", "iplromxv.dat" + }; + static const char FONTFILE[] = "cgrom.dat"; + static const char FONTFILETMP[] = "cgrom.tmp"; + FILEH fp; + int i; + BYTE tmp; + + for (fp = 0, i = 0; fp == 0 && i < NELEMENTS(BIOSFILE); ++i) { + fp = File_OpenCurDir((char *)BIOSFILE[i]); + printf("fp:%d (%s)\n",fp,(char *)BIOSFILE[i]); + } + + if (fp == 0) { + Error("BIOS ROM 促促叩臓促転測転束束棚損坦."); + return FALSE; + } + + File_Read(fp, &IPL[0x20000], 0x20000); + File_Close(fp); + + WinX68k_SCSICheck(); // SCSI IPL辿臓蔵$fc0000臓SCSI BIOS嘆俗 + + for (i = 0; i < 0x40000; i += 2) { + tmp = IPL[i]; + IPL[i] = IPL[i + 1]; + IPL[i + 1] = tmp; + } + + fp = File_OpenCurDir((char *)FONTFILE); + if (fp == 0) { + // cgrom.tmp測蔵谷臓息 + fp = File_OpenCurDir((char *)FONTFILETMP); + if (fp == 0) { +#if 1 + // 促促息促坦促転速 XXX + printf("促促息促坦促ROM促促叩臓促転測転束束棚損坦\n"); + return FALSE; +#else + MessageBox(hWndMain, + "促促息促坦促ROM促促叩臓促転測転束束棚損坦.\nWindows促促息促坦促束辿多揃袖測尊樽速揃孫.", + "賊鱈臓ﾂッ‖ッ促損臓促転", MB_ICONWARNING | MB_OK); + SSTP_SendMes(SSTPMES_MAKEFONT); + make_cgromdat(FONT, FALSE, "贈贈 促貼促揃促促俗", "贈贈 束"); + //WinX68k_MakeFont(); + //DialogBox(hInst, MAKEINTRESOURCE(IDD_PROGBAR), + // hWndMain, (DLGPROC)MakeFontProc); + fp = File_CreateCurDir(FONTFILETMP); + if (fp) + { + File_Write(fp, FONT, 0xc0000); + File_Close(fp); + return TRUE; + } + return TRUE; +#endif + } + } + File_Read(fp, FONT, 0xc0000); + File_Close(fp); + + return TRUE; +} + +int +WinX68k_Reset(void) +{ + OPM_Reset(); + + C68k_Reset(&C68K); +/* + C68k_Set_Reg(&C68K, C68K_A7, (IPL[0x30001]<<24)|(IPL[0x30000]<<16)|(IPL[0x30003]<<8)|IPL[0x30002]); + C68k_Set_Reg(&C68K, C68K_PC, (IPL[0x30005]<<24)|(IPL[0x30004]<<16)|(IPL[0x30007]<<8)|IPL[0x30006]); +*/ + C68k_Set_AReg(&C68K, 7, (IPL[0x30001]<<24)|(IPL[0x30000]<<16)|(IPL[0x30003]<<8)|IPL[0x30002]); + C68k_Set_PC(&C68K, (IPL[0x30005]<<24)|(IPL[0x30004]<<16)|(IPL[0x30007]<<8)|IPL[0x30006]); + Memory_Init(); + CRTC_Init(); + DMA_Init(); + MFP_Init(); + FDC_Init(); + FDD_Reset(); + SASI_Init(); + SCSI_Init(); + IOC_Init(); + SCC_Init(); + PIA_Init(); + RTC_Init(); + TVRAM_Init(); + GVRAM_Init(); + BG_Init(); + Pal_Init(); + IRQH_Init(); + MIDI_Init(); + //WinDrv_Init(); + +// C68K.ICount = 0; + m68000_ICountBk = 0; + ICount = 0; + + DSound_Stop(); + SRAM_VirusCheck(); + //CDROM_Init(); + DSound_Play(); + + return TRUE; +} + + +int +WinX68k_Init(void) +{ +#ifdef PSP +#define MEM_SIZE 0x400000 +#else +#define MEM_SIZE 0xc00000 +#endif + IPL = (BYTE*)malloc(0x40000); + MEM = (BYTE*)malloc(MEM_SIZE); + FONT = (BYTE*)malloc(0xc0000); + + if (MEM) + ZeroMemory(MEM, MEM_SIZE); + + if (MEM && FONT && IPL) { + m68000_init(); + return TRUE; + } else + return FALSE; +} + +void +WinX68k_Cleanup(void) +{ + + if (IPL) { + free(IPL); + IPL = 0; + } + if (MEM) { + free(MEM); + MEM = 0; + } + if (FONT) { + free(FONT); + FONT = 0; + } +} + +#define CLOCK_SLICE 200 +// ----------------------------------------------------------------------------------- +// 促続促蔵叩坦谷臓 +// ----------------------------------------------------------------------------------- +void WinX68k_Exec(void) +{ + //char *test = NULL; + int clk_total, clkdiv, usedclk, hsync, clk_next, clk_count, clk_line=0; + int KeyIntCnt = 0, MouseIntCnt = 0; + DWORD t_start = timeGetTime(), t_end; + + if ( Config.FrameRate != 7 ) { + DispFrame = (DispFrame+1)%Config.FrameRate; + } else { // Auto Frame Skip + if ( FrameSkipQueue ) { + if ( FrameSkipCount>15 ) { + FrameSkipCount = 0; + FrameSkipQueue++; + DispFrame = 0; + } else { + FrameSkipCount++; + FrameSkipQueue--; + DispFrame = 1; + } + } else { + FrameSkipCount = 0; + DispFrame = 0; + } + } + + vline = 0; + clk_count = -ICount; + clk_total = (CRTC_Regs[0x29] & 0x10) ? VSYNC_HIGH : VSYNC_NORM; + if (Config.XVIMode == 1) { + clk_total = (clk_total*16)/10; + clkdiv = 16; + } else if (Config.XVIMode == 2) { + clk_total = (clk_total*24)/10; + clkdiv = 24; + } else { + clkdiv = 10; + } + ICount += clk_total; + clk_next = (clk_total/VLINE_TOTAL); + hsync = 1; + + do { + int m, n = (ICount>CLOCK_SLICE)?CLOCK_SLICE:ICount; +// C68K.ICount = m68000_ICountBk = 0; // 続辰棚孫綻俗転属多邸捉束促促叩臓CARAT臓 + + if ( hsync ) { + hsync = 0; + clk_line = 0; + MFP_Int(0); + if ( (vline>=CRTC_VSTART)&&(vline=VLINE_TOTAL ) { + if ( (long)vline==(CRTC_VEND-VLINE_TOTAL) ) MFP_Int(9); // 促邸促足促袖促促促贈促坦促属促蔵促誰臓束臓TOTAL=0x2000)&&((regs.pc<=0x8e0e0))) tracing=50000; +// if (regs.pc<0x10000) tracing=1; +// if ( (regs.pc&1) ) +// fp=fopen("_trace68.txt", "a"); +// if ( (regs.pc==0x7176) /*&& (Memory_ReadW(oldpc)==0xff1a)*/ ) tracing=100; +// if ( (/*((regs.pc>=0x27000) && (regs.pc<=0x29000))||*/((regs.pc>=0x27000) && (regs.pc<=0x29000))) && (oldpc!=regs.pc)) + if (/*fdctrace&&*/(oldpc != C68k_Get_Reg(&C68K, C68K_PC))) + { +// //tracing--; + fprintf(fp, "D0:%08X D1:%08X D2:%08X D3:%08X D4:%08X D5:%08X D6:%08X D7:%08X CR:%04X\n", C68K.D[0], C68K.D[1], C68K.D[2], C68K.D[3], C68K.D[4], C68K.D[5], C68K.D[6], C68K.D[7], 0/* xxx 棚蔵邸尊0 C68K.ccr */); + fprintf(fp, "A0:%08X A1:%08X A2:%08X A3:%08X A4:%08X A5:%08X A6:%08X A7:%08X SR:%04X\n", C68K.A[0], C68K.A[1], C68K.A[2], C68K.A[3], C68K.A[4], C68K.A[5], C68K.A[6], C68K.A[7], C68k_Get_Reg(&C68K, C68K_SR) >> 8/* regs.sr_high*/); + fprintf(fp, "<%04X> (%08X ->) %08X : %s\n", Memory_ReadW(C68k_Get_Reg(&C68K, C68K_PC)), oldpc, C68k_Get_Reg(&C68K, C68K_PC), buf); + } + oldpc = C68k_Get_Reg(&C68K, C68K_PC); +// C68K.ICount = 1; +// C68k_Exec(&C68K, C68K.ICount); + C68k_Exec(&C68K, 1); + } + fclose(fp); + usedclk = clk_line = HSYNC_CLK; + clk_count = clk_next; + } + else +#endif + { +// C68K.ICount = n; +// C68k_Exec(&C68K, C68K.ICount); + C68k_Exec(&C68K, n); + m = (n-m68000_ICountBk); // 腟 +// m = (n-C68K.ICount-m68000_ICountBk); // 揃族叩促俗促鱈促促俗多担 + ClkUsed += m*10; + usedclk = ClkUsed/clkdiv; + clk_line += usedclk; + ClkUsed -= usedclk*clkdiv; + ICount -= m; + clk_count += m; +// C68K.ICount = m68000_ICountBk = 0; + } + + MFP_Timer(usedclk); + RTC_Timer(usedclk); + DMA_Exec(0); + DMA_Exec(1); + DMA_Exec(2); + + if ( clk_count>=clk_next ) { + //OPM_RomeoOut(Config.BufferSize*5); + //MIDI_DelayOut((Config.MIDIAutoDelay)?(Config.BufferSize*5):Config.MIDIDelay); + MFP_TimerA(); + if ( (MFP[MFP_AER]&0x40)&&(vline==CRTC_IntLine) ) + MFP_Int(1); + if ( (!DispFrame)&&(vline>=CRTC_VSTART)&&(vline(VLINE_TOTAL/4) ) { + KeyIntCnt = 0; + Keyboard_Int(); + } + MouseIntCnt++; + if ( MouseIntCnt>(VLINE_TOTAL/8) ) { + MouseIntCnt = 0; + SCC_IntCheck(); + } + DSound_Send0(clk_line); + + vline++; + clk_next = (clk_total*(vline+1))/VLINE_TOTAL; + hsync = 1; + } + } while ( vline((CRTC_Regs[0x29]&0x10)?14:16) ) { + FrameSkipQueue += ((t_end-t_start)/((CRTC_Regs[0x29]&0x10)?14:16))+1; + if ( FrameSkipQueue>100 ) + FrameSkipQueue = 100; + } +} + +#ifndef __LIBRETRO__ +// +// main +// +#ifdef PSP + +#include +#include +#include +#include +#include + +int exit_flag = 0; + +int exit_callback(int arg1, int arg2, void *common) +{ + exit_flag = 1; + + return 0; +} + +int CallbackThread(SceSize args, void *argp) +{ + int cbid; + + cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL); + sceKernelRegisterExitCallback(cbid); //SetExitCallback(cbid); + + sceKernelSleepThreadCB(); //KernelPollCallbacks(); + + return 0; +} + +int SetupCallbacks(void) +{ + int thid; + + thid = sceKernelCreateThread("update_thread", CallbackThread, + 0x11, 0xFA0, 0, 0); + if (thid >= 0) { + sceKernelStartThread(thid, 0, 0); + } + + return thid; +} + +PSP_HEAP_SIZE_KB(-1024); + +extern "C" int +SDL_main(int argc, char *argv[]) +#else +int pmain(int argc, char *argv[]) +#endif +{ +#ifndef PSP + SDL_Event ev; + SDL_Keycode menu_key_down; +#endif +#if defined(ANDROID) || TARGET_OS_IPHONE + int vk_cnt = -1; + int menu_cnt = -1; + BYTE state; +#endif + int sdlaudio = -1; + enum {menu_out, menu_enter, menu_in}; + int menu_mode = menu_out; + +#ifdef PSP + SetupCallbacks(); + scePowerSetClockFrequency(333, 333, 166); + + sceCtrlSetSamplingCycle(0); + sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); +#endif + + p6logd("PX68K Ver.%s\n", PX68KVERSTR); + +#ifdef RFMDRV + struct sockaddr_in dest; + + memset(&dest, 0, sizeof(dest)); + dest.sin_port = htons(2151); + dest.sin_family = AF_INET; + dest.sin_addr.s_addr = inet_addr("127.0.0.1"); + + rfd_sock = socket(AF_INET, SOCK_STREAM, 0); + connect (rfd_sock, (struct sockaddr *)&dest, sizeof(dest)); +#endif + + if (set_modulepath(winx68k_dir, sizeof(winx68k_dir))) + return 1; + + dosio_init(); + file_setcd(winx68k_dir); + puts(winx68k_dir); + + LoadConfig(); + +#ifndef NOSOUND + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) { + p6logd("SDL_Init error\n"); +#endif + if (SDL_Init(SDL_INIT_VIDEO) < 0) { + return 1; + } +#ifndef NOSOUND + } else { + sdlaudio = 0; + } +#endif + +#if !SDL_VERSION_ATLEAST(2, 0, 0) + SDL_WM_SetCaption(APPNAME" SDL", NULL); +#ifndef PSP + if (SDL_SetVideoMode(FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT, 16, SDL_SWSURFACE) == NULL) { +#else + if (SDL_SetVideoMode(480, 272, 16, SDL_SWSURFACE) == NULL) { +#endif + puts("SDL_SetVideoMode() failed"); + return 1; + } +#else +#ifdef USE_OGLES11 + SDL_DisplayMode sdl_dispmode; + SDL_GetCurrentDisplayMode(0, &sdl_dispmode); + p6logd("width: %d height: %d", sdl_dispmode.w, sdl_dispmode.h); + // 促促促族臓促揃促巽促坦促臓嘆端俗促蔵促促棚測多邸狸谷族竪 + realdisp_w = sdl_dispmode.w, realdisp_h = sdl_dispmode.h; + + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 1 ); + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1 ); + + SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); + +#if TARGET_OS_IPHONE + sdl_window = SDL_CreateWindow(APPNAME" SDL", 0, 0, FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT, SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN|SDL_WINDOW_BORDERLESS); +#else + // for Android: window sizeﾂ暫棚檑揃転俗促促谷促孫促俗促棚臓促坦谷多 + sdl_window = SDL_CreateWindow(APPNAME" SDL", 0, 0, FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT, SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN); +#endif +#else + sdl_window = SDL_CreateWindow(APPNAME" SDL", 0, 0, FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT, SDL_WINDOW_SHOWN); +#endif + if (sdl_window == NULL) { + p6logd("sdl_window: %ld", sdl_window); + } + +#ifdef USE_OGLES11 + SDL_GLContext glcontext = SDL_GL_CreateContext(sdl_window); + + glClearColor( 0, 0, 0, 0 ); + + glEnable(GL_TEXTURE_2D); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_BLEND); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + //glViewport(0, 0, 800, 600); //続続嘆箪辰袖OpenGLﾂ加損 + glViewport(0, 0, sdl_dispmode.w, sdl_dispmode.h); + // 促孫促促辰促多促ﾅ族竪貼揃転俗OpenGLﾃ族竪ﾃﾂ庵嘆800x600孫谷臓贈 + // 800x600揃多属贈臓贈 + glOrthof(0, 800, 600, 0, -1, 1); + // glOrthof(0, 1024, 0, 1024, -1, 1); + glMatrixMode(GL_MODELVIEW); +#endif +#endif // !SDL_VERSION_ATLEAST(2, 0, 0) + + if (!WinDraw_MenuInit()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + return 1; + } + + SplashFlag = 20; + SoundSampleRate = Config.SampleRate; + + StatBar_Show(Config.WindowFDDStat); + WinDraw_ChangeSize(); + WinDraw_ChangeMode(FALSE); + + WinUI_Init(); + WinDraw_StartupScreen(); + + if (!WinX68k_Init()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + return 1; + } + + if (!WinX68k_LoadROMs()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + exit (1); + } + + Keyboard_Init(); //WinDraw_Init()属属属 + + if (!WinDraw_Init()) { + WinDraw_Cleanup(); + Error("Error: Can't init screen.\n"); + return 1; + } + + if ( SoundSampleRate ) { + ADPCM_Init(SoundSampleRate); + OPM_Init(4000000/*3579545*/, SoundSampleRate); +#ifndef NO_MERCURY + Mcry_Init(SoundSampleRate, winx68k_dir); +#endif + } else { + ADPCM_Init(100); + OPM_Init(4000000/*3579545*/, 100); +#ifndef NO_MERCURY + Mcry_Init(100, winx68k_dir); +#endif + } + + FDD_Init(); + SysPort_Init(); + Mouse_Init(); + Joystick_Init(); + SRAM_Init(); + WinX68k_Reset(); + Timer_Init(); + + MIDI_Init(); + MIDI_SetMimpiMap(Config.ToneMapFile); // 族損多則棚促促臓促促谷損多賊 + MIDI_EnableMimpiDef(Config.ToneMap); + + if (sdlaudio == 0 && !DSound_Init(Config.SampleRate, Config.BufferSize)) { + if (Config.DSAlert) + fprintf(stderr, "Can't init sound.\n"); + } + + ADPCM_SetVolume((BYTE)Config.PCM_VOL); + OPM_SetVolume((BYTE)Config.OPM_VOL); +#ifndef NO_MERCURY + Mcry_SetVolume((BYTE)Config.MCR_VOL); +#endif + DSound_Play(); + + // command line 束辿損棚揃多展狸孫巽 + switch (argc) { + case 3: + strcpy(Config.FDDImage[1], argv[2]); + case 2: + strcpy(Config.FDDImage[0], argv[1]); + break; + } + + FDD_SetFD(0, Config.FDDImage[0], 0); + FDD_SetFD(1, Config.FDDImage[1], 0); + + //SDL_StartTextInput(); + + while (1) { + // OPM_RomeoOut(Config.BufferSize * 5); + if (menu_mode == menu_out + && (Config.NoWaitMode || Timer_GetCount())) { + WinX68k_Exec(); +#if defined(ANDROID) || TARGET_OS_IPHONE + if (vk_cnt > 0) { + vk_cnt--; + if (vk_cnt == 0) { + p6logd("vk_cnt 0"); + } + } + if (menu_cnt > 0) { + menu_cnt--; + if (menu_cnt == 0) { + p6logd("menu_cnt 0"); + } + } +#endif + if (SplashFlag) { + SplashFlag--; + if (SplashFlag == 0) + WinDraw_HideSplash(); + } + } +#ifndef PSP + menu_key_down = SDLK_UNKNOWN; + + while (SDL_PollEvent(&ev)) { + switch (ev.type) { + case SDL_QUIT: + goto end_loop; + case SDL_MOUSEMOTION: + p6logd("x:%d y:%d xrel:%d yrel:%d\n", ev.motion.x, ev.motion.y, ev.motion.xrel, ev.motion.yrel); + break; +#if defined(ANDROID) || TARGET_OS_IPHONE + case SDL_APP_WILLENTERBACKGROUND: + DSound_Stop(); + break; + case SDL_APP_WILLENTERFOREGROUND: + DSound_Play(); + break; + case SDL_FINGERDOWN: + //p6logd("FINGERDOWN: tid: %lld,,, x:%f y:%f", ev.tfinger.touchId, ev.tfinger.x, ev.tfinger.y); + if (touchId == -1) { + touchId = ev.tfinger.touchId; + } + break; + case SDL_FINGERMOTION: + float kx, ky, dx, dy; + p6logd("FM: x:%f y:%f dx:%f dy:%f\n", ev.tfinger.x, ev.tfinger.y, ev.tfinger.dx, ev.tfinger.dy); + if (vk_cnt == 0) { + kx = ev.tfinger.x * 800; + ky = ev.tfinger.y * 600; + dx = ev.tfinger.dx * 800; + dy = ev.tfinger.dy * 600; + if (kbd_x < kx && kbd_x + kbd_w > kx && + kbd_y < ky && kbd_y + kbd_h > ky) { + kbd_x += dx; + kbd_y += dy; + if (kbd_x < 0) kbd_x = 0; + if (kbd_y < 0) kbd_y = 0; + if (kbd_x > 700) { + vk_cnt = -1; + } + if (kbd_y > 550) kbd_y = 550; + } + } else if (Config.JoyOrMouse) { // Mouse mode is off when the keyboard is active + Mouse_Event(0, ev.tfinger.dx * 50 * Config.MouseSpeed, ev.tfinger.dy * 50 * Config.MouseSpeed); + } + break; +#endif + case SDL_KEYDOWN: +#if defined(ANDROID) || TARGET_OS_IPHONE + static DWORD bef = 0; + DWORD now; + switch (ev.key.keysym.sym) { + case SDLK_AC_BACK: + now = timeGetTime(); + if (now - bef < 1000) { + goto end_loop; + } + bef = now; + break; + case SDLK_MENU: + if (menu_mode == menu_out) { + menu_mode = menu_enter; + DSound_Stop(); + } else { + DSound_Play(); + menu_mode = menu_out; + } + break; + } +#endif + printf("keydown: 0x%x\n", ev.key.keysym.sym); + printf("font %d %d\n", FONT[100], FONT[101]); + if (ev.key.keysym.sym == SDLK_F12) { + if (menu_mode == menu_out) { + menu_mode = menu_enter; + DSound_Stop(); + } else { + DSound_Play(); + menu_mode = menu_out; + } + } +#ifdef WIN68DEBUG + if (ev.key.keysym.sym == SDLK_F10) { + traceflag ^= 1; + printf("trace %s\n", (traceflag)?"on":"off"); + } +#endif + if (menu_mode != menu_out) { + menu_key_down = ev.key.keysym.sym; + } else { + Keyboard_KeyDown(ev.key.keysym.sym); + } + break; + case SDL_KEYUP: + printf("keyup: 0x%x\n", ev.key.keysym.sym); + Keyboard_KeyUp(ev.key.keysym.sym); + break; + } + } +#endif //PSP + +#ifdef PSP + if (Joystick_get_downstate_psp(PSP_CTRL_START)) { + if (menu_mode == menu_out) { + menu_mode = menu_enter; + DSound_Stop(); + } else { + DSound_Play(); + menu_mode = menu_out; + } + } + + if (menu_mode == menu_out + && Joystick_get_downstate_psp(PSP_CTRL_SELECT)) { + Keyboard_ToggleSkbd(); + // 2端賊 + Joystick_reset_downstate_psp(PSP_CTRL_SELECT); + } + + if (menu_mode == menu_out && Keyboard_IsSwKeyboard()) { + Joystick_mv_anapad_psp(); + Joystatic_reset_anapad_psp(); + Keyboard_skbd(); + } +#endif + +#if defined(ANDROID) || TARGET_OS_IPHONE + + state = Joystick_get_vbtn_state(7); + + if (menu_mode == menu_in) { + if (state == VBTN_OFF && menu_cnt == 0) { + menu_cnt = -2; + } + if (state == VBTN_ON && menu_cnt == -2) { + DSound_Play(); + menu_mode = menu_out; + } + } else if (menu_mode == menu_out) { + if (state == VBTN_OFF && menu_cnt == -2) { + menu_cnt = -1; + } + if (menu_cnt == -1 && state == VBTN_ON) { + p6logd("menu_cnt start"); + menu_cnt = 20; + } else if (menu_cnt > 0 && state == VBTN_OFF) { + menu_cnt = -1; + } + if (menu_cnt == 0) { + p6logd("menu mode on"); + menu_mode = menu_enter; + DSound_Stop(); + } + } + +#endif + if (menu_mode != menu_out) { + int ret; + +#ifdef PSP + Joystick_Update(TRUE); +#else + Joystick_Update(TRUE, menu_key_down); +#endif + ret = WinUI_Menu(menu_mode == menu_enter); + menu_mode = menu_in; + if (ret == WUM_MENU_END) { + DSound_Play(); + menu_mode = menu_out; + } else if (ret == WUM_EMU_QUIT) { + goto end_loop; + } + } +#ifdef PSP + if (exit_flag) { + goto end_loop; + } +#endif + +#if defined(ANDROID) || TARGET_OS_IPHONE + + if (menu_mode == menu_out) { + state = Joystick_get_vbtn_state(6); + if (vk_cnt == -1 && state == VBTN_ON) { + p6logd("vk_cnt start"); + vk_cnt = 20; + } else if (vk_cnt > 0 && state == VBTN_OFF) { + vk_cnt = -1; + } + if (kbd_x > 700 && vk_cnt == 0) { + kbd_x = 0, kbd_y = 0; + p6logd("do_kbd"); + } + if (kbd_x < 700) { +#ifdef USE_OGLES11 + Keyboard_skbd(); +#endif + } + } +#endif + + } +end_loop: + Memory_WriteB(0xe8e00d, 0x31); // SRAM単足孫綻袖旦族 + Memory_WriteD(0xed0040, Memory_ReadD(0xed0040)+1); // 損損族俗損綻貼(min.) + Memory_WriteD(0xed0044, Memory_ReadD(0xed0044)+1); // 損損袖俗属族坦多担 + + OPM_Cleanup(); +#ifndef NO_MERCURY + Mcry_Cleanup(); +#endif + + Joystick_Cleanup(); + SRAM_Cleanup(); + FDD_Cleanup(); + //CDROM_Cleanup(); + MIDI_Cleanup(); + DSound_Cleanup(); + WinX68k_Cleanup(); + WinDraw_Cleanup(); + WinDraw_CleanupScreen(); + + SaveConfig(); + +#if defined(PSP) + puts("before end"); + sceKernelExitGame(); +#elif defined(ANDROID) || TARGET_OS_IPHONE + exit(0); +#endif + return 0; +} +#else +//idfef __LIBRETRO__ +#ifdef __cplusplus +extern "C" { +#endif +int mb1=0,mb2=0; +extern int retrow,retroh,CHANGEAV; +static int oldrw=0,oldrh=0; +SDL_Event ev; +SDL_Keycode menu_key_down; +int end_loop=0; +extern SDL_Surface *mysdl_surface; +enum {menu_out, menu_enter, menu_in}; +int menu_mode = menu_out; +#ifdef __cplusplus +}; +#endif +extern "C" int pmain(int argc, char *argv[]) +{ + + int sdlaudio = -1; + + p6logd("PX68K Ver.%s\n", PX68KVERSTR); + +#ifdef RFMDRV + struct sockaddr_in dest; + + memset(&dest, 0, sizeof(dest)); + dest.sin_port = htons(2151); + dest.sin_family = AF_INET; + dest.sin_addr.s_addr = inet_addr("127.0.0.1"); + + rfd_sock = socket(AF_INET, SOCK_STREAM, 0); + connect (rfd_sock, (struct sockaddr *)&dest, sizeof(dest)); +#endif + + if (set_modulepath(winx68k_dir, sizeof(winx68k_dir))) + return 1; + + dosio_init(); + file_setcd(winx68k_dir); + puts(winx68k_dir); + + LoadConfig(); + +#ifndef NOSOUND + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) { + p6logd("SDL_Init error\n"); +#endif + if (SDL_Init(SDL_INIT_VIDEO) < 0) { + return 1; + } +#ifndef NOSOUND + } else { + sdlaudio = 0; + } +#endif + + SDL_WM_SetCaption(APPNAME" SDL", NULL); + + if ((mysdl_surface=SDL_SetVideoMode(FULLSCREEN_WIDTH, FULLSCREEN_HEIGHT, 16, SDL_SWSURFACE)) == NULL) { + puts("SDL_SetVideoMode() failed"); + return 1; + } + + if (!WinDraw_MenuInit()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + return 1; + } + + SplashFlag = 20; + SoundSampleRate = Config.SampleRate; + + StatBar_Show(Config.WindowFDDStat); + WinDraw_ChangeSize(); + WinDraw_ChangeMode(FALSE); + + WinUI_Init(); + WinDraw_StartupScreen(); + + if (!WinX68k_Init()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + return 1; + } + + if (!WinX68k_LoadROMs()) { + WinX68k_Cleanup(); + WinDraw_Cleanup(); + exit (1); + } + + Keyboard_Init(); //WinDraw_Init()属属属 + + if (!WinDraw_Init()) { + WinDraw_Cleanup(); + Error("Error: Can't init screen.\n"); + return 1; + } + + if ( SoundSampleRate ) { + ADPCM_Init(SoundSampleRate); + OPM_Init(4000000/*3579545*/, SoundSampleRate); +#ifndef NO_MERCURY + Mcry_Init(SoundSampleRate, winx68k_dir); +#endif + } else { + ADPCM_Init(100); + OPM_Init(4000000/*3579545*/, 100); +#ifndef NO_MERCURY + Mcry_Init(100, winx68k_dir); +#endif + } + + FDD_Init(); + SysPort_Init(); + Mouse_Init(); + Joystick_Init(); + SRAM_Init(); + WinX68k_Reset(); + Timer_Init(); + + MIDI_Init(); + MIDI_SetMimpiMap(Config.ToneMapFile); // 族損多則棚促促臓促促谷損多賊 + MIDI_EnableMimpiDef(Config.ToneMap); + + if (sdlaudio == 0 && !DSound_Init(Config.SampleRate, Config.BufferSize)) { + if (Config.DSAlert) + fprintf(stderr, "Can't init sound.\n"); + } + + ADPCM_SetVolume((BYTE)Config.PCM_VOL); + OPM_SetVolume((BYTE)Config.OPM_VOL); +#ifndef NO_MERCURY + Mcry_SetVolume((BYTE)Config.MCR_VOL); +#endif + DSound_Play(); + + // command line 束辿損棚揃多展狸孫巽 + if(argc==3 && argv[1][0]=='-' && argv[1][1]=='h') + strcpy(Config.HDImage[0], argv[2]); + else { + switch (argc) { + case 3: + strcpy(Config.FDDImage[1], argv[2]); + case 2: + strcpy(Config.FDDImage[0], argv[1]); + break; + } + } + + FDD_SetFD(0, Config.FDDImage[0], 0); + FDD_SetFD(1, Config.FDDImage[1], 0); + + //SDL_StartTextInput(); +} + +extern "C" void exec_app_retro(){ + + //while (1) { + // OPM_RomeoOut(Config.BufferSize * 5); + if (menu_mode == menu_out + && (Config.NoWaitMode || Timer_GetCount())) { + WinX68k_Exec(); + + if (SplashFlag) { + SplashFlag--; + if (SplashFlag == 0) + WinDraw_HideSplash(); + } + } + + menu_key_down = SDLK_UNKNOWN; + + while (SDL_PollEvent(&ev)) { + switch (ev.type) { + case SDL_QUIT: + end_loop=1;break; + case SDL_MOUSEBUTTONDOWN: + + if (ev.button.button == SDL_BUTTON_LEFT)Mouse_Event(1,1.0,0); + if (ev.button.button == SDL_BUTTON_RIGHT)Mouse_Event(2,1.0,0); + + break; + case SDL_MOUSEBUTTONUP: + + if (ev.button.button == SDL_BUTTON_LEFT)Mouse_Event(1,0,0); + if (ev.button.button == SDL_BUTTON_RIGHT)Mouse_Event(2,0,0); + + break; + case SDL_MOUSEMOTION: + //p6logd("x:%d y:%d xrel:%d yrel:%d\n", ev.motion.x, ev.motion.y, ev.motion.xrel, ev.motion.yrel); + Mouse_Event(0, ev.motion.xrel, ev.motion.yrel); + break; + case SDL_KEYDOWN: + printf("keydown: 0x%x\n", ev.key.keysym.sym); + printf("font %d %d\n", FONT[100], FONT[101]); + if (ev.key.keysym.sym == SDLK_F12) { + if (menu_mode == menu_out) { + oldrw=retrow;oldrh=retroh; + retroh=600;retrow=800; + CHANGEAV=1; + menu_mode = menu_enter; + DSound_Stop(); + } else { + CHANGEAV=1; + retrow=oldrw;retroh=oldrh; + DSound_Play(); + menu_mode = menu_out; + } + } +#ifdef WIN68DEBUG + if (ev.key.keysym.sym == SDLK_F10) { + traceflag ^= 1; + printf("trace %s\n", (traceflag)?"on":"off"); + } +#endif + if (menu_mode != menu_out) { + menu_key_down = ev.key.keysym.sym; + } else { + Keyboard_KeyDown(ev.key.keysym.sym); + } + break; + case SDL_KEYUP: + printf("keyup: 0x%x\n", ev.key.keysym.sym); + Keyboard_KeyUp(ev.key.keysym.sym); + break; + } + } + + + + if (menu_mode != menu_out) { + int ret; + + Joystick_Update(TRUE, menu_key_down); + + ret = WinUI_Menu(menu_mode == menu_enter); + menu_mode = menu_in; + if (ret == WUM_MENU_END) { + DSound_Play(); + menu_mode = menu_out; + } else if (ret == WUM_EMU_QUIT) { + end_loop=1; + } + } + + //} +} + +extern "C" void end_loop_retro(){ +//end_loop: + Memory_WriteB(0xe8e00d, 0x31); // SRAM単足孫綻袖旦族 + Memory_WriteD(0xed0040, Memory_ReadD(0xed0040)+1); // 損損族俗損綻貼(min.) + Memory_WriteD(0xed0044, Memory_ReadD(0xed0044)+1); // 損損袖俗属族坦多担 + + OPM_Cleanup(); +#ifndef NO_MERCURY + Mcry_Cleanup(); +#endif + + Joystick_Cleanup(); + SRAM_Cleanup(); + FDD_Cleanup(); + //CDROM_Cleanup(); + MIDI_Cleanup(); + DSound_Cleanup(); + WinX68k_Cleanup(); + WinDraw_Cleanup(); + WinDraw_CleanupScreen(); + + SaveConfig(); + + return 0; +} + +#endif //ifndef __LIBRETRO__ diff --git a/x11/winx68k.cpp b/x11/winx68k.cpp index c7f96c8..e1aad48 100644 --- a/x11/winx68k.cpp +++ b/x11/winx68k.cpp @@ -17,7 +17,7 @@ extern "C" { #include "winx68k.h" #include "windraw.h" #include "winui.h" -#include "../x68k/m68000.h" // xxx これはいずれいらなくなるはず +#include "../x68k/m68000.h" // xxx 続狸尊狸辿俗谷尊 #include "../m68000/m68000.h" #include "../x68k/memory.h" #include "mfp.h" @@ -113,21 +113,21 @@ void WinX68k_SCSICheck(void) { static const BYTE SCSIIMG[] = { - 0x00, 0xfc, 0x00, 0x14, // $fc0000 SCSI起動用のエントリアドレス - 0x00, 0xfc, 0x00, 0x16, // $fc0004 IOCSベクタ設定のエントリアドレス(必ず"Human"の8バイト前) + 0x00, 0xfc, 0x00, 0x14, // $fc0000 SCSI袖俗属ﾂヅ‖ッ蛎ッ促棚促蔵促促狸促孫 + 0x00, 0xfc, 0x00, 0x16, // $fc0004 IOCS促促俗促多棚ﾂヅ‖ッ蛎ッ促棚促蔵促促狸促孫(測尊"Human"8促促促属) 0x00, 0x00, 0x00, 0x00, // $fc0008 ? - 0x48, 0x75, 0x6d, 0x61, // $fc000c ↓ - 0x6e, 0x36, 0x38, 0x6b, // $fc0010 ID "Human68k" (必ず起動エントリポイントの直前) - 0x4e, 0x75, // $fc0014 "rts" (起動エントリポイント) - 0x23, 0xfc, 0x00, 0xfc, 0x00, 0x2a, // $fc0016 ↓ (IOCSベクタ設定エントリポイント) + 0x48, 0x75, 0x6d, 0x61, // $fc000c 蔵足 + 0x6e, 0x36, 0x38, 0x6b, // $fc0010 ID "Human68k" (測尊袖俗属促邸促坦促促棚促促促坦促ﾃ展属) + 0x4e, 0x75, // $fc0014 "rts" (袖俗属促邸促坦促促棚促促促坦促) + 0x23, 0xfc, 0x00, 0xfc, 0x00, 0x2a, // $fc0016 蔵足 (IOCS促促俗促多棚促邸促坦促促棚促促促坦促) 0x00, 0x00, 0x07, 0xd4, // $fc001c "move.l #$fc002a, $7d4.l" 0x74, 0xff, // $fc0020 "moveq #-1, d2" 0x4e, 0x75, // $fc0022 "rts" // 0x53, 0x43, 0x53, 0x49, 0x49, 0x4e, // $fc0024 ID "SCSIIN" -// 内蔵SCSIをONにすると、SASIは自動的にOFFになっちゃうらしい… -// よって、IDはマッチしないようにしておく… +// 但蔵SCSI嘆ON孫谷臓蔵SASI束属捉OFF達辿揃臓 +// 竪臓蔵ID昤促促揃竪揃捉俗臓 0x44, 0x55, 0x4d, 0x4d, 0x59, 0x20, // $fc0024 ID "DUMMY " - 0x70, 0xff, // $fc002a "moveq #-1, d0" (SCSI IOCSコールエントリポイント) + 0x70, 0xff, // $fc002a "moveq #-1, d0" (SCSI IOCS促続臓促谷促邸促坦促促棚促促促坦促) 0x4e, 0x75, // $fc002c "rts" }; @@ -140,7 +140,7 @@ WinX68k_SCSICheck(void) scsi = 0; for (i = 0x30600; i < 0x30c00; i += 2) { -#if 0 // 4の倍数ではない偶数アドレスからの4バイト長アクセスはMIPSには無理 +#if 0 // 4ﾃ多担其旦多担促蔵促促狸促孫束辿4促促促孫促蔵促俗促損促孫MIPS袖箪 p = (DWORD *)(&IPL[i]); if (*p == 0x0000fc00) scsi = 1; @@ -155,14 +155,14 @@ WinX68k_SCSICheck(void) #endif } - // SCSIモデルのとき + // SCSI促但促促谷足 if (scsi) { - ZeroMemory(IPL, 0x2000); // 本体は8kb - memset(&IPL[0x2000], 0xff, 0x1e000); // 残りは0xff - memcpy(IPL, SCSIIMG, sizeof(SCSIIMG)); // インチキSCSI BIOS + ZeroMemory(IPL, 0x2000); // 8kb + memset(&IPL[0x2000], 0xff, 0x1e000); // 損棚0xff + memcpy(IPL, SCSIIMG, sizeof(SCSIIMG)); // 促促坦促促足SCSI BIOS // Memory_SetSCSIMode(); } else { - // SASIモデルはIPLがそのまま見える + // SASI促但促促谷IPL測転束邸谷 memcpy(IPL, &IPL[0x20000], 0x20000); } } @@ -184,14 +184,14 @@ WinX68k_LoadROMs(void) } if (fp == 0) { - Error("BIOS ROM イメージが見つかりません."); + Error("BIOS ROM 促促叩臓促転測転束束棚損坦."); return FALSE; } File_Read(fp, &IPL[0x20000], 0x20000); File_Close(fp); - WinX68k_SCSICheck(); // SCSI IPLなら、$fc0000〜にSCSI BIOSを置く + WinX68k_SCSICheck(); // SCSI IPL辿臓蔵$fc0000臓SCSI BIOS嘆俗 for (i = 0; i < 0x40000; i += 2) { tmp = IPL[i]; @@ -201,19 +201,19 @@ WinX68k_LoadROMs(void) fp = File_OpenCurDir((char *)FONTFILE); if (fp == 0) { - // cgrom.tmpがある？ + // cgrom.tmp測蔵谷臓息 fp = File_OpenCurDir((char *)FONTFILETMP); if (fp == 0) { #if 1 - // フォント生成 XXX - printf("フォントROMイメージが見つかりません\n"); + // 促促息促坦促転速 XXX + printf("促促息促坦促ROM促促叩臓促転測転束束棚損坦\n"); return FALSE; #else MessageBox(hWndMain, - "フォントROMイメージが見つかりません.\nWindowsフォントから新規に作成します.", - "けろぴーのメッセージ", MB_ICONWARNING | MB_OK); + "促促息促坦促ROM促促叩臓促転測転束束棚損坦.\nWindows促促息促坦促束辿多揃袖測尊樽速揃孫.", + "賊鱈臓ﾂッ‖ッ促損臓促転", MB_ICONWARNING | MB_OK); SSTP_SendMes(SSTPMES_MAKEFONT); - make_cgromdat(FONT, FALSE, "ＭＳ ゴシック", "ＭＳ 明朝"); + make_cgromdat(FONT, FALSE, "贈贈 促貼促揃促促俗", "贈贈 束"); //WinX68k_MakeFont(); //DialogBox(hInst, MAKEINTRESOURCE(IDD_PROGBAR), // hWndMain, (DLGPROC)MakeFontProc); @@ -240,9 +240,12 @@ WinX68k_Reset(void) OPM_Reset(); C68k_Reset(&C68K); +/* C68k_Set_Reg(&C68K, C68K_A7, (IPL[0x30001]<<24)|(IPL[0x30000]<<16)|(IPL[0x30003]<<8)|IPL[0x30002]); C68k_Set_Reg(&C68K, C68K_PC, (IPL[0x30005]<<24)|(IPL[0x30004]<<16)|(IPL[0x30007]<<8)|IPL[0x30006]); - +*/ + C68k_Set_AReg(&C68K, 7, (IPL[0x30001]<<24)|(IPL[0x30000]<<16)|(IPL[0x30003]<<8)|IPL[0x30002]); + C68k_Set_PC(&C68K, (IPL[0x30005]<<24)|(IPL[0x30004]<<16)|(IPL[0x30007]<<8)|IPL[0x30006]); Memory_Init(); CRTC_Init(); DMA_Init(); @@ -263,7 +266,7 @@ WinX68k_Reset(void) MIDI_Init(); //WinDrv_Init(); - C68K.ICount = 0; + //C68K.ICount = 0; m68000_ICountBk = 0; ICount = 0; @@ -318,7 +321,7 @@ WinX68k_Cleanup(void) #define CLOCK_SLICE 200 // ----------------------------------------------------------------------------------- -// コアのめいんるーぷ +// 促続促蔵叩坦谷臓 // ----------------------------------------------------------------------------------- void WinX68k_Exec(void) { @@ -364,7 +367,7 @@ void WinX68k_Exec(void) do { int m, n = (ICount>CLOCK_SLICE)?CLOCK_SLICE:ICount; - C68K.ICount = m68000_ICountBk = 0; // 割り込み発生前に与えておかないとダメ（CARAT） +// C68K.ICount = m68000_ICountBk = 0; // 続辰棚孫綻俗転属多邸捉束促促叩臓CARAT臓 if ( hsync ) { hsync = 0; @@ -381,9 +384,9 @@ void WinX68k_Exec(void) MFP_Int(9); } else { if ( CRTC_VEND>=VLINE_TOTAL ) { - if ( (long)vline==(CRTC_VEND-VLINE_TOTAL) ) MFP_Int(9); // エキサイティングアワーとか（TOTAL> 8/* regs.sr_high*/); fprintf(fp, "<%04X> (%08X ->) %08X : %s\n", Memory_ReadW(C68k_Get_Reg(&C68K, C68K_PC)), oldpc, C68k_Get_Reg(&C68K, C68K_PC), buf); } oldpc = C68k_Get_Reg(&C68K, C68K_PC); - C68K.ICount = 1; - C68k_Exec(&C68K, C68K.ICount); +// C68K.ICount = 1; +// C68k_Exec(&C68K, C68K.ICount); +// C68k_Exec(&C68K, 0); + C68k_Exec(&C68K, 1); } fclose(fp); usedclk = clk_line = HSYNC_CLK; @@ -425,16 +430,18 @@ void WinX68k_Exec(void) else #endif { - C68K.ICount = n; - C68k_Exec(&C68K, C68K.ICount); - m = (n-C68K.ICount-m68000_ICountBk); // 経過クロック数 +// C68K.ICount = n; +// C68k_Exec(&C68K, C68K.ICount); + C68k_Exec(&C68K, n); +// m = (n-C68K.ICount-m68000_ICountBk); // 揃族叩促俗促鱈促促俗多担 + m = (n-m68000_ICountBk); // 腟 ClkUsed += m*10; usedclk = ClkUsed/clkdiv; clk_line += usedclk; ClkUsed -= usedclk*clkdiv; ICount -= m; clk_count += m; - C68K.ICount = m68000_ICountBk = 0; +// C68K.ICount = m68000_ICountBk = 0; } MFP_Timer(usedclk); @@ -450,11 +457,11 @@ void WinX68k_Exec(void) if ( (MFP[MFP_AER]&0x40)&&(vline==CRTC_IntLine) ) MFP_Int(1); if ( (!DispFrame)&&(vline>=CRTC_VSTART)&&(vline0; i--) { if (IRQH_IRQ[i]) { C68k_Set_IRQ_Callback(&C68K, IRQH_CallBack[i]); - C68k_Set_IRQ(&C68K, i, HOLD_LINE); // xxx + C68k_Set_IRQ(&C68K, i); // xxx if ( C68K.ICount) { // 多重割り込み時（CARAT） m68000_ICountBk += C68K.ICount; // 強制的に割り込みチェックをさせる C68K.ICount = 0; // 苦肉の策 ^^; @@ -50,15 +51,28 @@ void IRQH_IRQCallBack(BYTE irq) break; } } -} +#endif + IRQH_IRQ[irq&7] = 0; +int i; +C68k_Set_IRQ(&C68K, 0); + for (i=7; i>0; i--) + { + if (IRQH_IRQ[i]) + { + C68k_Set_IRQ(&C68K, i); + return; + } + } +} // ----------------------------------------------------------------------- // 割り込み発生 // ----------------------------------------------------------------------- void IRQH_Int(BYTE irq, void* handler) { - int i; +#if 0 + int i; IRQH_IRQ[irq] = 1; if (handler==NULL) IRQH_CallBack[irq] = &IRQH_DefaultVector; @@ -77,4 +91,64 @@ void IRQH_Int(BYTE irq, void* handler) return; } } +#endif +#if 1 + int i; + IRQH_IRQ[irq&7] = 1; + if (handler==NULL) + IRQH_CallBack[irq&7] = &IRQH_DefaultVector; + else + IRQH_CallBack[irq&7] = handler; + for (i=7; i>0; i--) + { + if (IRQH_IRQ[i]) + { + C68k_Set_IRQ(&C68K, i); + return; + } + } +#endif +#if 0 + int i; + IRQH_IRQ[irq&7] = 1; + if (handler==NULL) + IRQH_CallBack[irq&7] = &IRQH_DefaultVector; + else + IRQH_CallBack[irq&7] = handler; + C68k_Set_IRQ(&C68K, irq&7); +#endif +} + +s32 my_irqh_callback(s32 level) +{ +#if 0 + int i; + int vect = -1; + for (i=7; i>0; i--) + { + if (IRQH_IRQ[i]) + { + IRQH_IRQ[level&7] = 0; + C68K_INT_CALLBACK *func = IRQH_CallBack[i]; + vect = (func)(level&7); + break; + } + } +#endif + + int i; + C68K_INT_CALLBACK *func = IRQH_CallBack[level&7]; + int vect = (func)(level&7); + //printf("irq vect = %x line = %d\n", vect, level); + + for (i=7; i>0; i--) + { + if (IRQH_IRQ[i]) + { + C68k_Set_IRQ(&C68K, i); + break; + } + } + + return (s32)vect; } diff --git a/x68k/mem_wrap.c b/x68k/mem_wrap.c index f6ae647..2fe3519 100644 --- a/x68k/mem_wrap.c +++ b/x68k/mem_wrap.c @@ -362,6 +362,7 @@ cpu_readmem24(DWORD addr) v = rm_main(addr); if (BusErrFlag & 1) { + printf("func = %s addr = %x flag = %d\n", __func__, addr, BusErrFlag); Memory_ErrTrace(); BusError(addr, 0); } @@ -383,6 +384,7 @@ cpu_readmem24_word(DWORD addr) v = rm_main(addr++) << 8; v |= rm_main(addr); if (BusErrFlag & 1) { + printf("func = %s addr = %x flag = %d\n", __func__, addr, BusErrFlag); Memory_ErrTrace(); BusError(addr, 0); } @@ -398,6 +400,7 @@ cpu_readmem24_dword(DWORD addr) if (addr & 1) { BusErrFlag = 3; + printf("func = %s addr = %x\n", __func__, addr); return 0; } @@ -477,6 +480,7 @@ rm_e82(DWORD addr) static BYTE FASTCALL rm_buserr(DWORD addr) { + printf("func = %s addr = %x flag = %d\n", __func__, addr, BusErrFlag); BusErrFlag = 1; BusErrAdr = addr; @@ -490,7 +494,8 @@ rm_buserr(DWORD addr) void Memory_Init(void) { - cpu_setOPbase24((DWORD)C68k_Get_Reg(&C68K, C68K_PC)); +// cpu_setOPbase24((DWORD)C68k_Get_Reg(&C68K, C68K_PC)); + cpu_setOPbase24((DWORD)C68k_Get_PC(&C68K)); } void FASTCALL @@ -582,7 +587,7 @@ AdrError(DWORD adr, DWORD unknown) (void)adr; (void)unknown; - printf("AdrError: %d\n", adr); + printf("AdrError: %x\n", adr); // assert(0); } @@ -593,7 +598,7 @@ BusError(DWORD adr, DWORD unknown) (void)adr; (void)unknown; - printf("BusError: %d\n", adr); + printf("BusError: %x\n", adr); BusErrHandling = 1; //assert(0); } diff --git a/x68k/mercury.c b/x68k/mercury.c index 9be537b..a6dd04a 100644 --- a/x68k/mercury.c +++ b/x68k/mercury.c @@ -256,6 +256,7 @@ fclose(fp); else if ( adr>=0xecc100 ) { // Bus Error? BusErrFlag = 1; + printf("func = %s addr = %x flag = %d\n", __func__, adr, BusErrFlag); } return ret; } diff --git a/x68k/sasi.c b/x68k/sasi.c index 655cf27..9dd8d7e 100644 --- a/x68k/sasi.c +++ b/x68k/sasi.c @@ -222,7 +222,8 @@ BYTE FASTCALL SASI_Read(DWORD adr) if (hddtrace&&((SASI_Phase!=3)||(adr!=0xe96001))) { FILE *fp; fp=fopen("_trace68.txt", "a"); -fprintf(fp, "Read - Adr:%08X Ret:%02X Phase:%d BufPtr:%d (Time:%08X) @ $%08X\n", adr, ret, SASI_Phase, SASI_BufPtr, timeGetTime(), C68k_Get_Reg(&C68K, C68K_PC)); +//fprintf(fp, "Read - Adr:%08X Ret:%02X Phase:%d BufPtr:%d (Time:%08X) @ $%08X\n", adr, ret, SASI_Phase, SASI_BufPtr, timeGetTime(), C68k_Get_Reg(&C68K, C68K_PC)); +fprintf(fp, "Read - Adr:%08X Ret:%02X Phase:%d BufPtr:%d (Time:%08X) @ $%08X\n", adr, ret, SASI_Phase, SASI_BufPtr, timeGetTime(), C68k_Get_PC(&C68K)); fclose(fp); } @@ -357,7 +358,8 @@ void FASTCALL SASI_Write(DWORD adr, BYTE data) if (hddtrace&&((SASI_Phase!=3)||(adr!=0xe96001))) { FILE *fp; fp=fopen("_trace68.txt", "a"); -fprintf(fp, "Write - Adr:%08X Data:%02X Phase:%d (Time:%08X) @ $%08X\n", adr, data, SASI_Phase, timeGetTime(), C68k_Get_Reg(&C68K, C68K_PC)); +//fprintf(fp, "Write - Adr:%08X Data:%02X Phase:%d (Time:%08X) @ $%08X\n", adr, data, SASI_Phase, timeGetTime(), C68k_Get_Reg(&C68K, C68K_PC)); +fprintf(fp, "Write - Adr:%08X Data:%02X Phase:%d (Time:%08X) @ $%08X\n", adr, data, SASI_Phase, timeGetTime(), C68k_Get_PC(&C68K)); fclose(fp); } if ( (adr==0xe96007)&&(SASI_Phase==0) )