From aeb585527d86109e4e2d3b86ed9e71663b39dcf7 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 15:11:12 -0700 Subject: [PATCH 01/10] changes for buildability under MSYS2 mingw32 --- BasiliskII/src/Windows/posix_emu.h | 45 +++++++++++++++++------------ BasiliskII/src/Windows/sysdeps.h | 1 + BasiliskII/src/slirp/slirp.h | 15 ---------- SheepShaver/Makefile | 2 +- SheepShaver/src/Windows/Makefile.in | 1 + SheepShaver/src/Windows/sysdeps.h | 2 ++ 6 files changed, 32 insertions(+), 34 deletions(-) diff --git a/BasiliskII/src/Windows/posix_emu.h b/BasiliskII/src/Windows/posix_emu.h index 730d63df..a238bece 100755 --- a/BasiliskII/src/Windows/posix_emu.h +++ b/BasiliskII/src/Windows/posix_emu.h @@ -79,24 +79,33 @@ extern int my_errno; // must hook all other functions that manipulate file names #ifndef NO_POSIX_API_HOOK -#define stat my_stat -#define fstat my_fstat -#define open my_open -#define rename my_rename -#define access my_access -#define mkdir my_mkdir -#define remove my_remove -#define creat my_creat -#define close my_close -#define lseek my_lseek -#define read my_read -#define write my_write -#define ftruncate my_chsize -#define locking my_locking -#define utime my_utime +# ifdef stat +# undef stat +# endif +# define stat my_stat +# ifdef fstat +# undef fstat +# endif +# define fstat my_fstat +# define open my_open +# define rename my_rename +# define access my_access +# define mkdir my_mkdir +# define remove my_remove +# define creat my_creat +# define close my_close +# ifdef lseek +# undef lseek +# endif +# define lseek my_lseek +# define read my_read +# define write my_write +# define ftruncate my_chsize +# define locking my_locking +# define utime my_utime -#undef errno -#define errno my_errno +# undef errno +# define errno my_errno #endif //!NO_POSIX_API_HOOK #ifndef S_ISDIR @@ -125,6 +134,6 @@ struct my_utimbuf }; // Your compiler may have different "struct stat" -> edit "struct my_stat" -#define validate_stat_struct ( sizeof(struct my_stat) == sizeof(struct stat) ) +#define validate_stat_struct ( sizeof(struct my_stat) == sizeof(struct _stat) ) #define st_crtime st_ctime diff --git a/BasiliskII/src/Windows/sysdeps.h b/BasiliskII/src/Windows/sysdeps.h index 3085a310..35a92f3b 100755 --- a/BasiliskII/src/Windows/sysdeps.h +++ b/BasiliskII/src/Windows/sysdeps.h @@ -23,6 +23,7 @@ #ifdef __MINGW32__ #define _UNICODE +#define UNICODE #endif #if !defined _MSC_VER && !defined __STDC__ diff --git a/BasiliskII/src/slirp/slirp.h b/BasiliskII/src/slirp/slirp.h index 3f9428af..a677185e 100755 --- a/BasiliskII/src/slirp/slirp.h +++ b/BasiliskII/src/slirp/slirp.h @@ -32,21 +32,6 @@ typedef unsigned long ioctlsockopt_t; # include # include -#ifdef __MINGW32__ -char * WSAAPI inet_ntop( - INT Family, - PVOID pAddr, - PTSTR pStringBuf, - size_t StringBufSize -); - -INT WSAAPI inet_pton( - INT Family, - const char * pszAddrString, - PVOID pAddrBuf -); -#endif - # include # include diff --git a/SheepShaver/Makefile b/SheepShaver/Makefile index e9e4ce7e..585417f4 100644 --- a/SheepShaver/Makefile +++ b/SheepShaver/Makefile @@ -99,7 +99,7 @@ links: case $$i in *codegen_x86.h) o=kpx_cpu/src/cpu/jit/x86/codegen_x86.h;; esac; \ SUB=`echo $$o | sed 's;[^/]*/;../;g' | sed 's;[^/]*$$;;'` ;\ cur_link=src/$$o ;\ - if [ -d "$$cur_link" ]; then rm -rf "$$cur_link"; fi ;\ + if [ -e "$$cur_link" ]; then rm -rf "$$cur_link"; fi ;\ ln -sf "$$PREFIX$$SUB$(B2_TOPDIR)/src/$$i" $$cur_link; \ fi; \ done; diff --git a/SheepShaver/src/Windows/Makefile.in b/SheepShaver/src/Windows/Makefile.in index 4c34ffac..67e5df9d 100755 --- a/SheepShaver/src/Windows/Makefile.in +++ b/SheepShaver/src/Windows/Makefile.in @@ -76,6 +76,7 @@ SRCS = ../main.cpp main_windows.cpp ../prefs.cpp ../prefs_items.cpp prefs_window UI_SRCS = ../prefs.cpp prefs_windows.cpp prefs_editor_gtk.cpp xpram_windows.cpp \ ../prefs_items.cpp ../user_strings.cpp user_strings_windows.cpp util_windows.cpp \ + ../dummy/prefs_dummy.cpp \ b2ether/packet32.cpp SheepShaverGUI.rc UI_APP = SheepShaverGUI.exe diff --git a/SheepShaver/src/Windows/sysdeps.h b/SheepShaver/src/Windows/sysdeps.h index 99834f0c..432b7e57 100755 --- a/SheepShaver/src/Windows/sysdeps.h +++ b/SheepShaver/src/Windows/sysdeps.h @@ -41,7 +41,9 @@ #undef _TEXT #include #ifdef __WIN32__ +#define WIN32_LEAN_AND_MEAN #include +#include #endif #include From f1b0a20b370bf52a14b8238da7df9981b718c5a0 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 15:55:27 -0700 Subject: [PATCH 02/10] get prefs_editor_gtk building in mingw32 --- BasiliskII/src/Windows/Makefile.in | 4 +- BasiliskII/src/Windows/prefs_editor_gtk.cpp | 136 +++++++++++++++----- SheepShaver/src/Windows/Makefile.in | 4 +- 3 files changed, 107 insertions(+), 37 deletions(-) diff --git a/BasiliskII/src/Windows/Makefile.in b/BasiliskII/src/Windows/Makefile.in index b3a3a11b..156d1f81 100755 --- a/BasiliskII/src/Windows/Makefile.in +++ b/BasiliskII/src/Windows/Makefile.in @@ -118,7 +118,7 @@ $(APP): $(XPLATSRCS) $(OBJ_DIR) $(OBJS) $(CXX) -o $@ $(LDFLAGS) $(OBJS) $(LIBS) $(SDL_LIBS) $(UI_APP): $(XPLATSRCS) $(OBJ_DIR) $(UI_OBJS) - $(CXX) -o $@ $(LDFLAGS) $(UI_OBJS) $(LIBS) $(GTK_LIBS) -mwindows -mno-cygwin + $(CXX) -o $@ $(LDFLAGS) $(UI_OBJS) $(LIBS) -Wl,-Bdynamic $(GTK_LIBS) -Wl,-Bstatic -mwindows -static-libgcc mostlyclean: rm -f $(APP) $(UI_APP) $(OBJ_DIR)/* core* *.core *~ *.bak @@ -149,7 +149,7 @@ $(OBJ_DIR)/%.o : %.cpp $(OBJ_DIR)/%.o : %.s $(CC) $(CPPFLAGS) $(DEFS) $(CFLAGS) -c $< -o $@ $(OBJ_DIR)/prefs_editor_gtk.o: prefs_editor_gtk.cpp - $(CXX) -O2 -mno-cygwin -mms-bitfields $(CPPFLAGS) $(DEFS) $(GTK_CFLAGS) -c $< -o $@ + $(CXX) -O2 -mms-bitfields $(CPPFLAGS) $(DEFS) $(GTK_CFLAGS) -c $< -o $@ # Windows resources $(OBJ_DIR)/%.o: %.rc diff --git a/BasiliskII/src/Windows/prefs_editor_gtk.cpp b/BasiliskII/src/Windows/prefs_editor_gtk.cpp index 66ad44c4..c9a5e6cf 100644 --- a/BasiliskII/src/Windows/prefs_editor_gtk.cpp +++ b/BasiliskII/src/Windows/prefs_editor_gtk.cpp @@ -26,6 +26,8 @@ #include #include +#include + #include "user_strings.h" #include "version.h" #include "cdrom.h" @@ -76,6 +78,27 @@ enum { * Utility functions */ +gchar * tchar_to_g_utf8(const TCHAR * str) { + gchar * out; + if (str == NULL) + return NULL; + int len = _tcslen(str) + 1; + #ifdef _UNICODE + /* First call just to find what the output size will be */ + int size = WideCharToMultiByte(CP_UTF8, 0, str, len, NULL, 0, NULL, NULL); + if (size == 0) + return NULL; + out = (gchar *) g_malloc(size); + if (out == NULL) + return NULL; + WideCharToMultiByte(CP_UTF8, 0, str, len, out, size, NULL, NULL); + #else /* _UNICODE */ + out = g_locale_to_utf8(str, -1, NULL, NULL, NULL); + #endif /* _UNICODE */ + return out; +} + + struct opt_desc { int label_id; GtkSignalFunc func; @@ -672,11 +695,11 @@ static GList *add_cdrom_names(void) { GList *glist = NULL; - char rootdir[4] = "X:\\"; - for (char letter = 'C'; letter <= 'Z'; letter++) { + TCHAR rootdir[4] = TEXT("X:\\"); + for (TCHAR letter = TEXT('C'); letter <= TEXT('Z'); letter++) { rootdir[0] = letter; if (GetDriveType(rootdir) == DRIVE_CDROM) - glist = g_list_append(glist, strdup(rootdir)); + glist = g_list_append(glist, _tcsdup(rootdir)); } return glist; @@ -1466,24 +1489,25 @@ static int create_ether_menu(GtkWidget *menu) n_items++; // Basilisk II Ethernet Adapter - PacketOpenAdapter("", 0); + PacketOpenAdapter(TEXT(""), 0); { ULONG sz; - char names[1024]; + TCHAR names[1024]; sz = sizeof(names); if (PacketGetAdapterNames(NULL, names, &sz) == ERROR_SUCCESS) { - char *p = names; + TCHAR *p = names; while (*p) { - const char DEVICE_HEADER[] = "\\Device\\B2ether_"; - if (strnicmp(p, DEVICE_HEADER, sizeof(DEVICE_HEADER) - 1) == 0) { + const TCHAR DEVICE_HEADER[] = TEXT("\\Device\\B2ether_"); + if (_tcsnicmp(p, DEVICE_HEADER, sizeof(DEVICE_HEADER) - 1) == 0) { LPADAPTER fd = PacketOpenAdapter(p + sizeof(DEVICE_HEADER) - 1, 0); if (fd) { - char guid[256]; - sprintf(guid, "%s", p + sizeof(DEVICE_HEADER) - 1); - const char *name = ether_guid_to_name(guid); - if (name && (name = g_locale_to_utf8(name, -1, NULL, NULL, NULL))) { - add_menu_item(menu, name, (GtkSignalFunc)mn_ether_b2ether, strdup(guid)); - if (etherguid && strcmp(guid, etherguid) == 0 && + TCHAR guid[256]; + _stprintf(guid, TEXT("%s"), p + sizeof(DEVICE_HEADER) - 1); + const gchar *name = tchar_to_g_utf8(ether_guid_to_name(guid)); + if (name) { + std::string str_guid = to_string(guid); + add_menu_item(menu, name, (GtkSignalFunc)mn_ether_b2ether, strdup(str_guid.c_str())); + if (etherguid && to_tstring(guid).compare(to_tstring(etherguid)) == 0 && ether && strcmp(ether, "b2ether") == 0) active = n_items; n_items++; @@ -1491,26 +1515,27 @@ static int create_ether_menu(GtkWidget *menu) PacketCloseAdapter(fd); } } - p += strlen(p) + 1; + p += _tcslen(p) + 1; } } } PacketCloseAdapter(NULL); // TAP-Win32 - const char *tap_devices; + const TCHAR *tap_devices; if ((tap_devices = ether_tap_devices()) != NULL) { - const char *guid = tap_devices; + const TCHAR *guid = tap_devices; while (*guid) { - const char *name = ether_guid_to_name(guid); - if (name && (name = g_locale_to_utf8(name, -1, NULL, NULL, NULL))) { - add_menu_item(menu, name, (GtkSignalFunc)mn_ether_tap, strdup(guid)); - if (etherguid && strcmp(guid, etherguid) == 0 && + const gchar *name = tchar_to_g_utf8(ether_guid_to_name(guid)); + if (name) { + std::string str_guid = to_string(guid); + add_menu_item(menu, name, (GtkSignalFunc)mn_ether_tap, strdup(str_guid.c_str())); + if (etherguid && to_tstring(guid).compare(to_tstring(etherguid)) == 0 && ether && strcmp(ether, "tap") == 0) active = n_items; n_items++; } - guid += strlen(guid) + 1; + guid += _tcslen(guid) + 1; } free((char *)tap_devices); } @@ -1734,21 +1759,66 @@ void SysAddSerialPrefs(void) * Display alerts */ +static HWND GetMainWindowHandle() { + return NULL; +} + static void display_alert(int title_id, const char *text, int flags) { - MessageBox(NULL, text, GetString(title_id), MB_OK | flags); + HWND hMainWnd = GetMainWindowHandle(); + MessageBoxA(hMainWnd, text, GetString(title_id), MB_OK | flags); } +#ifdef _UNICODE +static void display_alert(int title_id, const wchar_t *text, int flags) +{ + HWND hMainWnd = GetMainWindowHandle(); + MessageBoxW(hMainWnd, text, GetStringW(title_id).get(), MB_OK | flags); +} +#endif + + +/* + * Display error alert + */ void ErrorAlert(const char *text) { + if (PrefsFindBool("nogui")) + return; + display_alert(STR_ERROR_ALERT_TITLE, text, MB_ICONSTOP); } +#ifdef _UNICODE +void ErrorAlert(const wchar_t *text) +{ + if (PrefsFindBool("nogui")) + return; + + display_alert(STR_ERROR_ALERT_TITLE, text, MB_ICONSTOP); +} +#endif + + +/* + * Display warning alert + */ void WarningAlert(const char *text) { + if (PrefsFindBool("nogui")) + return; + display_alert(STR_WARNING_ALERT_TITLE, text, MB_ICONSTOP); } +#ifdef _UNICODE +void WarningAlert(const wchar_t *text) +{ + if (PrefsFindBool("nogui")) + return; + display_alert(STR_WARNING_ALERT_TITLE, text, MB_ICONSTOP); +} +#endif /* * Start standalone GUI @@ -1774,23 +1844,23 @@ int main(int argc, char *argv[]) // Transfer control to the executable if (start) { - char path[_MAX_PATH]; + TCHAR path[_MAX_PATH]; bool ok = GetModuleFileName(NULL, path, sizeof(path)) != 0; if (ok) { - char b2_path[_MAX_PATH]; - char *p = strrchr(path, '\\'); - *++p = '\0'; + TCHAR b2_path[_MAX_PATH]; + TCHAR *p = _tcsrchr(path, TEXT('\\')); + *++p = TEXT('\0'); SetCurrentDirectory(path); - strcpy(b2_path, path); - strcat(b2_path, PROGRAM_NAME); - strcat(b2_path, ".exe"); - HINSTANCE h = ShellExecute(GetDesktopWindow(), "open", - b2_path, "", path, SW_SHOWNORMAL); + _tcscpy(b2_path, path); + _tcscat(b2_path, TEXT(PROGRAM_NAME)); + _tcscat(b2_path, TEXT(".exe")); + HINSTANCE h = ShellExecute(GetDesktopWindow(), TEXT("open"), + b2_path, TEXT(""), path, SW_SHOWNORMAL); if ((int)h <= 32) ok = false; } if (!ok) { - ErrorAlert("Coult not start " PROGRAM_NAME " executable"); + ErrorAlert(TEXT("Could not start ") TEXT(PROGRAM_NAME) TEXT(" executable")); return 1; } } diff --git a/SheepShaver/src/Windows/Makefile.in b/SheepShaver/src/Windows/Makefile.in index 67e5df9d..57d5284f 100755 --- a/SheepShaver/src/Windows/Makefile.in +++ b/SheepShaver/src/Windows/Makefile.in @@ -129,7 +129,7 @@ $(APP): $(XPLATSRCS) $(OBJ_DIR) $(OBJS) $(CXX) -o $(APP) $(LDFLAGS) $(OBJS) $(LIBS) $(SDL_LIBS) $(UI_APP): $(XPLATSRCS) $(OBJ_DIR) $(UI_OBJS) - $(CXX) -o $@ $(LDFLAGS) $(UI_OBJS) $(LIBS) $(GTK_LIBS) -mwindows -mno-cygwin + $(CXX) -o $@ $(LDFLAGS) $(UI_OBJS) $(LIBS) -Wl,-Bdynamic $(GTK_LIBS) -Wl,-Bstatic -mwindows -static-libgcc mostlyclean: rm -f $(APP) $(UI_APP) $(OBJ_DIR)/* core* *.core *~ *.bak @@ -164,7 +164,7 @@ $(OBJ_DIR)/%.o : %.S $(AS) $(ASFLAGS) -o $@ $*.out.s rm $*.out.s $(OBJ_DIR)/prefs_editor_gtk.o: prefs_editor_gtk.cpp - $(CXX) -O2 -mno-cygwin -mms-bitfields $(CPPFLAGS) $(DEFS) $(GTK_CFLAGS) -c $< -o $@ + $(CXX) -O2 -mms-bitfields $(CPPFLAGS) $(DEFS) $(GTK_CFLAGS) -c $< -o $@ # Windows resources $(OBJ_DIR)/%.o: %.rc From cd269a9ce1e7440ebfd0e51ee14904009a356df0 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 15:27:51 -0700 Subject: [PATCH 03/10] In SheepShaver GUI don't show JIT checkbox in non-JIT build --- BasiliskII/src/Windows/prefs_editor_gtk.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/BasiliskII/src/Windows/prefs_editor_gtk.cpp b/BasiliskII/src/Windows/prefs_editor_gtk.cpp index c9a5e6cf..7e04ba80 100644 --- a/BasiliskII/src/Windows/prefs_editor_gtk.cpp +++ b/BasiliskII/src/Windows/prefs_editor_gtk.cpp @@ -910,11 +910,12 @@ static void create_jit_pane(GtkWidget *top) #endif set_jit_sensitive(); -#endif #ifdef SHEEPSHAVER make_checkbox(box, STR_JIT_68K_CTRL, "jit68k", GTK_SIGNAL_FUNC(tb_jit_68k)); #endif + +#endif } /* From ef2f205d6b2aff62bab16471e5c9853b898bf41a Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 15:29:38 -0700 Subject: [PATCH 04/10] Remove frsqrte dyngen op def because do_frsqrte is missing --- SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-dyngen-ops.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-dyngen-ops.cpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-dyngen-ops.cpp index 41d57c54..7f9e9f0b 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-dyngen-ops.cpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-dyngen-ops.cpp @@ -481,7 +481,6 @@ DEFINE_OP(fmov_FD_F2, FD_dw = F2_dw); DEFINE_OP(fabs_FD_F0, FD = do_fabs(F0)); DEFINE_OP(fneg_FD_F0, FD = do_fneg(F0)); DEFINE_OP(fnabs_FD_F0, FD = do_fnabs(F0)); -DEFINE_OP(frsqrte_FD_F0, FD = do_frsqrte(F0)); DEFINE_OP(fadd_FD_F0_F1, FD = do_fadd(F0, F1)); DEFINE_OP(fsub_FD_F0_F1, FD = do_fsub(F0, F1)); From a667dc9787f1e43133ac1a31c0f531838e1715e7 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 16:31:00 -0700 Subject: [PATCH 05/10] SS: add pregenerated dyngen output from cygwin; on cygwin run the dyngen, otherwise on Windows use this pregenerated dyngen --- SheepShaver/src/Windows/Makefile.in | 49 +- SheepShaver/src/Windows/configure.ac | 19 + .../basic-dyngen-ops.hpp | 1679 +++ .../ppc-dyngen-ops.hpp | 11173 ++++++++++++++++ 4 files changed, 12896 insertions(+), 24 deletions(-) create mode 100644 SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp create mode 100644 SheepShaver/src/Windows/cygwin_precompiled_dyngen/ppc-dyngen-ops.hpp diff --git a/SheepShaver/src/Windows/Makefile.in b/SheepShaver/src/Windows/Makefile.in index 57d5284f..a18c9029 100755 --- a/SheepShaver/src/Windows/Makefile.in +++ b/SheepShaver/src/Windows/Makefile.in @@ -35,7 +35,7 @@ CC = @CC@ CXX = @CXX@ CFLAGS = @CFLAGS@ $(SDL_CFLAGS) CXXFLAGS = @CXXFLAGS@ $(SDL_CFLAGS) -CPPFLAGS = @CPPFLAGS@ -I../include -I. -I../slirp -I../Unix/dyngen_precompiled +CPPFLAGS = @CPPFLAGS@ -I../include -I. -I../slirp DEFS = @DEFS@ LDFLAGS = @LDFLAGS@ -Wl,-Bstatic #TODO remove pthread part of that if irrelevant @@ -44,6 +44,7 @@ CPUSRCS = @CPUSRCS@ PERL = @PERL@ USE_DYNGEN = @USE_DYNGEN@ +USE_PREGENERATED_DYNGEN = @USE_PREGENERATED_DYNGEN@ DYNGENSRCS = @DYNGENSRCS@ DYNGEN_CC = $(CXX) DYNGEN_OP_FLAGS = @DYNGEN_OP_FLAGS@ @@ -134,8 +135,9 @@ $(UI_APP): $(XPLATSRCS) $(OBJ_DIR) $(UI_OBJS) mostlyclean: rm -f $(APP) $(UI_APP) $(OBJ_DIR)/* core* *.core *~ *.bak -clean: mostlyclean +clean: mostlyclean dyngenclean rm -f $(XPLATSRCS) +dyngenclean: rm -f dyngen basic-dyngen-ops.hpp ppc-dyngen-ops.hpp ppc-execute-impl.cpp distclean: clean @@ -177,36 +179,35 @@ DYNGEN = dyngen.exe ifeq ($(USE_DYNGEN),yes) DYNGENDEPS = basic-dyngen-ops.hpp ppc-dyngen-ops.hpp +dyngendeps: $(DYNGENDEPS) ### -basic-dyngen-ops.hpp: ../Unix/dyngen_precompiled/basic-dyngen-ops.hpp basic-dyngen-ops-x86_32.hpp basic-dyngen-ops-x86_64.hpp +$(OBJ_DIR)/basic-dyngen.o: basic-dyngen-ops.hpp +$(OBJ_DIR)/ppc-dyngen.o: ppc-dyngen-ops.hpp + +ifeq ($(USE_PREGENERATED_DYNGEN),yes) + +basic-dyngen-ops.hpp: cygwin_precompiled_dyngen/basic-dyngen-ops.hpp cp -f $< $@ -basic-dyngen-ops-x86_32.hpp: ../Unix/dyngen_precompiled/basic-dyngen-ops-x86_32.hpp - cp -f $< $@ -basic-dyngen-ops-x86_64.hpp: ../Unix/dyngen_precompiled/basic-dyngen-ops-x86_64.hpp - cp -f $< $@ -ppc-dyngen-ops.hpp: ../Unix/dyngen_precompiled/ppc-dyngen-ops.hpp ppc-dyngen-ops-x86_32.hpp ppc-dyngen-ops-x86_64.hpp - cp -f $< $@ -ppc-dyngen-ops-x86_32.hpp: ../Unix/dyngen_precompiled/ppc-dyngen-ops-x86_32.hpp - cp -f $< $@ -ppc-dyngen-ops-x86_64.hpp: ../Unix/dyngen_precompiled/ppc-dyngen-ops-x86_64.hpp +ppc-dyngen-ops.hpp: cygwin_precompiled_dyngen/ppc-dyngen-ops.hpp cp -f $< $@ + +else # Only GCC is supported for generating synthetic opcodes -#$(DYNGEN): $(DYNGENOBJS) -# $(HOST_CXX) -o $@ $(LDFLAGS) $(DYNGENOBJS) +$(DYNGEN): $(DYNGENOBJS) + $(HOST_CXX) -o $@ $(LDFLAGS) $(DYNGENOBJS) -#$(OBJ_DIR)/basic-dyngen.o: basic-dyngen-ops.hpp -#$(OBJ_DIR)/basic-dyngen-ops.o: $(kpxsrcdir)/cpu/jit/basic-dyngen-ops.cpp -# $(DYNGEN_CC) $(CPPFLAGS) $(DEFS) $(CXXFLAGS) $(DYNGEN_OP_FLAGS) -c $< -o $@ -#basic-dyngen-ops.hpp: $(OBJ_DIR)/basic-dyngen-ops.o $(DYNGEN) -# ./$(DYNGEN) -o $@ $< +$(OBJ_DIR)/basic-dyngen-ops.o: $(kpxsrcdir)/cpu/jit/basic-dyngen-ops.cpp + $(DYNGEN_CC) $(CPPFLAGS) $(DEFS) $(CXXFLAGS) $(DYNGEN_OP_FLAGS) -c $< -o $@ +basic-dyngen-ops.hpp: $(OBJ_DIR)/basic-dyngen-ops.o $(DYNGEN) + ./$(DYNGEN) -o $@ $< -#$(OBJ_DIR)/ppc-dyngen.o: ppc-dyngen-ops.hpp -#$(OBJ_DIR)/ppc-dyngen-ops.o: $(kpxsrcdir)/cpu/ppc/ppc-dyngen-ops.cpp basic-dyngen-ops.hpp -# $(DYNGEN_CC) $(CPPFLAGS) $(DEFS) $(CXXFLAGS) $(DYNGEN_OP_FLAGS) -c $< -o $@ -#ppc-dyngen-ops.hpp: $(OBJ_DIR)/ppc-dyngen-ops.o $(DYNGEN) -# ./$(DYNGEN) -o $@ $< +$(OBJ_DIR)/ppc-dyngen-ops.o: $(kpxsrcdir)/cpu/ppc/ppc-dyngen-ops.cpp basic-dyngen-ops.hpp + $(DYNGEN_CC) $(CPPFLAGS) $(DEFS) $(CXXFLAGS) $(DYNGEN_OP_FLAGS) -c $< -o $@ +ppc-dyngen-ops.hpp: $(OBJ_DIR)/ppc-dyngen-ops.o $(DYNGEN) + ./$(DYNGEN) -o $@ $< +endif $(OBJ_DIR)/sheepshaver_glue.o $(OBJ_DIR)/ppc-cpu.o $(OBJ_DIR)/ppc-decode.o $(OBJ_DIR)/ppc-translate.o $(OBJ_DIR)/ppc-jit.o: basic-dyngen-ops.hpp ppc-dyngen-ops.hpp endif diff --git a/SheepShaver/src/Windows/configure.ac b/SheepShaver/src/Windows/configure.ac index 21571618..12d75230 100644 --- a/SheepShaver/src/Windows/configure.ac +++ b/SheepShaver/src/Windows/configure.ac @@ -192,6 +192,13 @@ if [[ "x$HAVE_GCC30" = "xyes" ]]; then CFLAGS="$SAVED_CFLAGS" fi +case $host_os in +cygwin) + CFLAGS="$CFLAGS -mwin32" + CXXFLAGS="$CXXFLAGS -mwin32" + ;; +esac + dnl CPU emulator sources CPUSRCS="\ ../kpx_cpu/src/mathlib/ieeefp.cpp \ @@ -205,6 +212,7 @@ CPPFLAGS="$CPPFLAGS -I../kpx_cpu/include -I../kpx_cpu/src" dnl Enable JIT compiler, if possible USE_DYNGEN="no" +USE_PREGENERATED_DYNGEN="no" if [[ "x$WANT_JIT" = "xyes" ]]; then case $host_cpu in i?86) @@ -216,6 +224,16 @@ if [[ "x$WANT_JIT" = "xyes" ]]; then fi ;; esac + + case $host_os in + cygwin) + USE_PREGENERATED_DYNGEN="no" + ;; + *) + USE_PREGENERATED_DYNGEN="yes" + ;; + esac + USE_DYNGEN="yes" DYNGEN_OP_FLAGS="$DYNGEN_OP_FLAGS -finline-limit=10000 -g0" if [[ "x$HAVE_GCC30" = "xyes" ]]; then @@ -256,6 +274,7 @@ fi dnl Generate Makefile. AC_SUBST(PERL) AC_SUBST(USE_DYNGEN) +AC_SUBST(USE_PREGENERATED_DYNGEN) AC_SUBST(DYNGENSRCS) AC_SUBST(DYNGEN_OP_FLAGS) AC_SUBST(CPUSRCS) diff --git a/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp b/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp new file mode 100644 index 00000000..f244e88e --- /dev/null +++ b/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp @@ -0,0 +1,1679 @@ +#ifndef DEFINE_CST +#define DEFINE_CST(NAME, VALUE) +#endif +DEFINE_GEN(gen_op_mov_ad_A0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_ad_A0_im +{ + static const uint8 op_mov_ad_A0_im_code[] = { + 0xbb, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mov_ad_A0_im_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_mov_ad_A1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_ad_A1_im +{ + static const uint8 op_mov_ad_A1_im_code[] = { + 0xbe, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mov_ad_A1_im_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_mov_ad_A2_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_ad_A2_im +{ + static const uint8 op_mov_ad_A2_im_code[] = { + 0xbf, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mov_ad_A2_im_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T0_im +{ + static const uint8 op_mov_32_T0_im_code[] = { + 0xbb, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mov_32_T0_im_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T0_T1 +{ + static const uint8 op_mov_32_T0_T1_code[] = { + 0x89, 0xf3 + }; + copy_block(op_mov_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T0_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T0_T2 +{ + static const uint8 op_mov_32_T0_T2_code[] = { + 0x89, 0xfb + }; + copy_block(op_mov_32_T0_T2_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T1_im +{ + static const uint8 op_mov_32_T1_im_code[] = { + 0xbe, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mov_32_T1_im_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T1_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T1_T0 +{ + static const uint8 op_mov_32_T1_T0_code[] = { + 0x89, 0xde + }; + copy_block(op_mov_32_T1_T0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T1_T2 +{ + static const uint8 op_mov_32_T1_T2_code[] = { + 0x89, 0xfe + }; + copy_block(op_mov_32_T1_T2_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T2_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T2_im +{ + static const uint8 op_mov_32_T2_im_code[] = { + 0xbf, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mov_32_T2_im_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T2_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T2_T1 +{ + static const uint8 op_mov_32_T2_T1_code[] = { + 0x89, 0xf7 + }; + copy_block(op_mov_32_T2_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T2_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T2_T0 +{ + static const uint8 op_mov_32_T2_T0_code[] = { + 0x89, 0xdf + }; + copy_block(op_mov_32_T2_T0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T0_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T0_0 +{ + static const uint8 op_mov_32_T0_0_code[] = { + 0x31, 0xdb + }; + copy_block(op_mov_32_T0_0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T1_0 +{ + static const uint8 op_mov_32_T1_0_code[] = { + 0x31, 0xf6 + }; + copy_block(op_mov_32_T1_0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mov_32_T2_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mov_32_T2_0 +{ + static const uint8 op_mov_32_T2_0_code[] = { + 0x31, 0xff + }; + copy_block(op_mov_32_T2_0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_T2 +{ + static const uint8 op_add_32_T0_T2_code[] = { + 0x01, 0xfb + }; + copy_block(op_add_32_T0_T2_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_T1 +{ + static const uint8 op_add_32_T0_T1_code[] = { + 0x01, 0xf3 + }; + copy_block(op_add_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_im +{ + static const uint8 op_add_32_T0_im_code[] = { + 0x81, 0xc3, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_add_32_T0_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_1 +{ + static const uint8 op_add_32_T0_1_code[] = { + 0x43 + }; + copy_block(op_add_32_T0_1_code, 1); + inc_code_ptr(1); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_2 +{ + static const uint8 op_add_32_T0_2_code[] = { + 0x83, 0xc3, 0x02 + }; + copy_block(op_add_32_T0_2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_4 +{ + static const uint8 op_add_32_T0_4_code[] = { + 0x83, 0xc3, 0x04 + }; + copy_block(op_add_32_T0_4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_add_32_T0_8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T0_8 +{ + static const uint8 op_add_32_T0_8_code[] = { + 0x83, 0xc3, 0x08 + }; + copy_block(op_add_32_T0_8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_T2 +{ + static const uint8 op_sub_32_T0_T2_code[] = { + 0x29, 0xfb + }; + copy_block(op_sub_32_T0_T2_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_T1 +{ + static const uint8 op_sub_32_T0_T1_code[] = { + 0x29, 0xf3 + }; + copy_block(op_sub_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_im +{ + static const uint8 op_sub_32_T0_im_code[] = { + 0x81, 0xeb, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_sub_32_T0_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_1 +{ + static const uint8 op_sub_32_T0_1_code[] = { + 0x4b + }; + copy_block(op_sub_32_T0_1_code, 1); + inc_code_ptr(1); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_2 +{ + static const uint8 op_sub_32_T0_2_code[] = { + 0x83, 0xeb, 0x02 + }; + copy_block(op_sub_32_T0_2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_4 +{ + static const uint8 op_sub_32_T0_4_code[] = { + 0x83, 0xeb, 0x04 + }; + copy_block(op_sub_32_T0_4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T0_8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T0_8 +{ + static const uint8 op_sub_32_T0_8_code[] = { + 0x83, 0xeb, 0x08 + }; + copy_block(op_sub_32_T0_8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_T2 +{ + static const uint8 op_add_32_T1_T2_code[] = { + 0x01, 0xfe + }; + copy_block(op_add_32_T1_T2_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_T0 +{ + static const uint8 op_add_32_T1_T0_code[] = { + 0x01, 0xde + }; + copy_block(op_add_32_T1_T0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_im +{ + static const uint8 op_add_32_T1_im_code[] = { + 0x81, 0xc6, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_add_32_T1_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_1 +{ + static const uint8 op_add_32_T1_1_code[] = { + 0x46 + }; + copy_block(op_add_32_T1_1_code, 1); + inc_code_ptr(1); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_2 +{ + static const uint8 op_add_32_T1_2_code[] = { + 0x83, 0xc6, 0x02 + }; + copy_block(op_add_32_T1_2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_4 +{ + static const uint8 op_add_32_T1_4_code[] = { + 0x83, 0xc6, 0x04 + }; + copy_block(op_add_32_T1_4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_add_32_T1_8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_add_32_T1_8 +{ + static const uint8 op_add_32_T1_8_code[] = { + 0x83, 0xc6, 0x08 + }; + copy_block(op_add_32_T1_8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_T2 +{ + static const uint8 op_sub_32_T1_T2_code[] = { + 0x29, 0xfe + }; + copy_block(op_sub_32_T1_T2_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_T0 +{ + static const uint8 op_sub_32_T1_T0_code[] = { + 0x29, 0xde + }; + copy_block(op_sub_32_T1_T0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_im +{ + static const uint8 op_sub_32_T1_im_code[] = { + 0x81, 0xee, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_sub_32_T1_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_1 +{ + static const uint8 op_sub_32_T1_1_code[] = { + 0x4e + }; + copy_block(op_sub_32_T1_1_code, 1); + inc_code_ptr(1); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_2 +{ + static const uint8 op_sub_32_T1_2_code[] = { + 0x83, 0xee, 0x02 + }; + copy_block(op_sub_32_T1_2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_4 +{ + static const uint8 op_sub_32_T1_4_code[] = { + 0x83, 0xee, 0x04 + }; + copy_block(op_sub_32_T1_4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_sub_32_T1_8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sub_32_T1_8 +{ + static const uint8 op_sub_32_T1_8_code[] = { + 0x83, 0xee, 0x08 + }; + copy_block(op_sub_32_T1_8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_umul_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_umul_32_T0_T1 +{ + static const uint8 op_umul_32_T0_T1_code[] = { + 0x0f, 0xaf, 0xde + }; + copy_block(op_umul_32_T0_T1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_smul_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_smul_32_T0_T1 +{ + static const uint8 op_smul_32_T0_T1_code[] = { + 0x0f, 0xaf, 0xde + }; + copy_block(op_smul_32_T0_T1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_udiv_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_udiv_32_T0_T1 +{ + static const uint8 op_udiv_32_T0_T1_code[] = { + 0x89, 0xd8, 0x31, 0xd2, 0xf7, 0xf6, 0x89, 0xc3 + }; + copy_block(op_udiv_32_T0_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_sdiv_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sdiv_32_T0_T1 +{ + static const uint8 op_sdiv_32_T0_T1_code[] = { + 0x89, 0xd8, 0x99, 0xf7, 0xfe, 0x89, 0xc3 + }; + copy_block(op_sdiv_32_T0_T1_code, 7); + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_xchg_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_xchg_32_T0_T1 +{ + static const uint8 op_xchg_32_T0_T1_code[] = { + 0x87, 0xde + }; + copy_block(op_xchg_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_bswap_16_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_bswap_16_T0 +{ + static const uint8 op_bswap_16_T0_code[] = { + 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x0f, 0xb7, 0xd8 + }; + copy_block(op_bswap_16_T0_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_bswap_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_bswap_32_T0 +{ + static const uint8 op_bswap_32_T0_code[] = { + 0x0f, 0xcb + }; + copy_block(op_bswap_32_T0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_neg_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_neg_32_T0 +{ + static const uint8 op_neg_32_T0_code[] = { + 0xf7, 0xdb + }; + copy_block(op_neg_32_T0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_not_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_not_32_T0 +{ + static const uint8 op_not_32_T0_code[] = { + 0x85, 0xdb, 0x0f, 0x94, 0xc0, 0x0f, 0xb6, 0xd8 + }; + copy_block(op_not_32_T0_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_not_32_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_not_32_T1 +{ + static const uint8 op_not_32_T1_code[] = { + 0x85, 0xf6, 0x0f, 0x94, 0xc0, 0x0f, 0xb6, 0xf0 + }; + copy_block(op_not_32_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_and_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_and_32_T0_T1 +{ + static const uint8 op_and_32_T0_T1_code[] = { + 0x21, 0xf3 + }; + copy_block(op_and_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_and_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_and_32_T0_im +{ + static const uint8 op_and_32_T0_im_code[] = { + 0x81, 0xe3, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_and_32_T0_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_or_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_or_32_T0_T1 +{ + static const uint8 op_or_32_T0_T1_code[] = { + 0x09, 0xf3 + }; + copy_block(op_or_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_or_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_or_32_T0_im +{ + static const uint8 op_or_32_T0_im_code[] = { + 0x81, 0xcb, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_or_32_T0_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_xor_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_xor_32_T0_T1 +{ + static const uint8 op_xor_32_T0_T1_code[] = { + 0x31, 0xf3 + }; + copy_block(op_xor_32_T0_T1_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_xor_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_xor_32_T0_im +{ + static const uint8 op_xor_32_T0_im_code[] = { + 0x81, 0xf3, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_xor_32_T0_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_orc_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_orc_32_T0_T1 +{ + static const uint8 op_orc_32_T0_T1_code[] = { + 0x89, 0xf0, 0xf7, 0xd0, 0x09, 0xc3 + }; + copy_block(op_orc_32_T0_T1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_andc_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_andc_32_T0_T1 +{ + static const uint8 op_andc_32_T0_T1_code[] = { + 0x89, 0xf0, 0xf7, 0xd0, 0x21, 0xc3 + }; + copy_block(op_andc_32_T0_T1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_nand_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_nand_32_T0_T1 +{ + static const uint8 op_nand_32_T0_T1_code[] = { + 0x89, 0xd8, 0x21, 0xf0, 0x89, 0xc3, 0xf7, 0xd3 + }; + copy_block(op_nand_32_T0_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_nor_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_nor_32_T0_T1 +{ + static const uint8 op_nor_32_T0_T1_code[] = { + 0x89, 0xd8, 0x09, 0xf0, 0x89, 0xc3, 0xf7, 0xd3 + }; + copy_block(op_nor_32_T0_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_eqv_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_eqv_32_T0_T1 +{ + static const uint8 op_eqv_32_T0_T1_code[] = { + 0x89, 0xd8, 0x31, 0xf0, 0x89, 0xc3, 0xf7, 0xd3 + }; + copy_block(op_eqv_32_T0_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_lsl_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lsl_32_T0_T1 +{ + static const uint8 op_lsl_32_T0_T1_code[] = { + 0x89, 0xf1, 0xd3, 0xe3 + }; + copy_block(op_lsl_32_T0_T1_code, 4); + inc_code_ptr(4); +} +#endif + +DEFINE_GEN(gen_op_lsl_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lsl_32_T0_im +{ + static const uint8 op_lsl_32_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xe3 + }; + copy_block(op_lsl_32_T0_im_code, 9); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_lsr_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lsr_32_T0_T1 +{ + static const uint8 op_lsr_32_T0_T1_code[] = { + 0x89, 0xf1, 0xd3, 0xeb + }; + copy_block(op_lsr_32_T0_T1_code, 4); + inc_code_ptr(4); +} +#endif + +DEFINE_GEN(gen_op_lsr_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lsr_32_T0_im +{ + static const uint8 op_lsr_32_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xeb + }; + copy_block(op_lsr_32_T0_im_code, 9); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_asr_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_asr_32_T0_T1 +{ + static const uint8 op_asr_32_T0_T1_code[] = { + 0x89, 0xf1, 0xd3, 0xfb + }; + copy_block(op_asr_32_T0_T1_code, 4); + inc_code_ptr(4); +} +#endif + +DEFINE_GEN(gen_op_asr_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_asr_32_T0_im +{ + static const uint8 op_asr_32_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xfb + }; + copy_block(op_asr_32_T0_im_code, 9); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_rol_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_rol_32_T0_T1 +{ + static const uint8 op_rol_32_T0_T1_code[] = { + 0x89, 0xf1, 0xd3, 0xc3 + }; + copy_block(op_rol_32_T0_T1_code, 4); + inc_code_ptr(4); +} +#endif + +DEFINE_GEN(gen_op_rol_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_rol_32_T0_im +{ + static const uint8 op_rol_32_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xc3 + }; + copy_block(op_rol_32_T0_im_code, 9); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_ror_32_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_ror_32_T0_T1 +{ + static const uint8 op_ror_32_T0_T1_code[] = { + 0x89, 0xf1, 0xd3, 0xcb + }; + copy_block(op_ror_32_T0_T1_code, 4); + inc_code_ptr(4); +} +#endif + +DEFINE_GEN(gen_op_ror_32_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_ror_32_T0_im +{ + static const uint8 op_ror_32_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xcb + }; + copy_block(op_ror_32_T0_im_code, 9); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_se_16_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_se_16_32_T0 +{ + static const uint8 op_se_16_32_T0_code[] = { + 0x0f, 0xbf, 0xdb + }; + copy_block(op_se_16_32_T0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_se_16_32_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_se_16_32_T1 +{ + static const uint8 op_se_16_32_T1_code[] = { + 0x0f, 0xbf, 0xf6 + }; + copy_block(op_se_16_32_T1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_ze_16_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_ze_16_32_T0 +{ + static const uint8 op_ze_16_32_T0_code[] = { + 0x0f, 0xb7, 0xdb + }; + copy_block(op_ze_16_32_T0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_se_8_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_se_8_32_T0 +{ + static const uint8 op_se_8_32_T0_code[] = { + 0x0f, 0xbe, 0xdb + }; + copy_block(op_se_8_32_T0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_ze_8_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_ze_8_32_T0 +{ + static const uint8 op_ze_8_32_T0_code[] = { + 0x0f, 0xb6, 0xdb + }; + copy_block(op_ze_8_32_T0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_u32_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u32_T0_T1_0 +{ + static const uint8 op_load_u32_T0_T1_0_code[] = { + 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb + }; + copy_block(op_load_u32_T0_T1_0_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_load_s32_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s32_T0_T1_0 +{ + static const uint8 op_load_s32_T0_T1_0_code[] = { + 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb + }; + copy_block(op_load_s32_T0_T1_0_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_store_32_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_32_T0_T1_0 +{ + static const uint8 op_store_32_T0_T1_0_code[] = { + 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x86, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_32_T0_T1_0_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_load_u32_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u32_T0_T1_im +{ + static const uint8 op_load_u32_T0_T1_im_code[] = { + 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb + }; + copy_block(op_load_u32_T0_T1_im_code, 10); + *(uint32_t *)(code_ptr() + 2) = param1 + 285212672; + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_load_s32_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s32_T0_T1_im +{ + static const uint8 op_load_s32_T0_T1_im_code[] = { + 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb + }; + copy_block(op_load_s32_T0_T1_im_code, 10); + *(uint32_t *)(code_ptr() + 2) = param1 + 285212672; + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_store_32_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_32_T0_T1_im +{ + static const uint8 op_store_32_T0_T1_im_code[] = { + 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x82, + 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_32_T0_T1_im_code, 16); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(16); +} +#endif + +DEFINE_GEN(gen_op_load_u32_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u32_T0_T1_T2 +{ + static const uint8 op_load_u32_T0_T1_T2_code[] = { + 0x8b, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb + }; + copy_block(op_load_u32_T0_T1_T2_code, 11); + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_load_s32_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s32_T0_T1_T2 +{ + static const uint8 op_load_s32_T0_T1_T2_code[] = { + 0x8b, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb + }; + copy_block(op_load_s32_T0_T1_T2_code, 11); + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_store_32_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_32_T0_T1_T2 +{ + static const uint8 op_store_32_T0_T1_T2_code[] = { + 0x8d, 0x14, 0x3e, 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, + 0x11 + }; + copy_block(op_store_32_T0_T1_T2_code, 13); + inc_code_ptr(13); +} +#endif + +DEFINE_GEN(gen_op_load_u16_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u16_T0_T1_0 +{ + static const uint8 op_load_u16_T0_T1_0_code[] = { + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xb7, 0xd8 + }; + copy_block(op_load_u16_T0_T1_0_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_s16_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s16_T0_T1_0 +{ + static const uint8 op_load_s16_T0_T1_0_code[] = { + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xbf, 0xd8 + }; + copy_block(op_load_s16_T0_T1_0_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_16_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_16_T0_T1_0 +{ + static const uint8 op_store_16_T0_T1_0_code[] = { + 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x66, 0x89, 0x86, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_16_T0_T1_0_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_u16_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u16_T0_T1_im +{ + static const uint8 op_load_u16_T0_T1_im_code[] = { + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xb7, 0xd8 + }; + copy_block(op_load_u16_T0_T1_im_code, 12); + *(uint32_t *)(code_ptr() + 3) = param1 + 285212672; + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_s16_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s16_T0_T1_im +{ + static const uint8 op_load_s16_T0_T1_im_code[] = { + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xbf, 0xd8 + }; + copy_block(op_load_s16_T0_T1_im_code, 12); + *(uint32_t *)(code_ptr() + 3) = param1 + 285212672; + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_16_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_16_T0_T1_im +{ + static const uint8 op_store_16_T0_T1_im_code[] = { + 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x66, + 0x89, 0x82, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_16_T0_T1_im_code, 18); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(18); +} +#endif + +DEFINE_GEN(gen_op_load_u16_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u16_T0_T1_T2 +{ + static const uint8 op_load_u16_T0_T1_T2_code[] = { + 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xb7, + 0xd8 + }; + copy_block(op_load_u16_T0_T1_T2_code, 13); + inc_code_ptr(13); +} +#endif + +DEFINE_GEN(gen_op_load_s16_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s16_T0_T1_T2 +{ + static const uint8 op_load_s16_T0_T1_T2_code[] = { + 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xbf, + 0xd8 + }; + copy_block(op_load_s16_T0_T1_T2_code, 13); + inc_code_ptr(13); +} +#endif + +DEFINE_GEN(gen_op_store_16_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_16_T0_T1_T2 +{ + static const uint8 op_store_16_T0_T1_T2_code[] = { + 0x8d, 0x14, 0x3e, 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x66, 0x89, 0x82, 0x00, + 0x00, 0x00, 0x11 + }; + copy_block(op_store_16_T0_T1_T2_code, 15); + inc_code_ptr(15); +} +#endif + +DEFINE_GEN(gen_op_load_u8_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u8_T0_T1_0 +{ + static const uint8 op_load_u8_T0_T1_0_code[] = { + 0x0f, 0xb6, 0x9e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_load_u8_T0_T1_0_code, 7); + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_load_s8_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s8_T0_T1_0 +{ + static const uint8 op_load_s8_T0_T1_0_code[] = { + 0x0f, 0xbe, 0x9e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_load_s8_T0_T1_0_code, 7); + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_store_8_T0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_8_T0_T1_0 +{ + static const uint8 op_store_8_T0_T1_0_code[] = { + 0x88, 0x9e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_8_T0_T1_0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_u8_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u8_T0_T1_im +{ + static const uint8 op_load_u8_T0_T1_im_code[] = { + 0x0f, 0xb6, 0x9e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_load_u8_T0_T1_im_code, 7); + *(uint32_t *)(code_ptr() + 3) = param1 + 285212672; + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_load_s8_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s8_T0_T1_im +{ + static const uint8 op_load_s8_T0_T1_im_code[] = { + 0x0f, 0xbe, 0x9e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_load_s8_T0_T1_im_code, 7); + *(uint32_t *)(code_ptr() + 3) = param1 + 285212672; + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_store_8_T0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_8_T0_T1_im +{ + static const uint8 op_store_8_T0_T1_im_code[] = { + 0x88, 0x9e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_8_T0_T1_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 285212672; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_u8_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_u8_T0_T1_T2 +{ + static const uint8 op_load_u8_T0_T1_T2_code[] = { + 0x0f, 0xb6, 0x9c, 0x3e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_load_u8_T0_T1_T2_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_load_s8_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_s8_T0_T1_T2 +{ + static const uint8 op_load_s8_T0_T1_T2_code[] = { + 0x0f, 0xbe, 0x9c, 0x3e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_load_s8_T0_T1_T2_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_store_8_T0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_8_T0_T1_T2 +{ + static const uint8 op_store_8_T0_T1_T2_code[] = { + 0x88, 0x9c, 0x3e, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_8_T0_T1_T2_code, 7); + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_execute,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_execute +{ + static const uint8 op_execute_code[] = { + 0x83, 0xec, 0x50, 0x89, 0x6c, 0x24, 0x4c, 0x8b, 0x6c, 0x24, 0x58, 0x89, + 0x5c, 0x24, 0x48, 0x89, 0x74, 0x24, 0x44, 0x89, 0x7c, 0x24, 0x40, 0xff, + 0x64, 0x24, 0x54, 0x90, 0x8d, 0x74, 0x26, 0x00, 0xff, 0x54, 0x24, 0x54, + 0x8b, 0x7c, 0x24, 0x40, 0x8b, 0x74, 0x24, 0x44, 0x8b, 0x5c, 0x24, 0x48, + 0x8b, 0x6c, 0x24, 0x4c, 0x83, 0xc4, 0x50, 0xc3, 0x90, 0x8d, 0xb4, 0x26, + 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_execute_code, 64); + inc_code_ptr(64); +} +#endif + +DEFINE_GEN(gen_op_jmp_slow,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_jmp_slow +{ + static const uint8 op_jmp_slow_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe0 + }; + copy_block(op_jmp_slow_code, 7); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(7); +} +#endif + +DEFINE_GEN(gen_op_jmp_fast,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_jmp_fast +{ + static const uint8 op_jmp_fast_code[] = { + 0xe9, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_jmp_fast_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 - (long)(code_ptr() + 1) + 0 -4; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_jmp_A0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_jmp_A0 +{ + static const uint8 op_jmp_A0_code[] = { + 0xff, 0xe3 + }; + copy_block(op_jmp_A0_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_invoke,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke +{ + static const uint8 helper_op_invoke_code[] = { + 0xe8, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(helper_op_invoke_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 - (long)(code_ptr() + 1) + 0 -4; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_invoke_T0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_T0 +{ + static const uint8 helper_op_invoke_T0_code[] = { + 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x58 + }; + copy_block(helper_op_invoke_T0_code, 12); + *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4; + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_invoke_T0_T1,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_T0_T1 +{ + static const uint8 helper_op_invoke_T0_T1_code[] = { + 0x83, 0xec, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_T0_T1_code, 18); + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(18); +} +#endif + +DEFINE_GEN(gen_op_invoke_T0_T1_T2,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_T0_T1_T2 +{ + static const uint8 helper_op_invoke_T0_T1_T2_code[] = { + 0x83, 0xec, 0x0c, 0x89, 0x7c, 0x24, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89, + 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c + }; + copy_block(helper_op_invoke_T0_T1_T2_code, 22); + *(uint32_t *)(code_ptr() + 15) = param1 - (long)(code_ptr() + 15) + 0 -4; + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_invoke_T0_ret_T0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_T0_ret_T0 +{ + static const uint8 helper_op_invoke_T0_ret_T0_code[] = { + 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x5a, + 0x89, 0xc3 + }; + copy_block(helper_op_invoke_T0_ret_T0_code, 14); + *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4; + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_invoke_im,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_im +{ + static const uint8 helper_op_invoke_im_code[] = { + 0x83, 0xec, 0x04, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x59 + }; + copy_block(helper_op_invoke_im_code, 16); + *(uint32_t *)(code_ptr() + 6) = param2 + 0; + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(16); +} +#endif + +DEFINE_GEN(gen_op_invoke_CPU,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_CPU +{ + static const uint8 helper_op_invoke_CPU_code[] = { + 0x83, 0xec, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x58 + }; + copy_block(helper_op_invoke_CPU_code, 12); + *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4; + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_invoke_CPU_T0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_CPU_T0 +{ + static const uint8 helper_op_invoke_CPU_T0_code[] = { + 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_CPU_T0_code, 18); + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(18); +} +#endif + +DEFINE_GEN(gen_op_invoke_CPU_im,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_CPU_im +{ + static const uint8 helper_op_invoke_CPU_im_code[] = { + 0x83, 0xec, 0x08, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04, + 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_CPU_im_code, 23); + *(uint32_t *)(code_ptr() + 4) = param2 + 0; + *(uint32_t *)(code_ptr() + 16) = param1 - (long)(code_ptr() + 16) + 0 -4; + inc_code_ptr(23); +} +#endif + +DEFINE_GEN(gen_op_invoke_CPU_im_im,void,(long param1, long param2, long param3)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_CPU_im_im +{ + static const uint8 helper_op_invoke_CPU_im_im_code[] = { + 0x83, 0xec, 0x0c, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x08, + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04, 0x89, 0x2c, 0x24, + 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c + }; + copy_block(helper_op_invoke_CPU_im_im_code, 32); + *(uint32_t *)(code_ptr() + 4) = param3 + 0; + *(uint32_t *)(code_ptr() + 13) = param2 + 0; + *(uint32_t *)(code_ptr() + 25) = param1 - (long)(code_ptr() + 25) + 0 -4; + inc_code_ptr(32); +} +#endif + +DEFINE_GEN(gen_op_invoke_CPU_A0_ret_A0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_CPU_A0_ret_A0 +{ + static const uint8 helper_op_invoke_CPU_A0_ret_A0_code[] = { + 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_CPU_A0_ret_A0_code, 20); + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(20); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct +{ + static const uint8 helper_op_invoke_direct_code[] = { + 0xe8, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(helper_op_invoke_direct_code, 5); + *(uint32_t *)(code_ptr() + 1) = param1 - (long)(code_ptr() + 1) + 0 -4; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_T0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_T0 +{ + static const uint8 helper_op_invoke_direct_T0_code[] = { + 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x58 + }; + copy_block(helper_op_invoke_direct_T0_code, 12); + *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4; + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_T0_T1,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_T0_T1 +{ + static const uint8 helper_op_invoke_direct_T0_T1_code[] = { + 0x83, 0xec, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_direct_T0_T1_code, 18); + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(18); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_T0_T1_T2,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_T0_T1_T2 +{ + static const uint8 helper_op_invoke_direct_T0_T1_T2_code[] = { + 0x83, 0xec, 0x0c, 0x89, 0x7c, 0x24, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89, + 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c + }; + copy_block(helper_op_invoke_direct_T0_T1_T2_code, 22); + *(uint32_t *)(code_ptr() + 15) = param1 - (long)(code_ptr() + 15) + 0 -4; + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_T0_ret_T0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_T0_ret_T0 +{ + static const uint8 helper_op_invoke_direct_T0_ret_T0_code[] = { + 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x89, + 0xc3, 0x58 + }; + copy_block(helper_op_invoke_direct_T0_ret_T0_code, 14); + *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4; + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_im,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_im +{ + static const uint8 helper_op_invoke_direct_im_code[] = { + 0x83, 0xec, 0x04, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x5a + }; + copy_block(helper_op_invoke_direct_im_code, 16); + *(uint32_t *)(code_ptr() + 6) = param2 + 0; + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(16); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_CPU,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_CPU +{ + static const uint8 helper_op_invoke_direct_CPU_code[] = { + 0x83, 0xec, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x59 + }; + copy_block(helper_op_invoke_direct_CPU_code, 12); + *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4; + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_CPU_T0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_CPU_T0 +{ + static const uint8 helper_op_invoke_direct_CPU_T0_code[] = { + 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_direct_CPU_T0_code, 18); + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(18); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_CPU_im,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_CPU_im +{ + static const uint8 helper_op_invoke_direct_CPU_im_code[] = { + 0x83, 0xec, 0x08, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04, + 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_direct_CPU_im_code, 23); + *(uint32_t *)(code_ptr() + 4) = param2 + 0; + *(uint32_t *)(code_ptr() + 16) = param1 - (long)(code_ptr() + 16) + 0 -4; + inc_code_ptr(23); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_CPU_im_im,void,(long param1, long param2, long param3)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_CPU_im_im +{ + static const uint8 helper_op_invoke_direct_CPU_im_im_code[] = { + 0x83, 0xec, 0x0c, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x08, + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04, 0x89, 0x2c, 0x24, + 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c + }; + copy_block(helper_op_invoke_direct_CPU_im_im_code, 32); + *(uint32_t *)(code_ptr() + 4) = param3 + 0; + *(uint32_t *)(code_ptr() + 13) = param2 + 0; + *(uint32_t *)(code_ptr() + 25) = param1 - (long)(code_ptr() + 25) + 0 -4; + inc_code_ptr(32); +} +#endif + +DEFINE_GEN(gen_op_invoke_direct_CPU_A0_ret_A0,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_invoke_direct_CPU_A0_ret_A0 +{ + static const uint8 helper_op_invoke_direct_CPU_A0_ret_A0_code[] = { + 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, + 0x00, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xc4, 0x08 + }; + copy_block(helper_op_invoke_direct_CPU_A0_ret_A0_code, 20); + *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4; + inc_code_ptr(20); +} +#endif + +DEFINE_CST(op_exec_return_offset,0x24L) + +#undef DEFINE_CST +#undef DEFINE_GEN diff --git a/SheepShaver/src/Windows/cygwin_precompiled_dyngen/ppc-dyngen-ops.hpp b/SheepShaver/src/Windows/cygwin_precompiled_dyngen/ppc-dyngen-ops.hpp new file mode 100644 index 00000000..9f2e1f3f --- /dev/null +++ b/SheepShaver/src/Windows/cygwin_precompiled_dyngen/ppc-dyngen-ops.hpp @@ -0,0 +1,11173 @@ +#ifndef DEFINE_CST +#define DEFINE_CST(NAME, VALUE) +#endif +DEFINE_GEN(gen_op_load_T0_GPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR0 +{ + static const uint8 op_load_T0_GPR0_code[] = { + 0x8b, 0x5d, 0x10 + }; + copy_block(op_load_T0_GPR0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR0 +{ + static const uint8 op_store_T0_GPR0_code[] = { + 0x89, 0x5d, 0x10 + }; + copy_block(op_store_T0_GPR0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR0 +{ + static const uint8 op_load_T1_GPR0_code[] = { + 0x8b, 0x75, 0x10 + }; + copy_block(op_load_T1_GPR0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR0 +{ + static const uint8 op_store_T1_GPR0_code[] = { + 0x89, 0x75, 0x10 + }; + copy_block(op_store_T1_GPR0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR0 +{ + static const uint8 op_load_T2_GPR0_code[] = { + 0x8b, 0x7d, 0x10 + }; + copy_block(op_load_T2_GPR0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR0 +{ + static const uint8 op_store_T2_GPR0_code[] = { + 0x89, 0x7d, 0x10 + }; + copy_block(op_store_T2_GPR0_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR1 +{ + static const uint8 op_load_T0_GPR1_code[] = { + 0x8b, 0x5d, 0x14 + }; + copy_block(op_load_T0_GPR1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR1 +{ + static const uint8 op_store_T0_GPR1_code[] = { + 0x89, 0x5d, 0x14 + }; + copy_block(op_store_T0_GPR1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR1 +{ + static const uint8 op_load_T1_GPR1_code[] = { + 0x8b, 0x75, 0x14 + }; + copy_block(op_load_T1_GPR1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR1 +{ + static const uint8 op_store_T1_GPR1_code[] = { + 0x89, 0x75, 0x14 + }; + copy_block(op_store_T1_GPR1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR1 +{ + static const uint8 op_load_T2_GPR1_code[] = { + 0x8b, 0x7d, 0x14 + }; + copy_block(op_load_T2_GPR1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR1 +{ + static const uint8 op_store_T2_GPR1_code[] = { + 0x89, 0x7d, 0x14 + }; + copy_block(op_store_T2_GPR1_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR2 +{ + static const uint8 op_load_T0_GPR2_code[] = { + 0x8b, 0x5d, 0x18 + }; + copy_block(op_load_T0_GPR2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR2 +{ + static const uint8 op_store_T0_GPR2_code[] = { + 0x89, 0x5d, 0x18 + }; + copy_block(op_store_T0_GPR2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR2 +{ + static const uint8 op_load_T1_GPR2_code[] = { + 0x8b, 0x75, 0x18 + }; + copy_block(op_load_T1_GPR2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR2 +{ + static const uint8 op_store_T1_GPR2_code[] = { + 0x89, 0x75, 0x18 + }; + copy_block(op_store_T1_GPR2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR2 +{ + static const uint8 op_load_T2_GPR2_code[] = { + 0x8b, 0x7d, 0x18 + }; + copy_block(op_load_T2_GPR2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR2 +{ + static const uint8 op_store_T2_GPR2_code[] = { + 0x89, 0x7d, 0x18 + }; + copy_block(op_store_T2_GPR2_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR3 +{ + static const uint8 op_load_T0_GPR3_code[] = { + 0x8b, 0x5d, 0x1c + }; + copy_block(op_load_T0_GPR3_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR3 +{ + static const uint8 op_store_T0_GPR3_code[] = { + 0x89, 0x5d, 0x1c + }; + copy_block(op_store_T0_GPR3_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR3 +{ + static const uint8 op_load_T1_GPR3_code[] = { + 0x8b, 0x75, 0x1c + }; + copy_block(op_load_T1_GPR3_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR3 +{ + static const uint8 op_store_T1_GPR3_code[] = { + 0x89, 0x75, 0x1c + }; + copy_block(op_store_T1_GPR3_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR3 +{ + static const uint8 op_load_T2_GPR3_code[] = { + 0x8b, 0x7d, 0x1c + }; + copy_block(op_load_T2_GPR3_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR3 +{ + static const uint8 op_store_T2_GPR3_code[] = { + 0x89, 0x7d, 0x1c + }; + copy_block(op_store_T2_GPR3_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR4 +{ + static const uint8 op_load_T0_GPR4_code[] = { + 0x8b, 0x5d, 0x20 + }; + copy_block(op_load_T0_GPR4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR4 +{ + static const uint8 op_store_T0_GPR4_code[] = { + 0x89, 0x5d, 0x20 + }; + copy_block(op_store_T0_GPR4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR4 +{ + static const uint8 op_load_T1_GPR4_code[] = { + 0x8b, 0x75, 0x20 + }; + copy_block(op_load_T1_GPR4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR4 +{ + static const uint8 op_store_T1_GPR4_code[] = { + 0x89, 0x75, 0x20 + }; + copy_block(op_store_T1_GPR4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR4 +{ + static const uint8 op_load_T2_GPR4_code[] = { + 0x8b, 0x7d, 0x20 + }; + copy_block(op_load_T2_GPR4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR4 +{ + static const uint8 op_store_T2_GPR4_code[] = { + 0x89, 0x7d, 0x20 + }; + copy_block(op_store_T2_GPR4_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR5 +{ + static const uint8 op_load_T0_GPR5_code[] = { + 0x8b, 0x5d, 0x24 + }; + copy_block(op_load_T0_GPR5_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR5 +{ + static const uint8 op_store_T0_GPR5_code[] = { + 0x89, 0x5d, 0x24 + }; + copy_block(op_store_T0_GPR5_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR5 +{ + static const uint8 op_load_T1_GPR5_code[] = { + 0x8b, 0x75, 0x24 + }; + copy_block(op_load_T1_GPR5_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR5 +{ + static const uint8 op_store_T1_GPR5_code[] = { + 0x89, 0x75, 0x24 + }; + copy_block(op_store_T1_GPR5_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR5 +{ + static const uint8 op_load_T2_GPR5_code[] = { + 0x8b, 0x7d, 0x24 + }; + copy_block(op_load_T2_GPR5_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR5 +{ + static const uint8 op_store_T2_GPR5_code[] = { + 0x89, 0x7d, 0x24 + }; + copy_block(op_store_T2_GPR5_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR6 +{ + static const uint8 op_load_T0_GPR6_code[] = { + 0x8b, 0x5d, 0x28 + }; + copy_block(op_load_T0_GPR6_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR6 +{ + static const uint8 op_store_T0_GPR6_code[] = { + 0x89, 0x5d, 0x28 + }; + copy_block(op_store_T0_GPR6_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR6 +{ + static const uint8 op_load_T1_GPR6_code[] = { + 0x8b, 0x75, 0x28 + }; + copy_block(op_load_T1_GPR6_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR6 +{ + static const uint8 op_store_T1_GPR6_code[] = { + 0x89, 0x75, 0x28 + }; + copy_block(op_store_T1_GPR6_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR6 +{ + static const uint8 op_load_T2_GPR6_code[] = { + 0x8b, 0x7d, 0x28 + }; + copy_block(op_load_T2_GPR6_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR6 +{ + static const uint8 op_store_T2_GPR6_code[] = { + 0x89, 0x7d, 0x28 + }; + copy_block(op_store_T2_GPR6_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR7 +{ + static const uint8 op_load_T0_GPR7_code[] = { + 0x8b, 0x5d, 0x2c + }; + copy_block(op_load_T0_GPR7_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR7 +{ + static const uint8 op_store_T0_GPR7_code[] = { + 0x89, 0x5d, 0x2c + }; + copy_block(op_store_T0_GPR7_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR7 +{ + static const uint8 op_load_T1_GPR7_code[] = { + 0x8b, 0x75, 0x2c + }; + copy_block(op_load_T1_GPR7_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR7 +{ + static const uint8 op_store_T1_GPR7_code[] = { + 0x89, 0x75, 0x2c + }; + copy_block(op_store_T1_GPR7_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR7 +{ + static const uint8 op_load_T2_GPR7_code[] = { + 0x8b, 0x7d, 0x2c + }; + copy_block(op_load_T2_GPR7_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR7 +{ + static const uint8 op_store_T2_GPR7_code[] = { + 0x89, 0x7d, 0x2c + }; + copy_block(op_store_T2_GPR7_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR8 +{ + static const uint8 op_load_T0_GPR8_code[] = { + 0x8b, 0x5d, 0x30 + }; + copy_block(op_load_T0_GPR8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR8 +{ + static const uint8 op_store_T0_GPR8_code[] = { + 0x89, 0x5d, 0x30 + }; + copy_block(op_store_T0_GPR8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR8 +{ + static const uint8 op_load_T1_GPR8_code[] = { + 0x8b, 0x75, 0x30 + }; + copy_block(op_load_T1_GPR8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR8 +{ + static const uint8 op_store_T1_GPR8_code[] = { + 0x89, 0x75, 0x30 + }; + copy_block(op_store_T1_GPR8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR8 +{ + static const uint8 op_load_T2_GPR8_code[] = { + 0x8b, 0x7d, 0x30 + }; + copy_block(op_load_T2_GPR8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR8 +{ + static const uint8 op_store_T2_GPR8_code[] = { + 0x89, 0x7d, 0x30 + }; + copy_block(op_store_T2_GPR8_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR9 +{ + static const uint8 op_load_T0_GPR9_code[] = { + 0x8b, 0x5d, 0x34 + }; + copy_block(op_load_T0_GPR9_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR9 +{ + static const uint8 op_store_T0_GPR9_code[] = { + 0x89, 0x5d, 0x34 + }; + copy_block(op_store_T0_GPR9_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR9 +{ + static const uint8 op_load_T1_GPR9_code[] = { + 0x8b, 0x75, 0x34 + }; + copy_block(op_load_T1_GPR9_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR9 +{ + static const uint8 op_store_T1_GPR9_code[] = { + 0x89, 0x75, 0x34 + }; + copy_block(op_store_T1_GPR9_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR9 +{ + static const uint8 op_load_T2_GPR9_code[] = { + 0x8b, 0x7d, 0x34 + }; + copy_block(op_load_T2_GPR9_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR9 +{ + static const uint8 op_store_T2_GPR9_code[] = { + 0x89, 0x7d, 0x34 + }; + copy_block(op_store_T2_GPR9_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR10 +{ + static const uint8 op_load_T0_GPR10_code[] = { + 0x8b, 0x5d, 0x38 + }; + copy_block(op_load_T0_GPR10_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR10 +{ + static const uint8 op_store_T0_GPR10_code[] = { + 0x89, 0x5d, 0x38 + }; + copy_block(op_store_T0_GPR10_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR10 +{ + static const uint8 op_load_T1_GPR10_code[] = { + 0x8b, 0x75, 0x38 + }; + copy_block(op_load_T1_GPR10_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR10 +{ + static const uint8 op_store_T1_GPR10_code[] = { + 0x89, 0x75, 0x38 + }; + copy_block(op_store_T1_GPR10_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR10 +{ + static const uint8 op_load_T2_GPR10_code[] = { + 0x8b, 0x7d, 0x38 + }; + copy_block(op_load_T2_GPR10_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR10 +{ + static const uint8 op_store_T2_GPR10_code[] = { + 0x89, 0x7d, 0x38 + }; + copy_block(op_store_T2_GPR10_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR11 +{ + static const uint8 op_load_T0_GPR11_code[] = { + 0x8b, 0x5d, 0x3c + }; + copy_block(op_load_T0_GPR11_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR11 +{ + static const uint8 op_store_T0_GPR11_code[] = { + 0x89, 0x5d, 0x3c + }; + copy_block(op_store_T0_GPR11_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR11 +{ + static const uint8 op_load_T1_GPR11_code[] = { + 0x8b, 0x75, 0x3c + }; + copy_block(op_load_T1_GPR11_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR11 +{ + static const uint8 op_store_T1_GPR11_code[] = { + 0x89, 0x75, 0x3c + }; + copy_block(op_store_T1_GPR11_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR11 +{ + static const uint8 op_load_T2_GPR11_code[] = { + 0x8b, 0x7d, 0x3c + }; + copy_block(op_load_T2_GPR11_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR11 +{ + static const uint8 op_store_T2_GPR11_code[] = { + 0x89, 0x7d, 0x3c + }; + copy_block(op_store_T2_GPR11_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR12 +{ + static const uint8 op_load_T0_GPR12_code[] = { + 0x8b, 0x5d, 0x40 + }; + copy_block(op_load_T0_GPR12_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR12 +{ + static const uint8 op_store_T0_GPR12_code[] = { + 0x89, 0x5d, 0x40 + }; + copy_block(op_store_T0_GPR12_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR12 +{ + static const uint8 op_load_T1_GPR12_code[] = { + 0x8b, 0x75, 0x40 + }; + copy_block(op_load_T1_GPR12_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR12 +{ + static const uint8 op_store_T1_GPR12_code[] = { + 0x89, 0x75, 0x40 + }; + copy_block(op_store_T1_GPR12_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR12 +{ + static const uint8 op_load_T2_GPR12_code[] = { + 0x8b, 0x7d, 0x40 + }; + copy_block(op_load_T2_GPR12_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR12 +{ + static const uint8 op_store_T2_GPR12_code[] = { + 0x89, 0x7d, 0x40 + }; + copy_block(op_store_T2_GPR12_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR13 +{ + static const uint8 op_load_T0_GPR13_code[] = { + 0x8b, 0x5d, 0x44 + }; + copy_block(op_load_T0_GPR13_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR13 +{ + static const uint8 op_store_T0_GPR13_code[] = { + 0x89, 0x5d, 0x44 + }; + copy_block(op_store_T0_GPR13_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR13 +{ + static const uint8 op_load_T1_GPR13_code[] = { + 0x8b, 0x75, 0x44 + }; + copy_block(op_load_T1_GPR13_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR13 +{ + static const uint8 op_store_T1_GPR13_code[] = { + 0x89, 0x75, 0x44 + }; + copy_block(op_store_T1_GPR13_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR13 +{ + static const uint8 op_load_T2_GPR13_code[] = { + 0x8b, 0x7d, 0x44 + }; + copy_block(op_load_T2_GPR13_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR13 +{ + static const uint8 op_store_T2_GPR13_code[] = { + 0x89, 0x7d, 0x44 + }; + copy_block(op_store_T2_GPR13_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR14 +{ + static const uint8 op_load_T0_GPR14_code[] = { + 0x8b, 0x5d, 0x48 + }; + copy_block(op_load_T0_GPR14_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR14 +{ + static const uint8 op_store_T0_GPR14_code[] = { + 0x89, 0x5d, 0x48 + }; + copy_block(op_store_T0_GPR14_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR14 +{ + static const uint8 op_load_T1_GPR14_code[] = { + 0x8b, 0x75, 0x48 + }; + copy_block(op_load_T1_GPR14_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR14 +{ + static const uint8 op_store_T1_GPR14_code[] = { + 0x89, 0x75, 0x48 + }; + copy_block(op_store_T1_GPR14_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR14 +{ + static const uint8 op_load_T2_GPR14_code[] = { + 0x8b, 0x7d, 0x48 + }; + copy_block(op_load_T2_GPR14_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR14 +{ + static const uint8 op_store_T2_GPR14_code[] = { + 0x89, 0x7d, 0x48 + }; + copy_block(op_store_T2_GPR14_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR15 +{ + static const uint8 op_load_T0_GPR15_code[] = { + 0x8b, 0x5d, 0x4c + }; + copy_block(op_load_T0_GPR15_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR15 +{ + static const uint8 op_store_T0_GPR15_code[] = { + 0x89, 0x5d, 0x4c + }; + copy_block(op_store_T0_GPR15_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR15 +{ + static const uint8 op_load_T1_GPR15_code[] = { + 0x8b, 0x75, 0x4c + }; + copy_block(op_load_T1_GPR15_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR15 +{ + static const uint8 op_store_T1_GPR15_code[] = { + 0x89, 0x75, 0x4c + }; + copy_block(op_store_T1_GPR15_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR15 +{ + static const uint8 op_load_T2_GPR15_code[] = { + 0x8b, 0x7d, 0x4c + }; + copy_block(op_load_T2_GPR15_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR15 +{ + static const uint8 op_store_T2_GPR15_code[] = { + 0x89, 0x7d, 0x4c + }; + copy_block(op_store_T2_GPR15_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR16 +{ + static const uint8 op_load_T0_GPR16_code[] = { + 0x8b, 0x5d, 0x50 + }; + copy_block(op_load_T0_GPR16_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR16 +{ + static const uint8 op_store_T0_GPR16_code[] = { + 0x89, 0x5d, 0x50 + }; + copy_block(op_store_T0_GPR16_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR16 +{ + static const uint8 op_load_T1_GPR16_code[] = { + 0x8b, 0x75, 0x50 + }; + copy_block(op_load_T1_GPR16_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR16 +{ + static const uint8 op_store_T1_GPR16_code[] = { + 0x89, 0x75, 0x50 + }; + copy_block(op_store_T1_GPR16_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR16 +{ + static const uint8 op_load_T2_GPR16_code[] = { + 0x8b, 0x7d, 0x50 + }; + copy_block(op_load_T2_GPR16_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR16 +{ + static const uint8 op_store_T2_GPR16_code[] = { + 0x89, 0x7d, 0x50 + }; + copy_block(op_store_T2_GPR16_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR17 +{ + static const uint8 op_load_T0_GPR17_code[] = { + 0x8b, 0x5d, 0x54 + }; + copy_block(op_load_T0_GPR17_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR17 +{ + static const uint8 op_store_T0_GPR17_code[] = { + 0x89, 0x5d, 0x54 + }; + copy_block(op_store_T0_GPR17_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR17 +{ + static const uint8 op_load_T1_GPR17_code[] = { + 0x8b, 0x75, 0x54 + }; + copy_block(op_load_T1_GPR17_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR17 +{ + static const uint8 op_store_T1_GPR17_code[] = { + 0x89, 0x75, 0x54 + }; + copy_block(op_store_T1_GPR17_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR17 +{ + static const uint8 op_load_T2_GPR17_code[] = { + 0x8b, 0x7d, 0x54 + }; + copy_block(op_load_T2_GPR17_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR17 +{ + static const uint8 op_store_T2_GPR17_code[] = { + 0x89, 0x7d, 0x54 + }; + copy_block(op_store_T2_GPR17_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR18 +{ + static const uint8 op_load_T0_GPR18_code[] = { + 0x8b, 0x5d, 0x58 + }; + copy_block(op_load_T0_GPR18_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR18 +{ + static const uint8 op_store_T0_GPR18_code[] = { + 0x89, 0x5d, 0x58 + }; + copy_block(op_store_T0_GPR18_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR18 +{ + static const uint8 op_load_T1_GPR18_code[] = { + 0x8b, 0x75, 0x58 + }; + copy_block(op_load_T1_GPR18_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR18 +{ + static const uint8 op_store_T1_GPR18_code[] = { + 0x89, 0x75, 0x58 + }; + copy_block(op_store_T1_GPR18_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR18 +{ + static const uint8 op_load_T2_GPR18_code[] = { + 0x8b, 0x7d, 0x58 + }; + copy_block(op_load_T2_GPR18_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR18 +{ + static const uint8 op_store_T2_GPR18_code[] = { + 0x89, 0x7d, 0x58 + }; + copy_block(op_store_T2_GPR18_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR19 +{ + static const uint8 op_load_T0_GPR19_code[] = { + 0x8b, 0x5d, 0x5c + }; + copy_block(op_load_T0_GPR19_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR19 +{ + static const uint8 op_store_T0_GPR19_code[] = { + 0x89, 0x5d, 0x5c + }; + copy_block(op_store_T0_GPR19_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR19 +{ + static const uint8 op_load_T1_GPR19_code[] = { + 0x8b, 0x75, 0x5c + }; + copy_block(op_load_T1_GPR19_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR19 +{ + static const uint8 op_store_T1_GPR19_code[] = { + 0x89, 0x75, 0x5c + }; + copy_block(op_store_T1_GPR19_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR19 +{ + static const uint8 op_load_T2_GPR19_code[] = { + 0x8b, 0x7d, 0x5c + }; + copy_block(op_load_T2_GPR19_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR19 +{ + static const uint8 op_store_T2_GPR19_code[] = { + 0x89, 0x7d, 0x5c + }; + copy_block(op_store_T2_GPR19_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR20 +{ + static const uint8 op_load_T0_GPR20_code[] = { + 0x8b, 0x5d, 0x60 + }; + copy_block(op_load_T0_GPR20_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR20 +{ + static const uint8 op_store_T0_GPR20_code[] = { + 0x89, 0x5d, 0x60 + }; + copy_block(op_store_T0_GPR20_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR20 +{ + static const uint8 op_load_T1_GPR20_code[] = { + 0x8b, 0x75, 0x60 + }; + copy_block(op_load_T1_GPR20_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR20 +{ + static const uint8 op_store_T1_GPR20_code[] = { + 0x89, 0x75, 0x60 + }; + copy_block(op_store_T1_GPR20_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR20 +{ + static const uint8 op_load_T2_GPR20_code[] = { + 0x8b, 0x7d, 0x60 + }; + copy_block(op_load_T2_GPR20_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR20 +{ + static const uint8 op_store_T2_GPR20_code[] = { + 0x89, 0x7d, 0x60 + }; + copy_block(op_store_T2_GPR20_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR21 +{ + static const uint8 op_load_T0_GPR21_code[] = { + 0x8b, 0x5d, 0x64 + }; + copy_block(op_load_T0_GPR21_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR21 +{ + static const uint8 op_store_T0_GPR21_code[] = { + 0x89, 0x5d, 0x64 + }; + copy_block(op_store_T0_GPR21_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR21 +{ + static const uint8 op_load_T1_GPR21_code[] = { + 0x8b, 0x75, 0x64 + }; + copy_block(op_load_T1_GPR21_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR21 +{ + static const uint8 op_store_T1_GPR21_code[] = { + 0x89, 0x75, 0x64 + }; + copy_block(op_store_T1_GPR21_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR21 +{ + static const uint8 op_load_T2_GPR21_code[] = { + 0x8b, 0x7d, 0x64 + }; + copy_block(op_load_T2_GPR21_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR21 +{ + static const uint8 op_store_T2_GPR21_code[] = { + 0x89, 0x7d, 0x64 + }; + copy_block(op_store_T2_GPR21_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR22 +{ + static const uint8 op_load_T0_GPR22_code[] = { + 0x8b, 0x5d, 0x68 + }; + copy_block(op_load_T0_GPR22_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR22 +{ + static const uint8 op_store_T0_GPR22_code[] = { + 0x89, 0x5d, 0x68 + }; + copy_block(op_store_T0_GPR22_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR22 +{ + static const uint8 op_load_T1_GPR22_code[] = { + 0x8b, 0x75, 0x68 + }; + copy_block(op_load_T1_GPR22_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR22 +{ + static const uint8 op_store_T1_GPR22_code[] = { + 0x89, 0x75, 0x68 + }; + copy_block(op_store_T1_GPR22_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR22 +{ + static const uint8 op_load_T2_GPR22_code[] = { + 0x8b, 0x7d, 0x68 + }; + copy_block(op_load_T2_GPR22_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR22 +{ + static const uint8 op_store_T2_GPR22_code[] = { + 0x89, 0x7d, 0x68 + }; + copy_block(op_store_T2_GPR22_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR23 +{ + static const uint8 op_load_T0_GPR23_code[] = { + 0x8b, 0x5d, 0x6c + }; + copy_block(op_load_T0_GPR23_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR23 +{ + static const uint8 op_store_T0_GPR23_code[] = { + 0x89, 0x5d, 0x6c + }; + copy_block(op_store_T0_GPR23_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR23 +{ + static const uint8 op_load_T1_GPR23_code[] = { + 0x8b, 0x75, 0x6c + }; + copy_block(op_load_T1_GPR23_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR23 +{ + static const uint8 op_store_T1_GPR23_code[] = { + 0x89, 0x75, 0x6c + }; + copy_block(op_store_T1_GPR23_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR23 +{ + static const uint8 op_load_T2_GPR23_code[] = { + 0x8b, 0x7d, 0x6c + }; + copy_block(op_load_T2_GPR23_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR23 +{ + static const uint8 op_store_T2_GPR23_code[] = { + 0x89, 0x7d, 0x6c + }; + copy_block(op_store_T2_GPR23_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR24 +{ + static const uint8 op_load_T0_GPR24_code[] = { + 0x8b, 0x5d, 0x70 + }; + copy_block(op_load_T0_GPR24_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR24 +{ + static const uint8 op_store_T0_GPR24_code[] = { + 0x89, 0x5d, 0x70 + }; + copy_block(op_store_T0_GPR24_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR24 +{ + static const uint8 op_load_T1_GPR24_code[] = { + 0x8b, 0x75, 0x70 + }; + copy_block(op_load_T1_GPR24_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR24 +{ + static const uint8 op_store_T1_GPR24_code[] = { + 0x89, 0x75, 0x70 + }; + copy_block(op_store_T1_GPR24_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR24 +{ + static const uint8 op_load_T2_GPR24_code[] = { + 0x8b, 0x7d, 0x70 + }; + copy_block(op_load_T2_GPR24_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR24 +{ + static const uint8 op_store_T2_GPR24_code[] = { + 0x89, 0x7d, 0x70 + }; + copy_block(op_store_T2_GPR24_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR25 +{ + static const uint8 op_load_T0_GPR25_code[] = { + 0x8b, 0x5d, 0x74 + }; + copy_block(op_load_T0_GPR25_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR25 +{ + static const uint8 op_store_T0_GPR25_code[] = { + 0x89, 0x5d, 0x74 + }; + copy_block(op_store_T0_GPR25_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR25 +{ + static const uint8 op_load_T1_GPR25_code[] = { + 0x8b, 0x75, 0x74 + }; + copy_block(op_load_T1_GPR25_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR25 +{ + static const uint8 op_store_T1_GPR25_code[] = { + 0x89, 0x75, 0x74 + }; + copy_block(op_store_T1_GPR25_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR25 +{ + static const uint8 op_load_T2_GPR25_code[] = { + 0x8b, 0x7d, 0x74 + }; + copy_block(op_load_T2_GPR25_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR25 +{ + static const uint8 op_store_T2_GPR25_code[] = { + 0x89, 0x7d, 0x74 + }; + copy_block(op_store_T2_GPR25_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR26 +{ + static const uint8 op_load_T0_GPR26_code[] = { + 0x8b, 0x5d, 0x78 + }; + copy_block(op_load_T0_GPR26_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR26 +{ + static const uint8 op_store_T0_GPR26_code[] = { + 0x89, 0x5d, 0x78 + }; + copy_block(op_store_T0_GPR26_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR26 +{ + static const uint8 op_load_T1_GPR26_code[] = { + 0x8b, 0x75, 0x78 + }; + copy_block(op_load_T1_GPR26_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR26 +{ + static const uint8 op_store_T1_GPR26_code[] = { + 0x89, 0x75, 0x78 + }; + copy_block(op_store_T1_GPR26_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR26 +{ + static const uint8 op_load_T2_GPR26_code[] = { + 0x8b, 0x7d, 0x78 + }; + copy_block(op_load_T2_GPR26_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR26 +{ + static const uint8 op_store_T2_GPR26_code[] = { + 0x89, 0x7d, 0x78 + }; + copy_block(op_store_T2_GPR26_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR27 +{ + static const uint8 op_load_T0_GPR27_code[] = { + 0x8b, 0x5d, 0x7c + }; + copy_block(op_load_T0_GPR27_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR27 +{ + static const uint8 op_store_T0_GPR27_code[] = { + 0x89, 0x5d, 0x7c + }; + copy_block(op_store_T0_GPR27_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR27 +{ + static const uint8 op_load_T1_GPR27_code[] = { + 0x8b, 0x75, 0x7c + }; + copy_block(op_load_T1_GPR27_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR27 +{ + static const uint8 op_store_T1_GPR27_code[] = { + 0x89, 0x75, 0x7c + }; + copy_block(op_store_T1_GPR27_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR27 +{ + static const uint8 op_load_T2_GPR27_code[] = { + 0x8b, 0x7d, 0x7c + }; + copy_block(op_load_T2_GPR27_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR27 +{ + static const uint8 op_store_T2_GPR27_code[] = { + 0x89, 0x7d, 0x7c + }; + copy_block(op_store_T2_GPR27_code, 3); + inc_code_ptr(3); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR28 +{ + static const uint8 op_load_T0_GPR28_code[] = { + 0x8b, 0x9d, 0x80, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T0_GPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR28 +{ + static const uint8 op_store_T0_GPR28_code[] = { + 0x89, 0x9d, 0x80, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T0_GPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR28 +{ + static const uint8 op_load_T1_GPR28_code[] = { + 0x8b, 0xb5, 0x80, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T1_GPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR28 +{ + static const uint8 op_store_T1_GPR28_code[] = { + 0x89, 0xb5, 0x80, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T1_GPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR28 +{ + static const uint8 op_load_T2_GPR28_code[] = { + 0x8b, 0xbd, 0x80, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T2_GPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR28 +{ + static const uint8 op_store_T2_GPR28_code[] = { + 0x89, 0xbd, 0x80, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T2_GPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR29 +{ + static const uint8 op_load_T0_GPR29_code[] = { + 0x8b, 0x9d, 0x84, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T0_GPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR29 +{ + static const uint8 op_store_T0_GPR29_code[] = { + 0x89, 0x9d, 0x84, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T0_GPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR29 +{ + static const uint8 op_load_T1_GPR29_code[] = { + 0x8b, 0xb5, 0x84, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T1_GPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR29 +{ + static const uint8 op_store_T1_GPR29_code[] = { + 0x89, 0xb5, 0x84, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T1_GPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR29 +{ + static const uint8 op_load_T2_GPR29_code[] = { + 0x8b, 0xbd, 0x84, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T2_GPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR29 +{ + static const uint8 op_store_T2_GPR29_code[] = { + 0x89, 0xbd, 0x84, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T2_GPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR30 +{ + static const uint8 op_load_T0_GPR30_code[] = { + 0x8b, 0x9d, 0x88, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T0_GPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR30 +{ + static const uint8 op_store_T0_GPR30_code[] = { + 0x89, 0x9d, 0x88, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T0_GPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR30 +{ + static const uint8 op_load_T1_GPR30_code[] = { + 0x8b, 0xb5, 0x88, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T1_GPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR30 +{ + static const uint8 op_store_T1_GPR30_code[] = { + 0x89, 0xb5, 0x88, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T1_GPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR30 +{ + static const uint8 op_load_T2_GPR30_code[] = { + 0x8b, 0xbd, 0x88, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T2_GPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR30 +{ + static const uint8 op_store_T2_GPR30_code[] = { + 0x89, 0xbd, 0x88, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T2_GPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T0_GPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_GPR31 +{ + static const uint8 op_load_T0_GPR31_code[] = { + 0x8b, 0x9d, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T0_GPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_GPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_GPR31 +{ + static const uint8 op_store_T0_GPR31_code[] = { + 0x89, 0x9d, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T0_GPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T1_GPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_GPR31 +{ + static const uint8 op_load_T1_GPR31_code[] = { + 0x8b, 0xb5, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T1_GPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T1_GPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_GPR31 +{ + static const uint8 op_store_T1_GPR31_code[] = { + 0x89, 0xb5, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T1_GPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T2_GPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T2_GPR31 +{ + static const uint8 op_load_T2_GPR31_code[] = { + 0x8b, 0xbd, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_load_T2_GPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T2_GPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T2_GPR31 +{ + static const uint8 op_store_T2_GPR31_code[] = { + 0x89, 0xbd, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_T2_GPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR0 +{ + static const uint8 op_load_F0_FPR0_code[] = { + 0x8d, 0x9d, 0x90, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR0 +{ + static const uint8 op_store_F0_FPR0_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89, + 0x95, 0x94, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR0_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR0 +{ + static const uint8 op_load_F1_FPR0_code[] = { + 0x8d, 0xb5, 0x90, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR0 +{ + static const uint8 op_store_F1_FPR0_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89, + 0x95, 0x94, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR0_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR0 +{ + static const uint8 op_load_F2_FPR0_code[] = { + 0x8d, 0xbd, 0x90, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR0 +{ + static const uint8 op_store_F2_FPR0_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89, + 0x95, 0x94, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR0_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR0 +{ + static const uint8 op_store_FD_FPR0_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89, 0x95, 0x94, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR0_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR1 +{ + static const uint8 op_load_F0_FPR1_code[] = { + 0x8d, 0x9d, 0x98, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR1 +{ + static const uint8 op_store_F0_FPR1_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89, + 0x95, 0x9c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR1_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR1 +{ + static const uint8 op_load_F1_FPR1_code[] = { + 0x8d, 0xb5, 0x98, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR1 +{ + static const uint8 op_store_F1_FPR1_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89, + 0x95, 0x9c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR1_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR1 +{ + static const uint8 op_load_F2_FPR1_code[] = { + 0x8d, 0xbd, 0x98, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR1 +{ + static const uint8 op_store_F2_FPR1_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89, + 0x95, 0x9c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR1_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR1 +{ + static const uint8 op_store_FD_FPR1_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89, 0x95, 0x9c, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR1_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR2 +{ + static const uint8 op_load_F0_FPR2_code[] = { + 0x8d, 0x9d, 0xa0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR2_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR2 +{ + static const uint8 op_store_F0_FPR2_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xa4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR2_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR2 +{ + static const uint8 op_load_F1_FPR2_code[] = { + 0x8d, 0xb5, 0xa0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR2_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR2 +{ + static const uint8 op_store_F1_FPR2_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xa4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR2_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR2 +{ + static const uint8 op_load_F2_FPR2_code[] = { + 0x8d, 0xbd, 0xa0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR2_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR2 +{ + static const uint8 op_store_F2_FPR2_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xa4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR2_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR2 +{ + static const uint8 op_store_FD_FPR2_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xa4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR2_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR3 +{ + static const uint8 op_load_F0_FPR3_code[] = { + 0x8d, 0x9d, 0xa8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR3_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR3 +{ + static const uint8 op_store_F0_FPR3_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xac, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR3_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR3 +{ + static const uint8 op_load_F1_FPR3_code[] = { + 0x8d, 0xb5, 0xa8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR3_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR3 +{ + static const uint8 op_store_F1_FPR3_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xac, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR3_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR3 +{ + static const uint8 op_load_F2_FPR3_code[] = { + 0x8d, 0xbd, 0xa8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR3_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR3 +{ + static const uint8 op_store_F2_FPR3_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xac, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR3_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR3 +{ + static const uint8 op_store_FD_FPR3_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xac, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR3_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR4 +{ + static const uint8 op_load_F0_FPR4_code[] = { + 0x8d, 0x9d, 0xb0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR4_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR4 +{ + static const uint8 op_store_F0_FPR4_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xb4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR4_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR4 +{ + static const uint8 op_load_F1_FPR4_code[] = { + 0x8d, 0xb5, 0xb0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR4_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR4 +{ + static const uint8 op_store_F1_FPR4_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xb4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR4_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR4 +{ + static const uint8 op_load_F2_FPR4_code[] = { + 0x8d, 0xbd, 0xb0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR4_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR4 +{ + static const uint8 op_store_F2_FPR4_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xb4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR4_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR4 +{ + static const uint8 op_store_FD_FPR4_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xb4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR4_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR5 +{ + static const uint8 op_load_F0_FPR5_code[] = { + 0x8d, 0x9d, 0xb8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR5_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR5 +{ + static const uint8 op_store_F0_FPR5_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xbc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR5_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR5 +{ + static const uint8 op_load_F1_FPR5_code[] = { + 0x8d, 0xb5, 0xb8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR5_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR5 +{ + static const uint8 op_store_F1_FPR5_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xbc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR5_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR5 +{ + static const uint8 op_load_F2_FPR5_code[] = { + 0x8d, 0xbd, 0xb8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR5_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR5 +{ + static const uint8 op_store_F2_FPR5_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xbc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR5_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR5 +{ + static const uint8 op_store_FD_FPR5_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xbc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR5_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR6 +{ + static const uint8 op_load_F0_FPR6_code[] = { + 0x8d, 0x9d, 0xc0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR6_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR6 +{ + static const uint8 op_store_F0_FPR6_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xc4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR6_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR6 +{ + static const uint8 op_load_F1_FPR6_code[] = { + 0x8d, 0xb5, 0xc0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR6_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR6 +{ + static const uint8 op_store_F1_FPR6_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xc4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR6_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR6 +{ + static const uint8 op_load_F2_FPR6_code[] = { + 0x8d, 0xbd, 0xc0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR6_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR6 +{ + static const uint8 op_store_F2_FPR6_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xc4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR6_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR6 +{ + static const uint8 op_store_FD_FPR6_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xc4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR6_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR7 +{ + static const uint8 op_load_F0_FPR7_code[] = { + 0x8d, 0x9d, 0xc8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR7_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR7 +{ + static const uint8 op_store_F0_FPR7_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xcc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR7_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR7 +{ + static const uint8 op_load_F1_FPR7_code[] = { + 0x8d, 0xb5, 0xc8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR7_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR7 +{ + static const uint8 op_store_F1_FPR7_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xcc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR7_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR7 +{ + static const uint8 op_load_F2_FPR7_code[] = { + 0x8d, 0xbd, 0xc8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR7_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR7 +{ + static const uint8 op_store_F2_FPR7_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xcc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR7_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR7 +{ + static const uint8 op_store_FD_FPR7_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xcc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR7_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR8 +{ + static const uint8 op_load_F0_FPR8_code[] = { + 0x8d, 0x9d, 0xd0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR8_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR8 +{ + static const uint8 op_store_F0_FPR8_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xd4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR8_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR8 +{ + static const uint8 op_load_F1_FPR8_code[] = { + 0x8d, 0xb5, 0xd0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR8_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR8 +{ + static const uint8 op_store_F1_FPR8_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xd4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR8_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR8 +{ + static const uint8 op_load_F2_FPR8_code[] = { + 0x8d, 0xbd, 0xd0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR8_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR8 +{ + static const uint8 op_store_F2_FPR8_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xd4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR8_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR8 +{ + static const uint8 op_store_FD_FPR8_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xd4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR8_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR9 +{ + static const uint8 op_load_F0_FPR9_code[] = { + 0x8d, 0x9d, 0xd8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR9_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR9 +{ + static const uint8 op_store_F0_FPR9_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xdc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR9_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR9 +{ + static const uint8 op_load_F1_FPR9_code[] = { + 0x8d, 0xb5, 0xd8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR9_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR9 +{ + static const uint8 op_store_F1_FPR9_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xdc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR9_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR9 +{ + static const uint8 op_load_F2_FPR9_code[] = { + 0x8d, 0xbd, 0xd8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR9_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR9 +{ + static const uint8 op_store_F2_FPR9_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xdc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR9_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR9 +{ + static const uint8 op_store_FD_FPR9_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xdc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR9_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR10 +{ + static const uint8 op_load_F0_FPR10_code[] = { + 0x8d, 0x9d, 0xe0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR10_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR10 +{ + static const uint8 op_store_F0_FPR10_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xe4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR10_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR10 +{ + static const uint8 op_load_F1_FPR10_code[] = { + 0x8d, 0xb5, 0xe0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR10_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR10 +{ + static const uint8 op_store_F1_FPR10_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xe4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR10_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR10 +{ + static const uint8 op_load_F2_FPR10_code[] = { + 0x8d, 0xbd, 0xe0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR10_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR10 +{ + static const uint8 op_store_F2_FPR10_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xe4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR10_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR10 +{ + static const uint8 op_store_FD_FPR10_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xe4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR10_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR11 +{ + static const uint8 op_load_F0_FPR11_code[] = { + 0x8d, 0x9d, 0xe8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR11_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR11 +{ + static const uint8 op_store_F0_FPR11_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xec, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR11_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR11 +{ + static const uint8 op_load_F1_FPR11_code[] = { + 0x8d, 0xb5, 0xe8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR11_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR11 +{ + static const uint8 op_store_F1_FPR11_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xec, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR11_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR11 +{ + static const uint8 op_load_F2_FPR11_code[] = { + 0x8d, 0xbd, 0xe8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR11_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR11 +{ + static const uint8 op_store_F2_FPR11_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xec, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR11_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR11 +{ + static const uint8 op_store_FD_FPR11_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xec, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR11_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR12 +{ + static const uint8 op_load_F0_FPR12_code[] = { + 0x8d, 0x9d, 0xf0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR12_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR12 +{ + static const uint8 op_store_F0_FPR12_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xf4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR12_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR12 +{ + static const uint8 op_load_F1_FPR12_code[] = { + 0x8d, 0xb5, 0xf0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR12_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR12 +{ + static const uint8 op_store_F1_FPR12_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xf4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR12_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR12 +{ + static const uint8 op_load_F2_FPR12_code[] = { + 0x8d, 0xbd, 0xf0, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR12_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR12 +{ + static const uint8 op_store_F2_FPR12_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xf4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR12_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR12 +{ + static const uint8 op_store_FD_FPR12_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xf4, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR12_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR13 +{ + static const uint8 op_load_F0_FPR13_code[] = { + 0x8d, 0x9d, 0xf8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR13_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR13 +{ + static const uint8 op_store_F0_FPR13_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xfc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR13_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR13 +{ + static const uint8 op_load_F1_FPR13_code[] = { + 0x8d, 0xb5, 0xf8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR13_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR13 +{ + static const uint8 op_store_F1_FPR13_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xfc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR13_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR13 +{ + static const uint8 op_load_F2_FPR13_code[] = { + 0x8d, 0xbd, 0xf8, 0x00, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR13_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR13 +{ + static const uint8 op_store_F2_FPR13_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89, + 0x95, 0xfc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR13_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR13 +{ + static const uint8 op_store_FD_FPR13_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xfc, 0x00, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR13_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR14 +{ + static const uint8 op_load_F0_FPR14_code[] = { + 0x8d, 0x9d, 0x00, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR14_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR14 +{ + static const uint8 op_store_F0_FPR14_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x04, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR14_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR14 +{ + static const uint8 op_load_F1_FPR14_code[] = { + 0x8d, 0xb5, 0x00, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR14_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR14 +{ + static const uint8 op_store_F1_FPR14_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x04, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR14_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR14 +{ + static const uint8 op_load_F2_FPR14_code[] = { + 0x8d, 0xbd, 0x00, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR14_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR14 +{ + static const uint8 op_store_F2_FPR14_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x04, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR14_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR14 +{ + static const uint8 op_store_FD_FPR14_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89, 0x95, 0x04, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR14_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR15 +{ + static const uint8 op_load_F0_FPR15_code[] = { + 0x8d, 0x9d, 0x08, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR15_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR15 +{ + static const uint8 op_store_F0_FPR15_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x0c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR15_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR15 +{ + static const uint8 op_load_F1_FPR15_code[] = { + 0x8d, 0xb5, 0x08, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR15_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR15 +{ + static const uint8 op_store_F1_FPR15_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x0c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR15_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR15 +{ + static const uint8 op_load_F2_FPR15_code[] = { + 0x8d, 0xbd, 0x08, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR15_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR15 +{ + static const uint8 op_store_F2_FPR15_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x0c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR15_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR15 +{ + static const uint8 op_store_FD_FPR15_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89, 0x95, 0x0c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR15_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR16 +{ + static const uint8 op_load_F0_FPR16_code[] = { + 0x8d, 0x9d, 0x10, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR16_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR16 +{ + static const uint8 op_store_F0_FPR16_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x14, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR16_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR16 +{ + static const uint8 op_load_F1_FPR16_code[] = { + 0x8d, 0xb5, 0x10, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR16_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR16 +{ + static const uint8 op_store_F1_FPR16_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x14, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR16_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR16 +{ + static const uint8 op_load_F2_FPR16_code[] = { + 0x8d, 0xbd, 0x10, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR16_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR16 +{ + static const uint8 op_store_F2_FPR16_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x14, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR16_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR16 +{ + static const uint8 op_store_FD_FPR16_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89, 0x95, 0x14, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR16_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR17 +{ + static const uint8 op_load_F0_FPR17_code[] = { + 0x8d, 0x9d, 0x18, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR17_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR17 +{ + static const uint8 op_store_F0_FPR17_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x1c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR17_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR17 +{ + static const uint8 op_load_F1_FPR17_code[] = { + 0x8d, 0xb5, 0x18, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR17_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR17 +{ + static const uint8 op_store_F1_FPR17_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x1c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR17_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR17 +{ + static const uint8 op_load_F2_FPR17_code[] = { + 0x8d, 0xbd, 0x18, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR17_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR17 +{ + static const uint8 op_store_F2_FPR17_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x1c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR17_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR17 +{ + static const uint8 op_store_FD_FPR17_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89, 0x95, 0x1c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR17_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR18 +{ + static const uint8 op_load_F0_FPR18_code[] = { + 0x8d, 0x9d, 0x20, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR18_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR18 +{ + static const uint8 op_store_F0_FPR18_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x24, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR18_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR18 +{ + static const uint8 op_load_F1_FPR18_code[] = { + 0x8d, 0xb5, 0x20, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR18_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR18 +{ + static const uint8 op_store_F1_FPR18_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x24, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR18_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR18 +{ + static const uint8 op_load_F2_FPR18_code[] = { + 0x8d, 0xbd, 0x20, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR18_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR18 +{ + static const uint8 op_store_F2_FPR18_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x24, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR18_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR18 +{ + static const uint8 op_store_FD_FPR18_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89, 0x95, 0x24, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR18_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR19 +{ + static const uint8 op_load_F0_FPR19_code[] = { + 0x8d, 0x9d, 0x28, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR19_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR19 +{ + static const uint8 op_store_F0_FPR19_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x2c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR19_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR19 +{ + static const uint8 op_load_F1_FPR19_code[] = { + 0x8d, 0xb5, 0x28, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR19_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR19 +{ + static const uint8 op_store_F1_FPR19_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x2c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR19_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR19 +{ + static const uint8 op_load_F2_FPR19_code[] = { + 0x8d, 0xbd, 0x28, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR19_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR19 +{ + static const uint8 op_store_F2_FPR19_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x2c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR19_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR19 +{ + static const uint8 op_store_FD_FPR19_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89, 0x95, 0x2c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR19_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR20 +{ + static const uint8 op_load_F0_FPR20_code[] = { + 0x8d, 0x9d, 0x30, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR20_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR20 +{ + static const uint8 op_store_F0_FPR20_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x34, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR20_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR20 +{ + static const uint8 op_load_F1_FPR20_code[] = { + 0x8d, 0xb5, 0x30, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR20_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR20 +{ + static const uint8 op_store_F1_FPR20_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x34, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR20_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR20 +{ + static const uint8 op_load_F2_FPR20_code[] = { + 0x8d, 0xbd, 0x30, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR20_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR20 +{ + static const uint8 op_store_F2_FPR20_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x34, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR20_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR20 +{ + static const uint8 op_store_FD_FPR20_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89, 0x95, 0x34, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR20_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR21 +{ + static const uint8 op_load_F0_FPR21_code[] = { + 0x8d, 0x9d, 0x38, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR21_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR21 +{ + static const uint8 op_store_F0_FPR21_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x3c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR21_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR21 +{ + static const uint8 op_load_F1_FPR21_code[] = { + 0x8d, 0xb5, 0x38, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR21_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR21 +{ + static const uint8 op_store_F1_FPR21_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x3c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR21_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR21 +{ + static const uint8 op_load_F2_FPR21_code[] = { + 0x8d, 0xbd, 0x38, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR21_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR21 +{ + static const uint8 op_store_F2_FPR21_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x3c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR21_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR21 +{ + static const uint8 op_store_FD_FPR21_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89, 0x95, 0x3c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR21_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR22 +{ + static const uint8 op_load_F0_FPR22_code[] = { + 0x8d, 0x9d, 0x40, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR22_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR22 +{ + static const uint8 op_store_F0_FPR22_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x44, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR22_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR22 +{ + static const uint8 op_load_F1_FPR22_code[] = { + 0x8d, 0xb5, 0x40, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR22_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR22 +{ + static const uint8 op_store_F1_FPR22_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x44, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR22_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR22 +{ + static const uint8 op_load_F2_FPR22_code[] = { + 0x8d, 0xbd, 0x40, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR22_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR22 +{ + static const uint8 op_store_F2_FPR22_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x44, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR22_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR22 +{ + static const uint8 op_store_FD_FPR22_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89, 0x95, 0x44, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR22_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR23 +{ + static const uint8 op_load_F0_FPR23_code[] = { + 0x8d, 0x9d, 0x48, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR23_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR23 +{ + static const uint8 op_store_F0_FPR23_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x4c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR23_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR23 +{ + static const uint8 op_load_F1_FPR23_code[] = { + 0x8d, 0xb5, 0x48, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR23_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR23 +{ + static const uint8 op_store_F1_FPR23_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x4c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR23_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR23 +{ + static const uint8 op_load_F2_FPR23_code[] = { + 0x8d, 0xbd, 0x48, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR23_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR23 +{ + static const uint8 op_store_F2_FPR23_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x4c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR23_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR23 +{ + static const uint8 op_store_FD_FPR23_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89, 0x95, 0x4c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR23_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR24 +{ + static const uint8 op_load_F0_FPR24_code[] = { + 0x8d, 0x9d, 0x50, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR24_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR24 +{ + static const uint8 op_store_F0_FPR24_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x54, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR24_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR24 +{ + static const uint8 op_load_F1_FPR24_code[] = { + 0x8d, 0xb5, 0x50, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR24_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR24 +{ + static const uint8 op_store_F1_FPR24_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x54, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR24_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR24 +{ + static const uint8 op_load_F2_FPR24_code[] = { + 0x8d, 0xbd, 0x50, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR24_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR24 +{ + static const uint8 op_store_F2_FPR24_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x54, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR24_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR24 +{ + static const uint8 op_store_FD_FPR24_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89, 0x95, 0x54, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR24_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR25 +{ + static const uint8 op_load_F0_FPR25_code[] = { + 0x8d, 0x9d, 0x58, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR25_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR25 +{ + static const uint8 op_store_F0_FPR25_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x5c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR25_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR25 +{ + static const uint8 op_load_F1_FPR25_code[] = { + 0x8d, 0xb5, 0x58, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR25_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR25 +{ + static const uint8 op_store_F1_FPR25_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x5c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR25_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR25 +{ + static const uint8 op_load_F2_FPR25_code[] = { + 0x8d, 0xbd, 0x58, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR25_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR25 +{ + static const uint8 op_store_F2_FPR25_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x5c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR25_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR25 +{ + static const uint8 op_store_FD_FPR25_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89, 0x95, 0x5c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR25_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR26 +{ + static const uint8 op_load_F0_FPR26_code[] = { + 0x8d, 0x9d, 0x60, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR26_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR26 +{ + static const uint8 op_store_F0_FPR26_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x64, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR26_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR26 +{ + static const uint8 op_load_F1_FPR26_code[] = { + 0x8d, 0xb5, 0x60, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR26_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR26 +{ + static const uint8 op_store_F1_FPR26_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x64, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR26_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR26 +{ + static const uint8 op_load_F2_FPR26_code[] = { + 0x8d, 0xbd, 0x60, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR26_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR26 +{ + static const uint8 op_store_F2_FPR26_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x64, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR26_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR26 +{ + static const uint8 op_store_FD_FPR26_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89, 0x95, 0x64, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR26_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR27 +{ + static const uint8 op_load_F0_FPR27_code[] = { + 0x8d, 0x9d, 0x68, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR27_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR27 +{ + static const uint8 op_store_F0_FPR27_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x6c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR27_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR27 +{ + static const uint8 op_load_F1_FPR27_code[] = { + 0x8d, 0xb5, 0x68, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR27_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR27 +{ + static const uint8 op_store_F1_FPR27_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x6c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR27_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR27 +{ + static const uint8 op_load_F2_FPR27_code[] = { + 0x8d, 0xbd, 0x68, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR27_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR27 +{ + static const uint8 op_store_F2_FPR27_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x6c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR27_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR27 +{ + static const uint8 op_store_FD_FPR27_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89, 0x95, 0x6c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR27_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR28 +{ + static const uint8 op_load_F0_FPR28_code[] = { + 0x8d, 0x9d, 0x70, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR28 +{ + static const uint8 op_store_F0_FPR28_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x74, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR28_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR28 +{ + static const uint8 op_load_F1_FPR28_code[] = { + 0x8d, 0xb5, 0x70, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR28 +{ + static const uint8 op_store_F1_FPR28_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x74, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR28_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR28 +{ + static const uint8 op_load_F2_FPR28_code[] = { + 0x8d, 0xbd, 0x70, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR28 +{ + static const uint8 op_store_F2_FPR28_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x74, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR28_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR28 +{ + static const uint8 op_store_FD_FPR28_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89, 0x95, 0x74, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR28_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR29 +{ + static const uint8 op_load_F0_FPR29_code[] = { + 0x8d, 0x9d, 0x78, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR29 +{ + static const uint8 op_store_F0_FPR29_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x7c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR29_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR29 +{ + static const uint8 op_load_F1_FPR29_code[] = { + 0x8d, 0xb5, 0x78, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR29 +{ + static const uint8 op_store_F1_FPR29_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x7c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR29_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR29 +{ + static const uint8 op_load_F2_FPR29_code[] = { + 0x8d, 0xbd, 0x78, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR29 +{ + static const uint8 op_store_F2_FPR29_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x7c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR29_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR29 +{ + static const uint8 op_store_FD_FPR29_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89, 0x95, 0x7c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR29_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR30 +{ + static const uint8 op_load_F0_FPR30_code[] = { + 0x8d, 0x9d, 0x80, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR30 +{ + static const uint8 op_store_F0_FPR30_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x84, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR30_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR30 +{ + static const uint8 op_load_F1_FPR30_code[] = { + 0x8d, 0xb5, 0x80, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR30 +{ + static const uint8 op_store_F1_FPR30_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x84, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR30_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR30 +{ + static const uint8 op_load_F2_FPR30_code[] = { + 0x8d, 0xbd, 0x80, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR30 +{ + static const uint8 op_store_F2_FPR30_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x84, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR30_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR30 +{ + static const uint8 op_store_FD_FPR30_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89, 0x95, 0x84, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR30_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_F0_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F0_FPR31 +{ + static const uint8 op_load_F0_FPR31_code[] = { + 0x8d, 0x9d, 0x88, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F0_FPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F0_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F0_FPR31 +{ + static const uint8 op_store_F0_FPR31_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x8c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F0_FPR31_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F1_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F1_FPR31 +{ + static const uint8 op_load_F1_FPR31_code[] = { + 0x8d, 0xb5, 0x88, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F1_FPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F1_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F1_FPR31 +{ + static const uint8 op_store_F1_FPR31_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x8c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F1_FPR31_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_load_F2_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_F2_FPR31 +{ + static const uint8 op_load_F2_FPR31_code[] = { + 0x8d, 0xbd, 0x88, 0x01, 0x00, 0x00 + }; + copy_block(op_load_F2_FPR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_F2_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_F2_FPR31 +{ + static const uint8 op_store_F2_FPR31_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89, + 0x95, 0x8c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_F2_FPR31_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_store_FD_FPR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_FD_FPR31 +{ + static const uint8 op_store_FD_FPR31_code[] = { + 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00, + 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89, 0x95, 0x8c, 0x01, 0x00, 0x00 + }; + copy_block(op_store_FD_FPR31_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_double_FD_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_double_FD_T1_0 +{ + static const uint8 op_load_double_FD_T1_0_code[] = { + 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00, 0x00, 0x00, 0x11, + 0x0f, 0xca, 0x89, 0x50, 0x04, 0x8b, 0x96, 0x04, 0x00, 0x00, 0x11, 0x0f, + 0xca, 0x89, 0x10 + }; + copy_block(op_load_double_FD_T1_0_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_load_single_FD_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_single_FD_T1_0 +{ + static const uint8 op_load_single_FD_T1_0_code[] = { + 0x83, 0xec, 0x08, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00, + 0x00, 0x00, 0x11, 0x0f, 0xca, 0x89, 0x14, 0x24, 0x31, 0xc9, 0xd9, 0x04, + 0x24, 0x89, 0x4c, 0x24, 0x04, 0xdd, 0x1c, 0x24, 0x8b, 0x14, 0x24, 0x8b, + 0x4c, 0x24, 0x04, 0x89, 0x10, 0x89, 0x48, 0x04, 0x83, 0xc4, 0x08 + }; + copy_block(op_load_single_FD_T1_0_code, 47); + inc_code_ptr(47); +} +#endif + +DEFINE_GEN(gen_op_store_double_F0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_double_F0_T1_0 +{ + static const uint8 op_store_double_F0_T1_0_code[] = { + 0x8b, 0x43, 0x04, 0x0f, 0xc8, 0x89, 0x86, 0x00, 0x00, 0x00, 0x11, 0x8d, + 0x56, 0x04, 0x8b, 0x03, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_double_F0_T1_0_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_store_single_F0_T1_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_single_F0_T1_0 +{ + static const uint8 op_store_single_F0_T1_0_code[] = { + 0x83, 0xec, 0x18, 0x89, 0xf1, 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x44, + 0x24, 0x0c, 0x89, 0xd0, 0xc1, 0xe8, 0x14, 0x89, 0x54, 0x24, 0x10, 0x25, + 0xff, 0x07, 0x00, 0x00, 0x2d, 0x6a, 0x03, 0x00, 0x00, 0x83, 0xf8, 0x16, + 0x76, 0x3a, 0x8b, 0x54, 0x24, 0x10, 0x89, 0xd0, 0x25, 0x00, 0x00, 0x00, + 0xc0, 0x89, 0x04, 0x24, 0x8b, 0x54, 0x24, 0x10, 0x8b, 0x44, 0x24, 0x0c, + 0x0f, 0xac, 0xd0, 0x1d, 0xc1, 0xea, 0x1d, 0x89, 0x44, 0x24, 0x0c, 0x8b, + 0x44, 0x24, 0x0c, 0x89, 0x54, 0x24, 0x10, 0x25, 0xff, 0xff, 0xff, 0x3f, + 0x09, 0x04, 0x24, 0xeb, 0x26, 0x8d, 0xb4, 0x26, 0x00, 0x00, 0x00, 0x00, + 0x8b, 0x44, 0x24, 0x0c, 0x8b, 0x54, 0x24, 0x10, 0x89, 0x44, 0x24, 0x04, + 0x89, 0x54, 0x24, 0x08, 0xdd, 0x44, 0x24, 0x04, 0xd9, 0x5c, 0x24, 0x14, + 0x8b, 0x44, 0x24, 0x14, 0x89, 0x04, 0x24, 0x8b, 0x04, 0x24, 0x0f, 0xc8, + 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, 0x83, 0xc4, 0x18 + }; + copy_block(op_store_single_F0_T1_0_code, 141); + inc_code_ptr(141); +} +#endif + +DEFINE_GEN(gen_op_load_double_FD_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_double_FD_T1_im +{ + static const uint8 op_load_double_FD_T1_im_code[] = { + 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00, 0x00, 0x00, 0x11, + 0x0f, 0xca, 0x89, 0x50, 0x04, 0x8b, 0x96, 0x04, 0x00, 0x00, 0x11, 0x0f, + 0xca, 0x89, 0x10 + }; + copy_block(op_load_double_FD_T1_im_code, 27); + *(uint32_t *)(code_ptr() + 8) = param1 + 285212672; + *(uint32_t *)(code_ptr() + 19) = param1 + 285212676; + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_load_single_FD_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_single_FD_T1_im +{ + static const uint8 op_load_single_FD_T1_im_code[] = { + 0x83, 0xec, 0x08, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00, + 0x00, 0x00, 0x11, 0x0f, 0xca, 0x89, 0x14, 0x24, 0x31, 0xc9, 0xd9, 0x04, + 0x24, 0x89, 0x4c, 0x24, 0x04, 0xdd, 0x1c, 0x24, 0x8b, 0x14, 0x24, 0x8b, + 0x4c, 0x24, 0x04, 0x89, 0x10, 0x89, 0x48, 0x04, 0x83, 0xc4, 0x08 + }; + copy_block(op_load_single_FD_T1_im_code, 47); + *(uint32_t *)(code_ptr() + 11) = param1 + 285212672; + inc_code_ptr(47); +} +#endif + +DEFINE_GEN(gen_op_store_double_F0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_double_F0_T1_im +{ + static const uint8 op_store_double_F0_T1_im_code[] = { + 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x8b, 0x43, 0x04, 0x0f, 0xc8, 0x89, + 0x82, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x03, 0x8d, 0x96, 0x04, 0x00, 0x00, + 0x00, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_double_F0_T1_im_code, 33); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + *(uint32_t *)(code_ptr() + 21) = param1 + 4; + inc_code_ptr(33); +} +#endif + +DEFINE_GEN(gen_op_store_single_F0_T1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_single_F0_T1_im +{ + static const uint8 op_store_single_F0_T1_im_code[] = { + 0x83, 0xec, 0x18, 0x8d, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x8b, 0x03, 0x8b, + 0x53, 0x04, 0x89, 0x44, 0x24, 0x0c, 0x89, 0xd0, 0xc1, 0xe8, 0x14, 0x89, + 0x54, 0x24, 0x10, 0x25, 0xff, 0x07, 0x00, 0x00, 0x2d, 0x6a, 0x03, 0x00, + 0x00, 0x83, 0xf8, 0x16, 0x76, 0x36, 0x8b, 0x54, 0x24, 0x10, 0x89, 0xd0, + 0x25, 0x00, 0x00, 0x00, 0xc0, 0x89, 0x04, 0x24, 0x8b, 0x54, 0x24, 0x10, + 0x8b, 0x44, 0x24, 0x0c, 0x0f, 0xac, 0xd0, 0x1d, 0xc1, 0xea, 0x1d, 0x89, + 0x44, 0x24, 0x0c, 0x8b, 0x44, 0x24, 0x0c, 0x89, 0x54, 0x24, 0x10, 0x25, + 0xff, 0xff, 0xff, 0x3f, 0x09, 0x04, 0x24, 0xeb, 0x22, 0x8d, 0x76, 0x00, + 0x8b, 0x44, 0x24, 0x0c, 0x8b, 0x54, 0x24, 0x10, 0x89, 0x44, 0x24, 0x04, + 0x89, 0x54, 0x24, 0x08, 0xdd, 0x44, 0x24, 0x04, 0xd9, 0x5c, 0x24, 0x14, + 0x8b, 0x44, 0x24, 0x14, 0x89, 0x04, 0x24, 0x8b, 0x04, 0x24, 0x0f, 0xc8, + 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, 0x83, 0xc4, 0x18 + }; + copy_block(op_store_single_F0_T1_im_code, 141); + *(uint32_t *)(code_ptr() + 5) = param1 + 0; + inc_code_ptr(141); +} +#endif + +DEFINE_GEN(gen_op_load_double_FD_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_double_FD_T1_T2 +{ + static const uint8 op_load_double_FD_T1_T2_code[] = { + 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x94, 0x3e, 0x00, 0x00, 0x00, + 0x11, 0x0f, 0xca, 0x89, 0x50, 0x04, 0x8b, 0x94, 0x3e, 0x04, 0x00, 0x00, + 0x11, 0x0f, 0xca, 0x89, 0x10 + }; + copy_block(op_load_double_FD_T1_T2_code, 29); + inc_code_ptr(29); +} +#endif + +DEFINE_GEN(gen_op_load_single_FD_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_single_FD_T1_T2 +{ + static const uint8 op_load_single_FD_T1_T2_code[] = { + 0x83, 0xec, 0x08, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x94, 0x3e, + 0x00, 0x00, 0x00, 0x11, 0x0f, 0xca, 0x89, 0x14, 0x24, 0x31, 0xc9, 0xd9, + 0x04, 0x24, 0x89, 0x4c, 0x24, 0x04, 0xdd, 0x1c, 0x24, 0x8b, 0x14, 0x24, + 0x8b, 0x4c, 0x24, 0x04, 0x89, 0x10, 0x89, 0x48, 0x04, 0x83, 0xc4, 0x08 + }; + copy_block(op_load_single_FD_T1_T2_code, 48); + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_store_double_F0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_double_F0_T1_T2 +{ + static const uint8 op_store_double_F0_T1_T2_code[] = { + 0x8d, 0x14, 0x3e, 0x8b, 0x43, 0x04, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, + 0x00, 0x11, 0x8b, 0x03, 0x0f, 0xc8, 0x89, 0x82, 0x04, 0x00, 0x00, 0x11 + }; + copy_block(op_store_double_F0_T1_T2_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_store_single_F0_T1_T2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_single_F0_T1_T2 +{ + static const uint8 op_store_single_F0_T1_T2_code[] = { + 0x83, 0xec, 0x18, 0x8d, 0x0c, 0x3e, 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, + 0x44, 0x24, 0x0c, 0x89, 0xd0, 0xc1, 0xe8, 0x14, 0x89, 0x54, 0x24, 0x10, + 0x25, 0xff, 0x07, 0x00, 0x00, 0x2d, 0x6a, 0x03, 0x00, 0x00, 0x83, 0xf8, + 0x16, 0x76, 0x39, 0x8b, 0x54, 0x24, 0x10, 0x89, 0xd0, 0x25, 0x00, 0x00, + 0x00, 0xc0, 0x89, 0x04, 0x24, 0x8b, 0x54, 0x24, 0x10, 0x8b, 0x44, 0x24, + 0x0c, 0x0f, 0xac, 0xd0, 0x1d, 0xc1, 0xea, 0x1d, 0x89, 0x44, 0x24, 0x0c, + 0x8b, 0x44, 0x24, 0x0c, 0x89, 0x54, 0x24, 0x10, 0x25, 0xff, 0xff, 0xff, + 0x3f, 0x09, 0x04, 0x24, 0xeb, 0x25, 0x8d, 0xb6, 0x00, 0x00, 0x00, 0x00, + 0x8b, 0x44, 0x24, 0x0c, 0x8b, 0x54, 0x24, 0x10, 0x89, 0x44, 0x24, 0x04, + 0x89, 0x54, 0x24, 0x08, 0xdd, 0x44, 0x24, 0x04, 0xd9, 0x5c, 0x24, 0x14, + 0x8b, 0x44, 0x24, 0x14, 0x89, 0x04, 0x24, 0x8b, 0x04, 0x24, 0x0f, 0xc8, + 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, 0x83, 0xc4, 0x18 + }; + copy_block(op_store_single_F0_T1_T2_code, 141); + inc_code_ptr(141); +} +#endif + +DEFINE_GEN(gen_op_lwarx_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lwarx_T0_T1 +{ + static const uint8 op_lwarx_T0_T1_code[] = { + 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb, 0x89, 0xb5, + 0xbc, 0x03, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x00, 0x89, 0x85, 0xb8, + 0x03, 0x00, 0x00 + }; + copy_block(op_lwarx_T0_T1_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_stwcx_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stwcx_T0_T1 +{ + static const uint8 op_stwcx_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x8b, 0x8d, 0x90, 0x03, 0x00, + 0x00, 0xc1, 0xe0, 0x1c, 0x81, 0xe1, 0xff, 0xff, 0xff, 0x0f, 0x09, 0xc1, + 0x8d, 0x45, 0x10, 0x8b, 0x90, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xd2, 0x74, + 0x2b, 0x31, 0xd2, 0x39, 0xb0, 0xac, 0x03, 0x00, 0x00, 0x89, 0x90, 0xa8, + 0x03, 0x00, 0x00, 0x75, 0x1b, 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x86, 0x00, + 0x00, 0x00, 0x11, 0x81, 0xc9, 0x00, 0x00, 0x00, 0x20, 0x8d, 0x74, 0x26, + 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0x8d, 0x90, 0x03, + 0x00, 0x00 + }; + copy_block(op_stwcx_T0_T1_code, 86); + inc_code_ptr(86); +} +#endif + +DEFINE_GEN(gen_op_load_T0_CR,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_CR +{ + static const uint8 op_load_T0_CR_code[] = { + 0x8b, 0x9d, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_load_T0_CR_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_CR,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_CR +{ + static const uint8 op_store_T0_CR_code[] = { + 0x89, 0x9d, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_CR_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb0 +{ + static const uint8 op_load_T0_crb0_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xc3, 0xc1, 0xeb, 0x1f + }; + copy_block(op_load_T0_crb0_code, 11); + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb0 +{ + static const uint8 op_store_T0_crb0_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xda, 0xc1, 0xe2, 0x1f, 0x25, + 0xff, 0xff, 0xff, 0x7f, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb0_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb0 +{ + static const uint8 op_load_T1_crb0_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xc6, 0xc1, 0xee, 0x1f + }; + copy_block(op_load_T1_crb0_code, 11); + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb0 +{ + static const uint8 op_store_T1_crb0_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf2, 0xc1, 0xe2, 0x1f, 0x25, + 0xff, 0xff, 0xff, 0x7f, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb0_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb1 +{ + static const uint8 op_load_T0_crb1_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1e, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb1_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb1 +{ + static const uint8 op_store_T0_crb1_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1e, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xbf, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb1_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb1 +{ + static const uint8 op_load_T1_crb1_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1e, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb1_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb1 +{ + static const uint8 op_store_T1_crb1_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1e, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xbf, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb1_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb2 +{ + static const uint8 op_load_T0_crb2_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1d, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb2_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb2 +{ + static const uint8 op_store_T0_crb2_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1d, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xdf, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb2_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb2 +{ + static const uint8 op_load_T1_crb2_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1d, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb2_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb2 +{ + static const uint8 op_store_T1_crb2_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1d, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xdf, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb2_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb3 +{ + static const uint8 op_load_T0_crb3_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1c, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb3_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb3 +{ + static const uint8 op_store_T0_crb3_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1c, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xef, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb3_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb3 +{ + static const uint8 op_load_T1_crb3_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1c, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb3_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb3 +{ + static const uint8 op_store_T1_crb3_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1c, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xef, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb3_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb4 +{ + static const uint8 op_load_T0_crb4_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1b, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb4_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb4 +{ + static const uint8 op_store_T0_crb4_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1b, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xf7, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb4_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb4 +{ + static const uint8 op_load_T1_crb4_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1b, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb4_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb4 +{ + static const uint8 op_store_T1_crb4_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1b, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xf7, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb4_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb5 +{ + static const uint8 op_load_T0_crb5_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1a, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb5_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb5 +{ + static const uint8 op_store_T0_crb5_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1a, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfb, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb5_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb5 +{ + static const uint8 op_load_T1_crb5_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1a, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb5_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb5 +{ + static const uint8 op_store_T1_crb5_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x1a, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfb, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb5_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb6 +{ + static const uint8 op_load_T0_crb6_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x19, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb6_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb6 +{ + static const uint8 op_store_T0_crb6_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x19, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfd, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb6_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb6 +{ + static const uint8 op_load_T1_crb6_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x19, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb6_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb6 +{ + static const uint8 op_store_T1_crb6_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x19, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfd, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb6_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb7 +{ + static const uint8 op_load_T0_crb7_code[] = { + 0x0f, 0xb6, 0x85, 0x93, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x01 + }; + copy_block(op_load_T0_crb7_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb7 +{ + static const uint8 op_store_T0_crb7_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x18, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfe, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb7_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb7 +{ + static const uint8 op_load_T1_crb7_code[] = { + 0x0f, 0xb6, 0x85, 0x93, 0x03, 0x00, 0x00, 0x89, 0xc6, 0x83, 0xe6, 0x01 + }; + copy_block(op_load_T1_crb7_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb7 +{ + static const uint8 op_store_T1_crb7_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x18, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfe, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb7_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb8 +{ + static const uint8 op_load_T0_crb8_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x17, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb8_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb8 +{ + static const uint8 op_store_T0_crb8_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x17, 0x81, 0xe2, 0xff, 0xff, 0x7f, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb8_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb8 +{ + static const uint8 op_load_T1_crb8_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x17, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb8_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb8 +{ + static const uint8 op_store_T1_crb8_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x17, 0x81, 0xe2, 0xff, 0xff, 0x7f, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb8_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb9 +{ + static const uint8 op_load_T0_crb9_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x16, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb9_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb9 +{ + static const uint8 op_store_T0_crb9_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x16, 0x81, 0xe2, 0xff, 0xff, 0xbf, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb9_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb9 +{ + static const uint8 op_load_T1_crb9_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x16, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb9_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb9 +{ + static const uint8 op_store_T1_crb9_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x16, 0x81, 0xe2, 0xff, 0xff, 0xbf, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb9_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb10 +{ + static const uint8 op_load_T0_crb10_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x15, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb10_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb10 +{ + static const uint8 op_store_T0_crb10_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x15, 0x81, 0xe2, 0xff, 0xff, 0xdf, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb10_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb10 +{ + static const uint8 op_load_T1_crb10_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x15, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb10_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb10 +{ + static const uint8 op_store_T1_crb10_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x15, 0x81, 0xe2, 0xff, 0xff, 0xdf, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb10_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb11 +{ + static const uint8 op_load_T0_crb11_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x14, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb11_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb11 +{ + static const uint8 op_store_T0_crb11_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x14, 0x81, 0xe2, 0xff, 0xff, 0xef, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb11_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb11 +{ + static const uint8 op_load_T1_crb11_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x14, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb11_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb11 +{ + static const uint8 op_store_T1_crb11_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x14, 0x81, 0xe2, 0xff, 0xff, 0xef, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb11_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb12 +{ + static const uint8 op_load_T0_crb12_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x13, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb12_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb12 +{ + static const uint8 op_store_T0_crb12_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x13, 0x81, 0xe2, 0xff, 0xff, 0xf7, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb12_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb12 +{ + static const uint8 op_load_T1_crb12_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x13, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb12_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb12 +{ + static const uint8 op_store_T1_crb12_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x13, 0x81, 0xe2, 0xff, 0xff, 0xf7, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb12_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb13 +{ + static const uint8 op_load_T0_crb13_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x12, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb13_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb13 +{ + static const uint8 op_store_T0_crb13_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x12, 0x81, 0xe2, 0xff, 0xff, 0xfb, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb13_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb13 +{ + static const uint8 op_load_T1_crb13_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x12, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb13_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb13 +{ + static const uint8 op_store_T1_crb13_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x12, 0x81, 0xe2, 0xff, 0xff, 0xfb, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb13_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb14 +{ + static const uint8 op_load_T0_crb14_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x11, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb14_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb14 +{ + static const uint8 op_store_T0_crb14_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x11, 0x81, 0xe2, 0xff, 0xff, 0xfd, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb14_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb14 +{ + static const uint8 op_load_T1_crb14_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x11, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb14_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb14 +{ + static const uint8 op_store_T1_crb14_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x11, 0x81, 0xe2, 0xff, 0xff, 0xfd, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb14_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb15 +{ + static const uint8 op_load_T0_crb15_code[] = { + 0x0f, 0xb7, 0x85, 0x92, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x01 + }; + copy_block(op_load_T0_crb15_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb15 +{ + static const uint8 op_store_T0_crb15_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x10, 0x81, 0xe2, 0xff, 0xff, 0xfe, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb15_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb15 +{ + static const uint8 op_load_T1_crb15_code[] = { + 0x0f, 0xb7, 0x85, 0x92, 0x03, 0x00, 0x00, 0x89, 0xc6, 0x83, 0xe6, 0x01 + }; + copy_block(op_load_T1_crb15_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb15 +{ + static const uint8 op_store_T1_crb15_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x10, 0x81, 0xe2, 0xff, 0xff, 0xfe, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb15_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb16 +{ + static const uint8 op_load_T0_crb16_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0f, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb16_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb16 +{ + static const uint8 op_store_T0_crb16_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0f, 0x81, 0xe2, 0xff, 0x7f, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb16_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb16 +{ + static const uint8 op_load_T1_crb16_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0f, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb16_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb16 +{ + static const uint8 op_store_T1_crb16_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0f, 0x81, 0xe2, 0xff, 0x7f, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb16_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb17 +{ + static const uint8 op_load_T0_crb17_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0e, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb17_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb17 +{ + static const uint8 op_store_T0_crb17_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0e, 0x81, 0xe2, 0xff, 0xbf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb17_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb17 +{ + static const uint8 op_load_T1_crb17_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0e, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb17_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb17 +{ + static const uint8 op_store_T1_crb17_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0e, 0x81, 0xe2, 0xff, 0xbf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb17_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb18 +{ + static const uint8 op_load_T0_crb18_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0d, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb18_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb18 +{ + static const uint8 op_store_T0_crb18_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0d, 0x81, 0xe2, 0xff, 0xdf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb18_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb18 +{ + static const uint8 op_load_T1_crb18_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0d, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb18_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb18 +{ + static const uint8 op_store_T1_crb18_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0d, 0x81, 0xe2, 0xff, 0xdf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb18_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb19 +{ + static const uint8 op_load_T0_crb19_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0c, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb19_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb19 +{ + static const uint8 op_store_T0_crb19_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0c, 0x81, 0xe2, 0xff, 0xef, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb19_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb19 +{ + static const uint8 op_load_T1_crb19_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0c, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb19_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb19 +{ + static const uint8 op_store_T1_crb19_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0c, 0x81, 0xe2, 0xff, 0xef, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb19_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb20 +{ + static const uint8 op_load_T0_crb20_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0b, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb20_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb20 +{ + static const uint8 op_store_T0_crb20_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0b, 0x81, 0xe2, 0xff, 0xf7, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb20_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb20 +{ + static const uint8 op_load_T1_crb20_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0b, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb20_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb20 +{ + static const uint8 op_store_T1_crb20_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0b, 0x81, 0xe2, 0xff, 0xf7, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb20_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb21 +{ + static const uint8 op_load_T0_crb21_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0a, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb21_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb21 +{ + static const uint8 op_store_T0_crb21_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0a, 0x81, 0xe2, 0xff, 0xfb, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb21_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb21 +{ + static const uint8 op_load_T1_crb21_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0a, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb21_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb21 +{ + static const uint8 op_store_T1_crb21_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x0a, 0x81, 0xe2, 0xff, 0xfb, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb21_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb22 +{ + static const uint8 op_load_T0_crb22_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x09, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb22_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb22 +{ + static const uint8 op_store_T0_crb22_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x09, 0x81, 0xe2, 0xff, 0xfd, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb22_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb22 +{ + static const uint8 op_load_T1_crb22_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x09, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb22_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb22 +{ + static const uint8 op_store_T1_crb22_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x09, 0x81, 0xe2, 0xff, 0xfd, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb22_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb23 +{ + static const uint8 op_load_T0_crb23_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x08, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb23_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb23 +{ + static const uint8 op_store_T0_crb23_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x08, 0x81, 0xe2, 0xff, 0xfe, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb23_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb23 +{ + static const uint8 op_load_T1_crb23_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x08, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb23_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb23 +{ + static const uint8 op_store_T1_crb23_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x08, 0x81, 0xe2, 0xff, 0xfe, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb23_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb24 +{ + static const uint8 op_load_T0_crb24_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x07, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb24_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb24 +{ + static const uint8 op_store_T0_crb24_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x07, 0x81, 0xe2, 0x7f, 0xff, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb24_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb24 +{ + static const uint8 op_load_T1_crb24_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x07, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb24_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb24 +{ + static const uint8 op_store_T1_crb24_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x07, 0x81, 0xe2, 0x7f, 0xff, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95, + 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb24_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb25 +{ + static const uint8 op_load_T0_crb25_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x06, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb25_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb25 +{ + static const uint8 op_store_T0_crb25_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x06, 0x83, 0xe2, 0xbf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_crb25_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb25 +{ + static const uint8 op_load_T1_crb25_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x06, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb25_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb25 +{ + static const uint8 op_store_T1_crb25_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x06, 0x83, 0xe2, 0xbf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T1_crb25_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb26 +{ + static const uint8 op_load_T0_crb26_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x05, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb26_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb26 +{ + static const uint8 op_store_T0_crb26_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x05, 0x83, 0xe2, 0xdf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_crb26_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb26 +{ + static const uint8 op_load_T1_crb26_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x05, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb26_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb26 +{ + static const uint8 op_store_T1_crb26_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x05, 0x83, 0xe2, 0xdf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T1_crb26_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb27 +{ + static const uint8 op_load_T0_crb27_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x04, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb27_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb27 +{ + static const uint8 op_store_T0_crb27_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x04, 0x83, 0xe2, 0xef, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_crb27_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb27 +{ + static const uint8 op_load_T1_crb27_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x04, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb27_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb27 +{ + static const uint8 op_store_T1_crb27_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x04, 0x83, 0xe2, 0xef, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T1_crb27_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb28 +{ + static const uint8 op_load_T0_crb28_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x03, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb28_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb28 +{ + static const uint8 op_store_T0_crb28_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x03, 0x83, 0xe2, 0xf7, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_crb28_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb28 +{ + static const uint8 op_load_T1_crb28_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x03, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb28_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb28 +{ + static const uint8 op_store_T1_crb28_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x03, 0x83, 0xe2, 0xf7, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T1_crb28_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb29 +{ + static const uint8 op_load_T0_crb29_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x02, 0x89, 0xc3, 0x83, + 0xe3, 0x01 + }; + copy_block(op_load_T0_crb29_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb29 +{ + static const uint8 op_store_T0_crb29_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x02, 0x83, 0xe2, 0xfb, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_crb29_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb29 +{ + static const uint8 op_load_T1_crb29_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x02, 0x89, 0xc6, 0x83, + 0xe6, 0x01 + }; + copy_block(op_load_T1_crb29_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb29 +{ + static const uint8 op_store_T1_crb29_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1, + 0xe0, 0x02, 0x83, 0xe2, 0xfb, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T1_crb29_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb30 +{ + static const uint8 op_load_T0_crb30_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xd1, 0xe8, 0x89, 0xc3, 0x83, 0xe3, + 0x01 + }; + copy_block(op_load_T0_crb30_code, 13); + inc_code_ptr(13); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb30 +{ + static const uint8 op_store_T0_crb30_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0x01, + 0xc0, 0x83, 0xe2, 0xfd, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb30_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb30 +{ + static const uint8 op_load_T1_crb30_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xd1, 0xe8, 0x89, 0xc6, 0x83, 0xe6, + 0x01 + }; + copy_block(op_load_T1_crb30_code, 13); + inc_code_ptr(13); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb30 +{ + static const uint8 op_store_T1_crb30_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0x01, + 0xc0, 0x83, 0xe2, 0xfd, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb30_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_T0_crb31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_crb31 +{ + static const uint8 op_load_T0_crb31_code[] = { + 0x8b, 0x9d, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe3, 0x01 + }; + copy_block(op_load_T0_crb31_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_store_T0_crb31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_crb31 +{ + static const uint8 op_store_T0_crb31_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xda, 0x83, 0xe2, 0x01, 0x83, + 0xe0, 0xfe, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_crb31_code, 22); + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_load_T1_crb31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T1_crb31 +{ + static const uint8 op_load_T1_crb31_code[] = { + 0x8b, 0xb5, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe6, 0x01 + }; + copy_block(op_load_T1_crb31_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_store_T1_crb31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T1_crb31 +{ + static const uint8 op_store_T1_crb31_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf2, 0x83, 0xe2, 0x01, 0x83, + 0xe0, 0xfe, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T1_crb31_code, 22); + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr0 +{ + static const uint8 op_load_T0_cr0_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xc3, 0xc1, 0xeb, 0x1c + }; + copy_block(op_load_T0_cr0_code, 11); + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr0 +{ + static const uint8 op_store_T0_cr0_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x1c, 0x81, + 0xe2, 0xff, 0xff, 0xff, 0x0f, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr0_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr1 +{ + static const uint8 op_load_T0_cr1_code[] = { + 0x0f, 0xb6, 0x85, 0x93, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x0f + }; + copy_block(op_load_T0_cr1_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr1 +{ + static const uint8 op_store_T0_cr1_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x18, 0x81, + 0xe2, 0xff, 0xff, 0xff, 0xf0, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr1_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr2 +{ + static const uint8 op_load_T0_cr2_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x14, 0x89, 0xc3, 0x83, + 0xe3, 0x0f + }; + copy_block(op_load_T0_cr2_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr2 +{ + static const uint8 op_store_T0_cr2_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x14, 0x81, + 0xe2, 0xff, 0xff, 0x0f, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr2_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr3 +{ + static const uint8 op_load_T0_cr3_code[] = { + 0x0f, 0xb7, 0x85, 0x92, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x0f + }; + copy_block(op_load_T0_cr3_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr3 +{ + static const uint8 op_store_T0_cr3_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x10, 0x81, + 0xe2, 0xff, 0xff, 0xf0, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr3_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr4 +{ + static const uint8 op_load_T0_cr4_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0c, 0x89, 0xc3, 0x83, + 0xe3, 0x0f + }; + copy_block(op_load_T0_cr4_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr4 +{ + static const uint8 op_store_T0_cr4_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x0c, 0x81, + 0xe2, 0xff, 0x0f, 0xff, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr4_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr5 +{ + static const uint8 op_load_T0_cr5_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x08, 0x89, 0xc3, 0x83, + 0xe3, 0x0f + }; + copy_block(op_load_T0_cr5_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr5 +{ + static const uint8 op_store_T0_cr5_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x08, 0x81, + 0xe2, 0xff, 0xf0, 0xff, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr5_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr6 +{ + static const uint8 op_load_T0_cr6_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x04, 0x89, 0xc3, 0x83, + 0xe3, 0x0f + }; + copy_block(op_load_T0_cr6_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr6 +{ + static const uint8 op_store_T0_cr6_code[] = { + 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x04, 0x81, + 0xe2, 0x0f, 0xff, 0xff, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00, + 0x00 + }; + copy_block(op_store_T0_cr6_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_load_T0_cr7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_cr7 +{ + static const uint8 op_load_T0_cr7_code[] = { + 0x8b, 0x9d, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe3, 0x0f + }; + copy_block(op_load_T0_cr7_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_store_T0_cr7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_cr7 +{ + static const uint8 op_store_T0_cr7_code[] = { + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe0, 0xf0, 0x09, 0xd8, 0x89, + 0x85, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_cr7_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_mtcrf_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mtcrf_T0_im +{ + static const uint8 op_mtcrf_T0_im_code[] = { + 0x8b, 0x8d, 0x90, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, + 0xda, 0xf7, 0xd0, 0x81, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x21, 0xc8, 0x09, + 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_mtcrf_T0_im_code, 31); + *(uint32_t *)(code_ptr() + 7) = param1 + 0; + *(uint32_t *)(code_ptr() + 17) = param1 + 0; + inc_code_ptr(31); +} +#endif + +DEFINE_GEN(gen_op_fmov_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_F0_F1 +{ + static const uint8 op_fmov_F0_F1_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x03, 0x89, 0x53, 0x04 + }; + copy_block(op_fmov_F0_F1_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmov_F0_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_F0_F2 +{ + static const uint8 op_fmov_F0_F2_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x03, 0x89, 0x53, 0x04 + }; + copy_block(op_fmov_F0_F2_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmov_F1_F0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_F1_F0 +{ + static const uint8 op_fmov_F1_F0_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x06, 0x89, 0x56, 0x04 + }; + copy_block(op_fmov_F1_F0_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmov_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_F1_F2 +{ + static const uint8 op_fmov_F1_F2_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x06, 0x89, 0x56, 0x04 + }; + copy_block(op_fmov_F1_F2_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmov_F2_F0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_F2_F0 +{ + static const uint8 op_fmov_F2_F0_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x07, 0x89, 0x57, 0x04 + }; + copy_block(op_fmov_F2_F0_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmov_F2_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_F2_F1 +{ + static const uint8 op_fmov_F2_F1_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x07, 0x89, 0x57, 0x04 + }; + copy_block(op_fmov_F2_F1_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmov_FD_F0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_FD_F0 +{ + static const uint8 op_fmov_FD_F0_code[] = { + 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x89, + 0x95, 0x44, 0x08, 0x0e, 0x00 + }; + copy_block(op_fmov_FD_F0_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_fmov_FD_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_FD_F1 +{ + static const uint8 op_fmov_FD_F1_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x89, + 0x95, 0x44, 0x08, 0x0e, 0x00 + }; + copy_block(op_fmov_FD_F1_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_fmov_FD_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmov_FD_F2 +{ + static const uint8 op_fmov_FD_F2_code[] = { + 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x89, + 0x95, 0x44, 0x08, 0x0e, 0x00 + }; + copy_block(op_fmov_FD_F2_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_fabs_FD_F0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fabs_FD_F0 +{ + static const uint8 op_fabs_FD_F0_code[] = { + 0xdd, 0x03, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xd9, 0xe1, 0xdd, 0x18 + }; + copy_block(op_fabs_FD_F0_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_fneg_FD_F0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fneg_FD_F0 +{ + static const uint8 op_fneg_FD_F0_code[] = { + 0xdd, 0x03, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xd9, 0xe0, 0xdd, 0x18 + }; + copy_block(op_fneg_FD_F0_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_fnabs_FD_F0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fnabs_FD_F0 +{ + static const uint8 op_fnabs_FD_F0_code[] = { + 0xdd, 0x03, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xd9, 0xe1, 0xd9, 0xe0, + 0xdd, 0x18 + }; + copy_block(op_fnabs_FD_F0_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_fadd_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fadd_FD_F0_F1 +{ + static const uint8 op_fadd_FD_F0_F1_code[] = { + 0xdd, 0x06, 0xdc, 0x03, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00 + }; + copy_block(op_fadd_FD_F0_F1_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fsub_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fsub_FD_F0_F1 +{ + static const uint8 op_fsub_FD_F0_F1_code[] = { + 0xdd, 0x06, 0xdc, 0x2b, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00 + }; + copy_block(op_fsub_FD_F0_F1_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmul_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmul_FD_F0_F1 +{ + static const uint8 op_fmul_FD_F0_F1_code[] = { + 0xdd, 0x06, 0xdc, 0x0b, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00 + }; + copy_block(op_fmul_FD_F0_F1_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fdiv_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fdiv_FD_F0_F1 +{ + static const uint8 op_fdiv_FD_F0_F1_code[] = { + 0xdd, 0x06, 0xdc, 0x3b, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00 + }; + copy_block(op_fdiv_FD_F0_F1_code, 10); + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_fmadd_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmadd_FD_F0_F1_F2 +{ + static const uint8 op_fmadd_FD_F0_F1_F2_code[] = { + 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x07, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00 + }; + copy_block(op_fmadd_FD_F0_F1_F2_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_fmsub_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmsub_FD_F0_F1_F2 +{ + static const uint8 op_fmsub_FD_F0_F1_F2_code[] = { + 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x27, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00 + }; + copy_block(op_fmsub_FD_F0_F1_F2_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_fnmadd_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fnmadd_FD_F0_F1_F2 +{ + static const uint8 op_fnmadd_FD_F0_F1_F2_code[] = { + 0xdd, 0x06, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xdc, 0x0b, 0xdc, 0x07, + 0xd9, 0xe0, 0xdd, 0x18 + }; + copy_block(op_fnmadd_FD_F0_F1_F2_code, 16); + inc_code_ptr(16); +} +#endif + +DEFINE_GEN(gen_op_fnmsub_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fnmsub_FD_F0_F1_F2 +{ + static const uint8 op_fnmsub_FD_F0_F1_F2_code[] = { + 0xdd, 0x06, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xdc, 0x0b, 0xdc, 0x27, + 0xd9, 0xe0, 0xdd, 0x18 + }; + copy_block(op_fnmsub_FD_F0_F1_F2_code, 16); + inc_code_ptr(16); +} +#endif + +DEFINE_GEN(gen_op_fadds_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fadds_FD_F0_F1 +{ + static const uint8 op_fadds_FD_F0_F1_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x03, 0xd9, 0x1c, 0x24, 0xd9, 0x04, + 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58 + }; + copy_block(op_fadds_FD_F0_F1_code, 20); + inc_code_ptr(20); +} +#endif + +DEFINE_GEN(gen_op_fsubs_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fsubs_FD_F0_F1 +{ + static const uint8 op_fsubs_FD_F0_F1_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x2b, 0xd9, 0x1c, 0x24, 0xd9, 0x04, + 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58 + }; + copy_block(op_fsubs_FD_F0_F1_code, 20); + inc_code_ptr(20); +} +#endif + +DEFINE_GEN(gen_op_fmuls_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmuls_FD_F0_F1 +{ + static const uint8 op_fmuls_FD_F0_F1_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xd9, 0x1c, 0x24, 0xd9, 0x04, + 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58 + }; + copy_block(op_fmuls_FD_F0_F1_code, 20); + inc_code_ptr(20); +} +#endif + +DEFINE_GEN(gen_op_fdivs_FD_F0_F1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fdivs_FD_F0_F1 +{ + static const uint8 op_fdivs_FD_F0_F1_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x3b, 0xd9, 0x1c, 0x24, 0xd9, 0x04, + 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58 + }; + copy_block(op_fdivs_FD_F0_F1_code, 20); + inc_code_ptr(20); +} +#endif + +DEFINE_GEN(gen_op_fmadds_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmadds_FD_F0_F1_F2 +{ + static const uint8 op_fmadds_FD_F0_F1_F2_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x07, 0xd9, 0x1c, 0x24, + 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58 + }; + copy_block(op_fmadds_FD_F0_F1_F2_code, 22); + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_fmsubs_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fmsubs_FD_F0_F1_F2 +{ + static const uint8 op_fmsubs_FD_F0_F1_F2_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x27, 0xd9, 0x1c, 0x24, + 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58 + }; + copy_block(op_fmsubs_FD_F0_F1_F2_code, 22); + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_fnmadds_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fnmadds_FD_F0_F1_F2 +{ + static const uint8 op_fnmadds_FD_F0_F1_F2_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x07, 0xd9, 0xe0, 0xd9, + 0x1c, 0x24, 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x5a + }; + copy_block(op_fnmadds_FD_F0_F1_F2_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_fnmsubs_FD_F0_F1_F2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_fnmsubs_FD_F0_F1_F2 +{ + static const uint8 op_fnmsubs_FD_F0_F1_F2_code[] = { + 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x27, 0xd9, 0xe0, 0xd9, + 0x1c, 0x24, 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x59 + }; + copy_block(op_fnmsubs_FD_F0_F1_F2_code, 24); + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_load_T0_VRSAVE,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_VRSAVE +{ + static const uint8 op_load_T0_VRSAVE_code[] = { + 0x8b, 0x9d, 0x9c, 0x03, 0x00, 0x00 + }; + copy_block(op_load_T0_VRSAVE_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_VRSAVE,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_VRSAVE +{ + static const uint8 op_store_T0_VRSAVE_code[] = { + 0x89, 0x9d, 0x9c, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_VRSAVE_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T0_XER,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_XER +{ + static const uint8 op_load_T0_XER_code[] = { + 0x0f, 0xb6, 0x95, 0x94, 0x03, 0x00, 0x00, 0x8d, 0x8d, 0x94, 0x03, 0x00, + 0x00, 0x0f, 0xb6, 0x41, 0x01, 0xc1, 0xe2, 0x1f, 0xc1, 0xe0, 0x1e, 0x09, + 0xc2, 0x0f, 0xb6, 0x41, 0x02, 0xc1, 0xe0, 0x1d, 0x09, 0xc2, 0x0f, 0xb6, + 0x41, 0x03, 0x89, 0xd3, 0x09, 0xc3 + }; + copy_block(op_load_T0_XER_code, 42); + inc_code_ptr(42); +} +#endif + +DEFINE_GEN(gen_op_load_T0_PC,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_PC +{ + static const uint8 op_load_T0_PC_code[] = { + 0x8b, 0x9d, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_load_T0_PC_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_PC,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_PC +{ + static const uint8 op_store_T0_PC_code[] = { + 0x89, 0x9d, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_PC_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_set_PC_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_set_PC_im +{ + static const uint8 op_set_PC_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x85, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_set_PC_im_code, 11); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_set_PC_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_set_PC_T0 +{ + static const uint8 op_set_PC_T0_code[] = { + 0x89, 0x9d, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_set_PC_T0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_inc_PC,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_inc_PC +{ + static const uint8 op_inc_PC_code[] = { + 0x81, 0x85, 0xac, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_inc_PC_code, 10); + *(uint32_t *)(code_ptr() + 6) = param1 + 0; + inc_code_ptr(10); +} +#endif + +DEFINE_GEN(gen_op_load_T0_LR,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_LR +{ + static const uint8 op_load_T0_LR_code[] = { + 0x8b, 0x9d, 0xa4, 0x03, 0x00, 0x00 + }; + copy_block(op_load_T0_LR_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_LR,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_LR +{ + static const uint8 op_store_T0_LR_code[] = { + 0x89, 0x9d, 0xa4, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_LR_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_T0_CTR,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_CTR +{ + static const uint8 op_load_T0_CTR_code[] = { + 0x8b, 0x9d, 0xa8, 0x03, 0x00, 0x00 + }; + copy_block(op_load_T0_CTR_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_T0_CTR,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_CTR +{ + static const uint8 op_store_T0_CTR_code[] = { + 0x89, 0x9d, 0xa8, 0x03, 0x00, 0x00 + }; + copy_block(op_store_T0_CTR_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_store_im_LR,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_im_LR +{ + static const uint8 op_store_im_LR_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x85, 0xa4, 0x03, 0x00, 0x00 + }; + copy_block(op_store_im_LR_code, 11); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_load_T0_CTR_aligned,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_CTR_aligned +{ + static const uint8 op_load_T0_CTR_aligned_code[] = { + 0x8b, 0x9d, 0xa8, 0x03, 0x00, 0x00, 0x83, 0xe3, 0xfc + }; + copy_block(op_load_T0_CTR_aligned_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_load_T0_LR_aligned,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_T0_LR_aligned +{ + static const uint8 op_load_T0_LR_aligned_code[] = { + 0x8b, 0x9d, 0xa4, 0x03, 0x00, 0x00, 0x83, 0xe3, 0xfc + }; + copy_block(op_load_T0_LR_aligned_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_spcflags_init,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_spcflags_init +{ + static const uint8 op_spcflags_init_code[] = { + 0x8d, 0x95, 0xb0, 0x03, 0x00, 0x00, 0x83, 0xec, 0x04, 0xb9, 0x01, 0x00, + 0x00, 0x00, 0x89, 0x14, 0x24, 0x8d, 0x95, 0xb4, 0x03, 0x00, 0x00, 0x89, + 0xf6, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0xc8, 0x87, 0x02, + 0x85, 0xc0, 0x75, 0xf8, 0x8b, 0x04, 0x24, 0x81, 0x08, 0x00, 0x00, 0x00, + 0x00, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x58 + }; + copy_block(op_spcflags_init_code, 57); + *(uint32_t *)(code_ptr() + 45) = param1 + 0; + inc_code_ptr(57); +} +#endif + +DEFINE_GEN(gen_op_spcflags_set,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_spcflags_set +{ + static const uint8 op_spcflags_set_code[] = { + 0x8d, 0x95, 0xb0, 0x03, 0x00, 0x00, 0x83, 0xec, 0x04, 0xb9, 0x01, 0x00, + 0x00, 0x00, 0x89, 0x14, 0x24, 0x8d, 0x95, 0xb4, 0x03, 0x00, 0x00, 0x89, + 0xf6, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0xc8, 0x87, 0x02, + 0x85, 0xc0, 0x75, 0xf8, 0x8b, 0x04, 0x24, 0x81, 0x08, 0x00, 0x00, 0x00, + 0x00, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x58 + }; + copy_block(op_spcflags_set_code, 57); + *(uint32_t *)(code_ptr() + 45) = param1 + 0; + inc_code_ptr(57); +} +#endif + +DEFINE_GEN(gen_op_spcflags_clear,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_spcflags_clear +{ + static const uint8 op_spcflags_clear_code[] = { + 0x83, 0xec, 0x08, 0x8d, 0x95, 0xb0, 0x03, 0x00, 0x00, 0xb9, 0x01, 0x00, + 0x00, 0x00, 0x89, 0x54, 0x24, 0x04, 0x8d, 0x95, 0xb4, 0x03, 0x00, 0x00, + 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, 0x90, 0x89, 0xc8, 0x87, 0x02, + 0x85, 0xc0, 0x75, 0xf8, 0xf7, 0x14, 0x24, 0x8b, 0x44, 0x24, 0x04, 0x8b, + 0x14, 0x24, 0x21, 0x10, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x83, + 0xc4, 0x08 + }; + copy_block(op_spcflags_clear_code, 62); + *(uint32_t *)(code_ptr() + 27) = param1 + 0; + inc_code_ptr(62); +} +#endif + +DEFINE_GEN(gen_op_spcflags_check,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_spcflags_check +{ + static const uint8 op_spcflags_check_code[] = { + 0x8b, 0x85, 0xb0, 0x03, 0x00, 0x00, 0x85, 0xc0, 0x75, 0x05, 0xe9, 0x00, + 0x00, 0x00, 0x00 + }; + copy_block(op_spcflags_check_code, 15); + jmp_addr[0] = code_ptr() + 11; + inc_code_ptr(15); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_0000,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_0000 +{ + static const uint8 op_prep_branch_bo_0000_code[] = { + 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x94, 0xc1, 0x31, + 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7, + 0x74, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d, + 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, + 0x89, 0xd6 + }; + copy_block(op_prep_branch_bo_0000_code, 50); + inc_code_ptr(50); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_0001,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_0001 +{ + static const uint8 op_prep_branch_bo_0001_code[] = { + 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x94, 0xc1, 0x31, + 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7, + 0x75, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d, + 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, + 0x89, 0xd6 + }; + copy_block(op_prep_branch_bo_0001_code, 50); + inc_code_ptr(50); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_001x,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_001x +{ + static const uint8 op_prep_branch_bo_001x_code[] = { + 0x31, 0xc0, 0x85, 0xf6, 0x0f, 0x94, 0xc0, 0x89, 0xc6 + }; + copy_block(op_prep_branch_bo_001x_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_0100,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_0100 +{ + static const uint8 op_prep_branch_bo_0100_code[] = { + 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x95, 0xc1, 0x31, + 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7, + 0x74, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d, + 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, + 0x89, 0xd6 + }; + copy_block(op_prep_branch_bo_0100_code, 50); + inc_code_ptr(50); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_0101,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_0101 +{ + static const uint8 op_prep_branch_bo_0101_code[] = { + 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x95, 0xc1, 0x31, + 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7, + 0x75, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d, + 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, + 0x89, 0xd6 + }; + copy_block(op_prep_branch_bo_0101_code, 50); + inc_code_ptr(50); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_011x,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_011x +{ + static const uint8 op_prep_branch_bo_011x_code[] = { + 0x31, 0xc0, 0x85, 0xf6, 0x0f, 0x95, 0xc0, 0x89, 0xc6 + }; + copy_block(op_prep_branch_bo_011x_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_1x00,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_1x00 +{ + static const uint8 op_prep_branch_bo_1x00_code[] = { + 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, + 0x03, 0x00, 0x00, 0x89, 0xc7, 0x0f, 0x95, 0xc0, 0x0f, 0xb6, 0xc0, 0x89, + 0xc6 + }; + copy_block(op_prep_branch_bo_1x00_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_1x01,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_1x01 +{ + static const uint8 op_prep_branch_bo_1x01_code[] = { + 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, + 0x03, 0x00, 0x00, 0x89, 0xc7, 0x0f, 0x94, 0xc0, 0x0f, 0xb6, 0xc0, 0x89, + 0xc6 + }; + copy_block(op_prep_branch_bo_1x01_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_prep_branch_bo_1x1x,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_prep_branch_bo_1x1x +{ + static const uint8 op_prep_branch_bo_1x1x_code[] = { + 0xbe, 0x01, 0x00, 0x00, 0x00 + }; + copy_block(op_prep_branch_bo_1x1x_code, 5); + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_branch_chain_1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_branch_chain_1 +{ + static const uint8 op_branch_chain_1_code[] = { + 0xe9, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_branch_chain_1_code, 5); + jmp_addr[0] = code_ptr() + 1; + inc_code_ptr(5); +} +#endif + +DEFINE_GEN(gen_op_branch_chain_2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_branch_chain_2 +{ + static const uint8 op_branch_chain_2_code[] = { + 0x85, 0xf6, 0x74, 0x0c, 0xe9, 0x00, 0x00, 0x00, 0x00, 0xeb, 0x0a, 0x90, + 0x8d, 0x74, 0x26, 0x00, 0xe9, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_branch_chain_2_code, 21); + jmp_addr[0] = code_ptr() + 5; + jmp_addr[1] = code_ptr() + 17; + inc_code_ptr(21); +} +#endif + +DEFINE_GEN(gen_op_branch_1_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_branch_1_T0 +{ + static const uint8 op_branch_1_T0_code[] = { + 0x89, 0x9d, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_branch_1_T0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_branch_1_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_branch_1_im +{ + static const uint8 op_branch_1_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x85, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_branch_1_im_code, 11); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_branch_2_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_branch_2_T0_im +{ + static const uint8 op_branch_2_T0_im_code[] = { + 0x85, 0xf6, 0x89, 0xd8, 0x75, 0x05, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, + 0x85, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_branch_2_T0_im_code, 17); + *(uint32_t *)(code_ptr() + 7) = param1 + 0; + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_branch_2_im_im,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_branch_2_im_im +{ + static const uint8 op_branch_2_im_im_code[] = { + 0x85, 0xf6, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x75, 0x05, 0xb8, 0x00, 0x00, + 0x00, 0x00, 0x89, 0x85, 0xac, 0x03, 0x00, 0x00 + }; + copy_block(op_branch_2_im_im_code, 20); + *(uint32_t *)(code_ptr() + 3) = param1 + 0; + *(uint32_t *)(code_ptr() + 10) = param2 + 0; + inc_code_ptr(20); +} +#endif + +DEFINE_GEN(gen_op_record_cr0_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_record_cr0_T0 +{ + static const uint8 op_record_cr0_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x8b, 0x95, 0x90, 0x03, 0x00, + 0x00, 0xc1, 0xe0, 0x1c, 0x81, 0xe2, 0xff, 0xff, 0xff, 0x0f, 0x09, 0xc2, + 0x85, 0xdb, 0x7d, 0x08, 0x81, 0xca, 0x00, 0x00, 0x00, 0x80, 0xeb, 0x1c, + 0x7e, 0x0a, 0x81, 0xca, 0x00, 0x00, 0x00, 0x40, 0xeb, 0x12, 0x66, 0x90, + 0x81, 0xca, 0x00, 0x00, 0x00, 0x20, 0x8d, 0x76, 0x00, 0x8d, 0xbc, 0x27, + 0x00, 0x00, 0x00, 0x00, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_record_cr0_T0_code, 70); + inc_code_ptr(70); +} +#endif + +DEFINE_GEN(gen_op_record_cr1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_record_cr1 +{ + static const uint8 op_record_cr1_code[] = { + 0x8b, 0x85, 0xa0, 0x03, 0x00, 0x00, 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, + 0xc1, 0xe8, 0x04, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xf0, 0x25, 0x00, 0x00, + 0x00, 0x0f, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00 + }; + copy_block(op_record_cr1_code, 34); + inc_code_ptr(34); +} +#endif + +DEFINE_GEN(gen_op_compare_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_compare_T0_T1 +{ + static const uint8 op_compare_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x39, 0xf3, 0x7d, 0x07, 0x89, + 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1e, 0x7e, 0x0c, 0x89, 0xc3, 0x83, 0xcb, + 0x04, 0xeb, 0x15, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x89, 0xc3, 0x83, 0xcb, + 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_compare_T0_T1_code, 48); + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_compare_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_compare_T0_im +{ + static const uint8 op_compare_T0_im_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x81, 0xfb, 0x00, 0x00, 0x00, + 0x00, 0x7d, 0x07, 0x89, 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1a, 0x7e, 0x08, + 0x89, 0xc3, 0x83, 0xcb, 0x04, 0xeb, 0x11, 0x90, 0x89, 0xc3, 0x83, 0xcb, + 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_compare_T0_im_code, 48); + *(uint32_t *)(code_ptr() + 9) = param1 + 0; + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_compare_T0_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_compare_T0_0 +{ + static const uint8 op_compare_T0_0_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x85, 0xdb, 0x7d, 0x07, 0x89, + 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1e, 0x7e, 0x0c, 0x89, 0xc3, 0x83, 0xcb, + 0x04, 0xeb, 0x15, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x89, 0xc3, 0x83, 0xcb, + 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_compare_T0_0_code, 48); + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_compare_logical_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_compare_logical_T0_T1 +{ + static const uint8 op_compare_logical_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x39, 0xf3, 0x73, 0x07, 0x89, + 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1e, 0x76, 0x0c, 0x89, 0xc3, 0x83, 0xcb, + 0x04, 0xeb, 0x15, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x89, 0xc3, 0x83, 0xcb, + 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_compare_logical_T0_T1_code, 48); + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_compare_logical_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_compare_logical_T0_im +{ + static const uint8 op_compare_logical_T0_im_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x81, 0xfb, 0x00, 0x00, 0x00, + 0x00, 0x73, 0x07, 0x89, 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1a, 0x76, 0x08, + 0x89, 0xc3, 0x83, 0xcb, 0x04, 0xeb, 0x11, 0x90, 0x89, 0xc3, 0x83, 0xcb, + 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_compare_logical_T0_im_code, 48); + *(uint32_t *)(code_ptr() + 9) = param1 + 0; + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_compare_logical_T0_0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_compare_logical_T0_0 +{ + static const uint8 op_compare_logical_T0_0_code[] = { + 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x85, 0xdb, 0x74, 0x07, 0x89, + 0xc3, 0x83, 0xcb, 0x04, 0xeb, 0x05, 0x89, 0xc3, 0x83, 0xcb, 0x02 + }; + copy_block(op_compare_logical_T0_0_code, 23); + inc_code_ptr(23); +} +#endif + +DEFINE_GEN(gen_op_divw_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_divw_T0_T1 +{ + static const uint8 op_divw_T0_T1_code[] = { + 0x83, 0xec, 0x04, 0x85, 0xf6, 0x89, 0x1c, 0x24, 0x74, 0x13, 0x81, 0xfb, + 0x00, 0x00, 0x00, 0x80, 0x0f, 0x94, 0xc2, 0x83, 0xfe, 0xff, 0x0f, 0x94, + 0xc0, 0x84, 0xc2, 0x74, 0x08, 0x8b, 0x0c, 0x24, 0xc1, 0xf9, 0x1f, 0xeb, + 0x0b, 0x8b, 0x04, 0x24, 0x99, 0xf7, 0xfe, 0x89, 0xc1, 0x8d, 0x76, 0x00, + 0x5a, 0x89, 0xcb + }; + copy_block(op_divw_T0_T1_code, 51); + inc_code_ptr(51); +} +#endif + +DEFINE_GEN(gen_op_divwo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_divwo_T0_T1 +{ + static const uint8 op_divwo_T0_T1_code[] = { + 0x83, 0xec, 0x04, 0x85, 0xf6, 0x89, 0x1c, 0x24, 0x74, 0x13, 0x81, 0xfb, + 0x00, 0x00, 0x00, 0x80, 0x0f, 0x94, 0xc2, 0x83, 0xfe, 0xff, 0x0f, 0x94, + 0xc0, 0x84, 0xc2, 0x74, 0x16, 0x80, 0x8d, 0x94, 0x03, 0x00, 0x00, 0x01, + 0x8b, 0x0c, 0x24, 0xc6, 0x85, 0x95, 0x03, 0x00, 0x00, 0x01, 0xc1, 0xf9, + 0x1f, 0xeb, 0x1d, 0xc6, 0x85, 0x95, 0x03, 0x00, 0x00, 0x00, 0x8b, 0x04, + 0x24, 0x99, 0xf7, 0xfe, 0x89, 0xc1, 0x8d, 0xb4, 0x26, 0x00, 0x00, 0x00, + 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0xcb, 0x59 + }; + copy_block(op_divwo_T0_T1_code, 83); + inc_code_ptr(83); +} +#endif + +DEFINE_GEN(gen_op_divwu_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_divwu_T0_T1 +{ + static const uint8 op_divwu_T0_T1_code[] = { + 0x83, 0xec, 0x04, 0x31, 0xc9, 0x85, 0xf6, 0x89, 0x34, 0x24, 0x74, 0x08, + 0x89, 0xd8, 0x31, 0xd2, 0xf7, 0xf6, 0x89, 0xc1, 0x58, 0x89, 0xcb + }; + copy_block(op_divwu_T0_T1_code, 23); + inc_code_ptr(23); +} +#endif + +DEFINE_GEN(gen_op_divwuo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_divwuo_T0_T1 +{ + static const uint8 op_divwuo_T0_T1_code[] = { + 0x85, 0xf6, 0x89, 0xf1, 0x75, 0x10, 0x80, 0x8d, 0x94, 0x03, 0x00, 0x00, + 0x01, 0xc6, 0x85, 0x95, 0x03, 0x00, 0x00, 0x01, 0xeb, 0x0f, 0xc6, 0x85, + 0x95, 0x03, 0x00, 0x00, 0x00, 0x89, 0xd8, 0x31, 0xd2, 0xf7, 0xf6, 0x89, + 0xc1, 0x89, 0xcb + }; + copy_block(op_divwuo_T0_T1_code, 39); + inc_code_ptr(39); +} +#endif + +DEFINE_GEN(gen_op_mulhw_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mulhw_T0_T1 +{ + static const uint8 op_mulhw_T0_T1_code[] = { + 0x89, 0xda, 0x89, 0xf0, 0xf7, 0xea, 0x89, 0xd3 + }; + copy_block(op_mulhw_T0_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_mulhwu_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mulhwu_T0_T1 +{ + static const uint8 op_mulhwu_T0_T1_code[] = { + 0x89, 0xda, 0x89, 0xf0, 0xf7, 0xe2, 0x89, 0xd3 + }; + copy_block(op_mulhwu_T0_T1_code, 8); + inc_code_ptr(8); +} +#endif + +DEFINE_GEN(gen_op_mulli_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mulli_T0_im +{ + static const uint8 op_mulli_T0_im_code[] = { + 0x69, 0xdb, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_mulli_T0_im_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_mullwo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mullwo_T0_T1 +{ + static const uint8 op_mullwo_T0_T1_code[] = { + 0x89, 0xd8, 0x83, 0xec, 0x08, 0xf7, 0xee, 0x89, 0x04, 0x24, 0x8b, 0x04, + 0x24, 0x89, 0x54, 0x24, 0x04, 0x8b, 0x1c, 0x24, 0x99, 0x33, 0x54, 0x24, + 0x04, 0x33, 0x04, 0x24, 0x09, 0xd0, 0x0f, 0x95, 0xc0, 0x0f, 0xb6, 0xc0, + 0x88, 0x85, 0x95, 0x03, 0x00, 0x00, 0x08, 0x85, 0x94, 0x03, 0x00, 0x00, + 0x83, 0xc4, 0x08 + }; + copy_block(op_mullwo_T0_T1_code, 51); + inc_code_ptr(51); +} +#endif + +DEFINE_GEN(gen_op_slw_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_slw_T0_T1 +{ + static const uint8 op_slw_T0_T1_code[] = { + 0x89, 0xf0, 0x89, 0xf1, 0xd3, 0xe3, 0xa8, 0x20, 0x74, 0x02, 0x31, 0xdb + }; + copy_block(op_slw_T0_T1_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_srw_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_srw_T0_T1 +{ + static const uint8 op_srw_T0_T1_code[] = { + 0x89, 0xf0, 0x89, 0xf1, 0xd3, 0xeb, 0xa8, 0x20, 0x74, 0x02, 0x31, 0xdb + }; + copy_block(op_srw_T0_T1_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_sraw_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sraw_T0_T1 +{ + static const uint8 op_sraw_T0_T1_code[] = { + 0x89, 0xf0, 0x83, 0xec, 0x04, 0x83, 0xe0, 0x3f, 0x89, 0xc6, 0xc1, 0xe8, + 0x05, 0x84, 0xc0, 0x74, 0x11, 0x89, 0xd8, 0xc1, 0xe8, 0x1f, 0x89, 0xc3, + 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0xf7, 0xdb, 0xeb, 0x3b, 0xc6, 0x44, + 0x24, 0x03, 0x00, 0x89, 0xf1, 0x89, 0xda, 0xd3, 0xfa, 0x85, 0xdb, 0x79, + 0x1f, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xd3, 0xe0, 0xf7, 0xd0, 0x85, 0xd8, + 0x74, 0x12, 0xc6, 0x44, 0x24, 0x03, 0x01, 0x8d, 0xb6, 0x00, 0x00, 0x00, + 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xb6, 0x44, 0x24, + 0x03, 0x89, 0xd3, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x58 + }; + copy_block(op_sraw_T0_T1_code, 94); + inc_code_ptr(94); +} +#endif + +DEFINE_GEN(gen_op_sraw_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_sraw_T0_im +{ + static const uint8 op_sraw_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0xda, 0x88, 0xc1, 0x83, 0xec, 0x04, + 0xd3, 0xfa, 0x85, 0xdb, 0xc6, 0x44, 0x24, 0x03, 0x00, 0x79, 0x19, 0xb8, + 0xff, 0xff, 0xff, 0xff, 0xd3, 0xe0, 0xf7, 0xd0, 0x85, 0xc3, 0x74, 0x0c, + 0xc6, 0x44, 0x24, 0x03, 0x01, 0x8d, 0xb4, 0x26, 0x00, 0x00, 0x00, 0x00, + 0x0f, 0xb6, 0x44, 0x24, 0x03, 0x89, 0xd3, 0x88, 0x85, 0x96, 0x03, 0x00, + 0x00, 0x5a + }; + copy_block(op_sraw_T0_im_code, 62); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + inc_code_ptr(62); +} +#endif + +DEFINE_GEN(gen_op_rlwimi_T0_T1,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_rlwimi_T0_T1 +{ + static const uint8 op_rlwimi_T0_T1_code[] = { + 0xb9, 0x00, 0x00, 0x00, 0x00, 0x89, 0xf2, 0xb8, 0x00, 0x00, 0x00, 0x00, + 0xd3, 0xc2, 0x21, 0xc2, 0xf7, 0xd0, 0x21, 0xd8, 0x89, 0xd3, 0x09, 0xc3 + }; + copy_block(op_rlwimi_T0_T1_code, 24); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + *(uint32_t *)(code_ptr() + 8) = param2 + 0; + inc_code_ptr(24); +} +#endif + +DEFINE_GEN(gen_op_rlwinm_T0_T1,void,(long param1, long param2)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_rlwinm_T0_T1 +{ + static const uint8 op_rlwinm_T0_T1_code[] = { + 0x89, 0xd8, 0xb9, 0x00, 0x00, 0x00, 0x00, 0xd3, 0xc0, 0x89, 0xc3, 0x81, + 0xe3, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_rlwinm_T0_T1_code, 17); + *(uint32_t *)(code_ptr() + 3) = param1 + 0; + *(uint32_t *)(code_ptr() + 13) = param2 + 0; + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_rlwnm_T0_T1,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_rlwnm_T0_T1 +{ + static const uint8 op_rlwnm_T0_T1_code[] = { + 0x89, 0xd8, 0x89, 0xf1, 0xd3, 0xc0, 0x89, 0xc3, 0x81, 0xe3, 0x00, 0x00, + 0x00, 0x00 + }; + copy_block(op_rlwnm_T0_T1_code, 14); + *(uint32_t *)(code_ptr() + 10) = param1 + 0; + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_cntlzw_32_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_cntlzw_32_T0 +{ + static const uint8 op_cntlzw_32_T0_code[] = { + 0xb8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xbd, 0xc3, 0xba, 0x1f, 0x00, 0x00, + 0x00, 0x89, 0xd3, 0x29, 0xc3 + }; + copy_block(op_cntlzw_32_T0_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_addo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addo_T0_T1 +{ + static const uint8 op_addo_T0_T1_code[] = { + 0x01, 0xf3, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, 0x00, 0x00, 0x88, + 0x95, 0x95, 0x03, 0x00, 0x00 + }; + copy_block(op_addo_T0_T1_code, 17); + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_addc_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addc_T0_im +{ + static const uint8 op_addc_T0_im_code[] = { + 0x8d, 0x93, 0x00, 0x00, 0x00, 0x00, 0x39, 0xda, 0x0f, 0x92, 0x85, 0x96, + 0x03, 0x00, 0x00, 0x89, 0xd3 + }; + copy_block(op_addc_T0_im_code, 17); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(17); +} +#endif + +DEFINE_GEN(gen_op_addc_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addc_T0_T1 +{ + static const uint8 op_addc_T0_T1_code[] = { + 0x01, 0xf3, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00 + }; + copy_block(op_addc_T0_T1_code, 11); + inc_code_ptr(11); +} +#endif + +DEFINE_GEN(gen_op_addco_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addco_T0_T1 +{ + static const uint8 op_addco_T0_T1_code[] = { + 0x01, 0xf3, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, + 0x00, 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03, + 0x00, 0x00 + }; + copy_block(op_addco_T0_T1_code, 26); + inc_code_ptr(26); +} +#endif + +DEFINE_GEN(gen_op_adde_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_adde_T0_T1 +{ + static const uint8 op_adde_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x11, + 0xf3, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00 + }; + copy_block(op_adde_T0_T1_code, 22); + inc_code_ptr(22); +} +#endif + +DEFINE_GEN(gen_op_addeo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addeo_T0_T1 +{ + static const uint8 op_addeo_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x11, + 0xf3, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, 0x00, + 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03, 0x00, + 0x00 + }; + copy_block(op_addeo_T0_T1_code, 37); + inc_code_ptr(37); +} +#endif + +DEFINE_GEN(gen_op_addme_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addme_T0 +{ + static const uint8 op_addme_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83, + 0xd3, 0xff, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00 + }; + copy_block(op_addme_T0_code, 23); + inc_code_ptr(23); +} +#endif + +DEFINE_GEN(gen_op_addmeo_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addmeo_T0 +{ + static const uint8 op_addmeo_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83, + 0xd3, 0xff, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, + 0x00, 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03, + 0x00, 0x00 + }; + copy_block(op_addmeo_T0_code, 38); + inc_code_ptr(38); +} +#endif + +DEFINE_GEN(gen_op_addze_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addze_T0 +{ + static const uint8 op_addze_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83, + 0xd3, 0x00, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00 + }; + copy_block(op_addze_T0_code, 23); + inc_code_ptr(23); +} +#endif + +DEFINE_GEN(gen_op_addzeo_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_addzeo_T0 +{ + static const uint8 op_addzeo_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83, + 0xd3, 0x00, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, + 0x00, 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03, + 0x00, 0x00 + }; + copy_block(op_addzeo_T0_code, 38); + inc_code_ptr(38); +} +#endif + +DEFINE_GEN(gen_op_subf_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subf_T0_T1 +{ + static const uint8 op_subf_T0_T1_code[] = { + 0x89, 0xf0, 0x29, 0xd8, 0x89, 0xc3 + }; + copy_block(op_subf_T0_T1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_subfo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfo_T0_T1 +{ + static const uint8 op_subfo_T0_T1_code[] = { + 0x89, 0xf0, 0x29, 0xd8, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, 0x00, + 0x00, 0x89, 0xc3, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00 + }; + copy_block(op_subfo_T0_T1_code, 21); + inc_code_ptr(21); +} +#endif + +DEFINE_GEN(gen_op_subfc_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfc_T0_im +{ + static const uint8 op_subfc_T0_im_code[] = { + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x29, 0xd8, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x0f, 0x96, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xc3 + }; + copy_block(op_subfc_T0_im_code, 21); + *(uint32_t *)(code_ptr() + 1) = param1 + 0; + *(uint32_t *)(code_ptr() + 8) = param1 + 0; + inc_code_ptr(21); +} +#endif + +DEFINE_GEN(gen_op_subfc_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfc_T0_T1 +{ + static const uint8 op_subfc_T0_T1_code[] = { + 0x89, 0xf2, 0x29, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, + 0x00, 0x00, 0x89, 0xd3 + }; + copy_block(op_subfc_T0_T1_code, 16); + inc_code_ptr(16); +} +#endif + +DEFINE_GEN(gen_op_subfco_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfco_T0_T1 +{ + static const uint8 op_subfco_T0_T1_code[] = { + 0x89, 0xf1, 0x29, 0xd9, 0xf5, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, + 0x95, 0x94, 0x03, 0x00, 0x00, 0x89, 0xcb, 0x88, 0x85, 0x96, 0x03, 0x00, + 0x00, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00 + }; + copy_block(op_subfco_T0_T1_code, 31); + inc_code_ptr(31); +} +#endif + +DEFINE_GEN(gen_op_subfe_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfe_T0_T1 +{ + static const uint8 op_subfe_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xf2, 0x0f, 0xba, 0xe0, + 0x00, 0xf5, 0x19, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, + 0x00, 0x00, 0x89, 0xd3 + }; + copy_block(op_subfe_T0_T1_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_subfeo_T0_T1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfeo_T0_T1 +{ + static const uint8 op_subfeo_T0_T1_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xf1, 0x0f, 0xba, 0xe0, + 0x00, 0xf5, 0x19, 0xd9, 0xf5, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, + 0x95, 0x94, 0x03, 0x00, 0x00, 0x89, 0xcb, 0x88, 0x85, 0x96, 0x03, 0x00, + 0x00, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00 + }; + copy_block(op_subfeo_T0_T1_code, 43); + inc_code_ptr(43); +} +#endif + +DEFINE_GEN(gen_op_subfme_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfme_T0 +{ + static const uint8 op_subfme_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0xba, 0xff, 0xff, 0xff, 0xff, + 0x0f, 0xba, 0xe0, 0x00, 0xf5, 0x19, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, + 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xd3 + }; + copy_block(op_subfme_T0_code, 31); + inc_code_ptr(31); +} +#endif + +DEFINE_GEN(gen_op_subfmeo_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfmeo_T0 +{ + static const uint8 op_subfmeo_T0_code[] = { + 0x83, 0xec, 0x04, 0xb9, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xb6, 0x95, 0x96, + 0x03, 0x00, 0x00, 0x89, 0xd0, 0x0f, 0xba, 0xe0, 0x00, 0xf5, 0x19, 0xd9, + 0xf5, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x88, 0x85, 0x96, 0x03, 0x00, + 0x00, 0x89, 0xcb, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00, 0x08, 0x95, 0x94, + 0x03, 0x00, 0x00, 0x59 + }; + copy_block(op_subfmeo_T0_code, 52); + inc_code_ptr(52); +} +#endif + +DEFINE_GEN(gen_op_subfze_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfze_T0 +{ + static const uint8 op_subfze_T0_code[] = { + 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x31, 0xd2, 0x0f, 0xba, 0xe0, + 0x00, 0xf5, 0x19, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, + 0x00, 0x00, 0x89, 0xd3 + }; + copy_block(op_subfze_T0_code, 28); + inc_code_ptr(28); +} +#endif + +DEFINE_GEN(gen_op_subfzeo_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_subfzeo_T0 +{ + static const uint8 op_subfzeo_T0_code[] = { + 0x83, 0xec, 0x04, 0x31, 0xc9, 0x0f, 0xb6, 0x95, 0x96, 0x03, 0x00, 0x00, + 0x89, 0xd0, 0x0f, 0xba, 0xe0, 0x00, 0xf5, 0x19, 0xd9, 0xf5, 0x0f, 0x92, + 0xc0, 0x0f, 0x90, 0xc2, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xcb, + 0x88, 0x95, 0x95, 0x03, 0x00, 0x00, 0x08, 0x95, 0x94, 0x03, 0x00, 0x00, + 0x58 + }; + copy_block(op_subfzeo_T0_code, 49); + inc_code_ptr(49); +} +#endif + +DEFINE_GEN(gen_op_inc_32_mem,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_inc_32_mem +{ + static const uint8 op_inc_32_mem_code[] = { + 0xff, 0x05, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_inc_32_mem_code, 6); + *(uint32_t *)(code_ptr() + 2) = param1 + 0; + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_nego_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_nego_T0 +{ + static const uint8 op_nego_T0_code[] = { + 0x31, 0xd2, 0x81, 0xfb, 0x00, 0x00, 0x00, 0x80, 0x0f, 0x94, 0xc2, 0x08, + 0x95, 0x94, 0x03, 0x00, 0x00, 0xf7, 0xdb, 0x88, 0x95, 0x95, 0x03, 0x00, + 0x00 + }; + copy_block(op_nego_T0_code, 25); + inc_code_ptr(25); +} +#endif + +DEFINE_GEN(gen_op_dcbz_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_dcbz_T0 +{ + static const uint8 op_dcbz_T0_code[] = { + 0x83, 0xe3, 0xe0, 0x31, 0xc9, 0x8d, 0x83, 0x00, 0x00, 0x00, 0x11, 0x89, + 0x8b, 0x00, 0x00, 0x00, 0x11, 0x31, 0xc9, 0x89, 0x8b, 0x04, 0x00, 0x00, + 0x11, 0xc7, 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x40, 0x0c, 0x00, + 0x00, 0x00, 0x00, 0xc7, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x40, + 0x14, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00, + 0xc7, 0x40, 0x1c, 0x00, 0x00, 0x00, 0x00 + }; + copy_block(op_dcbz_T0_code, 67); + inc_code_ptr(67); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_im +{ + static const uint8 op_lmw_T0_im_code[] = { + 0x83, 0xec, 0x04, 0x89, 0xd9, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, + 0x83, 0x3c, 0x24, 0x1f, 0x77, 0x27, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x8d, + 0x54, 0x85, 0x10, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x8b, 0x81, 0x00, 0x00, + 0x00, 0x11, 0x0f, 0xc8, 0xff, 0x04, 0x24, 0x83, 0xc1, 0x04, 0x89, 0x02, + 0x83, 0xc2, 0x04, 0x83, 0x3c, 0x24, 0x1f, 0x76, 0xe7, 0x58 + }; + copy_block(op_lmw_T0_im_code, 58); + *(uint32_t *)(code_ptr() + 8) = param1 + 0; + *(uint32_t *)(code_ptr() + 19) = param1 + 0; + inc_code_ptr(58); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_im,void,(long param1)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_im +{ + static const uint8 op_stmw_T0_im_code[] = { + 0x83, 0xec, 0x04, 0x89, 0xd9, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, + 0x83, 0x3c, 0x24, 0x1f, 0x77, 0x27, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x8d, + 0x54, 0x85, 0x10, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x8b, 0x02, 0x0f, 0xc8, + 0xff, 0x04, 0x24, 0x83, 0xc2, 0x04, 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, + 0x83, 0xc1, 0x04, 0x83, 0x3c, 0x24, 0x1f, 0x76, 0xe7, 0x58 + }; + copy_block(op_stmw_T0_im_code, 58); + *(uint32_t *)(code_ptr() + 8) = param1 + 0; + *(uint32_t *)(code_ptr() + 19) = param1 + 0; + inc_code_ptr(58); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_29 +{ + static const uint8 op_lmw_T0_29_code[] = { + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x84, 0x00, + 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, + 0xc8, 0x89, 0x85, 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, + 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_lmw_T0_29_code, 48); + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_28 +{ + static const uint8 op_lmw_T0_28_code[] = { + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x80, 0x00, + 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, + 0xc8, 0x89, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, + 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x88, 0x00, 0x00, 0x00, + 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, + 0x85, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_lmw_T0_28_code, 65); + inc_code_ptr(65); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_27 +{ + static const uint8 op_lmw_T0_27_code[] = { + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x45, 0x7c, 0x83, + 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, + 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, + 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x88, 0x00, + 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, + 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_lmw_T0_27_code, 79); + inc_code_ptr(79); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_26 +{ + static const uint8 op_lmw_T0_26_code[] = { + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x45, 0x78, 0x83, + 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x45, + 0x7c, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, + 0x89, 0x85, 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, + 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, + 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, + 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, + 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_lmw_T0_26_code, 93); + inc_code_ptr(93); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_30 +{ + static const uint8 op_lmw_T0_30_code[] = { + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x88, 0x00, + 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, + 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00 + }; + copy_block(op_lmw_T0_30_code, 31); + inc_code_ptr(31); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_29 +{ + static const uint8 op_stmw_T0_29_code[] = { + 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, + 0x00, 0x11, 0x8b, 0x85, 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, + 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, + 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_stmw_T0_29_code, 48); + inc_code_ptr(48); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_28 +{ + static const uint8 op_stmw_T0_28_code[] = { + 0x8b, 0x85, 0x80, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, + 0x00, 0x11, 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, + 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x88, 0x00, 0x00, + 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, + 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, + 0x83, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_stmw_T0_28_code, 65); + inc_code_ptr(65); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_27 +{ + static const uint8 op_stmw_T0_27_code[] = { + 0x8b, 0x45, 0x7c, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, + 0x85, 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, + 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, + 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x88, + 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, + 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, + 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_stmw_T0_27_code, 79); + inc_code_ptr(79); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_26 +{ + static const uint8 op_stmw_T0_26_code[] = { + 0x8b, 0x45, 0x78, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, + 0x45, 0x7c, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, + 0x11, 0x8b, 0x85, 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, + 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, + 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, + 0x85, 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, + 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, + 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_stmw_T0_26_code, 93); + inc_code_ptr(93); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_30 +{ + static const uint8 op_stmw_T0_30_code[] = { + 0x8b, 0x85, 0x88, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, + 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, + 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_stmw_T0_30_code, 31); + inc_code_ptr(31); +} +#endif + +DEFINE_GEN(gen_op_lmw_T0_31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_lmw_T0_31 +{ + static const uint8 op_lmw_T0_31_code[] = { + 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x8c, 0x00, + 0x00, 0x00 + }; + copy_block(op_lmw_T0_31_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_stmw_T0_31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_stmw_T0_31 +{ + static const uint8 op_stmw_T0_31_code[] = { + 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, + 0x00, 0x11 + }; + copy_block(op_stmw_T0_31_code, 14); + inc_code_ptr(14); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR0 +{ + static const uint8 op_load_ad_VD_VR0_code[] = { + 0x8d, 0x85, 0x90, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR0_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR0 +{ + static const uint8 op_load_ad_V0_VR0_code[] = { + 0x8d, 0x9d, 0x90, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR0 +{ + static const uint8 op_load_ad_V1_VR0_code[] = { + 0x8d, 0xb5, 0x90, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR0 +{ + static const uint8 op_load_ad_V2_VR0_code[] = { + 0x8d, 0xbd, 0x90, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR0_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR1 +{ + static const uint8 op_load_ad_VD_VR1_code[] = { + 0x8d, 0x85, 0xa0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR1_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR1 +{ + static const uint8 op_load_ad_V0_VR1_code[] = { + 0x8d, 0x9d, 0xa0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR1 +{ + static const uint8 op_load_ad_V1_VR1_code[] = { + 0x8d, 0xb5, 0xa0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR1 +{ + static const uint8 op_load_ad_V2_VR1_code[] = { + 0x8d, 0xbd, 0xa0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR1_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR2 +{ + static const uint8 op_load_ad_VD_VR2_code[] = { + 0x8d, 0x85, 0xb0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR2_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR2 +{ + static const uint8 op_load_ad_V0_VR2_code[] = { + 0x8d, 0x9d, 0xb0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR2_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR2 +{ + static const uint8 op_load_ad_V1_VR2_code[] = { + 0x8d, 0xb5, 0xb0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR2_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR2 +{ + static const uint8 op_load_ad_V2_VR2_code[] = { + 0x8d, 0xbd, 0xb0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR2_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR3 +{ + static const uint8 op_load_ad_VD_VR3_code[] = { + 0x8d, 0x85, 0xc0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR3_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR3 +{ + static const uint8 op_load_ad_V0_VR3_code[] = { + 0x8d, 0x9d, 0xc0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR3_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR3 +{ + static const uint8 op_load_ad_V1_VR3_code[] = { + 0x8d, 0xb5, 0xc0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR3_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR3,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR3 +{ + static const uint8 op_load_ad_V2_VR3_code[] = { + 0x8d, 0xbd, 0xc0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR3_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR4 +{ + static const uint8 op_load_ad_VD_VR4_code[] = { + 0x8d, 0x85, 0xd0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR4_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR4 +{ + static const uint8 op_load_ad_V0_VR4_code[] = { + 0x8d, 0x9d, 0xd0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR4_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR4 +{ + static const uint8 op_load_ad_V1_VR4_code[] = { + 0x8d, 0xb5, 0xd0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR4_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR4,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR4 +{ + static const uint8 op_load_ad_V2_VR4_code[] = { + 0x8d, 0xbd, 0xd0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR4_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR5 +{ + static const uint8 op_load_ad_VD_VR5_code[] = { + 0x8d, 0x85, 0xe0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR5_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR5 +{ + static const uint8 op_load_ad_V0_VR5_code[] = { + 0x8d, 0x9d, 0xe0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR5_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR5 +{ + static const uint8 op_load_ad_V1_VR5_code[] = { + 0x8d, 0xb5, 0xe0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR5_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR5,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR5 +{ + static const uint8 op_load_ad_V2_VR5_code[] = { + 0x8d, 0xbd, 0xe0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR5_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR6 +{ + static const uint8 op_load_ad_VD_VR6_code[] = { + 0x8d, 0x85, 0xf0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR6_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR6 +{ + static const uint8 op_load_ad_V0_VR6_code[] = { + 0x8d, 0x9d, 0xf0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR6_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR6 +{ + static const uint8 op_load_ad_V1_VR6_code[] = { + 0x8d, 0xb5, 0xf0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR6_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR6,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR6 +{ + static const uint8 op_load_ad_V2_VR6_code[] = { + 0x8d, 0xbd, 0xf0, 0x01, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR6_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR7 +{ + static const uint8 op_load_ad_VD_VR7_code[] = { + 0x8d, 0x85, 0x00, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR7_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR7 +{ + static const uint8 op_load_ad_V0_VR7_code[] = { + 0x8d, 0x9d, 0x00, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR7_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR7 +{ + static const uint8 op_load_ad_V1_VR7_code[] = { + 0x8d, 0xb5, 0x00, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR7_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR7,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR7 +{ + static const uint8 op_load_ad_V2_VR7_code[] = { + 0x8d, 0xbd, 0x00, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR7_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR8 +{ + static const uint8 op_load_ad_VD_VR8_code[] = { + 0x8d, 0x85, 0x10, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR8_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR8 +{ + static const uint8 op_load_ad_V0_VR8_code[] = { + 0x8d, 0x9d, 0x10, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR8_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR8 +{ + static const uint8 op_load_ad_V1_VR8_code[] = { + 0x8d, 0xb5, 0x10, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR8_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR8,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR8 +{ + static const uint8 op_load_ad_V2_VR8_code[] = { + 0x8d, 0xbd, 0x10, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR8_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR9 +{ + static const uint8 op_load_ad_VD_VR9_code[] = { + 0x8d, 0x85, 0x20, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR9_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR9 +{ + static const uint8 op_load_ad_V0_VR9_code[] = { + 0x8d, 0x9d, 0x20, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR9_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR9 +{ + static const uint8 op_load_ad_V1_VR9_code[] = { + 0x8d, 0xb5, 0x20, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR9_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR9,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR9 +{ + static const uint8 op_load_ad_V2_VR9_code[] = { + 0x8d, 0xbd, 0x20, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR9_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR10 +{ + static const uint8 op_load_ad_VD_VR10_code[] = { + 0x8d, 0x85, 0x30, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR10_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR10 +{ + static const uint8 op_load_ad_V0_VR10_code[] = { + 0x8d, 0x9d, 0x30, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR10_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR10 +{ + static const uint8 op_load_ad_V1_VR10_code[] = { + 0x8d, 0xb5, 0x30, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR10_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR10,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR10 +{ + static const uint8 op_load_ad_V2_VR10_code[] = { + 0x8d, 0xbd, 0x30, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR10_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR11 +{ + static const uint8 op_load_ad_VD_VR11_code[] = { + 0x8d, 0x85, 0x40, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR11_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR11 +{ + static const uint8 op_load_ad_V0_VR11_code[] = { + 0x8d, 0x9d, 0x40, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR11_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR11 +{ + static const uint8 op_load_ad_V1_VR11_code[] = { + 0x8d, 0xb5, 0x40, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR11_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR11,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR11 +{ + static const uint8 op_load_ad_V2_VR11_code[] = { + 0x8d, 0xbd, 0x40, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR11_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR12 +{ + static const uint8 op_load_ad_VD_VR12_code[] = { + 0x8d, 0x85, 0x50, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR12_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR12 +{ + static const uint8 op_load_ad_V0_VR12_code[] = { + 0x8d, 0x9d, 0x50, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR12_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR12 +{ + static const uint8 op_load_ad_V1_VR12_code[] = { + 0x8d, 0xb5, 0x50, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR12_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR12,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR12 +{ + static const uint8 op_load_ad_V2_VR12_code[] = { + 0x8d, 0xbd, 0x50, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR12_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR13 +{ + static const uint8 op_load_ad_VD_VR13_code[] = { + 0x8d, 0x85, 0x60, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR13_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR13 +{ + static const uint8 op_load_ad_V0_VR13_code[] = { + 0x8d, 0x9d, 0x60, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR13_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR13 +{ + static const uint8 op_load_ad_V1_VR13_code[] = { + 0x8d, 0xb5, 0x60, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR13_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR13,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR13 +{ + static const uint8 op_load_ad_V2_VR13_code[] = { + 0x8d, 0xbd, 0x60, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR13_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR14 +{ + static const uint8 op_load_ad_VD_VR14_code[] = { + 0x8d, 0x85, 0x70, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR14_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR14 +{ + static const uint8 op_load_ad_V0_VR14_code[] = { + 0x8d, 0x9d, 0x70, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR14_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR14 +{ + static const uint8 op_load_ad_V1_VR14_code[] = { + 0x8d, 0xb5, 0x70, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR14_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR14,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR14 +{ + static const uint8 op_load_ad_V2_VR14_code[] = { + 0x8d, 0xbd, 0x70, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR14_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR15 +{ + static const uint8 op_load_ad_VD_VR15_code[] = { + 0x8d, 0x85, 0x80, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR15_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR15 +{ + static const uint8 op_load_ad_V0_VR15_code[] = { + 0x8d, 0x9d, 0x80, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR15_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR15 +{ + static const uint8 op_load_ad_V1_VR15_code[] = { + 0x8d, 0xb5, 0x80, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR15_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR15,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR15 +{ + static const uint8 op_load_ad_V2_VR15_code[] = { + 0x8d, 0xbd, 0x80, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR15_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR16 +{ + static const uint8 op_load_ad_VD_VR16_code[] = { + 0x8d, 0x85, 0x90, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR16_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR16 +{ + static const uint8 op_load_ad_V0_VR16_code[] = { + 0x8d, 0x9d, 0x90, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR16_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR16 +{ + static const uint8 op_load_ad_V1_VR16_code[] = { + 0x8d, 0xb5, 0x90, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR16_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR16,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR16 +{ + static const uint8 op_load_ad_V2_VR16_code[] = { + 0x8d, 0xbd, 0x90, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR16_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR17 +{ + static const uint8 op_load_ad_VD_VR17_code[] = { + 0x8d, 0x85, 0xa0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR17_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR17 +{ + static const uint8 op_load_ad_V0_VR17_code[] = { + 0x8d, 0x9d, 0xa0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR17_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR17 +{ + static const uint8 op_load_ad_V1_VR17_code[] = { + 0x8d, 0xb5, 0xa0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR17_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR17,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR17 +{ + static const uint8 op_load_ad_V2_VR17_code[] = { + 0x8d, 0xbd, 0xa0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR17_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR18 +{ + static const uint8 op_load_ad_VD_VR18_code[] = { + 0x8d, 0x85, 0xb0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR18_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR18 +{ + static const uint8 op_load_ad_V0_VR18_code[] = { + 0x8d, 0x9d, 0xb0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR18_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR18 +{ + static const uint8 op_load_ad_V1_VR18_code[] = { + 0x8d, 0xb5, 0xb0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR18_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR18,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR18 +{ + static const uint8 op_load_ad_V2_VR18_code[] = { + 0x8d, 0xbd, 0xb0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR18_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR19 +{ + static const uint8 op_load_ad_VD_VR19_code[] = { + 0x8d, 0x85, 0xc0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR19_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR19 +{ + static const uint8 op_load_ad_V0_VR19_code[] = { + 0x8d, 0x9d, 0xc0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR19_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR19 +{ + static const uint8 op_load_ad_V1_VR19_code[] = { + 0x8d, 0xb5, 0xc0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR19_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR19,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR19 +{ + static const uint8 op_load_ad_V2_VR19_code[] = { + 0x8d, 0xbd, 0xc0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR19_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR20 +{ + static const uint8 op_load_ad_VD_VR20_code[] = { + 0x8d, 0x85, 0xd0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR20_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR20 +{ + static const uint8 op_load_ad_V0_VR20_code[] = { + 0x8d, 0x9d, 0xd0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR20_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR20 +{ + static const uint8 op_load_ad_V1_VR20_code[] = { + 0x8d, 0xb5, 0xd0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR20_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR20,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR20 +{ + static const uint8 op_load_ad_V2_VR20_code[] = { + 0x8d, 0xbd, 0xd0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR20_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR21 +{ + static const uint8 op_load_ad_VD_VR21_code[] = { + 0x8d, 0x85, 0xe0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR21_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR21 +{ + static const uint8 op_load_ad_V0_VR21_code[] = { + 0x8d, 0x9d, 0xe0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR21_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR21 +{ + static const uint8 op_load_ad_V1_VR21_code[] = { + 0x8d, 0xb5, 0xe0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR21_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR21,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR21 +{ + static const uint8 op_load_ad_V2_VR21_code[] = { + 0x8d, 0xbd, 0xe0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR21_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR22 +{ + static const uint8 op_load_ad_VD_VR22_code[] = { + 0x8d, 0x85, 0xf0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR22_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR22 +{ + static const uint8 op_load_ad_V0_VR22_code[] = { + 0x8d, 0x9d, 0xf0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR22_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR22 +{ + static const uint8 op_load_ad_V1_VR22_code[] = { + 0x8d, 0xb5, 0xf0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR22_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR22,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR22 +{ + static const uint8 op_load_ad_V2_VR22_code[] = { + 0x8d, 0xbd, 0xf0, 0x02, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR22_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR23 +{ + static const uint8 op_load_ad_VD_VR23_code[] = { + 0x8d, 0x85, 0x00, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR23_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR23 +{ + static const uint8 op_load_ad_V0_VR23_code[] = { + 0x8d, 0x9d, 0x00, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR23_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR23 +{ + static const uint8 op_load_ad_V1_VR23_code[] = { + 0x8d, 0xb5, 0x00, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR23_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR23,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR23 +{ + static const uint8 op_load_ad_V2_VR23_code[] = { + 0x8d, 0xbd, 0x00, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR23_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR24 +{ + static const uint8 op_load_ad_VD_VR24_code[] = { + 0x8d, 0x85, 0x10, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR24_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR24 +{ + static const uint8 op_load_ad_V0_VR24_code[] = { + 0x8d, 0x9d, 0x10, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR24_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR24 +{ + static const uint8 op_load_ad_V1_VR24_code[] = { + 0x8d, 0xb5, 0x10, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR24_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR24,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR24 +{ + static const uint8 op_load_ad_V2_VR24_code[] = { + 0x8d, 0xbd, 0x10, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR24_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR25 +{ + static const uint8 op_load_ad_VD_VR25_code[] = { + 0x8d, 0x85, 0x20, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR25_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR25 +{ + static const uint8 op_load_ad_V0_VR25_code[] = { + 0x8d, 0x9d, 0x20, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR25_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR25 +{ + static const uint8 op_load_ad_V1_VR25_code[] = { + 0x8d, 0xb5, 0x20, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR25_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR25,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR25 +{ + static const uint8 op_load_ad_V2_VR25_code[] = { + 0x8d, 0xbd, 0x20, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR25_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR26 +{ + static const uint8 op_load_ad_VD_VR26_code[] = { + 0x8d, 0x85, 0x30, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR26_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR26 +{ + static const uint8 op_load_ad_V0_VR26_code[] = { + 0x8d, 0x9d, 0x30, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR26_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR26 +{ + static const uint8 op_load_ad_V1_VR26_code[] = { + 0x8d, 0xb5, 0x30, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR26_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR26,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR26 +{ + static const uint8 op_load_ad_V2_VR26_code[] = { + 0x8d, 0xbd, 0x30, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR26_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR27 +{ + static const uint8 op_load_ad_VD_VR27_code[] = { + 0x8d, 0x85, 0x40, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR27_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR27 +{ + static const uint8 op_load_ad_V0_VR27_code[] = { + 0x8d, 0x9d, 0x40, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR27_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR27 +{ + static const uint8 op_load_ad_V1_VR27_code[] = { + 0x8d, 0xb5, 0x40, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR27_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR27,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR27 +{ + static const uint8 op_load_ad_V2_VR27_code[] = { + 0x8d, 0xbd, 0x40, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR27_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR28 +{ + static const uint8 op_load_ad_VD_VR28_code[] = { + 0x8d, 0x85, 0x50, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR28_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR28 +{ + static const uint8 op_load_ad_V0_VR28_code[] = { + 0x8d, 0x9d, 0x50, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR28 +{ + static const uint8 op_load_ad_V1_VR28_code[] = { + 0x8d, 0xb5, 0x50, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR28,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR28 +{ + static const uint8 op_load_ad_V2_VR28_code[] = { + 0x8d, 0xbd, 0x50, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR28_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR29 +{ + static const uint8 op_load_ad_VD_VR29_code[] = { + 0x8d, 0x85, 0x60, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR29_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR29 +{ + static const uint8 op_load_ad_V0_VR29_code[] = { + 0x8d, 0x9d, 0x60, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR29 +{ + static const uint8 op_load_ad_V1_VR29_code[] = { + 0x8d, 0xb5, 0x60, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR29,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR29 +{ + static const uint8 op_load_ad_V2_VR29_code[] = { + 0x8d, 0xbd, 0x60, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR29_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR30 +{ + static const uint8 op_load_ad_VD_VR30_code[] = { + 0x8d, 0x85, 0x70, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR30_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR30 +{ + static const uint8 op_load_ad_V0_VR30_code[] = { + 0x8d, 0x9d, 0x70, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR30 +{ + static const uint8 op_load_ad_V1_VR30_code[] = { + 0x8d, 0xb5, 0x70, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR30,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR30 +{ + static const uint8 op_load_ad_V2_VR30_code[] = { + 0x8d, 0xbd, 0x70, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR30_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_VD_VR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_VD_VR31 +{ + static const uint8 op_load_ad_VD_VR31_code[] = { + 0x8d, 0x85, 0x80, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00 + }; + copy_block(op_load_ad_VD_VR31_code, 12); + inc_code_ptr(12); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V0_VR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V0_VR31 +{ + static const uint8 op_load_ad_V0_VR31_code[] = { + 0x8d, 0x9d, 0x80, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V0_VR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V1_VR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V1_VR31 +{ + static const uint8 op_load_ad_V1_VR31_code[] = { + 0x8d, 0xb5, 0x80, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V1_VR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_ad_V2_VR31,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_ad_V2_VR31 +{ + static const uint8 op_load_ad_V2_VR31_code[] = { + 0x8d, 0xbd, 0x80, 0x03, 0x00, 0x00 + }; + copy_block(op_load_ad_V2_VR31_code, 6); + inc_code_ptr(6); +} +#endif + +DEFINE_GEN(gen_op_load_word_VD_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_word_VD_T0 +{ + static const uint8 op_load_word_VD_T0_code[] = { + 0x89, 0xd8, 0x89, 0xda, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0xc1, 0xea, + 0x02, 0x83, 0xe0, 0xfc, 0x83, 0xe2, 0x03, 0x8b, 0x80, 0x00, 0x00, 0x00, + 0x11, 0x0f, 0xc8, 0x89, 0x04, 0x91 + }; + copy_block(op_load_word_VD_T0_code, 30); + inc_code_ptr(30); +} +#endif + +DEFINE_GEN(gen_op_store_word_VD_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_word_VD_T0 +{ + static const uint8 op_store_word_VD_T0_code[] = { + 0x89, 0xd8, 0x8b, 0x95, 0x3c, 0x08, 0x0e, 0x00, 0x89, 0xd9, 0xc1, 0xe8, + 0x02, 0x83, 0xe1, 0xfc, 0x83, 0xe0, 0x03, 0x8b, 0x04, 0x82, 0x0f, 0xc8, + 0x89, 0x81, 0x00, 0x00, 0x00, 0x11 + }; + copy_block(op_store_word_VD_T0_code, 30); + inc_code_ptr(30); +} +#endif + +DEFINE_GEN(gen_op_load_vect_VD_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_load_vect_VD_T0 +{ + static const uint8 op_load_vect_VD_T0_code[] = { + 0x89, 0xda, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x83, 0xe2, 0xf0, 0x8b, + 0x82, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x01, 0x8b, 0x8d, 0x3c, + 0x08, 0x0e, 0x00, 0x8b, 0x82, 0x04, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, + 0x41, 0x04, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x8b, 0x82, 0x08, 0x00, + 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x41, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, + 0x00, 0x8b, 0x82, 0x0c, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x41, 0x0c + }; + copy_block(op_load_vect_VD_T0_code, 72); + inc_code_ptr(72); +} +#endif + +DEFINE_GEN(gen_op_store_vect_VD_T0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_vect_VD_T0 +{ + static const uint8 op_store_vect_VD_T0_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x89, 0xda, 0x83, 0xe2, 0xf0, 0x8b, + 0x00, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x3c, + 0x08, 0x0e, 0x00, 0x8b, 0x40, 0x04, 0x0f, 0xc8, 0x89, 0x82, 0x04, 0x00, + 0x00, 0x11, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x8b, 0x40, 0x08, 0x0f, + 0xc8, 0x89, 0x82, 0x08, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x3c, 0x08, 0x0e, + 0x00, 0x8b, 0x40, 0x0c, 0x0f, 0xc8, 0x89, 0x82, 0x0c, 0x00, 0x00, 0x11 + }; + copy_block(op_store_vect_VD_T0_code, 72); + inc_code_ptr(72); +} +#endif + +DEFINE_GEN(gen_op_record_cr6_VD,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_record_cr6_VD +{ + static const uint8 op_record_cr6_VD_code[] = { + 0x83, 0xec, 0x04, 0x8b, 0x95, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x04, 0x24, + 0x00, 0x00, 0x00, 0x00, 0x8b, 0x0a, 0x8b, 0x42, 0x04, 0x21, 0xc8, 0x8b, + 0x4a, 0x08, 0x21, 0xc8, 0x23, 0x42, 0x0c, 0x8d, 0x8d, 0x3c, 0x08, 0x0e, + 0x00, 0x40, 0x75, 0x09, 0xc7, 0x04, 0x24, 0x08, 0x00, 0x00, 0x00, 0xeb, + 0x1f, 0x8b, 0x11, 0x8b, 0x0a, 0x8b, 0x42, 0x04, 0x09, 0xc8, 0x8b, 0x4a, + 0x08, 0x09, 0xc8, 0x0b, 0x42, 0x0c, 0x75, 0x0c, 0xc7, 0x04, 0x24, 0x02, + 0x00, 0x00, 0x00, 0x90, 0x8d, 0x74, 0x26, 0x00, 0xc1, 0x24, 0x24, 0x04, + 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x8b, 0x0c, 0x24, 0x25, 0x0f, 0xff, + 0xff, 0xff, 0x09, 0xc8, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00, 0x58 + }; + copy_block(op_record_cr6_VD_code, 107); + inc_code_ptr(107); +} +#endif + +DEFINE_GEN(gen_op_mfvscr_VD,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mfvscr_VD +{ + static const uint8 op_mfvscr_VD_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, + 0x00, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x40, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x8b, 0x95, 0x3c, 0x08, 0x0e, 0x00, 0x8b, 0x85, 0x98, 0x03, + 0x00, 0x00, 0x89, 0x42, 0x0c + }; + copy_block(op_mfvscr_VD_code, 53); + inc_code_ptr(53); +} +#endif + +DEFINE_GEN(gen_op_mtvscr_V0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mtvscr_V0 +{ + static const uint8 op_mtvscr_V0_code[] = { + 0x8b, 0x43, 0x0c, 0x89, 0x85, 0x98, 0x03, 0x00, 0x00 + }; + copy_block(op_mtvscr_V0_code, 9); + inc_code_ptr(9); +} +#endif + +DEFINE_GEN(gen_op_emms,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_emms +{ + static const uint8 op_emms_code[] = { + 0x0f, 0x77 + }; + copy_block(op_emms_code, 2); + inc_code_ptr(2); +} +#endif + +DEFINE_GEN(gen_op_mmx_vcmpequb,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vcmpequb +{ + static const uint8 op_mmx_vcmpequb_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0x74, 0x06, 0x0f, 0x74, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vcmpequb_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vcmpequh,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vcmpequh +{ + static const uint8 op_mmx_vcmpequh_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0x75, 0x06, 0x0f, 0x75, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vcmpequh_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vcmpequw,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vcmpequw +{ + static const uint8 op_mmx_vcmpequw_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0x76, 0x06, 0x0f, 0x76, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vcmpequw_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vcmpgtsb,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vcmpgtsb +{ + static const uint8 op_mmx_vcmpgtsb_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0x64, 0x06, 0x0f, 0x64, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vcmpgtsb_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vcmpgtsh,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vcmpgtsh +{ + static const uint8 op_mmx_vcmpgtsh_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0x65, 0x06, 0x0f, 0x65, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vcmpgtsh_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vcmpgtsw,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vcmpgtsw +{ + static const uint8 op_mmx_vcmpgtsw_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0x66, 0x06, 0x0f, 0x66, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vcmpgtsw_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vaddubm,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vaddubm +{ + static const uint8 op_mmx_vaddubm_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xfc, 0x06, 0x0f, 0xfc, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vaddubm_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vadduhm,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vadduhm +{ + static const uint8 op_mmx_vadduhm_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xfd, 0x06, 0x0f, 0xfd, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vadduhm_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vadduwm,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vadduwm +{ + static const uint8 op_mmx_vadduwm_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xfe, 0x06, 0x0f, 0xfe, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vadduwm_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vsububm,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vsububm +{ + static const uint8 op_mmx_vsububm_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xf8, 0x06, 0x0f, 0xf8, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vsububm_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vsubuhm,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vsubuhm +{ + static const uint8 op_mmx_vsubuhm_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xf9, 0x06, 0x0f, 0xf9, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vsubuhm_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vsubuwm,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vsubuwm +{ + static const uint8 op_mmx_vsubuwm_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xfa, 0x06, 0x0f, 0xfa, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vsubuwm_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vand,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vand +{ + static const uint8 op_mmx_vand_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xdb, 0x06, 0x0f, 0xdb, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vand_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vandc,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vandc +{ + static const uint8 op_mmx_vandc_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x06, 0x0f, 0x6f, 0x4e, + 0x08, 0x0f, 0xdf, 0x03, 0x0f, 0xdf, 0x4b, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vandc_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vor,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vor +{ + static const uint8 op_mmx_vor_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xeb, 0x06, 0x0f, 0xeb, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vor_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vxor,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vxor +{ + static const uint8 op_mmx_vxor_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xef, 0x06, 0x0f, 0xef, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vxor_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vmaxub,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vmaxub +{ + static const uint8 op_mmx_vmaxub_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xde, 0x06, 0x0f, 0xde, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vmaxub_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vminub,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vminub +{ + static const uint8 op_mmx_vminub_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xda, 0x06, 0x0f, 0xda, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vminub_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vmaxsh,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vmaxsh +{ + static const uint8 op_mmx_vmaxsh_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xee, 0x06, 0x0f, 0xee, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vmaxsh_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_mmx_vminsh,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_mmx_vminsh +{ + static const uint8 op_mmx_vminsh_code[] = { + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b, + 0x08, 0x0f, 0xea, 0x06, 0x0f, 0xea, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f, + 0x7f, 0x48, 0x08 + }; + copy_block(op_mmx_vminsh_code, 27); + inc_code_ptr(27); +} +#endif + +DEFINE_GEN(gen_op_store_T0_XER,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_store_T0_XER +{ + static const uint8 op_store_T0_XER_code[] = { + 0x83, 0xec, 0x04, 0x8d, 0x85, 0x94, 0x03, 0x00, 0x00, 0x89, 0xda, 0x89, + 0x04, 0x24, 0x89, 0xd8, 0xc1, 0xe8, 0x1f, 0x88, 0x85, 0x94, 0x03, 0x00, + 0x00, 0x8b, 0x0c, 0x24, 0x89, 0xd8, 0xc1, 0xe8, 0x1e, 0x83, 0xe2, 0x7f, + 0x83, 0xe0, 0x01, 0x88, 0x41, 0x01, 0x89, 0xd8, 0xc1, 0xe8, 0x1d, 0x88, + 0x51, 0x03, 0x83, 0xe0, 0x01, 0x88, 0x41, 0x02, 0x58 + }; + copy_block(op_store_T0_XER_code, 57); + inc_code_ptr(57); +} +#endif + +DEFINE_GEN(gen_op_jump_next_A0,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_jump_next_A0 +{ + static const uint8 op_jump_next_A0_code[] = { + 0x8b, 0x95, 0xac, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x39, 0x13, 0x74, 0x24, + 0x89, 0xd0, 0xc1, 0xe8, 0x02, 0x25, 0xff, 0x7f, 0x00, 0x00, 0x8b, 0x84, + 0x85, 0xfc, 0x07, 0x0c, 0x00, 0x85, 0xc0, 0x74, 0x04, 0x39, 0x10, 0x74, + 0x02, 0x31, 0xc0, 0x85, 0xc0, 0x74, 0x08, 0x90, 0x8d, 0x74, 0x26, 0x00, + 0xff, 0x60, 0x40 + }; + copy_block(op_jump_next_A0_code, 51); + inc_code_ptr(51); +} +#endif + +DEFINE_GEN(gen_op_vand_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vand_VD_V0_V1 +{ + static const uint8 op_vand_VD_V0_V1_code[] = { + 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x21, 0xd0, + 0x8b, 0x53, 0x04, 0x23, 0x56, 0x04, 0x89, 0x01, 0x89, 0x51, 0x04, 0x8b, + 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x21, + 0xd0, 0x8b, 0x53, 0x0c, 0x23, 0x56, 0x0c, 0x89, 0x41, 0x08, 0x89, 0x51, + 0x0c + }; + copy_block(op_vand_VD_V0_V1_code, 49); + inc_code_ptr(49); +} +#endif + +DEFINE_GEN(gen_op_vandc_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vandc_VD_V0_V1 +{ + static const uint8 op_vandc_VD_V0_V1_code[] = { + 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0xf7, + 0xd0, 0xf7, 0xd2, 0x23, 0x03, 0x23, 0x53, 0x04, 0x89, 0x01, 0x89, 0x51, + 0x04, 0x8b, 0x46, 0x08, 0x8b, 0x56, 0x0c, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, + 0x00, 0xf7, 0xd0, 0xf7, 0xd2, 0x23, 0x43, 0x08, 0x23, 0x53, 0x0c, 0x89, + 0x41, 0x08, 0x89, 0x51, 0x0c + }; + copy_block(op_vandc_VD_V0_V1_code, 53); + inc_code_ptr(53); +} +#endif + +DEFINE_GEN(gen_op_vnor_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vnor_VD_V0_V1 +{ + static const uint8 op_vnor_VD_V0_V1_code[] = { + 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x09, 0xd0, + 0x8b, 0x53, 0x04, 0xf7, 0xd0, 0x0b, 0x56, 0x04, 0x89, 0x01, 0xf7, 0xd2, + 0x89, 0x51, 0x04, 0x8b, 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, + 0x08, 0x0e, 0x00, 0x09, 0xd0, 0x8b, 0x53, 0x0c, 0x0b, 0x56, 0x0c, 0xf7, + 0xd0, 0x89, 0x41, 0x08, 0xf7, 0xd2, 0x89, 0x51, 0x0c + }; + copy_block(op_vnor_VD_V0_V1_code, 57); + inc_code_ptr(57); +} +#endif + +DEFINE_GEN(gen_op_vor_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vor_VD_V0_V1 +{ + static const uint8 op_vor_VD_V0_V1_code[] = { + 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x09, 0xd0, + 0x8b, 0x53, 0x04, 0x0b, 0x56, 0x04, 0x89, 0x01, 0x89, 0x51, 0x04, 0x8b, + 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x09, + 0xd0, 0x8b, 0x53, 0x0c, 0x0b, 0x56, 0x0c, 0x89, 0x41, 0x08, 0x89, 0x51, + 0x0c + }; + copy_block(op_vor_VD_V0_V1_code, 49); + inc_code_ptr(49); +} +#endif + +DEFINE_GEN(gen_op_vxor_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vxor_VD_V0_V1 +{ + static const uint8 op_vxor_VD_V0_V1_code[] = { + 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x31, 0xd0, + 0x8b, 0x53, 0x04, 0x33, 0x56, 0x04, 0x89, 0x01, 0x89, 0x51, 0x04, 0x8b, + 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x31, + 0xd0, 0x8b, 0x53, 0x0c, 0x33, 0x56, 0x0c, 0x89, 0x41, 0x08, 0x89, 0x51, + 0x0c + }; + copy_block(op_vxor_VD_V0_V1_code, 49); + inc_code_ptr(49); +} +#endif + +DEFINE_GEN(gen_op_vaddfp_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vaddfp_VD_V0_V1 +{ + static const uint8 op_vaddfp_VD_V0_V1_code[] = { + 0xd9, 0x06, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x03, 0xd9, 0x18, + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x04, 0xd8, 0x43, 0x04, + 0xd9, 0x58, 0x04, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x08, + 0xd8, 0x43, 0x08, 0xd9, 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, + 0xd9, 0x46, 0x0c, 0xd8, 0x43, 0x0c, 0xd9, 0x58, 0x0c + }; + copy_block(op_vaddfp_VD_V0_V1_code, 57); + inc_code_ptr(57); +} +#endif + +DEFINE_GEN(gen_op_vsubfp_VD_V0_V1,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vsubfp_VD_V0_V1 +{ + static const uint8 op_vsubfp_VD_V0_V1_code[] = { + 0xd9, 0x06, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x2b, 0xd9, 0x18, + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x04, 0xd8, 0x6b, 0x04, + 0xd9, 0x58, 0x04, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x08, + 0xd8, 0x6b, 0x08, 0xd9, 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, + 0xd9, 0x46, 0x0c, 0xd8, 0x6b, 0x0c, 0xd9, 0x58, 0x0c + }; + copy_block(op_vsubfp_VD_V0_V1_code, 57); + inc_code_ptr(57); +} +#endif + +DEFINE_GEN(gen_op_vmaddfp_VD_V0_V1_V2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vmaddfp_VD_V0_V1_V2 +{ + static const uint8 op_vmaddfp_VD_V0_V1_V2_code[] = { + 0xd9, 0x07, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x0b, 0xd8, 0x06, + 0xd9, 0x18, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, 0x04, 0xd8, + 0x4b, 0x04, 0xd8, 0x46, 0x04, 0xd9, 0x58, 0x04, 0x8b, 0x85, 0x3c, 0x08, + 0x0e, 0x00, 0xd9, 0x47, 0x08, 0xd8, 0x4b, 0x08, 0xd8, 0x46, 0x08, 0xd9, + 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, 0x0c, 0xd8, + 0x4b, 0x0c, 0xd8, 0x46, 0x0c, 0xd9, 0x58, 0x0c + }; + copy_block(op_vmaddfp_VD_V0_V1_V2_code, 68); + inc_code_ptr(68); +} +#endif + +DEFINE_GEN(gen_op_vnmsubfp_VD_V0_V1_V2,void,(void)) +#ifdef DYNGEN_IMPL +#define HAVE_gen_op_vnmsubfp_VD_V0_V1_V2 +{ + static const uint8 op_vnmsubfp_VD_V0_V1_V2_code[] = { + 0xd9, 0x07, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x0b, 0xd8, 0x26, + 0xd9, 0xe0, 0xd9, 0x18, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, + 0x04, 0xd8, 0x4b, 0x04, 0xd8, 0x66, 0x04, 0xd9, 0xe0, 0xd9, 0x58, 0x04, + 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, 0x08, 0xd8, 0x4b, 0x08, + 0xd8, 0x66, 0x08, 0xd9, 0xe0, 0xd9, 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, + 0x0e, 0x00, 0xd9, 0x47, 0x0c, 0xd8, 0x4b, 0x0c, 0xd8, 0x66, 0x0c, 0xd9, + 0xe0, 0xd9, 0x58, 0x0c + }; + copy_block(op_vnmsubfp_VD_V0_V1_V2_code, 76); + inc_code_ptr(76); +} +#endif + +#undef DEFINE_CST +#undef DEFINE_GEN From d936e9938d79cc1bac7e4154bb942443dab4a1a1 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 17:45:38 -0700 Subject: [PATCH 06/10] SS: Fix JIT on minwg32 - add wrappers with default calling convention for powerpc_cpu member functions used through nv_mem_fun ptr() ** explicit wrappers for member functions that were used explicitly ** dynamic wrapper generator in nv_mem_fun1_t for member functions used dynamically via the instruction table - add missing direct addressing (non-zero constant offset to Mac memory) support in lvx and stvx implementations - fix mismatched parameter lists between powerpc_jit member functions and the calls they get through the jit_info table to fix problems at -O2 --- SheepShaver/src/kpx_cpu/include/nvmemfun.hpp | 118 +++++++++++++++++- SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp | 25 +++- .../src/kpx_cpu/src/cpu/ppc/ppc-cpu.cpp | 17 ++- .../src/kpx_cpu/src/cpu/ppc/ppc-cpu.hpp | 4 + .../src/kpx_cpu/src/cpu/ppc/ppc-jit.cpp | 43 ++++--- .../src/kpx_cpu/src/cpu/ppc/ppc-jit.hpp | 6 +- .../src/kpx_cpu/src/cpu/ppc/ppc-translate.cpp | 37 +++++- 7 files changed, 218 insertions(+), 32 deletions(-) diff --git a/SheepShaver/src/kpx_cpu/include/nvmemfun.hpp b/SheepShaver/src/kpx_cpu/include/nvmemfun.hpp index 830b8ecd..e5df5dab 100644 --- a/SheepShaver/src/kpx_cpu/include/nvmemfun.hpp +++ b/SheepShaver/src/kpx_cpu/include/nvmemfun.hpp @@ -23,6 +23,10 @@ #include +#ifdef __MINGW32__ +#include "vm_alloc.h" +#endif + #if defined __GNUC__ #define HAVE_FAST_NV_MEM_FUN 1 #define MEM_FUN_WORDS 2 @@ -91,11 +95,123 @@ template< class R, class T, class A > class nv_mem_fun1_t : public std::binary_function { typedef R (T::*pmf_t)(A); typedef R (* PF_CONVENTION pf_t)(T *, A x); +#ifdef __MINGW32__ + typedef R (* default_call_conv_pf_t)(T *, A x); +#endif pf_t pf; public: - nv_mem_fun1_t(pmf_t pmf) : pf(nv_mem_fun_of(pmf)) {} + nv_mem_fun1_t(pmf_t pmf) : pf(nv_mem_fun_of(pmf)) { + #ifdef __MINGW32__ + init_func(); + #endif + } R operator()(T *p, A x) const { return (*pf)(p, x); } + + #ifdef __MINGW32__ + + #define NVMEMFUN_THUNK_DEBUG 0 + +private: + #define DO_CONVENTION_CALL_PF_PLACEHOLDER 0x12345678 + + #define DO_CONVENTION_CALL_STATICS + static bool do_convention_call_init_done; + static int do_convention_call_code_len; + static int do_convention_call_pf_offset; + unsigned char * do_convention_call_instance_copy; + + static void init_do_convention_call() { + if (do_convention_call_init_done) return; + + const int max_code_bytes = 100; + const unsigned char last_code_byte_value = 0xc3; + + // figure out the size of the function + unsigned char * func_pos = (unsigned char *) &do_convention_call; + int i; + for (i = 0; i < max_code_bytes; i++) { + if (func_pos[i] == last_code_byte_value) { + break; + } + } + do_convention_call_code_len = i + 1; + + #if NVMEMFUN_THUNK_DEBUG + printf("do_convention_call func size %d ", do_convention_call_code_len); + #endif + + // find the position of the pf placeholder in the function + int placeholder_matches = 0; + for (i = 0; i < do_convention_call_code_len - 3; i++) { + pf_t * cur_ptr = (pf_t*)(func_pos + i); + if (*cur_ptr == (pf_t) DO_CONVENTION_CALL_PF_PLACEHOLDER) { + do_convention_call_pf_offset = i; + #if NVMEMFUN_THUNK_DEBUG + printf("ptr pos offset %x", (uint32)cur_ptr - (uint32)func_pos); + #endif + ++placeholder_matches; + } + } + + #if NVMEMFUN_THUNK_DEBUG + printf("\n"); + fflush(stdout); + #endif + + assert(placeholder_matches == 1); + + do_convention_call_init_done = true; + } + + void init_func() { + if (!do_convention_call_init_done) { + init_do_convention_call(); + } + + // copy do_convention_call and patch in the address of pf + + do_convention_call_instance_copy = (unsigned char *) vm_acquire(do_convention_call_code_len); + // Thunk buffer needs to be around while default_call_conv_ptr() is still in use, + // longer than nv_mem_fun1_t lifetime + //FIXME track the lifetime of this + if (do_convention_call_instance_copy == NULL) return; + unsigned char * func_pos = (unsigned char *) &do_convention_call; + memcpy((void *)do_convention_call_instance_copy, func_pos, do_convention_call_code_len); + + // replace byte sequence in buf copy + *(pf_t*)(do_convention_call_instance_copy + do_convention_call_pf_offset) = pf; + + #if NVMEMFUN_THUNK_DEBUG + printf("patching do_convention_call to %x; func size %d ", do_convention_call_instance_copy, do_convention_call_code_len); + for (int i = 0 ; i < do_convention_call_code_len; i ++) { + printf("%02x ", do_convention_call_instance_copy[i]); + } + printf("\n"); + fflush(stdout); + #endif + + vm_protect(do_convention_call_instance_copy, do_convention_call_code_len, VM_PAGE_READ | VM_PAGE_EXECUTE); + } + + // Cheesy thunk solution to adapt the calling convention: + // do_convention_call accepts the default calling convention and calls pf with PF_CONVENTION + // Each instance makes its own copy of do_convention_call in a buffer and patches the address of pf into it + static R do_convention_call(T * obj, A x) { + pf_t fn = (pf_t) DO_CONVENTION_CALL_PF_PLACEHOLDER; + return (*fn)(obj, x); + } + +public: + + default_call_conv_pf_t default_call_conv_ptr() const { return (default_call_conv_pf_t) do_convention_call_instance_copy; } + + #else + pf_t ptr() const { return pf; } + + #endif + + }; template< class R, class T, class A > diff --git a/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp b/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp index 4f1910b2..9b6d8794 100755 --- a/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp +++ b/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp @@ -151,9 +151,11 @@ public: // Execute NATIVE_OP routine void execute_native_op(uint32 native_op); + static void call_execute_native_op(powerpc_cpu * cpu, uint32 native_op); // Execute EMUL_OP routine void execute_emul_op(uint32 emul_op); + static void call_execute_emul_op(powerpc_cpu * cpu, uint32 emul_op); // Execute 68k routine void execute_68k(uint32 entry, M68kRegisters *r); @@ -170,6 +172,7 @@ public: #endif // Resource manager thunk void get_resource(uint32 old_get_resource); + static void call_get_resource(powerpc_cpu * cpu, uint32 old_get_resource); // Handle MacOS interrupt void interrupt(uint32 entry); @@ -218,6 +221,10 @@ typedef bit_field< 19, 19 > FN_field; typedef bit_field< 20, 25 > NATIVE_OP_field; typedef bit_field< 26, 31 > EMUL_OP_field; +void sheepshaver_cpu::call_execute_emul_op(powerpc_cpu * cpu, uint32 emul_op) { + static_cast(cpu)->execute_emul_op(emul_op); +} + // Execute EMUL_OP routine void sheepshaver_cpu::execute_emul_op(uint32 emul_op) { @@ -332,7 +339,7 @@ int sheepshaver_cpu::compile1(codegen_context_t & cg_context) }; uint32 old_get_resource = ReadMacInt32(get_resource_ptr[selector - NATIVE_GET_RESOURCE]); typedef void (*func_t)(dyngen_cpu_base, uint32); - func_t func = (func_t)nv_mem_fun(&sheepshaver_cpu::get_resource).ptr(); + func_t func = &sheepshaver_cpu::call_get_resource; dg.gen_invoke_CPU_im(func, old_get_resource); status = COMPILE_CODE_OK; break; @@ -421,7 +428,7 @@ int sheepshaver_cpu::compile1(codegen_context_t & cg_context) // Invoke NativeOp handler if (!FN_field::test(opcode)) { typedef void (*func_t)(dyngen_cpu_base, uint32); - func_t func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_native_op).ptr(); + func_t func = &sheepshaver_cpu::call_execute_native_op; dg.gen_invoke_CPU_im(func, selector); cg_context.done_compile = false; status = COMPILE_CODE_OK; @@ -445,7 +452,7 @@ int sheepshaver_cpu::compile1(codegen_context_t & cg_context) #else // Invoke EmulOp handler typedef void (*func_t)(dyngen_cpu_base, uint32); - func_t func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op).ptr(); + func_t func = &sheepshaver_cpu::call_execute_emul_op; dg.gen_invoke_CPU_im(func, emul_op); cg_context.done_compile = false; status = COMPILE_CODE_OK; @@ -685,6 +692,10 @@ inline void sheepshaver_cpu::execute_ppc(uint32 entry) lr() = saved_lr; } +void sheepshaver_cpu::call_get_resource(powerpc_cpu * cpu, uint32 old_get_resource) { + static_cast(cpu)->get_resource(old_get_resource); +} + // Resource Manager thunk inline void sheepshaver_cpu::get_resource(uint32 old_get_resource) { @@ -897,14 +908,14 @@ void init_emul_op_trampolines(basic_dyngen & dg) // EmulOp emul_op_trampoline = dg.gen_start(); - func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op).ptr(); + func = &sheepshaver_cpu::call_execute_emul_op; dg.gen_invoke_CPU_T0(func); dg.gen_exec_return(); dg.gen_end(); // NativeOp native_op_trampoline = dg.gen_start(); - func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_native_op).ptr(); + func = &sheepshaver_cpu::call_execute_native_op; dg.gen_invoke_CPU_T0(func); dg.gen_exec_return(); dg.gen_end(); @@ -1030,6 +1041,10 @@ void HandleInterrupt(powerpc_registers *r) } } +void sheepshaver_cpu::call_execute_native_op(powerpc_cpu * cpu, uint32 selector) { + static_cast(cpu)->execute_native_op(selector); +} + // Execute NATIVE_OP routine void sheepshaver_cpu::execute_native_op(uint32 selector) { diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.cpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.cpp index 4654a86a..eefa1f95 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.cpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.cpp @@ -64,6 +64,12 @@ int register_info_compare(const void *e1, const void *e2) static int ppc_refcount = 0; +#ifdef DO_CONVENTION_CALL_STATICS +template<> bool nv_mem_fun1_t::do_convention_call_init_done = false; +template<> int nv_mem_fun1_t::do_convention_call_code_len = 0; +template<> int nv_mem_fun1_t::do_convention_call_pf_offset = 0; +#endif + void powerpc_cpu::set_register(int id, any_register const & value) { if (id >= powerpc_registers::GPR(0) && id <= powerpc_registers::GPR(31)) { @@ -542,7 +548,12 @@ bool powerpc_cpu::check_spcflags() } #if DYNGEN_DIRECT_BLOCK_CHAINING -void *powerpc_cpu::compile_chain_block(block_info *sbi) +void * powerpc_cpu::call_compile_chain_block(powerpc_cpu * the_cpu, block_info *sbi) +{ + return the_cpu->compile_chain_block(sbi); +} + +void * PF_CONVENTION powerpc_cpu::compile_chain_block(block_info *sbi) { // Block index is stuffed into the source basic block pointer, // which is aligned at least on 4-byte boundaries @@ -719,7 +730,11 @@ void powerpc_cpu::execute(uint32 entry) if (is_logging()) record_step(opcode); #endif +#ifdef __MINGW32__ + assert(ii->execute.default_call_conv_ptr() != 0); +#else assert(ii->execute.ptr() != 0); +#endif ii->execute(this, opcode); #if PPC_EXECUTE_DUMP_STATE if (dump_state) diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.hpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.hpp index c418386e..f1739a5f 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.hpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-cpu.hpp @@ -371,8 +371,10 @@ private: friend class powerpc_jit; powerpc_jit codegen; block_info *compile_block(uint32 entry); + static void call_do_record_step(powerpc_cpu * cpu, uint32 pc, uint32 opcode); #if DYNGEN_DIRECT_BLOCK_CHAINING void *compile_chain_block(block_info *sbi); + static void * call_compile_chain_block(powerpc_cpu * the_cpu, block_info *sbi); #endif #endif @@ -389,6 +391,7 @@ private: // Instruction handlers void execute_nop(uint32 opcode); void execute_illegal(uint32 opcode); + static void call_execute_illegal(powerpc_cpu * cpu, uint32 opcode); template< class RA, class RB, class RC, class CA, class OE, class Rc > void execute_addition(uint32 opcode); template< class OP, class RD, class RA, class RB, class RC, class OE, class Rc > @@ -453,6 +456,7 @@ private: void execute_icbi(uint32 opcode); void execute_isync(uint32 opcode); void execute_invalidate_cache_range(); + static void call_execute_invalidate_cache_range(powerpc_cpu * cpu); template< class RA, class RB > void execute_dcbz(uint32 opcode); template< bool SL > diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.cpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.cpp index 4b294401..57163a5b 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.cpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.cpp @@ -36,6 +36,11 @@ powerpc_jit::powerpc_jit(dyngen_cpu_base cpu) { } +// An operand that refers to an address relative to the emulated machine +static x86_memory_operand vm_memory_operand(int32 d, int b, int i = X86_NOREG, int s = 1) { + return x86_memory_operand(d + VMBaseDiff, b, i, s); +} + bool powerpc_jit::initialize(void) { if (!powerpc_dyngen::initialize()) @@ -239,21 +244,25 @@ bool powerpc_jit::initialize(void) // Dispatch mid-level code generators bool powerpc_jit::gen_vector_1(int mnemo, int vD) { + if (jit_info[mnemo]->handler == (gen_handler_t)&powerpc_jit::gen_not_available) return false; return (this->*((bool (powerpc_jit::*)(int, int))jit_info[mnemo]->handler))(mnemo, vD); } bool powerpc_jit::gen_vector_2(int mnemo, int vD, int vA, int vB) { + if (jit_info[mnemo]->handler == (gen_handler_t)&powerpc_jit::gen_not_available) return false; return (this->*((bool (powerpc_jit::*)(int, int, int, int))jit_info[mnemo]->handler))(mnemo, vD, vA, vB); } bool powerpc_jit::gen_vector_3(int mnemo, int vD, int vA, int vB, int vC) { + if (jit_info[mnemo]->handler == (gen_handler_t)&powerpc_jit::gen_not_available) return false; return (this->*((bool (powerpc_jit::*)(int, int, int, int, int))jit_info[mnemo]->handler))(mnemo, vD, vA, vB, vC); } bool powerpc_jit::gen_vector_compare(int mnemo, int vD, int vA, int vB, bool Rc) { + if (jit_info[mnemo]->handler == (gen_handler_t)&powerpc_jit::gen_not_available) return false; return (this->*((bool (powerpc_jit::*)(int, int, int, int, bool))jit_info[mnemo]->handler))(mnemo, vD, vA, vB, Rc); } @@ -395,8 +404,8 @@ bool powerpc_jit::gen_x86_lvx(int mnemo, int vD, int rA, int rB) gen_add_32(x86_memory_operand(xPPC_GPR(rA), REG_CPU_ID), REG_T0_ID); gen_and_32(x86_immediate_operand(-16), REG_T0_ID); #if SIZEOF_VOID_P == 8 - gen_mov_64(x86_memory_operand(0, REG_T0_ID), REG_T1_ID); - gen_mov_64(x86_memory_operand(8, REG_T0_ID), REG_T2_ID); + gen_mov_64(vm_memory_operand(0, REG_T0_ID), REG_T1_ID); + gen_mov_64(vm_memory_operand(8, REG_T0_ID), REG_T2_ID); gen_bswap_64(REG_T1_ID); gen_bswap_64(REG_T2_ID); gen_rol_64(x86_immediate_operand(32), REG_T1_ID); @@ -404,14 +413,14 @@ bool powerpc_jit::gen_x86_lvx(int mnemo, int vD, int rA, int rB) gen_mov_64(REG_T1_ID, x86_memory_operand(xPPC_VR(vD) + 0, REG_CPU_ID)); gen_mov_64(REG_T2_ID, x86_memory_operand(xPPC_VR(vD) + 8, REG_CPU_ID)); #else - gen_mov_32(x86_memory_operand(0*4, REG_T0_ID), REG_T1_ID); - gen_mov_32(x86_memory_operand(1*4, REG_T0_ID), REG_T2_ID); + gen_mov_32(vm_memory_operand(0*4, REG_T0_ID), REG_T1_ID); + gen_mov_32(vm_memory_operand(1*4, REG_T0_ID), REG_T2_ID); gen_bswap_32(REG_T1_ID); gen_bswap_32(REG_T2_ID); gen_mov_32(REG_T1_ID, x86_memory_operand(xPPC_VR(vD) + 0*4, REG_CPU_ID)); gen_mov_32(REG_T2_ID, x86_memory_operand(xPPC_VR(vD) + 1*4, REG_CPU_ID)); - gen_mov_32(x86_memory_operand(2*4, REG_T0_ID), REG_T1_ID); - gen_mov_32(x86_memory_operand(3*4, REG_T0_ID), REG_T2_ID); + gen_mov_32(vm_memory_operand(2*4, REG_T0_ID), REG_T1_ID); + gen_mov_32(vm_memory_operand(3*4, REG_T0_ID), REG_T2_ID); gen_bswap_32(REG_T1_ID); gen_bswap_32(REG_T2_ID); gen_mov_32(REG_T1_ID, x86_memory_operand(xPPC_VR(vD) + 2*4, REG_CPU_ID)); @@ -435,8 +444,8 @@ bool powerpc_jit::gen_x86_stvx(int mnemo, int vS, int rA, int rB) gen_and_32(x86_immediate_operand(-16), REG_T0_ID); gen_rol_64(x86_immediate_operand(32), REG_T1_ID); gen_rol_64(x86_immediate_operand(32), REG_T2_ID); - gen_mov_64(REG_T1_ID, x86_memory_operand(0, REG_T0_ID)); - gen_mov_64(REG_T2_ID, x86_memory_operand(8, REG_T0_ID)); + gen_mov_64(REG_T1_ID, vm_memory_operand(0, REG_T0_ID)); + gen_mov_64(REG_T2_ID, vm_memory_operand(8, REG_T0_ID)); #else gen_mov_32(x86_memory_operand(xPPC_VR(vS) + 0*4, REG_CPU_ID), REG_T1_ID); gen_mov_32(x86_memory_operand(xPPC_VR(vS) + 1*4, REG_CPU_ID), REG_T2_ID); @@ -445,14 +454,14 @@ bool powerpc_jit::gen_x86_stvx(int mnemo, int vS, int rA, int rB) gen_bswap_32(REG_T1_ID); gen_bswap_32(REG_T2_ID); gen_and_32(x86_immediate_operand(-16), REG_T0_ID); - gen_mov_32(REG_T1_ID, x86_memory_operand(0*4, REG_T0_ID)); - gen_mov_32(REG_T2_ID, x86_memory_operand(1*4, REG_T0_ID)); + gen_mov_32(REG_T1_ID, vm_memory_operand(0*4, REG_T0_ID)); + gen_mov_32(REG_T2_ID, vm_memory_operand(1*4, REG_T0_ID)); gen_mov_32(x86_memory_operand(xPPC_VR(vS) + 2*4, REG_CPU_ID), REG_T1_ID); gen_mov_32(x86_memory_operand(xPPC_VR(vS) + 3*4, REG_CPU_ID), REG_T2_ID); gen_bswap_32(REG_T1_ID); gen_bswap_32(REG_T2_ID); - gen_mov_32(REG_T1_ID, x86_memory_operand(2*4, REG_T0_ID)); - gen_mov_32(REG_T2_ID, x86_memory_operand(3*4, REG_T0_ID)); + gen_mov_32(REG_T1_ID, vm_memory_operand(2*4, REG_T0_ID)); + gen_mov_32(REG_T2_ID, vm_memory_operand(3*4, REG_T0_ID)); #endif return true; } @@ -667,7 +676,7 @@ void powerpc_jit::gen_sse2_vsplat(int vD, int rValue) } // vspltisb -bool powerpc_jit::gen_sse2_vspltisb(int mnemo, int vD, int SIMM) +bool powerpc_jit::gen_sse2_vspltisb(int mnemo, int vD, int SIMM, int unused) { switch (SIMM) { case 0: @@ -718,7 +727,7 @@ bool powerpc_jit::gen_sse2_vspltisb(int mnemo, int vD, int SIMM) } // vspltish -bool powerpc_jit::gen_sse2_vspltish(int mnemo, int vD, int SIMM) +bool powerpc_jit::gen_sse2_vspltish(int mnemo, int vD, int SIMM, int unused) { switch (SIMM) { case 0: @@ -764,7 +773,7 @@ bool powerpc_jit::gen_sse2_vspltish(int mnemo, int vD, int SIMM) } // vspltisw -bool powerpc_jit::gen_sse2_vspltisw(int mnemo, int vD, int SIMM) +bool powerpc_jit::gen_sse2_vspltisw(int mnemo, int vD, int SIMM, int unused) { switch (SIMM) { case 0: @@ -866,7 +875,7 @@ bool powerpc_jit::gen_ssse3_lvx(int mnemo, int vD, int rA, int rB) gen_and_32(x86_immediate_operand(-16), REG_T0_ID); x86_memory_operand vswapmask(gen_ssse3_vswap_mask(), X86_NOREG); - gen_movdqa(x86_memory_operand(0, REG_T0_ID), REG_V0_ID); + gen_movdqa(vm_memory_operand(0, REG_T0_ID), REG_V0_ID); gen_insn(X86_INSN_SSE_3P, X86_SSSE3_PSHUFB, vswapmask, REG_V0_ID); gen_movdqa(REG_V0_ID, x86_memory_operand(xPPC_VR(vD), REG_CPU_ID)); return true; @@ -883,7 +892,7 @@ bool powerpc_jit::gen_ssse3_stvx(int mnemo, int vS, int rA, int rB) x86_memory_operand vswapmask(gen_ssse3_vswap_mask(), X86_NOREG); gen_movdqa(x86_memory_operand(xPPC_VR(vS), REG_CPU_ID), REG_V0_ID); gen_insn(X86_INSN_SSE_3P, X86_SSSE3_PSHUFB, vswapmask, REG_V0_ID); - gen_movdqa(REG_V0_ID, x86_memory_operand(0, REG_T0_ID)); + gen_movdqa(REG_V0_ID, vm_memory_operand(0, REG_T0_ID)); return true; } diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.hpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.hpp index a8e563ae..2117c5a7 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.hpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-jit.hpp @@ -90,9 +90,9 @@ private: bool gen_sse2_vsel(int mnemo, int vD, int vA, int vB, int vC); bool gen_sse2_vsldoi(int mnemo, int vD, int vA, int vB, int SH); void gen_sse2_vsplat(int vD, int rValue); - bool gen_sse2_vspltisb(int mnemo, int vD, int SIMM); - bool gen_sse2_vspltish(int mnemo, int vD, int SIMM); - bool gen_sse2_vspltisw(int mnemo, int vD, int SIMM); + bool gen_sse2_vspltisb(int mnemo, int vD, int SIMM, int unused); + bool gen_sse2_vspltish(int mnemo, int vD, int SIMM, int unused); + bool gen_sse2_vspltisw(int mnemo, int vD, int SIMM, int unused); bool gen_sse2_vspltb(int mnemo, int vD, int UIMM, int vB); bool gen_sse2_vsplth(int mnemo, int vD, int UIMM, int vB); bool gen_sse2_vspltw(int mnemo, int vD, int UIMM, int vB); diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-translate.cpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-translate.cpp index 7d023147..fe882373 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-translate.cpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-translate.cpp @@ -125,6 +125,22 @@ static void disasm_translation(uint32 src_addr, uint32 src_len, **/ #if PPC_ENABLE_JIT + +void +powerpc_cpu::call_do_record_step(powerpc_cpu * cpu, uint32 param1, uint32 param2) { + cpu->do_record_step(param1, param2); +} + +void +powerpc_cpu::call_execute_invalidate_cache_range(powerpc_cpu * cpu) { + cpu->execute_invalidate_cache_range(); +} + +void +powerpc_cpu::call_execute_illegal(powerpc_cpu * cpu, uint32 param1) { + cpu->execute_illegal(param1); +} + powerpc_cpu::block_info * powerpc_cpu::compile_block(uint32 entry_point) { @@ -169,7 +185,7 @@ powerpc_cpu::compile_block(uint32 entry_point) #if PPC_FLIGHT_RECORDER if (is_logging()) { typedef void (*func_t)(dyngen_cpu_base, uint32, uint32); - func_t func = (func_t)nv_mem_fun((execute_pmf)&powerpc_cpu::do_record_step).ptr(); + func_t func = &powerpc_cpu::call_do_record_step; dg.gen_invoke_CPU_im_im(func, dpc, opcode); } #endif @@ -1120,7 +1136,7 @@ powerpc_cpu::compile_block(uint32 entry_point) case PPC_I(ISYNC): // Instruction synchronize { typedef void (*func_t)(dyngen_cpu_base); - func_t func = (func_t)nv_mem_fun(&powerpc_cpu::execute_invalidate_cache_range).ptr(); + func_t func = &powerpc_cpu::call_execute_invalidate_cache_range; dg.gen_invoke_CPU(func); break; } @@ -1377,10 +1393,17 @@ powerpc_cpu::compile_block(uint32 entry_point) case PPC_I(STVEWX): case PPC_I(STVX): case PPC_I(STVXL): + { assert(vD_field::mask() == vS_field::mask()); assert(vA_field::mask() == rA_field::mask()); assert(vB_field::mask() == rB_field::mask()); - // fall-through + const int vD = vD_field::extract(opcode); + const int vA = vA_field::extract(opcode); + const int vB = vB_field::extract(opcode); + if (!dg.gen_vector_2(ii->mnemo, vD, vA, vB)) + goto do_generic; + break; + } case PPC_I(VCMPEQFP): case PPC_I(VCMPEQUB): case PPC_I(VCMPEQUH): @@ -1488,10 +1511,14 @@ powerpc_cpu::compile_block(uint32 entry_point) typedef void (*func_t)(dyngen_cpu_base, uint32); func_t func; do_generic: + #ifdef __MINGW32__ + func = (func_t)ii->execute.default_call_conv_ptr(); + #else func = (func_t)ii->execute.ptr(); + #endif goto do_invoke; do_illegal: - func = (func_t)nv_mem_fun(&powerpc_cpu::execute_illegal).ptr(); + func = &powerpc_cpu::call_execute_illegal; goto do_invoke; do_invoke: #if PPC_PROFILE_GENERIC_CALLS @@ -1554,7 +1581,7 @@ powerpc_cpu::compile_block(uint32 entry_point) // Generate backpatch trampolines if (use_direct_block_chaining) { typedef void *(*func_t)(dyngen_cpu_base); - func_t func = (func_t)nv_mem_fun(&powerpc_cpu::compile_chain_block).ptr(); + func_t func = (func_t)&powerpc_cpu::call_compile_chain_block; for (int i = 0; i < block_info::MAX_TARGETS; i++) { if (bi->li[i].jmp_pc != block_info::INVALID_PC) { uint8 *p = dg.gen_align(16); From 12f84691728d731e459cd0b9446cac691dfc01fd Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 18:21:36 -0700 Subject: [PATCH 07/10] fix clean of dyngen binary --- SheepShaver/src/Windows/Makefile.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SheepShaver/src/Windows/Makefile.in b/SheepShaver/src/Windows/Makefile.in index a18c9029..cb7a0650 100755 --- a/SheepShaver/src/Windows/Makefile.in +++ b/SheepShaver/src/Windows/Makefile.in @@ -138,7 +138,7 @@ mostlyclean: clean: mostlyclean dyngenclean rm -f $(XPLATSRCS) dyngenclean: - rm -f dyngen basic-dyngen-ops.hpp ppc-dyngen-ops.hpp ppc-execute-impl.cpp + rm -f $(DYNGEN) basic-dyngen-ops.hpp ppc-dyngen-ops.hpp ppc-execute-impl.cpp distclean: clean rm -rf $(OBJ_DIR) From 40cb4bf236a56328ee60978166334828ee726c12 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 18:46:40 -0700 Subject: [PATCH 08/10] implementing bswap_16 to avoid incorrect result from cygwin 1.7 gcc 3.4.4 built dyngen for lhz --- SheepShaver/src/Windows/sysdeps.h | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/SheepShaver/src/Windows/sysdeps.h b/SheepShaver/src/Windows/sysdeps.h index 432b7e57..0d73d2bd 100755 --- a/SheepShaver/src/Windows/sysdeps.h +++ b/SheepShaver/src/Windows/sysdeps.h @@ -149,6 +149,19 @@ static inline uint32 do_opt_bswap_32(uint32 x) __asm__ __volatile__ ("bswap %0" : "=r" (v) : "0" (x)); return v; } + +#if defined(__CYGWIN__) || defined(__MINGW32__) + +#define opt_bswap_16 do_opt_bswap_16 +static inline uint16 do_opt_bswap_16(uint16 x) +{ + uint16 v; + __asm__ __volatile__ ("rolw $8, %0" : "=r" (v) : "0" (x)); + return v; +} + +#endif + #endif #endif From 2a6dc7e3288929e9652a3b3fedfcfbe0bd813ab0 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 18:47:02 -0700 Subject: [PATCH 09/10] clean up some warnings --- BasiliskII/src/slirp/slirp.c | 2 +- SheepShaver/src/include/ether_defs.h | 4 ++-- SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-execute.cpp | 1 + SheepShaver/src/kpx_cpu/src/mathlib/mathlib.cpp | 2 ++ 4 files changed, 6 insertions(+), 3 deletions(-) diff --git a/BasiliskII/src/slirp/slirp.c b/BasiliskII/src/slirp/slirp.c index 0ecb09c4..cd97e299 100755 --- a/BasiliskII/src/slirp/slirp.c +++ b/BasiliskII/src/slirp/slirp.c @@ -427,7 +427,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds) /* Connected */ so->so_state &= ~SS_ISFCONNECTING; - ret = send(so->s, &ret, 0, 0); + ret = send(so->s, NULL, 0, 0); if (ret < 0) { /* XXXXX Must fix, zero bytes is a NOP */ if (errno == EAGAIN || errno == EWOULDBLOCK || diff --git a/SheepShaver/src/include/ether_defs.h b/SheepShaver/src/include/ether_defs.h index 390aee4c..60468d86 100644 --- a/SheepShaver/src/include/ether_defs.h +++ b/SheepShaver/src/include/ether_defs.h @@ -525,7 +525,7 @@ union DL_primitives { struct EnetPacketHeader { uint8 fDestAddr[6]; uint8 fSourceAddr[6]; - nw_uint16 fProto; + uint16 fProto; } PACKED__; struct T8022Header { @@ -548,7 +548,7 @@ struct T8022FullPacketHeader { struct T8022AddressStruct { uint8 fHWAddr[6]; - nw_uint16 fSAP; + uint16 fSAP; uint8 fSNAP[k8022SNAPLength]; } PACKED__; diff --git a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-execute.cpp b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-execute.cpp index ec366e59..8e2ccac0 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-execute.cpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/ppc/ppc-execute.cpp @@ -90,6 +90,7 @@ static inline int ppc_to_native_rounding_mode(int round) case 2: return FE_UPWARD; case 3: return FE_DOWNWARD; } + return FE_TONEAREST; } /** diff --git a/SheepShaver/src/kpx_cpu/src/mathlib/mathlib.cpp b/SheepShaver/src/kpx_cpu/src/mathlib/mathlib.cpp index d51a8db2..dc8a8d94 100644 --- a/SheepShaver/src/kpx_cpu/src/mathlib/mathlib.cpp +++ b/SheepShaver/src/kpx_cpu/src/mathlib/mathlib.cpp @@ -88,6 +88,7 @@ int mathlib_fpclassify (double x) int mathlib_fpclassifyl(long double x) { unimplemented("fpclassifyl"); + return -1; } @@ -114,6 +115,7 @@ int mathlib_signbit (double x) int mathlib_signbitl(long double x) { unimplemented("signbitl"); + return -1; } From 9dabd45086f6cf731015952536f1b9d702a4dfc9 Mon Sep 17 00:00:00 2001 From: rakslice Date: Tue, 17 Mar 2020 19:37:58 -0700 Subject: [PATCH 10/10] bump dyngen output for updated bswap_16 --- .../basic-dyngen-ops.hpp | 73 ++++++++++--------- 1 file changed, 39 insertions(+), 34 deletions(-) diff --git a/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp b/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp index f244e88e..de8b740f 100644 --- a/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp +++ b/SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp @@ -592,10 +592,10 @@ DEFINE_GEN(gen_op_bswap_16_T0,void,(void)) #define HAVE_gen_op_bswap_16_T0 { static const uint8 op_bswap_16_T0_code[] = { - 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x0f, 0xb7, 0xd8 + 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, 0x08, 0x0f, 0xb7, 0xd8 }; - copy_block(op_bswap_16_T0_code, 8); - inc_code_ptr(8); + copy_block(op_bswap_16_T0_code, 10); + inc_code_ptr(10); } #endif @@ -1085,10 +1085,11 @@ DEFINE_GEN(gen_op_load_u16_T0_T1_0,void,(void)) #define HAVE_gen_op_load_u16_T0_T1_0 { static const uint8 op_load_u16_T0_T1_0_code[] = { - 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xb7, 0xd8 + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f, + 0xb7, 0xd8 }; - copy_block(op_load_u16_T0_T1_0_code, 12); - inc_code_ptr(12); + copy_block(op_load_u16_T0_T1_0_code, 14); + inc_code_ptr(14); } #endif @@ -1097,10 +1098,11 @@ DEFINE_GEN(gen_op_load_s16_T0_T1_0,void,(void)) #define HAVE_gen_op_load_s16_T0_T1_0 { static const uint8 op_load_s16_T0_T1_0_code[] = { - 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xbf, 0xd8 + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f, + 0xbf, 0xd8 }; - copy_block(op_load_s16_T0_T1_0_code, 12); - inc_code_ptr(12); + copy_block(op_load_s16_T0_T1_0_code, 14); + inc_code_ptr(14); } #endif @@ -1109,10 +1111,11 @@ DEFINE_GEN(gen_op_store_16_T0_T1_0,void,(void)) #define HAVE_gen_op_store_16_T0_T1_0 { static const uint8 op_store_16_T0_T1_0_code[] = { - 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x66, 0x89, 0x86, 0x00, 0x00, 0x00, 0x11 + 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, 0x08, 0x66, 0x89, 0x86, 0x00, 0x00, + 0x00, 0x11 }; - copy_block(op_store_16_T0_T1_0_code, 12); - inc_code_ptr(12); + copy_block(op_store_16_T0_T1_0_code, 14); + inc_code_ptr(14); } #endif @@ -1121,11 +1124,12 @@ DEFINE_GEN(gen_op_load_u16_T0_T1_im,void,(long param1)) #define HAVE_gen_op_load_u16_T0_T1_im { static const uint8 op_load_u16_T0_T1_im_code[] = { - 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xb7, 0xd8 + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f, + 0xb7, 0xd8 }; - copy_block(op_load_u16_T0_T1_im_code, 12); + copy_block(op_load_u16_T0_T1_im_code, 14); *(uint32_t *)(code_ptr() + 3) = param1 + 285212672; - inc_code_ptr(12); + inc_code_ptr(14); } #endif @@ -1134,11 +1138,12 @@ DEFINE_GEN(gen_op_load_s16_T0_T1_im,void,(long param1)) #define HAVE_gen_op_load_s16_T0_T1_im { static const uint8 op_load_s16_T0_T1_im_code[] = { - 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xbf, 0xd8 + 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f, + 0xbf, 0xd8 }; - copy_block(op_load_s16_T0_T1_im_code, 12); + copy_block(op_load_s16_T0_T1_im_code, 14); *(uint32_t *)(code_ptr() + 3) = param1 + 285212672; - inc_code_ptr(12); + inc_code_ptr(14); } #endif @@ -1147,12 +1152,12 @@ DEFINE_GEN(gen_op_store_16_T0_T1_im,void,(long param1)) #define HAVE_gen_op_store_16_T0_T1_im { static const uint8 op_store_16_T0_T1_im_code[] = { - 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x66, - 0x89, 0x82, 0x00, 0x00, 0x00, 0x11 + 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, + 0x08, 0x66, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11 }; - copy_block(op_store_16_T0_T1_im_code, 18); + copy_block(op_store_16_T0_T1_im_code, 20); *(uint32_t *)(code_ptr() + 2) = param1 + 0; - inc_code_ptr(18); + inc_code_ptr(20); } #endif @@ -1161,11 +1166,11 @@ DEFINE_GEN(gen_op_load_u16_T0_T1_T2,void,(void)) #define HAVE_gen_op_load_u16_T0_T1_T2 { static const uint8 op_load_u16_T0_T1_T2_code[] = { - 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xb7, - 0xd8 + 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, + 0x0f, 0xb7, 0xd8 }; - copy_block(op_load_u16_T0_T1_T2_code, 13); - inc_code_ptr(13); + copy_block(op_load_u16_T0_T1_T2_code, 15); + inc_code_ptr(15); } #endif @@ -1174,11 +1179,11 @@ DEFINE_GEN(gen_op_load_s16_T0_T1_T2,void,(void)) #define HAVE_gen_op_load_s16_T0_T1_T2 { static const uint8 op_load_s16_T0_T1_T2_code[] = { - 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x86, 0xe0, 0x0f, 0xbf, - 0xd8 + 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, + 0x0f, 0xbf, 0xd8 }; - copy_block(op_load_s16_T0_T1_T2_code, 13); - inc_code_ptr(13); + copy_block(op_load_s16_T0_T1_T2_code, 15); + inc_code_ptr(15); } #endif @@ -1187,11 +1192,11 @@ DEFINE_GEN(gen_op_store_16_T0_T1_T2,void,(void)) #define HAVE_gen_op_store_16_T0_T1_T2 { static const uint8 op_store_16_T0_T1_T2_code[] = { - 0x8d, 0x14, 0x3e, 0x0f, 0xb7, 0xc3, 0x86, 0xe0, 0x66, 0x89, 0x82, 0x00, - 0x00, 0x00, 0x11 + 0x8d, 0x14, 0x3e, 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, 0x08, 0x66, 0x89, + 0x82, 0x00, 0x00, 0x00, 0x11 }; - copy_block(op_store_16_T0_T1_T2_code, 15); - inc_code_ptr(15); + copy_block(op_store_16_T0_T1_T2_code, 17); + inc_code_ptr(17); } #endif