This is the real 0.1 release, I think.
This commit is contained in:
jpenner
parent
08c2389591
commit
d793f81b51
|
|
@ -1,3 +1,4 @@
|
|||
SUBDIRS = . lightning
|
||||
lib_LIBRARIES = libclosure.a
|
||||
|
||||
libclosure_a_SOURCES = src/closure.c src/closure.h
|
||||
|
|
|
|||
163
Makefile.in
163
Makefile.in
|
|
@ -119,6 +119,7 @@ sbindir = @sbindir@
|
|||
sharedstatedir = @sharedstatedir@
|
||||
sysconfdir = @sysconfdir@
|
||||
target_alias = @target_alias@
|
||||
SUBDIRS = . lightning
|
||||
lib_LIBRARIES = libclosure.a
|
||||
|
||||
libclosure_a_SOURCES = src/closure.c src/closure.h
|
||||
|
|
@ -160,14 +161,21 @@ COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
|
|||
CCLD = $(CC)
|
||||
LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
|
||||
DIST_SOURCES = $(libclosure_a_SOURCES) $(tests_test_SOURCES)
|
||||
|
||||
RECURSIVE_TARGETS = info-recursive dvi-recursive pdf-recursive \
|
||||
ps-recursive install-info-recursive uninstall-info-recursive \
|
||||
all-recursive install-data-recursive install-exec-recursive \
|
||||
installdirs-recursive install-recursive uninstall-recursive \
|
||||
check-recursive installcheck-recursive
|
||||
DIST_COMMON = README $(srcdir)/Makefile.in $(srcdir)/configure AUTHORS \
|
||||
COPYING COPYING.DOC COPYING.LESSER ChangeLog INSTALL \
|
||||
Makefile.am NEWS acinclude.m4 aclocal.m4 compile config.guess \
|
||||
config.sub configure configure.in depcomp install-sh missing \
|
||||
mkinstalldirs
|
||||
DIST_SUBDIRS = $(SUBDIRS)
|
||||
SOURCES = $(libclosure_a_SOURCES) $(tests_test_SOURCES)
|
||||
|
||||
all: all-am
|
||||
all: all-recursive
|
||||
|
||||
.SUFFIXES:
|
||||
.SUFFIXES: .c .o .obj
|
||||
|
|
@ -309,6 +317,65 @@ tests_test-test.obj: tests/test.c
|
|||
@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(tests_test_CFLAGS) $(CFLAGS) -c -o tests_test-test.obj `if test -f 'tests/test.c'; then $(CYGPATH_W) 'tests/test.c'; else $(CYGPATH_W) '$(srcdir)/tests/test.c'; fi`
|
||||
uninstall-info-am:
|
||||
|
||||
# This directory's subdirectories are mostly independent; you can cd
|
||||
# into them and run `make' without going through this Makefile.
|
||||
# To change the values of `make' variables: instead of editing Makefiles,
|
||||
# (1) if the variable is set in `config.status', edit `config.status'
|
||||
# (which will cause the Makefiles to be regenerated when you run `make');
|
||||
# (2) otherwise, pass the desired values on the `make' command line.
|
||||
$(RECURSIVE_TARGETS):
|
||||
@set fnord $$MAKEFLAGS; amf=$$2; \
|
||||
dot_seen=no; \
|
||||
target=`echo $@ | sed s/-recursive//`; \
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
echo "Making $$target in $$subdir"; \
|
||||
if test "$$subdir" = "."; then \
|
||||
dot_seen=yes; \
|
||||
local_target="$$target-am"; \
|
||||
else \
|
||||
local_target="$$target"; \
|
||||
fi; \
|
||||
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|
||||
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
|
||||
done; \
|
||||
if test "$$dot_seen" = "no"; then \
|
||||
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
|
||||
fi; test -z "$$fail"
|
||||
|
||||
mostlyclean-recursive clean-recursive distclean-recursive \
|
||||
maintainer-clean-recursive:
|
||||
@set fnord $$MAKEFLAGS; amf=$$2; \
|
||||
dot_seen=no; \
|
||||
case "$@" in \
|
||||
distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
|
||||
*) list='$(SUBDIRS)' ;; \
|
||||
esac; \
|
||||
rev=''; for subdir in $$list; do \
|
||||
if test "$$subdir" = "."; then :; else \
|
||||
rev="$$subdir $$rev"; \
|
||||
fi; \
|
||||
done; \
|
||||
rev="$$rev ."; \
|
||||
target=`echo $@ | sed s/-recursive//`; \
|
||||
for subdir in $$rev; do \
|
||||
echo "Making $$target in $$subdir"; \
|
||||
if test "$$subdir" = "."; then \
|
||||
local_target="$$target-am"; \
|
||||
else \
|
||||
local_target="$$target"; \
|
||||
fi; \
|
||||
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|
||||
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
|
||||
done && test -z "$$fail"
|
||||
tags-recursive:
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
|
||||
done
|
||||
ctags-recursive:
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
|
||||
done
|
||||
|
||||
ETAGS = etags
|
||||
ETAGSFLAGS =
|
||||
|
||||
|
|
@ -326,10 +393,21 @@ ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
|
|||
END { for (i in files) print i; }'`; \
|
||||
mkid -fID $$unique
|
||||
|
||||
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
|
||||
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
|
||||
$(TAGS_FILES) $(LISP)
|
||||
tags=; \
|
||||
here=`pwd`; \
|
||||
if (etags --etags-include --version) >/dev/null 2>&1; then \
|
||||
include_option=--etags-include; \
|
||||
else \
|
||||
include_option=--include; \
|
||||
fi; \
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
if test "$$subdir" = .; then :; else \
|
||||
test -f $$subdir/TAGS && \
|
||||
tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \
|
||||
fi; \
|
||||
done; \
|
||||
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
|
||||
unique=`for i in $$list; do \
|
||||
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
|
||||
|
|
@ -341,7 +419,7 @@ TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
|
|||
$$tags $$unique
|
||||
|
||||
ctags: CTAGS
|
||||
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
|
||||
CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
|
||||
$(TAGS_FILES) $(LISP)
|
||||
tags=; \
|
||||
here=`pwd`; \
|
||||
|
|
@ -479,6 +557,19 @@ distdir: $(DISTFILES)
|
|||
|| exit 1; \
|
||||
fi; \
|
||||
done
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
if test "$$subdir" = .; then :; else \
|
||||
test -d $(distdir)/$$subdir \
|
||||
|| mkdir $(distdir)/$$subdir \
|
||||
|| exit 1; \
|
||||
(cd $$subdir && \
|
||||
$(MAKE) $(AM_MAKEFLAGS) \
|
||||
top_distdir="$(top_distdir)" \
|
||||
distdir=../$(distdir)/$$subdir \
|
||||
distdir) \
|
||||
|| exit 1; \
|
||||
fi; \
|
||||
done
|
||||
-find $(distdir) -type d ! -perm -777 -exec chmod a+rwx {} \; -o \
|
||||
! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
|
||||
! -type d ! -perm -400 -exec chmod a+r {} \; -o \
|
||||
|
|
@ -550,20 +641,21 @@ distcleancheck: distclean
|
|||
exit 1; } >&2
|
||||
check-am: all-am
|
||||
$(MAKE) $(AM_MAKEFLAGS) check-TESTS
|
||||
check: check-am
|
||||
check: check-recursive
|
||||
all-am: Makefile $(LIBRARIES) $(PROGRAMS)
|
||||
|
||||
installdirs:
|
||||
installdirs: installdirs-recursive
|
||||
installdirs-am:
|
||||
$(mkinstalldirs) $(DESTDIR)$(libdir)
|
||||
install: install-am
|
||||
install-exec: install-exec-am
|
||||
install-data: install-data-am
|
||||
uninstall: uninstall-am
|
||||
|
||||
install: install-recursive
|
||||
install-exec: install-exec-recursive
|
||||
install-data: install-data-recursive
|
||||
uninstall: uninstall-recursive
|
||||
|
||||
install-am: all-am
|
||||
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
|
||||
|
||||
installcheck: installcheck-am
|
||||
installcheck: installcheck-recursive
|
||||
install-strip:
|
||||
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
|
||||
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
|
||||
|
|
@ -580,23 +672,23 @@ distclean-generic:
|
|||
maintainer-clean-generic:
|
||||
@echo "This command is intended for maintainers to use"
|
||||
@echo "it deletes files that may require special tools to rebuild."
|
||||
clean: clean-am
|
||||
clean: clean-recursive
|
||||
|
||||
clean-am: clean-generic clean-libLIBRARIES clean-noinstPROGRAMS \
|
||||
mostlyclean-am
|
||||
|
||||
distclean: distclean-am
|
||||
distclean: distclean-recursive
|
||||
-rm -f $(am__CONFIG_DISTCLEAN_FILES)
|
||||
-rm -rf ./$(DEPDIR)
|
||||
-rm -f Makefile
|
||||
distclean-am: clean-am distclean-compile distclean-generic \
|
||||
distclean-tags
|
||||
|
||||
dvi: dvi-am
|
||||
dvi: dvi-recursive
|
||||
|
||||
dvi-am:
|
||||
|
||||
info: info-am
|
||||
info: info-recursive
|
||||
|
||||
info-am:
|
||||
|
||||
|
|
@ -604,45 +696,54 @@ install-data-am:
|
|||
|
||||
install-exec-am: install-libLIBRARIES
|
||||
|
||||
install-info: install-info-am
|
||||
install-info: install-info-recursive
|
||||
|
||||
install-man:
|
||||
|
||||
installcheck-am:
|
||||
|
||||
maintainer-clean: maintainer-clean-am
|
||||
maintainer-clean: maintainer-clean-recursive
|
||||
-rm -f $(am__CONFIG_DISTCLEAN_FILES)
|
||||
-rm -rf $(top_srcdir)/autom4te.cache
|
||||
-rm -rf ./$(DEPDIR)
|
||||
-rm -f Makefile
|
||||
maintainer-clean-am: distclean-am maintainer-clean-generic
|
||||
|
||||
mostlyclean: mostlyclean-am
|
||||
mostlyclean: mostlyclean-recursive
|
||||
|
||||
mostlyclean-am: mostlyclean-compile mostlyclean-generic
|
||||
|
||||
pdf: pdf-am
|
||||
pdf: pdf-recursive
|
||||
|
||||
pdf-am:
|
||||
|
||||
ps: ps-am
|
||||
ps: ps-recursive
|
||||
|
||||
ps-am:
|
||||
|
||||
uninstall-am: uninstall-info-am uninstall-libLIBRARIES
|
||||
|
||||
.PHONY: CTAGS GTAGS all all-am check check-TESTS check-am clean \
|
||||
clean-generic clean-libLIBRARIES clean-noinstPROGRAMS ctags \
|
||||
dist dist-all dist-gzip distcheck distclean distclean-compile \
|
||||
distclean-generic distclean-tags distcleancheck distdir \
|
||||
distuninstallcheck dvi dvi-am info info-am install install-am \
|
||||
install-data install-data-am install-exec install-exec-am \
|
||||
install-info install-info-am install-libLIBRARIES install-man \
|
||||
uninstall-info: uninstall-info-recursive
|
||||
|
||||
.PHONY: $(RECURSIVE_TARGETS) CTAGS GTAGS all all-am check check-TESTS \
|
||||
check-am clean clean-generic clean-libLIBRARIES \
|
||||
clean-noinstPROGRAMS clean-recursive ctags ctags-recursive dist \
|
||||
dist-all dist-gzip distcheck distclean distclean-compile \
|
||||
distclean-generic distclean-recursive distclean-tags \
|
||||
distcleancheck distdir distuninstallcheck dvi dvi-am \
|
||||
dvi-recursive info info-am info-recursive install install-am \
|
||||
install-data install-data-am install-data-recursive \
|
||||
install-exec install-exec-am install-exec-recursive \
|
||||
install-info install-info-am install-info-recursive \
|
||||
install-libLIBRARIES install-man install-recursive \
|
||||
install-strip installcheck installcheck-am installdirs \
|
||||
maintainer-clean maintainer-clean-generic mostlyclean \
|
||||
mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
|
||||
tags uninstall uninstall-am uninstall-info-am \
|
||||
uninstall-libLIBRARIES
|
||||
installdirs-am installdirs-recursive maintainer-clean \
|
||||
maintainer-clean-generic maintainer-clean-recursive mostlyclean \
|
||||
mostlyclean-compile mostlyclean-generic mostlyclean-recursive \
|
||||
pdf pdf-am pdf-recursive ps ps-am ps-recursive tags \
|
||||
tags-recursive uninstall uninstall-am uninstall-info-am \
|
||||
uninstall-info-recursive uninstall-libLIBRARIES \
|
||||
uninstall-recursive
|
||||
|
||||
# Tell versions [3.59,3.63) of GNU make to not export all variables.
|
||||
# Otherwise a system limit (for SysV at least) may be exceeded.
|
||||
|
|
|
|||
|
|
@ -24,7 +24,8 @@ fi
|
|||
ifdef([AC_HELP_STRING], [
|
||||
dnl autoconf 2.50 style
|
||||
if test -n "$cpu_subdir"; then
|
||||
AC_CONFIG_LINKS(lightning/asm.h:lightning/$cpu_subdir/asm.h
|
||||
AC_CONFIG_LINKS(lightning.h:lightning/lightning.h
|
||||
lightning/asm.h:lightning/$cpu_subdir/asm.h
|
||||
lightning/core.h:lightning/$cpu_subdir/core.h
|
||||
lightning/fp.h:lightning/$cpu_subdir/fp.h
|
||||
lightning/funcs.h:lightning/$cpu_subdir/funcs.h, , [
|
||||
|
|
|
|||
3
aclocal.m4
vendored
3
aclocal.m4
vendored
|
|
@ -37,7 +37,8 @@ fi
|
|||
ifdef([AC_HELP_STRING], [
|
||||
dnl autoconf 2.50 style
|
||||
if test -n "$cpu_subdir"; then
|
||||
AC_CONFIG_LINKS(lightning/asm.h:lightning/$cpu_subdir/asm.h
|
||||
AC_CONFIG_LINKS(lightning.h:lightning/lightning.h
|
||||
lightning/asm.h:lightning/$cpu_subdir/asm.h
|
||||
lightning/core.h:lightning/$cpu_subdir/core.h
|
||||
lightning/fp.h:lightning/$cpu_subdir/fp.h
|
||||
lightning/funcs.h:lightning/$cpu_subdir/funcs.h, , [
|
||||
|
|
|
|||
6
configure
vendored
6
configure
vendored
|
|
@ -3701,7 +3701,7 @@ fi
|
|||
|
||||
|
||||
if test -n "$cpu_subdir"; then
|
||||
ac_config_links="$ac_config_links lightning/asm.h:lightning/$cpu_subdir/asm.h lightning/core.h:lightning/$cpu_subdir/core.h lightning/fp.h:lightning/$cpu_subdir/fp.h lightning/funcs.h:lightning/$cpu_subdir/funcs.h"
|
||||
ac_config_links="$ac_config_links lightning.h:lightning/lightning.h lightning/asm.h:lightning/$cpu_subdir/asm.h lightning/core.h:lightning/$cpu_subdir/core.h lightning/fp.h:lightning/$cpu_subdir/fp.h lightning/funcs.h:lightning/$cpu_subdir/funcs.h"
|
||||
|
||||
fi
|
||||
|
||||
|
|
@ -3719,7 +3719,7 @@ else
|
|||
fi
|
||||
|
||||
|
||||
ac_config_files="$ac_config_files Makefile"
|
||||
ac_config_files="$ac_config_files Makefile lightning/Makefile"
|
||||
cat >confcache <<\_ACEOF
|
||||
# This file is a shell script that caches the results of configure
|
||||
# tests run on this system so they can be shared between configure
|
||||
|
|
@ -4316,6 +4316,8 @@ do
|
|||
case "$ac_config_target" in
|
||||
# Handling of arguments.
|
||||
"Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
|
||||
"lightning/Makefile" ) CONFIG_FILES="$CONFIG_FILES lightning/Makefile" ;;
|
||||
"lightning.h" ) CONFIG_LINKS="$CONFIG_LINKS lightning.h:lightning/lightning.h" ;;
|
||||
"lightning/asm.h" ) CONFIG_LINKS="$CONFIG_LINKS lightning/asm.h:lightning/$cpu_subdir/asm.h" ;;
|
||||
"lightning/core.h" ) CONFIG_LINKS="$CONFIG_LINKS lightning/core.h:lightning/$cpu_subdir/core.h" ;;
|
||||
"lightning/fp.h" ) CONFIG_LINKS="$CONFIG_LINKS lightning/fp.h:lightning/$cpu_subdir/fp.h" ;;
|
||||
|
|
|
|||
|
|
@ -5,4 +5,4 @@ AC_PROG_RANLIB
|
|||
AC_PROG_INSTALL
|
||||
AC_EXEEXT
|
||||
LIGHTNING_CONFIGURE_IF_NOT_FOUND
|
||||
AC_OUTPUT([Makefile])
|
||||
AC_OUTPUT([Makefile lightning/Makefile])
|
||||
|
|
|
|||
16
lightning/Makefile.am
Normal file
16
lightning/Makefile.am
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
DISTCLEANFILES = asm.h core.h funcs.h fp.h
|
||||
|
||||
LIGHTNING_FILES = funcs-common.h core-common.h fp-common.h \
|
||||
asm-common.h \
|
||||
i386/asm.h i386/core.h i386/funcs.h i386/fp.h \
|
||||
sparc/asm.h sparc/core.h sparc/funcs.h sparc/fp.h \
|
||||
ppc/asm.h ppc/core.h ppc/funcs.h ppc/fp.h
|
||||
|
||||
if LIGHTNING_MAIN
|
||||
lightningdir = $(includedir)/lightning
|
||||
dist_pkgdata_DATA = Makefile.am
|
||||
nobase_dist_lightning_HEADERS = $(LIGHTNING_FILES)
|
||||
nodist_lightning_HEADERS = asm.h core.h funcs.h fp.h
|
||||
else
|
||||
dist_noinst_HEADERS = $(LIGHTNING_FILES) lightning.h
|
||||
endif
|
||||
197
lightning/asm-common.h
Normal file
197
lightning/asm-common.h
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Dynamic assembler support
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
#ifndef __lightning_asm_common_h
|
||||
#define __lightning_asm_common_h_
|
||||
|
||||
|
||||
#ifndef _ASM_SAFETY
|
||||
#define JITFAIL(MSG) 0
|
||||
#else
|
||||
#if defined __GNUC__ && (__GNUC__ == 3 ? __GNUC_MINOR__ >= 2 : __GNUC__ > 3)
|
||||
#define JITFAIL(MSG) jit_fail(MSG, __FILE__, __LINE__, __func__)
|
||||
#else
|
||||
#define JITFAIL(MSG) jit_fail(MSG, __FILE__, __LINE__, __FUNCTION__)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined __GNUC__ && (__GNUC__ == 3 ? __GNUC_MINOR__ >= 2 : __GNUC__ > 3)
|
||||
#define JITSORRY(MSG) jit_fail("sorry, unimplemented: " MSG, __FILE__, __LINE__, __func__)
|
||||
#else
|
||||
#define JITSORRY(MSG) jit_fail("sorry, unimplemented: " MSG, __FILE__, __LINE__, __FUNCTION__)
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define JIT_UNUSED __attribute__((unused))
|
||||
#else
|
||||
#define JIT_UNUSED
|
||||
#endif
|
||||
|
||||
|
||||
/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
|
||||
does not implement __extension__. But that compiler doesn't define
|
||||
__GNUC_MINOR__. */
|
||||
#ifdef __GNUC__
|
||||
#if __GNUC__ < 2 || (defined(__NeXT__) && !__GNUC_MINOR__)
|
||||
#define __extension__
|
||||
#endif
|
||||
|
||||
#define _TEMPD(type, var)
|
||||
|
||||
#define _TEMP(type, var, val, body) __extension__ ({ \
|
||||
register struct { type var } _jitl; _jitl.var = val; \
|
||||
body; \
|
||||
})
|
||||
|
||||
#else
|
||||
|
||||
/* Between loading a global and calling a subroutine, we choose the lesser
|
||||
* evil. */
|
||||
#define _TEMPD(type, var) static type var;
|
||||
#define _TEMP(type, var, val, body) ((var = val), body)
|
||||
|
||||
#endif
|
||||
|
||||
typedef char _sc;
|
||||
typedef unsigned char _uc;
|
||||
typedef unsigned short _us;
|
||||
typedef unsigned int _ui;
|
||||
typedef long _sl;
|
||||
typedef unsigned long _ul;
|
||||
|
||||
#define _UC(X) ((_uc )(X))
|
||||
#define _US(X) ((_us )(X))
|
||||
#define _UI(X) ((_ui )(X))
|
||||
#define _SL(X) ((_sl )(X))
|
||||
#define _UL(X) ((_ul )(X))
|
||||
|
||||
# define _PUC(X) ((_uc *)(X))
|
||||
# define _PUS(X) ((_us *)(X))
|
||||
# define _PUI(X) ((_ui *)(X))
|
||||
# define _PSL(X) ((_sl *)(X))
|
||||
# define _PUL(X) ((_ul *)(X))
|
||||
|
||||
#define _B(B) ((*_PUC(_jit.pc)++)= _UC((B)& 0xff))
|
||||
#define _W(W) ((*_PUS(_jit.pc)++)= _US((W)&0xffff))
|
||||
#define _I(I) ((*_PUI(_jit.pc)++)= _UI((I) ))
|
||||
#define _L(L) ((*_PUL(_jit.pc)++)= _UL((L) ))
|
||||
|
||||
#define _MASK(N) ((unsigned)((1<<(N)))-1)
|
||||
#define _siP(N,I) (!((((unsigned)(I))^(((unsigned)(I))<<1))&~_MASK(N)))
|
||||
#define _uiP(N,I) (!(((unsigned)(I))&~_MASK(N)))
|
||||
#define _suiP(N,I) (_siP(N,I) | _uiP(N,I))
|
||||
|
||||
#ifndef _ASM_SAFETY
|
||||
#define _ck_s(W,I) (_UL(I) & _MASK(W))
|
||||
#define _ck_u(W,I) (_UL(I) & _MASK(W))
|
||||
#define _ck_su(W,I) (_UL(I) & _MASK(W))
|
||||
#define _ck_d(W,I) (_UL(I) & _MASK(W))
|
||||
#else
|
||||
#define _ck_s(W,I) (_siP(W,I) ? (_UL(I) & _MASK(W)) : JITFAIL( "signed integer `"#I"' too large for "#W"-bit field"))
|
||||
#define _ck_u(W,I) (_uiP(W,I) ? (_UL(I) & _MASK(W)) : JITFAIL("unsigned integer `"#I"' too large for "#W"-bit field"))
|
||||
#define _ck_su(W,I) (_suiP(W,I) ? (_UL(I) & _MASK(W)) : JITFAIL( "integer `"#I"' too large for "#W"-bit field"))
|
||||
#define _ck_d(W,I) (_siP(W,I) ? (_UL(I) & _MASK(W)) : JITFAIL( "displacement `"#I"' too large for "#W"-bit field"))
|
||||
#endif
|
||||
|
||||
#define _s0P(I) ((I)==0)
|
||||
#define _s8P(I) _siP(8,I)
|
||||
#define _s16P(I) _siP(16,I)
|
||||
#define _u8P(I) _uiP(8,I)
|
||||
#define _u16P(I) _uiP(16,I)
|
||||
|
||||
#define _su8(I) _ck_su(8,I)
|
||||
#define _su16(I) _ck_su(16,I)
|
||||
|
||||
#define _s1(I) _ck_s( 1,I)
|
||||
#define _s2(I) _ck_s( 2,I)
|
||||
#define _s3(I) _ck_s( 3,I)
|
||||
#define _s4(I) _ck_s( 4,I)
|
||||
#define _s5(I) _ck_s( 5,I)
|
||||
#define _s6(I) _ck_s( 6,I)
|
||||
#define _s7(I) _ck_s( 7,I)
|
||||
#define _s8(I) _ck_s( 8,I)
|
||||
#define _s9(I) _ck_s( 9,I)
|
||||
#define _s10(I) _ck_s(10,I)
|
||||
#define _s11(I) _ck_s(11,I)
|
||||
#define _s12(I) _ck_s(12,I)
|
||||
#define _s13(I) _ck_s(13,I)
|
||||
#define _s14(I) _ck_s(14,I)
|
||||
#define _s15(I) _ck_s(15,I)
|
||||
#define _s16(I) _ck_s(16,I)
|
||||
#define _s17(I) _ck_s(17,I)
|
||||
#define _s18(I) _ck_s(18,I)
|
||||
#define _s19(I) _ck_s(19,I)
|
||||
#define _s20(I) _ck_s(20,I)
|
||||
#define _s21(I) _ck_s(21,I)
|
||||
#define _s22(I) _ck_s(22,I)
|
||||
#define _s23(I) _ck_s(23,I)
|
||||
#define _s24(I) _ck_s(24,I)
|
||||
#define _s25(I) _ck_s(25,I)
|
||||
#define _s26(I) _ck_s(26,I)
|
||||
#define _s27(I) _ck_s(27,I)
|
||||
#define _s28(I) _ck_s(28,I)
|
||||
#define _s29(I) _ck_s(29,I)
|
||||
#define _s30(I) _ck_s(30,I)
|
||||
#define _s31(I) _ck_s(31,I)
|
||||
#define _u1(I) _ck_u( 1,I)
|
||||
#define _u2(I) _ck_u( 2,I)
|
||||
#define _u3(I) _ck_u( 3,I)
|
||||
#define _u4(I) _ck_u( 4,I)
|
||||
#define _u5(I) _ck_u( 5,I)
|
||||
#define _u6(I) _ck_u( 6,I)
|
||||
#define _u7(I) _ck_u( 7,I)
|
||||
#define _u8(I) _ck_u( 8,I)
|
||||
#define _u9(I) _ck_u( 9,I)
|
||||
#define _u10(I) _ck_u(10,I)
|
||||
#define _u11(I) _ck_u(11,I)
|
||||
#define _u12(I) _ck_u(12,I)
|
||||
#define _u13(I) _ck_u(13,I)
|
||||
#define _u14(I) _ck_u(14,I)
|
||||
#define _u15(I) _ck_u(15,I)
|
||||
#define _u16(I) _ck_u(16,I)
|
||||
#define _u17(I) _ck_u(17,I)
|
||||
#define _u18(I) _ck_u(18,I)
|
||||
#define _u19(I) _ck_u(19,I)
|
||||
#define _u20(I) _ck_u(20,I)
|
||||
#define _u21(I) _ck_u(21,I)
|
||||
#define _u22(I) _ck_u(22,I)
|
||||
#define _u23(I) _ck_u(23,I)
|
||||
#define _u24(I) _ck_u(24,I)
|
||||
#define _u25(I) _ck_u(25,I)
|
||||
#define _u26(I) _ck_u(26,I)
|
||||
#define _u27(I) _ck_u(27,I)
|
||||
#define _u28(I) _ck_u(28,I)
|
||||
#define _u29(I) _ck_u(29,I)
|
||||
#define _u30(I) _ck_u(30,I)
|
||||
#define _u31(I) _ck_u(31,I)
|
||||
|
||||
#endif /* __lightning_asm_common_h */
|
||||
570
lightning/core-common.h
Normal file
570
lightning/core-common.h
Normal file
|
|
@ -0,0 +1,570 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer support
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
#ifndef __lightning_core_common_h
|
||||
#define __lightning_core_common_h_
|
||||
|
||||
typedef struct {
|
||||
jit_insn *pc;
|
||||
struct jit_fp *fp;
|
||||
struct jit_local_state jitl;
|
||||
} jit_state;
|
||||
|
||||
static jit_state _jit;
|
||||
|
||||
#define JIT_NOREG (-1)
|
||||
|
||||
#define _jitl _jit.jitl
|
||||
|
||||
#define jit_get_ip() (*(jit_code *) &_jit.pc)
|
||||
#define jit_set_ip(ptr) (_jit.pc = (jit_insn *) ptr, jit_get_ip())
|
||||
#define jit_get_label() (_jit.pc)
|
||||
#define jit_forward() (_jit.pc)
|
||||
|
||||
#define jit_field(struc, f) ( ((long) (&((struc *) 8)->f) ) - 8)
|
||||
#define jit_ptr_field(struc_p, f) ( ((long) (&((struc_p) 8)->f) ) - 8)
|
||||
|
||||
/* realignment via N-byte no-ops */
|
||||
|
||||
#ifndef jit_align
|
||||
#define jit_align(n)
|
||||
#endif
|
||||
|
||||
/* jit_code: union of many possible function pointer types. Returned
|
||||
* by jit_get_ip().
|
||||
*/
|
||||
typedef union jit_code {
|
||||
char *ptr;
|
||||
void (*vptr)();
|
||||
char (*cptr)();
|
||||
unsigned char (*ucptr)();
|
||||
short (*sptr)();
|
||||
unsigned short (*usptr)();
|
||||
int (*iptr)();
|
||||
unsigned int (*uiptr)();
|
||||
long (*lptr)();
|
||||
unsigned long (*ulptr)();
|
||||
void * (*pptr)();
|
||||
float (*fptr)();
|
||||
double (*dptr)();
|
||||
} jit_code;
|
||||
|
||||
#ifndef jit_fill_delay_after
|
||||
#define jit_fill_delay_after(branch) (branch)
|
||||
#endif
|
||||
|
||||
#define jit_delay(insn, branch) ((insn), jit_fill_delay_after(branch))
|
||||
|
||||
|
||||
/* ALU synonyms */
|
||||
#define jit_addi_ui(d, rs, is) jit_addi_i((d), (rs), (is))
|
||||
#define jit_addr_ui(d, s1, s2) jit_addr_i((d), (s1), (s2))
|
||||
#define jit_addci_ui(d, rs, is) jit_addci_i((d), (rs), (is))
|
||||
#define jit_addcr_ui(d, s1, s2) jit_addcr_i((d), (s1), (s2))
|
||||
#define jit_addxi_ui(d, rs, is) jit_addxi_i((d), (rs), (is))
|
||||
#define jit_addxr_ui(d, s1, s2) jit_addxr_i((d), (s1), (s2))
|
||||
#define jit_andi_ui(d, rs, is) jit_andi_i((d), (rs), (is))
|
||||
#define jit_andr_ui(d, s1, s2) jit_andr_i((d), (s1), (s2))
|
||||
#define jit_lshi_ui(d, rs, is) jit_lshi_i((d), (rs), (is))
|
||||
#define jit_lshr_ui(d, s1, s2) jit_lshr_i((d), (s1), (s2))
|
||||
#define jit_movi_ui(d, rs) jit_movi_i((d), (rs))
|
||||
#define jit_movr_ui(d, rs) jit_movr_i((d), (rs))
|
||||
#define jit_ori_ui(d, rs, is) jit_ori_i((d), (rs), (is))
|
||||
#define jit_orr_ui(d, s1, s2) jit_orr_i((d), (s1), (s2))
|
||||
#define jit_rsbi_ui(d, rs, is) jit_rsbi_i((d), (rs), (is))
|
||||
#define jit_rsbr_ui(d, s1, s2) jit_rsbr_i((d), (s1), (s2))
|
||||
#define jit_subi_ui(d, rs, is) jit_subi_i((d), (rs), (is))
|
||||
#define jit_subr_ui(d, s1, s2) jit_subr_i((d), (s1), (s2))
|
||||
#define jit_subci_ui(d, rs, is) jit_subci_i((d), (rs), (is))
|
||||
#define jit_subcr_ui(d, s1, s2) jit_subcr_i((d), (s1), (s2))
|
||||
#define jit_subxi_ui(d, rs, is) jit_subxi_i((d), (rs), (is))
|
||||
#define jit_subxr_ui(d, s1, s2) jit_subxr_i((d), (s1), (s2))
|
||||
#define jit_xori_ui(d, rs, is) jit_xori_i((d), (rs), (is))
|
||||
#define jit_xorr_ui(d, s1, s2) jit_xorr_i((d), (s1), (s2))
|
||||
|
||||
#define jit_addi_ul(d, rs, is) jit_addi_l((d), (rs), (is))
|
||||
#define jit_addr_ul(d, s1, s2) jit_addr_l((d), (s1), (s2))
|
||||
#define jit_addci_ul(d, rs, is) jit_addci_l((d), (rs), (is))
|
||||
#define jit_addcr_ul(d, s1, s2) jit_addcr_l((d), (s1), (s2))
|
||||
#define jit_addxi_ul(d, rs, is) jit_addxi_l((d), (rs), (is))
|
||||
#define jit_addxr_ul(d, s1, s2) jit_addxr_l((d), (s1), (s2))
|
||||
#define jit_andi_ul(d, rs, is) jit_andi_l((d), (rs), (is))
|
||||
#define jit_andr_ul(d, s1, s2) jit_andr_l((d), (s1), (s2))
|
||||
#define jit_lshi_ul(d, rs, is) jit_lshi_l((d), (rs), (is))
|
||||
#define jit_lshr_ul(d, s1, s2) jit_lshr_l((d), (s1), (s2))
|
||||
#define jit_movi_ul(d, rs) jit_movi_l((d), (rs))
|
||||
#define jit_movr_ul(d, rs) jit_movr_l((d), (rs))
|
||||
#define jit_ori_ul(d, rs, is) jit_ori_l((d), (rs), (is))
|
||||
#define jit_orr_ul(d, s1, s2) jit_orr_l((d), (s1), (s2))
|
||||
#define jit_rsbi_ul(d, rs, is) jit_rsbi_l((d), (rs), (is))
|
||||
#define jit_rsbr_ul(d, s1, s2) jit_rsbr_l((d), (s1), (s2))
|
||||
#define jit_subi_ul(d, rs, is) jit_subi_l((d), (rs), (is))
|
||||
#define jit_subr_ul(d, s1, s2) jit_subr_l((d), (s1), (s2))
|
||||
#define jit_subci_ul(d, rs, is) jit_subci_l((d), (rs), (is))
|
||||
#define jit_subcr_ul(d, s1, s2) jit_subcr_l((d), (s1), (s2))
|
||||
#define jit_subxi_ui(d, rs, is) jit_subxi_i((d), (rs), (is))
|
||||
#define jit_subxr_ui(d, s1, s2) jit_subxr_i((d), (s1), (s2))
|
||||
#define jit_xori_ul(d, rs, is) jit_xori_l((d), (rs), (is))
|
||||
#define jit_xorr_ul(d, s1, s2) jit_xorr_l((d), (s1), (s2))
|
||||
|
||||
#define jit_addr_p(d, s1, s2) jit_addr_ul((d), (s1), (s2))
|
||||
#define jit_addi_p(d, rs, is) jit_addi_ul((d), (rs), (long) (is))
|
||||
#define jit_movr_p(d, rs) jit_movr_ul((d), (rs))
|
||||
#define jit_movi_p(d, is) jit_movi_ul((d), (long) (is))
|
||||
#define jit_subr_p(d, s1, s2) jit_subr_ul((d), (s1), (s2))
|
||||
#define jit_subi_p(d, rs, is) jit_subi_ul((d), (rs), (long) (is))
|
||||
|
||||
#ifndef jit_addci_i
|
||||
#define jit_addci_i(d, rs, is) jit_addi_i((d), (rs), (is))
|
||||
#define jit_addcr_i(d, s1, s2) jit_addr_i((d), (s1), (s2))
|
||||
#define jit_addci_l(d, rs, is) jit_addi_l((d), (rs), (is))
|
||||
#define jit_addcr_l(d, s1, s2) jit_addr_l((d), (s1), (s2))
|
||||
#endif
|
||||
|
||||
#ifndef jit_subcr_i
|
||||
#define jit_subcr_i(d, s1, s2) jit_subr_i((d), (s1), (s2))
|
||||
#endif
|
||||
|
||||
/* NEG is not mandatory -- pick an appropriate implementation */
|
||||
#ifndef jit_negr_i
|
||||
# ifdef JIT_RZERO
|
||||
# define jit_negr_i(d, rs) jit_subr_i((d), JIT_RZERO, (rs))
|
||||
# define jit_negr_l(d, rs) jit_subr_l((d), JIT_RZERO, (rs))
|
||||
# else /* !JIT_RZERO */
|
||||
# ifndef jit_rsbi_i
|
||||
# define jit_negr_i(d, rs) (jit_xori_i((d), (rs), -1), jit_addi_l((d), (d), 1))
|
||||
# define jit_negr_l(d, rs) (jit_xori_l((d), (rs), -1), jit_addi_l((d), (d), 1))
|
||||
# else /* jit_rsbi_i */
|
||||
# define jit_negr_i(d, rs) jit_rsbi_i((d), (rs), 0)
|
||||
# define jit_negr_l(d, rs) jit_rsbi_l((d), (rs), 0)
|
||||
# endif /* jit_rsbi_i */
|
||||
# endif /* !JIT_RZERO */
|
||||
#endif /* !jit_negr_i */
|
||||
|
||||
/* RSB is not mandatory */
|
||||
#ifndef jit_rsbi_i
|
||||
# define jit_rsbi_i(d, rs, is) (jit_subi_i((d), (rs), (is)), jit_negr_i((d), (d)))
|
||||
|
||||
# ifndef jit_rsbi_l
|
||||
# define jit_rsbi_l(d, rs, is) (jit_subi_l((d), (rs), (is)), jit_negr_l((d), (d)))
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Common 'shortcut' implementations */
|
||||
#define jit_subi_i(d, rs, is) jit_addi_i((d), (rs), -(is))
|
||||
#define jit_subi_l(d, rs, is) jit_addi_l((d), (rs), -(is))
|
||||
#define jit_subci_i(d, rs, is) jit_addci_i((d), (rs), -(is))
|
||||
#define jit_subci_l(d, rs, is) jit_addci_l((d), (rs), -(is))
|
||||
#define jit_rsbr_i(d, s1, s2) jit_subr_i((d), (s2), (s1))
|
||||
#define jit_rsbr_l(d, s1, s2) jit_subr_l((d), (s2), (s1))
|
||||
|
||||
/* Unary */
|
||||
#define jit_notr_c(d, rs) jit_xori_c((d), (rs), 255)
|
||||
#define jit_notr_uc(d, rs) jit_xori_c((d), (rs), 255)
|
||||
#define jit_notr_s(d, rs) jit_xori_s((d), (rs), 65535)
|
||||
#define jit_notr_us(d, rs) jit_xori_s((d), (rs), 65535)
|
||||
|
||||
#if SIZEOF_LONG != 4
|
||||
#define jit_notr_i(d, rs) jit_xori_i((d), (rs), 0xFFFFFFFF)
|
||||
#define jit_notr_ui(d, rs) jit_xori_i((d), (rs), 0xFFFFFFFF)
|
||||
#define jit_notr_l(d, rs) jit_xori_l((d), (rs), 0xFFFFFFFFFFFFFFFFL)
|
||||
#define jit_notr_ul(d, rs) jit_xori_l((d), (rs), 0xFFFFFFFFFFFFFFFFL)
|
||||
#else
|
||||
#define jit_notr_i(d, rs) jit_xori_i((d), (rs), 0xFFFFFFFFL)
|
||||
#define jit_notr_ui(d, rs) jit_xori_i((d), (rs), 0xFFFFFFFFL)
|
||||
#define jit_notr_l(d, rs) jit_xori_i((d), (rs), 0xFFFFFFFFL)
|
||||
#define jit_notr_ul(d, rs) jit_xori_i((d), (rs), 0xFFFFFFFFL)
|
||||
#endif
|
||||
|
||||
#ifndef jit_extr_c_ui
|
||||
#define jit_extr_c_ui(d, rs) jit_andi_ui((d), (rs), 0xFF)
|
||||
#endif
|
||||
#ifndef jit_extr_s_ui
|
||||
#define jit_extr_s_ui(d, rs) jit_andi_ui((d), (rs), 0xFFFF)
|
||||
#endif
|
||||
#ifndef jit_extr_c_i
|
||||
#define jit_extr_c_i(d, rs) (jit_lshi_i((d), (rs), 24), jit_rshi_i((d), (d), 24))
|
||||
#endif
|
||||
#ifndef jit_extr_s_i
|
||||
#define jit_extr_s_i(d, rs) (jit_lshi_i((d), (rs), 16), jit_rshi_i((d), (d), 16))
|
||||
#endif
|
||||
|
||||
|
||||
#define jit_extr_uc_i(d, rs) jit_extr_c_ui((d), (rs))
|
||||
#define jit_extr_uc_ui(d, rs) jit_extr_c_ui((d), (rs))
|
||||
#define jit_extr_us_i(d, rs) jit_extr_s_ui((d), (rs))
|
||||
#define jit_extr_us_ui(d, rs) jit_extr_s_ui((d), (rs))
|
||||
|
||||
#ifndef jit_extr_i_ul
|
||||
#ifdef jit_addi_l /* sizeof(long) != sizeof(int) */
|
||||
#define jit_extr_i_ul(d, rs) jit_andi_ui((d), (rs), 0xFF)
|
||||
#else /* sizeof(long) == sizeof(int) */
|
||||
#define jit_extr_i_ul(d, rs) jit_movr_i(d, rs)
|
||||
#endif /* sizeof(long) == sizeof(int) */
|
||||
#endif
|
||||
|
||||
#define jit_extr_ui_l(d, rs) jit_extr_i_ul((d), (rs))
|
||||
#define jit_extr_ui_ul(d, rs) jit_extr_i_ul((d), (rs))
|
||||
|
||||
/* NTOH/HTON is not mandatory for big endian architectures */
|
||||
#ifndef jit_ntoh_ui /* big endian */
|
||||
#define jit_ntoh_ui(d, rs) ((d) == (rs) ? (void)0 : jit_movr_i((d), (rs)))
|
||||
#define jit_ntoh_us(d, rs) ((d) == (rs) ? (void)0 : jit_movr_i((d), (rs)))
|
||||
#endif /* big endian */
|
||||
|
||||
/* hton is a synonym for ntoh */
|
||||
#define jit_hton_ui(d, rs) jit_ntoh_ui((d), (rs))
|
||||
#define jit_hton_us(d, rs) jit_ntoh_us((d), (rs))
|
||||
|
||||
/* Stack synonyms */
|
||||
#define jit_pushr_ui(rs) jit_pushr_i(rs)
|
||||
#define jit_popr_ui(rs) jit_popr_i(rs)
|
||||
#define jit_pushr_ul(rs) jit_pushr_l(rs)
|
||||
#define jit_popr_ul(rs) jit_popr_l(rs)
|
||||
#define jit_pushr_p(rs) jit_pushr_ul(rs)
|
||||
#define jit_popr_p(rs) jit_popr_ul(rs)
|
||||
|
||||
#define jit_prepare(nint) jitfp_prepare((nint), 0, 0)
|
||||
#define jit_pusharg_c(rs) jit_pusharg_i(rs)
|
||||
#define jit_pusharg_s(rs) jit_pusharg_i(rs)
|
||||
#define jit_pusharg_uc(rs) jit_pusharg_i(rs)
|
||||
#define jit_pusharg_us(rs) jit_pusharg_i(rs)
|
||||
#define jit_pusharg_ui(rs) jit_pusharg_i(rs)
|
||||
#define jit_pusharg_ul(rs) jit_pusharg_l(rs)
|
||||
#define jit_pusharg_p(rs) jit_pusharg_ul(rs)
|
||||
|
||||
/* Memory synonyms */
|
||||
|
||||
#ifdef JIT_RZERO
|
||||
#ifndef jit_ldi_c
|
||||
#define jit_ldi_c(rd, is) jit_ldxi_c((rd), JIT_RZERO, (is))
|
||||
#define jit_sti_c(id, rs) jit_stxi_c((id), JIT_RZERO, (rs))
|
||||
#define jit_ldi_s(rd, is) jit_ldxi_s((rd), JIT_RZERO, (is))
|
||||
#define jit_sti_s(id, rs) jit_stxi_s((id), JIT_RZERO, (rs))
|
||||
#define jit_ldi_i(rd, is) jit_ldxi_i((rd), JIT_RZERO, (is))
|
||||
#define jit_sti_i(id, rs) jit_stxi_i((id), JIT_RZERO, (rs))
|
||||
#define jit_ldi_l(rd, is) jit_ldxi_l((rd), JIT_RZERO, (is))
|
||||
#define jit_sti_l(id, rs) jit_stxi_l((id), JIT_RZERO, (rs))
|
||||
#define jit_ldi_uc(rd, is) jit_ldxi_uc((rd), JIT_RZERO, (is))
|
||||
#define jit_ldi_us(rd, is) jit_ldxi_us((rd), JIT_RZERO, (is))
|
||||
#define jit_ldi_ui(rd, is) jit_ldxi_ui((rd), JIT_RZERO, (is))
|
||||
#define jit_ldi_ul(rd, is) jit_ldxi_ul((rd), JIT_RZERO, (is))
|
||||
#endif
|
||||
|
||||
#ifndef jit_ldr_c
|
||||
#define jit_ldr_c(rd, rs) jit_ldxr_c((rd), JIT_RZERO, (rs))
|
||||
#define jit_str_c(rd, rs) jit_stxr_c(JIT_RZERO, (rd), (rs))
|
||||
#define jit_ldr_s(rd, rs) jit_ldxr_s((rd), JIT_RZERO, (rs))
|
||||
#define jit_str_s(rd, rs) jit_stxr_s(JIT_RZERO, (rd), (rs))
|
||||
#define jit_ldr_i(rd, rs) jit_ldxr_i((rd), JIT_RZERO, (rs))
|
||||
#define jit_str_i(rd, rs) jit_stxr_i(JIT_RZERO, (rd), (rs))
|
||||
#define jit_ldr_l(rd, rs) jit_ldxr_l((rd), JIT_RZERO, (rs))
|
||||
#define jit_str_l(rd, rs) jit_stxr_l(JIT_RZERO, (rd), (rs))
|
||||
#define jit_ldr_uc(rd, rs) jit_ldxr_uc((rd), JIT_RZERO, (rs))
|
||||
#define jit_ldr_us(rd, rs) jit_ldxr_us((rd), JIT_RZERO, (rs))
|
||||
#define jit_ldr_ui(rd, rs) jit_ldxr_ui((rd), JIT_RZERO, (rs))
|
||||
#define jit_ldr_ul(rd, rs) jit_ldxr_ul((rd), JIT_RZERO, (rs))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define jit_str_uc(rd, rs) jit_str_c((rd), (rs))
|
||||
#define jit_sti_uc(id, rs) jit_sti_c((id), (rs))
|
||||
#define jit_stxr_uc(d1, d2, rs) jit_stxr_c((d1), (d2), (rs))
|
||||
#define jit_stxi_uc(id, rd, is) jit_stxi_c((id), (rd), (is))
|
||||
|
||||
#define jit_str_us(rd, rs) jit_str_s((rd), (rs))
|
||||
#define jit_sti_us(id, rs) jit_sti_s((id), (rs))
|
||||
#define jit_stxr_us(d1, d2, rs) jit_stxr_s((d1), (d2), (rs))
|
||||
#define jit_stxi_us(id, rd, is) jit_stxi_s((id), (rd), (is))
|
||||
|
||||
#define jit_str_ui(rd, rs) jit_str_i((rd), (rs))
|
||||
#define jit_sti_ui(id, rs) jit_sti_i((id), (rs))
|
||||
#define jit_stxr_ui(d1, d2, rs) jit_stxr_i((d1), (d2), (rs))
|
||||
#define jit_stxi_ui(id, rd, is) jit_stxi_i((id), (rd), (is))
|
||||
|
||||
#define jit_str_ul(rd, rs) jit_str_l((rd), (rs))
|
||||
#define jit_sti_ul(id, rs) jit_sti_l((id), (rs))
|
||||
#define jit_stxr_ul(d1, d2, rs) jit_stxr_l((d1), (d2), (rs))
|
||||
#define jit_stxi_ul(id, rd, is) jit_stxi_l((id), (rd), (is))
|
||||
|
||||
#define jit_str_p(rd, rs) jit_str_l((rd), (rs))
|
||||
#define jit_sti_p(id, rs) jit_sti_l((id), (rs))
|
||||
#define jit_stxr_p(d1, d2, rs) jit_stxr_l((d1), (d2), (rs))
|
||||
#define jit_stxi_p(id, rd, is) jit_stxi_l((id), (rd), (is))
|
||||
|
||||
#define jit_ldr_p(rd, rs) jit_ldr_l((rd), (rs))
|
||||
#define jit_ldi_p(rd, is) jit_ldi_l((rd), (is))
|
||||
#define jit_ldxr_p(rd, s1, s2) jit_ldxr_l((rd), (s1), (s2))
|
||||
#define jit_ldxi_p(rd, rs, is) jit_ldxi_l((rd), (rs), (is))
|
||||
|
||||
|
||||
/* Boolean & branch synonyms */
|
||||
#define jit_eqr_ui(d, s1, s2) jit_eqr_i((d), (s1), (s2))
|
||||
#define jit_eqi_ui(d, rs, is) jit_eqi_i((d), (rs), (is))
|
||||
#define jit_ner_ui(d, s1, s2) jit_ner_i((d), (s1), (s2))
|
||||
#define jit_nei_ui(d, rs, is) jit_nei_i((d), (rs), (is))
|
||||
|
||||
#define jit_eqr_ul(d, s1, s2) jit_eqr_l((d), (s1), (s2))
|
||||
#define jit_eqi_ul(d, rs, is) jit_eqi_l((d), (rs), (is))
|
||||
#define jit_ner_ul(d, s1, s2) jit_ner_l((d), (s1), (s2))
|
||||
#define jit_nei_ul(d, rs, is) jit_nei_l((d), (rs), (is))
|
||||
|
||||
#define jit_beqr_ui(label, s1, s2) jit_beqr_i((label), (s1), (s2))
|
||||
#define jit_beqi_ui(label, rs, is) jit_beqi_i((label), (rs), (is))
|
||||
#define jit_bner_ui(label, s1, s2) jit_bner_i((label), (s1), (s2))
|
||||
#define jit_bnei_ui(label, rs, is) jit_bnei_i((label), (rs), (is))
|
||||
#define jit_bmcr_ui(label, s1, s2) jit_bmcr_i((label), (s1), (s2))
|
||||
#define jit_bmci_ui(label, rs, is) jit_bmci_i((label), (rs), (is))
|
||||
#define jit_bmsr_ui(label, s1, s2) jit_bmsr_i((label), (s1), (s2))
|
||||
#define jit_bmsi_ui(label, rs, is) jit_bmsi_i((label), (rs), (is))
|
||||
|
||||
#define jit_beqr_ul(label, s1, s2) jit_beqr_l((label), (s1), (s2))
|
||||
#define jit_beqi_ul(label, rs, is) jit_beqi_l((label), (rs), (is))
|
||||
#define jit_bner_ul(label, s1, s2) jit_bner_l((label), (s1), (s2))
|
||||
#define jit_bnei_ul(label, rs, is) jit_bnei_l((label), (rs), (is))
|
||||
#define jit_bmcr_ul(label, s1, s2) jit_bmcr_l((label), (s1), (s2))
|
||||
#define jit_bmci_ul(label, rs, is) jit_bmci_l((label), (rs), (is))
|
||||
#define jit_bmsr_ul(label, s1, s2) jit_bmsr_l((label), (s1), (s2))
|
||||
#define jit_bmsi_ul(label, rs, is) jit_bmsi_l((label), (rs), (is))
|
||||
|
||||
#define jit_ltr_p(d, s1, s2) jit_ltr_ul((d), (s1), (s2))
|
||||
#define jit_lti_p(d, rs, is) jit_lti_ul((d), (rs), (is))
|
||||
#define jit_ler_p(d, s1, s2) jit_ler_ul((d), (s1), (s2))
|
||||
#define jit_lei_p(d, rs, is) jit_lei_ul((d), (rs), (is))
|
||||
#define jit_gtr_p(d, s1, s2) jit_gtr_ul((d), (s1), (s2))
|
||||
#define jit_gti_p(d, rs, is) jit_gti_ul((d), (rs), (is))
|
||||
#define jit_ger_p(d, s1, s2) jit_ger_ul((d), (s1), (s2))
|
||||
#define jit_gei_p(d, rs, is) jit_gei_ul((d), (rs), (is))
|
||||
#define jit_eqr_p(d, s1, s2) jit_eqr_ul((d), (s1), (s2))
|
||||
#define jit_eqi_p(d, rs, is) jit_eqi_ul((d), (rs), (is))
|
||||
#define jit_ner_p(d, s1, s2) jit_ner_ul((d), (s1), (s2))
|
||||
#define jit_nei_p(d, rs, is) jit_nei_ul((d), (rs), (is))
|
||||
|
||||
#define jit_bltr_p(label, s1, s2) jit_bltr_ul((label), (s1), (s2))
|
||||
#define jit_blti_p(label, rs, is) jit_blti_ul((label), (rs), (is))
|
||||
#define jit_bler_p(label, s1, s2) jit_bler_ul((label), (s1), (s2))
|
||||
#define jit_blei_p(label, rs, is) jit_blei_ul((label), (rs), (is))
|
||||
#define jit_bgtr_p(label, s1, s2) jit_bgtr_ul((label), (s1), (s2))
|
||||
#define jit_bgti_p(label, rs, is) jit_bgti_ul((label), (rs), (is))
|
||||
#define jit_bger_p(label, s1, s2) jit_bger_ul((label), (s1), (s2))
|
||||
#define jit_bgei_p(label, rs, is) jit_bgei_ul((label), (rs), (is))
|
||||
#define jit_beqr_p(label, s1, s2) jit_beqr_ul((label), (s1), (s2))
|
||||
#define jit_beqi_p(label, rs, is) jit_beqi_ul((label), (rs), (is))
|
||||
#define jit_bner_p(label, s1, s2) jit_bner_ul((label), (s1), (s2))
|
||||
#define jit_bnei_p(label, rs, is) jit_bnei_ul((label), (rs), (is))
|
||||
|
||||
#define jit_retval_ui(rd) jit_retval_i((rd))
|
||||
#define jit_retval_uc(rd) jit_retval_i((rd))
|
||||
#define jit_retval_us(rd) jit_retval_i((rd))
|
||||
#define jit_retval_ul(rd) jit_retval_l((rd))
|
||||
#define jit_retval_p(rd) jit_retval_ul((rd))
|
||||
#define jit_retval_c(rd) jit_retval_i((rd))
|
||||
#define jit_retval_s(rd) jit_retval_i((rd))
|
||||
|
||||
#ifndef jit_finish
|
||||
#define jit_finish(sub) jit_calli(sub)
|
||||
#endif
|
||||
|
||||
#ifndef jit_prolog
|
||||
#define jit_prolog(numargs)
|
||||
#endif
|
||||
|
||||
#ifndef jit_leaf
|
||||
#define jit_leaf(numargs) jit_prolog(numargs)
|
||||
#endif
|
||||
|
||||
#ifndef jit_getarg_c
|
||||
#ifndef JIT_FP
|
||||
#define jit_getarg_c(reg, ofs) jit_extr_c_i ((reg), (ofs))
|
||||
#define jit_getarg_i(reg, ofs) jit_movr_i ((reg), (ofs))
|
||||
#define jit_getarg_l(reg, ofs) jit_movr_l ((reg), (ofs))
|
||||
#define jit_getarg_p(reg, ofs) jit_movr_p ((reg), (ofs))
|
||||
#define jit_getarg_s(reg, ofs) jit_extr_s_i ((reg), (ofs))
|
||||
#define jit_getarg_uc(reg, ofs) jit_extr_uc_ui((reg), (ofs))
|
||||
#define jit_getarg_ui(reg, ofs) jit_movr_ui ((reg), (ofs))
|
||||
#define jit_getarg_ul(reg, ofs) jit_extr_uc_ul((reg), (ofs))
|
||||
#define jit_getarg_us(reg, ofs) jit_extr_us_ul((reg), (ofs))
|
||||
#else
|
||||
#define jit_getarg_c(reg, ofs) jit_ldxi_c((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_uc(reg, ofs) jit_ldxi_uc((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_s(reg, ofs) jit_ldxi_s((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_us(reg, ofs) jit_ldxi_us((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_i(reg, ofs) jit_ldxi_i((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_ui(reg, ofs) jit_ldxi_ui((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_l(reg, ofs) jit_ldxi_l((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_ul(reg, ofs) jit_ldxi_ul((reg), JIT_FP, (ofs));
|
||||
#define jit_getarg_p(reg, ofs) jit_ldxi_p((reg), JIT_FP, (ofs));
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/* Common definitions when sizeof(long) = sizeof(int) */
|
||||
#ifndef jit_addi_l
|
||||
#define JIT_LONG_IS_INT
|
||||
|
||||
/* ALU */
|
||||
#define jit_addi_l(d, rs, is) jit_addi_i((d), (rs), (is))
|
||||
#define jit_addr_l(d, s1, s2) jit_addr_i((d), (s1), (s2))
|
||||
#define jit_addci_l(d, rs, is) jit_addci_i((d), (rs), (is))
|
||||
#define jit_addcr_l(d, s1, s2) jit_addcr_i((d), (s1), (s2))
|
||||
#define jit_addxi_l(d, rs, is) jit_addxi_i((d), (rs), (is))
|
||||
#define jit_addxr_l(d, s1, s2) jit_addxr_i((d), (s1), (s2))
|
||||
#define jit_andi_l(d, rs, is) jit_andi_i((d), (rs), (is))
|
||||
#define jit_andr_l(d, s1, s2) jit_andr_i((d), (s1), (s2))
|
||||
#define jit_divi_l(d, rs, is) jit_divi_i((d), (rs), (is))
|
||||
#define jit_divr_l(d, s1, s2) jit_divr_i((d), (s1), (s2))
|
||||
#define jit_hmuli_l(d, rs, is) jit_hmuli_i((d), (rs), (is))
|
||||
#define jit_hmulr_l(d, s1, s2) jit_hmulr_i((d), (s1), (s2))
|
||||
#define jit_lshi_l(d, rs, is) jit_lshi_i((d), (rs), (is))
|
||||
#define jit_lshr_l(d, s1, s2) jit_lshr_i((d), (s1), (s2))
|
||||
#define jit_modi_l(d, rs, is) jit_modi_i((d), (rs), (is))
|
||||
#define jit_modr_l(d, s1, s2) jit_modr_i((d), (s1), (s2))
|
||||
#define jit_muli_l(d, rs, is) jit_muli_i((d), (rs), (is))
|
||||
#define jit_mulr_l(d, s1, s2) jit_mulr_i((d), (s1), (s2))
|
||||
#define jit_ori_l(d, rs, is) jit_ori_i((d), (rs), (is))
|
||||
#define jit_orr_l(d, s1, s2) jit_orr_i((d), (s1), (s2))
|
||||
#define jit_rshi_l(d, rs, is) jit_rshi_i((d), (rs), (is))
|
||||
#define jit_rshr_l(d, s1, s2) jit_rshr_i((d), (s1), (s2))
|
||||
#define jit_subr_l(d, s1, s2) jit_subr_i((d), (s1), (s2))
|
||||
#define jit_subcr_l(d, s1, s2) jit_subcr_i((d), (s1), (s2))
|
||||
#define jit_subxi_l(d, rs, is) jit_subxi_i((d), (rs), (is))
|
||||
#define jit_subxr_l(d, s1, s2) jit_subxr_i((d), (s1), (s2))
|
||||
#define jit_xori_l(d, rs, is) jit_xori_i((d), (rs), (is))
|
||||
#define jit_xorr_l(d, s1, s2) jit_xorr_i((d), (s1), (s2))
|
||||
|
||||
#ifndef jit_rsbi_l
|
||||
#define jit_rsbi_l(d, rs, is) jit_rsbi_i((d), (rs), (is))
|
||||
#endif
|
||||
|
||||
#define jit_divi_ul(d, rs, is) jit_divi_ui((d), (rs), (is))
|
||||
#define jit_divr_ul(d, s1, s2) jit_divr_ui((d), (s1), (s2))
|
||||
#define jit_hmuli_ul(d, rs, is) jit_hmuli_ui((d), (rs), (is))
|
||||
#define jit_hmulr_ul(d, s1, s2) jit_hmulr_ui((d), (s1), (s2))
|
||||
#define jit_modi_ul(d, rs, is) jit_modi_ui((d), (rs), (is))
|
||||
#define jit_modr_ul(d, s1, s2) jit_modr_ui((d), (s1), (s2))
|
||||
#define jit_muli_ul(d, rs, is) jit_muli_ui((d), (rs), (is))
|
||||
#define jit_mulr_ul(d, s1, s2) jit_mulr_ui((d), (s1), (s2))
|
||||
#define jit_rshi_ul(d, rs, is) jit_rshi_ui((d), (rs), (is))
|
||||
#define jit_rshr_ul(d, s1, s2) jit_rshr_ui((d), (s1), (s2))
|
||||
|
||||
/* Unary */
|
||||
#define jit_movi_l(d, rs) jit_movi_i((d), (rs))
|
||||
#define jit_movr_l(d, rs) jit_movr_i((d), (rs))
|
||||
|
||||
/* Stack */
|
||||
#define jit_pushr_l(rs) jit_pushr_i(rs)
|
||||
#define jit_popr_l(rs) jit_popr_i(rs)
|
||||
#define jit_pusharg_l(rs) jit_pusharg_i(rs)
|
||||
|
||||
/* Memory */
|
||||
#ifndef JIT_RZERO
|
||||
#define jit_ldr_l(d, rs) jit_ldr_i((d), (rs))
|
||||
#define jit_ldi_l(d, is) jit_ldi_i((d), (is))
|
||||
#define jit_str_l(d, rs) jit_str_i((d), (rs))
|
||||
#define jit_sti_l(d, is) jit_sti_i((d), (is))
|
||||
#define jit_ldr_ui(d, rs) jit_ldr_i((d), (rs))
|
||||
#define jit_ldi_ui(d, is) jit_ldi_i((d), (is))
|
||||
#define jit_ldr_ul(d, rs) jit_ldr_ui((d), (rs))
|
||||
#define jit_ldi_ul(d, is) jit_ldi_ui((d), (is))
|
||||
#endif
|
||||
|
||||
#define jit_ldxr_l(d, s1, s2) jit_ldxr_i((d), (s1), (s2))
|
||||
#define jit_ldxi_l(d, rs, is) jit_ldxi_i((d), (rs), (is))
|
||||
#define jit_stxr_l(d, s1, s2) jit_stxr_i((d), (s1), (s2))
|
||||
#define jit_stxi_l(d, rs, is) jit_stxi_i((d), (rs), (is))
|
||||
#define jit_ldxr_ui(d, s1, s2) jit_ldxr_i((d), (s1), (s2))
|
||||
#define jit_ldxi_ui(d, rs, is) jit_ldxi_i((d), (rs), (is))
|
||||
#define jit_ldxr_ul(d, s1, s2) jit_ldxr_ui((d), (s1), (s2))
|
||||
#define jit_ldxi_ul(d, rs, is) jit_ldxi_ui((d), (rs), (is))
|
||||
|
||||
|
||||
/* Boolean */
|
||||
#define jit_ltr_l(d, s1, s2) jit_ltr_i((d), (s1), (s2))
|
||||
#define jit_lti_l(d, rs, is) jit_lti_i((d), (rs), (is))
|
||||
#define jit_ler_l(d, s1, s2) jit_ler_i((d), (s1), (s2))
|
||||
#define jit_lei_l(d, rs, is) jit_lei_i((d), (rs), (is))
|
||||
#define jit_gtr_l(d, s1, s2) jit_gtr_i((d), (s1), (s2))
|
||||
#define jit_gti_l(d, rs, is) jit_gti_i((d), (rs), (is))
|
||||
#define jit_ger_l(d, s1, s2) jit_ger_i((d), (s1), (s2))
|
||||
#define jit_gei_l(d, rs, is) jit_gei_i((d), (rs), (is))
|
||||
#define jit_eqr_l(d, s1, s2) jit_eqr_i((d), (s1), (s2))
|
||||
#define jit_eqi_l(d, rs, is) jit_eqi_i((d), (rs), (is))
|
||||
#define jit_ner_l(d, s1, s2) jit_ner_i((d), (s1), (s2))
|
||||
#define jit_nei_l(d, rs, is) jit_nei_i((d), (rs), (is))
|
||||
#define jit_ltr_ul(d, s1, s2) jit_ltr_ui((d), (s1), (s2))
|
||||
#define jit_lti_ul(d, rs, is) jit_lti_ui((d), (rs), (is))
|
||||
#define jit_ler_ul(d, s1, s2) jit_ler_ui((d), (s1), (s2))
|
||||
#define jit_lei_ul(d, rs, is) jit_lei_ui((d), (rs), (is))
|
||||
#define jit_gtr_ul(d, s1, s2) jit_gtr_ui((d), (s1), (s2))
|
||||
#define jit_gti_ul(d, rs, is) jit_gti_ui((d), (rs), (is))
|
||||
#define jit_ger_ul(d, s1, s2) jit_ger_ui((d), (s1), (s2))
|
||||
#define jit_gei_ul(d, rs, is) jit_gei_ui((d), (rs), (is))
|
||||
|
||||
/* Branches */
|
||||
#define jit_bltr_l(label, s1, s2) jit_bltr_i((label), (s1), (s2))
|
||||
#define jit_blti_l(label, rs, is) jit_blti_i((label), (rs), (is))
|
||||
#define jit_bler_l(label, s1, s2) jit_bler_i((label), (s1), (s2))
|
||||
#define jit_blei_l(label, rs, is) jit_blei_i((label), (rs), (is))
|
||||
#define jit_bgtr_l(label, s1, s2) jit_bgtr_i((label), (s1), (s2))
|
||||
#define jit_bgti_l(label, rs, is) jit_bgti_i((label), (rs), (is))
|
||||
#define jit_bger_l(label, s1, s2) jit_bger_i((label), (s1), (s2))
|
||||
#define jit_bgei_l(label, rs, is) jit_bgei_i((label), (rs), (is))
|
||||
#define jit_beqr_l(label, s1, s2) jit_beqr_i((label), (s1), (s2))
|
||||
#define jit_beqi_l(label, rs, is) jit_beqi_i((label), (rs), (is))
|
||||
#define jit_bner_l(label, s1, s2) jit_bner_i((label), (s1), (s2))
|
||||
#define jit_bnei_l(label, rs, is) jit_bnei_i((label), (rs), (is))
|
||||
#define jit_bmcr_l(label, s1, s2) jit_bmcr_i((label), (s1), (s2))
|
||||
#define jit_bmci_l(label, rs, is) jit_bmci_i((label), (rs), (is))
|
||||
#define jit_bmsr_l(label, s1, s2) jit_bmsr_i((label), (s1), (s2))
|
||||
#define jit_bmsi_l(label, rs, is) jit_bmsi_i((label), (rs), (is))
|
||||
#define jit_boaddr_l(label, s1, s2) jit_boaddr_i((label), (s1), (s2))
|
||||
#define jit_boaddi_l(label, rs, is) jit_boaddi_i((label), (rs), (is))
|
||||
#define jit_bosubr_l(label, s1, s2) jit_bosubr_i((label), (s1), (s2))
|
||||
#define jit_bosubi_l(label, rs, is) jit_bosubi_i((label), (rs), (is))
|
||||
#define jit_bltr_ul(label, s1, s2) jit_bltr_ui((label), (s1), (s2))
|
||||
#define jit_blti_ul(label, rs, is) jit_blti_ui((label), (rs), (is))
|
||||
#define jit_bler_ul(label, s1, s2) jit_bler_ui((label), (s1), (s2))
|
||||
#define jit_blei_ul(label, rs, is) jit_blei_ui((label), (rs), (is))
|
||||
#define jit_bgtr_ul(label, s1, s2) jit_bgtr_ui((label), (s1), (s2))
|
||||
#define jit_bgti_ul(label, rs, is) jit_bgti_ui((label), (rs), (is))
|
||||
#define jit_bger_ul(label, s1, s2) jit_bger_ui((label), (s1), (s2))
|
||||
#define jit_bgei_ul(label, rs, is) jit_bgei_ui((label), (rs), (is))
|
||||
#define jit_boaddr_ul(label, s1, s2) jit_boaddr_ui((label), (s1), (s2))
|
||||
#define jit_boaddi_ul(label, rs, is) jit_boaddi_ui((label), (rs), (is))
|
||||
#define jit_bosubr_ul(label, s1, s2) jit_bosubr_ui((label), (s1), (s2))
|
||||
#define jit_bosubi_ul(label, rs, is) jit_bosubi_ui((label), (rs), (is))
|
||||
|
||||
#define jit_retval_l(rd) jit_retval_i((rd))
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* __lightning_core_common_h_ */
|
||||
260
lightning/fp-common.h
Normal file
260
lightning/fp-common.h
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer floating-point interface
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
struct jit_fp {
|
||||
char kind;
|
||||
char subkind;
|
||||
union {
|
||||
struct {
|
||||
int displ;
|
||||
char reg1;
|
||||
char reg2;
|
||||
} addr;
|
||||
union {
|
||||
double number;
|
||||
long split[sizeof(double) / sizeof(long)];
|
||||
} imm;
|
||||
struct {
|
||||
struct jit_fp *lhs, *rhs;
|
||||
} ops;
|
||||
} d;
|
||||
};
|
||||
|
||||
#ifdef jit_trunc
|
||||
|
||||
enum { JIT_NULL, /* unused */
|
||||
|
||||
JIT_CMP, JIT_FLOOR, JIT_CEIL, JIT_ROUND, JIT_TRUNC, /* integer */
|
||||
|
||||
JIT_XI, JIT_ADD, JIT_XR, JIT_SUB, /* subkinds */
|
||||
JIT_I, JIT_MUL, JIT_R, JIT_DIV,
|
||||
JIT_INT,
|
||||
|
||||
JIT_ABS, JIT_SIN, JIT_COS, JIT_TAN, JIT_ATN, /* functions */
|
||||
JIT_EXP, JIT_LOG, JIT_NEG, JIT_SQRT,
|
||||
|
||||
JIT_OP, JIT_FN, JIT_LD, JIT_IMM }; /* kinds */
|
||||
|
||||
/* Declarations */
|
||||
|
||||
static void _jit_emit(jit_state *, struct jit_fp *,
|
||||
int, int, int, int) JIT_UNUSED;
|
||||
static struct jit_fp *_jit_op(struct jit_fp *, int,
|
||||
struct jit_fp *, struct jit_fp *) JIT_UNUSED;
|
||||
static struct jit_fp *_jit_ld(struct jit_fp *, int,
|
||||
int, int) JIT_UNUSED;
|
||||
static struct jit_fp *_jit_fn(struct jit_fp *, int,
|
||||
struct jit_fp *) JIT_UNUSED;
|
||||
static struct jit_fp *_jit_imm(struct jit_fp *, double) JIT_UNUSED;
|
||||
|
||||
/* Internal function to walk the tree */
|
||||
|
||||
void
|
||||
_jit_emit(jit_state *jit, struct jit_fp *head,
|
||||
int store_kind, int store1, int store2, int reg0)
|
||||
{
|
||||
#define _jit (*jit)
|
||||
switch (head->kind) {
|
||||
case JIT_OP:
|
||||
_jit_emit(jit, head->d.ops.lhs, JIT_NULL, 0, 0, reg0);
|
||||
_jit_emit(jit, head->d.ops.rhs, JIT_NULL, 0, 0, reg0 + 1);
|
||||
switch (head->subkind) {
|
||||
case JIT_ADD: jit_add_two(reg0); break;
|
||||
case JIT_SUB: jit_sub_two(reg0); break;
|
||||
case JIT_MUL: jit_mul_two(reg0); break;
|
||||
case JIT_DIV: jit_div_two(reg0); break;
|
||||
}
|
||||
break;
|
||||
|
||||
case JIT_IMM:
|
||||
#ifdef JIT_LONG_IS_INT
|
||||
jit_fpimm(reg0, head->d.imm.split[0], head->d.imm.split[1]);
|
||||
#else
|
||||
jit_fpimm(reg0, head->d.imm.split[0]);
|
||||
#endif
|
||||
break;
|
||||
|
||||
case JIT_FN:
|
||||
_jit_emit(jit, head->d.ops.lhs, JIT_NULL, 0, 0, reg0);
|
||||
switch (head->subkind) {
|
||||
case JIT_ABS: jit_abs(reg0); break;
|
||||
#ifdef JIT_TRANSCENDENTAL
|
||||
case JIT_SIN: jit_sin(reg0); break;
|
||||
case JIT_SQRT: jit_sqrt(reg0); break;
|
||||
case JIT_COS: jit_cos(reg0); break;
|
||||
case JIT_TAN: jit_tan(reg0); break;
|
||||
case JIT_ATN: jit_atn(reg0); break;
|
||||
case JIT_EXP: jit_exp(reg0); break;
|
||||
case JIT_LOG: jit_log(reg0); break;
|
||||
case JIT_NEG: jit_neg(reg0); break;
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
|
||||
case JIT_LD:
|
||||
switch (head->subkind) {
|
||||
case JIT_INT: jit_exti_d(reg0, head->d.addr.reg1); break;
|
||||
case JIT_XI: jit_ldxi_f(reg0, head->d.addr.reg1, head->d.addr.displ); break;
|
||||
case JIT_XR: jit_ldxr_f(reg0, head->d.addr.reg1, head->d.addr.reg2); break;
|
||||
case JIT_XI | 1: jit_ldxi_d(reg0, head->d.addr.reg1, head->d.addr.displ); break;
|
||||
case JIT_XR | 1: jit_ldxr_d(reg0, head->d.addr.reg1, head->d.addr.reg2); break;
|
||||
#ifndef JIT_RZERO
|
||||
case JIT_I: jit_ldi_f(reg0, head->d.addr.displ); break;
|
||||
case JIT_R: jit_ldr_f(reg0, head->d.addr.reg1); break;
|
||||
case JIT_I | 1: jit_ldi_d(reg0, head->d.addr.displ); break;
|
||||
case JIT_R | 1: jit_ldr_d(reg0, head->d.addr.reg1); break;
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
switch (store_kind) {
|
||||
case JIT_FLOOR: jit_floor(store1, reg0); break;
|
||||
case JIT_CEIL: jit_ceil(store1, reg0); break;
|
||||
case JIT_TRUNC: jit_trunc(store1, reg0); break;
|
||||
case JIT_ROUND: jit_round(store1, reg0); break;
|
||||
case JIT_CMP: jit_cmp(store1, store2, reg0); break;
|
||||
case JIT_XI: jit_stxi_f(store2, store1, reg0); break;
|
||||
case JIT_XR: jit_stxr_f(store2, store1, reg0); break;
|
||||
case JIT_XI | 1: jit_stxi_d(store2, store1, reg0); break;
|
||||
case JIT_XR | 1: jit_stxr_d(store2, store1, reg0); break;
|
||||
#ifndef JIT_RZERO
|
||||
case JIT_I: jit_sti_f(store2, reg0); break;
|
||||
case JIT_R: jit_str_f(store2, reg0); break;
|
||||
case JIT_I | 1: jit_sti_d(store2, reg0); break;
|
||||
case JIT_R | 1: jit_str_d(store2, reg0); break;
|
||||
case JIT_NULL: break;
|
||||
#endif
|
||||
}
|
||||
#undef _jit
|
||||
}
|
||||
|
||||
/* Internal functions to build the tree */
|
||||
|
||||
struct jit_fp *
|
||||
_jit_op(struct jit_fp *where, int which,
|
||||
struct jit_fp *op1, struct jit_fp *op2)
|
||||
{
|
||||
where->kind = JIT_OP;
|
||||
where->subkind = which;
|
||||
where->d.ops.lhs = op1;
|
||||
where->d.ops.rhs = op2;
|
||||
return (where);
|
||||
}
|
||||
|
||||
struct jit_fp *
|
||||
_jit_ld(struct jit_fp *where, int which, int op1, int op2)
|
||||
{
|
||||
where->kind = JIT_LD;
|
||||
where->subkind = which;
|
||||
switch (which & ~1) {
|
||||
case JIT_XI: where->d.addr.reg1 = op1;
|
||||
case JIT_I: where->d.addr.displ = op2; break;
|
||||
case JIT_XR: where->d.addr.reg2 = op2;
|
||||
case JIT_INT:
|
||||
case JIT_R: where->d.addr.reg1 = op1; break;
|
||||
}
|
||||
return (where);
|
||||
}
|
||||
|
||||
struct jit_fp *
|
||||
_jit_fn(struct jit_fp *where, int which, struct jit_fp *op1)
|
||||
{
|
||||
where->kind = JIT_FN;
|
||||
where->subkind = which;
|
||||
where->d.ops.lhs = op1;
|
||||
return (where);
|
||||
}
|
||||
|
||||
struct jit_fp *
|
||||
_jit_imm(struct jit_fp *where, double number)
|
||||
{
|
||||
where->kind = JIT_IMM;
|
||||
where->d.imm.number = number;
|
||||
return (where);
|
||||
}
|
||||
|
||||
#define jitfp_begin(buf) (_jit.fp = (buf), --_jit.fp)
|
||||
#define jitfp_add(op1, op2) _jit_op(++_jit.fp, JIT_ADD, (op1), (op2))
|
||||
#define jitfp_sub(op1, op2) _jit_op(++_jit.fp, JIT_SUB, (op1), (op2))
|
||||
#define jitfp_mul(op1, op2) _jit_op(++_jit.fp, JIT_MUL, (op1), (op2))
|
||||
#define jitfp_div(op1, op2) _jit_op(++_jit.fp, JIT_DIV, (op1), (op2))
|
||||
#define jitfp_imm(imm) _jit_imm(++_jit.fp, (imm))
|
||||
#define jitfp_exti_d(reg1) _jit_ld(++_jit.fp, JIT_INT, (reg1), 0)
|
||||
#define jitfp_ldxi_f(reg1, imm) _jit_ld(++_jit.fp, JIT_XI, (reg1), (long)(imm))
|
||||
#define jitfp_ldxr_f(reg1, reg2) _jit_ld(++_jit.fp, JIT_XR, (reg1), (reg2))
|
||||
#define jitfp_ldxi_d(reg1, imm) _jit_ld(++_jit.fp, JIT_XI | 1, (reg1), (long)(imm))
|
||||
#define jitfp_ldxr_d(reg1, reg2) _jit_ld(++_jit.fp, JIT_XR | 1, (reg1), (reg2))
|
||||
#define jitfp_abs(op1) _jit_fn(++_jit.fp, JIT_ABS, (op1))
|
||||
#define jitfp_sqrt(op1) _jit_fn(++_jit.fp, JIT_SQRT, (op1))
|
||||
#define jitfp_neg(op1) _jit_fn(++_jit.fp, JIT_NEG, (op1))
|
||||
#define jitfp_stxi_f(imm, reg1, op1) _jit_emit(&_jit, (op1), JIT_XI, (reg1), (long)(imm), 0)
|
||||
#define jitfp_stxr_f(reg1, reg2, op2) _jit_emit(&_jit, (op1), JIT_XR, (reg1), (reg2), 0)
|
||||
#define jitfp_stxi_d(imm, reg1, op1) _jit_emit(&_jit, (op1), JIT_XI | 1, (reg1), (long)(imm), 0)
|
||||
#define jitfp_stxr_d(reg1, reg2, op2) _jit_emit(&_jit, (op1), JIT_XR | 1, (reg1), (reg2), 0)
|
||||
#define jitfp_cmp(regle, regge, op1) _jit_emit(&_jit, (op1), JIT_CMP, regle, regge, 0)
|
||||
#define jitfp_floor(reg1, op1) _jit_emit(&_jit, (op1), JIT_FLOOR, reg1, 0, 0)
|
||||
#define jitfp_ceil(reg1, op1) _jit_emit(&_jit, (op1), JIT_CEIL, reg1, 0, 0)
|
||||
#define jitfp_trunc(reg1, op1) _jit_emit(&_jit, (op1), JIT_TRUNC, reg1, 0, 0)
|
||||
#define jitfp_round(reg1, op1) _jit_emit(&_jit, (op1), JIT_ROUND, reg1, 0, 0)
|
||||
|
||||
|
||||
#ifdef JIT_TRANSCENDENTAL
|
||||
#define jitfp_sin(op1) _jit_fn(++_jit.fp, JIT_SIN, (op1))
|
||||
#define jitfp_cos(op1) _jit_fn(++_jit.fp, JIT_COS, (op1))
|
||||
#define jitfp_tan(op1) _jit_fn(++_jit.fp, JIT_TAN, (op1))
|
||||
#define jitfp_atn(op1) _jit_fn(++_jit.fp, JIT_ATN, (op1))
|
||||
#define jitfp_exp(op1) _jit_fn(++_jit.fp, JIT_EXP, (op1))
|
||||
#define jitfp_log(op1) _jit_fn(++_jit.fp, JIT_LOG, (op1))
|
||||
#endif
|
||||
|
||||
#ifdef JIT_RZERO
|
||||
#define jitfp_ldi_f(imm) _jit_ld(++_jit.fp, JIT_XI, JIT_RZERO, (long)(imm))
|
||||
#define jitfp_ldr_f(reg1) _jit_ld(++_jit.fp, JIT_XR, JIT_RZERO, (reg1))
|
||||
#define jitfp_ldi_d(imm) _jit_ld(++_jit.fp, JIT_XI | 1, JIT_RZERO, (long)(imm))
|
||||
#define jitfp_ldr_d(reg1) _jit_ld(++_jit.fp, JIT_XR | 1, JIT_RZERO, (reg1))
|
||||
#define jitfp_sti_f(imm, op1) _jit_emit(&_jit, (op1), JIT_XI, JIT_RZERO, (long)(imm), 0)
|
||||
#define jitfp_str_f(reg1, op1) _jit_emit(&_jit, (op1), JIT_XR, JIT_RZERO, (reg1), 0)
|
||||
#define jitfp_sti_d(imm, op1) _jit_emit(&_jit, (op1), JIT_XI | 1, JIT_RZERO, (long)(imm), 0)
|
||||
#define jitfp_str_d(reg1, op1) _jit_emit(&_jit, (op1), JIT_XR | 1, JIT_RZERO, (reg1), 0)
|
||||
#else
|
||||
#define jitfp_ldi_f(imm) _jit_ld(++_jit.fp, JIT_I, 0, (long)(imm))
|
||||
#define jitfp_ldr_f(reg1) _jit_ld(++_jit.fp, JIT_R, 0, (reg1))
|
||||
#define jitfp_ldi_d(imm) _jit_ld(++_jit.fp, JIT_I | 1, 0, (long)(imm))
|
||||
#define jitfp_ldr_d(reg1) _jit_ld(++_jit.fp, JIT_R | 1, 0, (reg1))
|
||||
#define jitfp_sti_f(imm, op1) _jit_emit(&_jit, (op1), JIT_I, 0, (long)(imm), 0)
|
||||
#define jitfp_str_f(reg1, op1) _jit_emit(&_jit, (op1), JIT_R, 0, (reg1), 0)
|
||||
#define jitfp_sti_d(imm, op1) _jit_emit(&_jit, (op1), JIT_I | 1, 0, (long)(imm), 0)
|
||||
#define jitfp_str_d(reg1, op1) _jit_emit(&_jit, (op1), JIT_R | 1, 0, (reg1), 0)
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
48
lightning/funcs-common.h
Normal file
48
lightning/funcs-common.h
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer inline functions (common part)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
#ifndef __lightning_funcs_common_h
|
||||
#define __lightning_funcs_common_h
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
static int jit_fail(char *, char*, int, char *) JIT_UNUSED;
|
||||
|
||||
int
|
||||
jit_fail(char *msg, char *file, int line, char *function)
|
||||
{
|
||||
fprintf(stderr, "%s: In function `%s':\n", file, function);
|
||||
fprintf(stderr, "%s:%d: %s\n", file, line, msg);
|
||||
abort();
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* __lightning_funcs_common_h */
|
||||
982
lightning/i386/asm.h
Normal file
982
lightning/i386/asm.h
Normal file
|
|
@ -0,0 +1,982 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler for the i386
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 1999, 2000, 2001, 2002 Ian Piumarta
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_asm_h
|
||||
#define __lightning_asm_h
|
||||
|
||||
/* OPCODE + i = immediate operand
|
||||
* + r = register operand
|
||||
* + m = memory operand (disp,base,index,scale)
|
||||
* + sr/sm = a star preceding a register or memory
|
||||
*/
|
||||
|
||||
|
||||
typedef _uc jit_insn;
|
||||
|
||||
#define _b00 0
|
||||
#define _b01 1
|
||||
#define _b10 2
|
||||
#define _b11 3
|
||||
|
||||
#define _b000 0
|
||||
#define _b001 1
|
||||
#define _b010 2
|
||||
#define _b011 3
|
||||
#define _b100 4
|
||||
#define _b101 5
|
||||
#define _b110 6
|
||||
#define _b111 7
|
||||
|
||||
/*** REGISTERS ***/ /* [size,,number] */
|
||||
|
||||
|
||||
#define _AL 0x10
|
||||
#define _CL 0x11
|
||||
#define _DL 0x12
|
||||
#define _BL 0x13
|
||||
#define _AH 0x14
|
||||
#define _CH 0x15
|
||||
#define _DH 0x16
|
||||
#define _BH 0x17
|
||||
|
||||
#define _AX 0x20
|
||||
#define _CX 0x21
|
||||
#define _DX 0x22
|
||||
#define _BX 0x23
|
||||
#define _SP 0x24
|
||||
#define _BP 0x25
|
||||
#define _SI 0x26
|
||||
#define _DI 0x27
|
||||
|
||||
#define _EAX 0x40
|
||||
#define _ECX 0x41
|
||||
#define _EDX 0x42
|
||||
#define _EBX 0x43
|
||||
#define _ESP 0x44
|
||||
#define _EBP 0x45
|
||||
#define _ESI 0x46
|
||||
#define _EDI 0x47
|
||||
|
||||
#define _rS(R) ((R)>>4)
|
||||
#define _rN(R) ((R)&0x7)
|
||||
#define _r0P(R) ((R)==0)
|
||||
|
||||
#ifndef _ASM_SAFETY
|
||||
#define _r1(R) _rN(R)
|
||||
#define _r2(R) _rN(R)
|
||||
#define _r4(R) _rN(R)
|
||||
#else
|
||||
#define _r1(R) ((_rS(R)==1) ? _rN(R) : JITFAIL( "8-bit register required"))
|
||||
#define _r2(R) ((_rS(R)==2) ? _rN(R) : JITFAIL("16-bit register required"))
|
||||
#define _r4(R) ((_rS(R)==4) ? _rN(R) : JITFAIL("32-bit register required"))
|
||||
#endif
|
||||
|
||||
/*** ASSEMBLER ***/
|
||||
|
||||
#define _OFF4(D) (_UL(D) - _UL(_jit.pc))
|
||||
#define _CKD8(D) _ck_d(8, ((_uc) _OFF4(D)) )
|
||||
|
||||
#define _D8(D) (_B(0), ((*(_PUC(_jit.pc)-1))= _CKD8(D)))
|
||||
#define _D32(D) (_L(0), ((*(_PUL(_jit.pc)-1))= _OFF4(D)))
|
||||
|
||||
#ifndef _ASM_SAFETY
|
||||
# define _M(M) (M)
|
||||
# define _r(R) (R)
|
||||
# define _m(M) (M)
|
||||
# define _s(S) (S)
|
||||
# define _i(I) (I)
|
||||
# define _b(B) (B)
|
||||
# define _noESP(I,OK) (OK)
|
||||
#else
|
||||
# define _M(M) (((M)>3) ? JITFAIL("internal error: mod = " #M) : (M))
|
||||
# define _r(R) (((R)>7) ? JITFAIL("internal error: reg = " #R) : (R))
|
||||
# define _m(M) (((M)>7) ? JITFAIL("internal error: r/m = " #M) : (M))
|
||||
# define _s(S) (((S)>3) ? JITFAIL("internal error: memory scale = " #S) : (S))
|
||||
# define _i(I) (((I)>7) ? JITFAIL("internal error: memory index = " #I) : (I))
|
||||
# define _b(B) (((B)>7) ? JITFAIL("internal error: memory base = " #B) : (B))
|
||||
# define _noESP(I,OK) (((I)==_ESP) ? JITFAIL("illegal index register: %esp") : (OK))
|
||||
#endif
|
||||
|
||||
#define _Mrm(Md,R,M) _B((_M(Md)<<6)|(_r(R)<<3)|_m(M))
|
||||
#define _SIB(Sc,I, B) _B((_s(Sc)<<6)|(_i(I)<<3)|_b(B))
|
||||
|
||||
#define _SCL(S) ((((S)==1) ? _b00 : \
|
||||
(((S)==2) ? _b01 : \
|
||||
(((S)==4) ? _b10 : \
|
||||
(((S)==8) ? _b11 : JITFAIL("illegal scale: " #S))))))
|
||||
|
||||
/* memory subformats - urgh! */
|
||||
|
||||
#define _r_D( R, D ) (_Mrm(_b00,_rN(R),_b101 ) ,_L((long)(D)))
|
||||
#define _r_0B( R, B ) (_Mrm(_b00,_rN(R),_r4(B)) )
|
||||
#define _r_0BIS(R, B,I,S) (_Mrm(_b00,_rN(R),_b100 ),_SIB(_SCL(S),_r4(I),_r4(B)) )
|
||||
#define _r_1B( R, D,B ) (_Mrm(_b01,_rN(R),_r4(B)) ,_B((long)(D)))
|
||||
#define _r_1BIS(R, D,B,I,S) (_Mrm(_b01,_rN(R),_b100 ),_SIB(_SCL(S),_r4(I),_r4(B)),_B((long)(D)))
|
||||
#define _r_4B( R, D,B ) (_Mrm(_b10,_rN(R),_r4(B)) ,_L((long)(D)))
|
||||
#define _r_4IS( R, D,I,S) (_Mrm(_b00,_rN(R),_b100 ),_SIB(_SCL(S),_r4(I),_b101 ),_L((long)(D)))
|
||||
#define _r_4BIS(R, D,B,I,S) (_Mrm(_b10,_rN(R),_b100 ),_SIB(_SCL(S),_r4(I),_r4(B)),_L((long)(D)))
|
||||
|
||||
#define _r_DB( R, D,B ) ((_s0P(D) && (B != _EBP) ? _r_0B (R, B ) : (_s8P(D) ? _r_1B( R,D,B ) : _r_4B( R,D,B ))))
|
||||
#define _r_DBIS(R, D,B,I,S) ((_s0P(D) ? _r_0BIS(R, B,I,S) : (_s8P(D) ? _r_1BIS(R,D,B,I,S) : _r_4BIS(R,D,B,I,S))))
|
||||
|
||||
#define _r_X( R, D,B,I,S) (_r0P(I) ? (_r0P(B) ? _r_D (R,D ) : \
|
||||
(_ESP==(B) ? _r_DBIS(R,D,_ESP,_ESP,1) : \
|
||||
_r_DB (R,D, B ))) : \
|
||||
(_r0P(B) ? _r_4IS (R,D, I,S) : \
|
||||
(((I)!=_ESP) ? _r_DBIS(R,D, B, I,S) : \
|
||||
JITFAIL("illegal index register: %esp"))))
|
||||
|
||||
|
||||
/* instruction formats */
|
||||
|
||||
/* _format Opcd ModR/M dN(rB,rI,Sc) imm... */
|
||||
|
||||
#define _d16() ( _B(0x66 ) )
|
||||
#define _O( OP ) ( _B( OP ) )
|
||||
#define _Or( OP,R ) ( _B( (OP)|_r(R)) )
|
||||
#define _OO( OP ) ( _B((OP)>>8), _B( (OP) ) )
|
||||
#define _OOr( OP,R ) ( _B((OP)>>8), _B( (OP)|_r(R)) )
|
||||
#define _Os( OP,B ) ( _s8P(B) ? _B(((OP)|_b10)) : _B(OP) )
|
||||
#define _sW( W ) ( _s8P(W) ? _B(W):_W(W) )
|
||||
#define _sL( L ) ( _s8P(L) ? _B(L):_L(L) )
|
||||
#define _O_W( OP ,W ) ( _O ( OP ) ,_W(W) )
|
||||
#define _O_D8( OP ,D ) ( _O ( OP ) ,_D8(D) )
|
||||
#define _O_D32( OP ,D ) ( _O ( OP ) ,_D32(D) )
|
||||
#define _OO_D32( OP ,D ) ( _OO ( OP ) ,_D32(D) )
|
||||
#define _Os_sW( OP ,W ) ( _Os ( OP,W) ,_sW(W) )
|
||||
#define _Os_sL( OP ,L ) ( _Os ( OP,L) ,_sL(L) )
|
||||
#define _O_W_B( OP ,W,B) ( _O ( OP ) ,_W(W),_B(B))
|
||||
#define _Or_B( OP,R ,B ) ( _Or ( OP,R) ,_B(B) )
|
||||
#define _Or_W( OP,R ,W ) ( _Or ( OP,R) ,_W(W) )
|
||||
#define _Or_L( OP,R ,L ) ( _Or ( OP,R) ,_L(L) )
|
||||
#define _O_Mrm( OP ,MO,R,M ) ( _O ( OP ),_Mrm(MO,R,M ) )
|
||||
#define _OO_Mrm( OP ,MO,R,M ) ( _OO ( OP ),_Mrm(MO,R,M ) )
|
||||
#define _O_Mrm_B( OP ,MO,R,M ,B ) ( _O ( OP ),_Mrm(MO,R,M ) ,_B(B) )
|
||||
#define _O_Mrm_W( OP ,MO,R,M ,W ) ( _O ( OP ),_Mrm(MO,R,M ) ,_W(W) )
|
||||
#define _O_Mrm_L( OP ,MO,R,M ,L ) ( _O ( OP ),_Mrm(MO,R,M ) ,_L(L) )
|
||||
#define _OO_Mrm_B( OP ,MO,R,M ,B ) ( _OO ( OP ),_Mrm(MO,R,M ) ,_B(B) )
|
||||
#define _Os_Mrm_sW(OP ,MO,R,M ,W ) ( _Os ( OP,W),_Mrm(MO,R,M ),_sW(W) )
|
||||
#define _Os_Mrm_sL(OP ,MO,R,M ,L ) ( _Os ( OP,L),_Mrm(MO,R,M ),_sL(L) )
|
||||
#define _O_r_X( OP ,R ,MD,MB,MI,MS ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS) )
|
||||
#define _OO_r_X( OP ,R ,MD,MB,MI,MS ) ( _OO ( OP ),_r_X( R ,MD,MB,MI,MS) )
|
||||
#define _O_r_X_B( OP ,R ,MD,MB,MI,MS,B ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS) ,_B(B) )
|
||||
#define _O_r_X_W( OP ,R ,MD,MB,MI,MS,W ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS) ,_W(W) )
|
||||
#define _O_r_X_L( OP ,R ,MD,MB,MI,MS,L ) ( _O ( OP ),_r_X( R ,MD,MB,MI,MS) ,_L(L) )
|
||||
#define _OO_r_X_B( OP ,R ,MD,MB,MI,MS,B ) ( _OO ( OP ),_r_X( R ,MD,MB,MI,MS) ,_B(B) )
|
||||
#define _Os_r_X_sW(OP ,R ,MD,MB,MI,MS,W ) ( _Os ( OP,W),_r_X( R ,MD,MB,MI,MS),_sW(W) )
|
||||
#define _Os_r_X_sL(OP ,R ,MD,MB,MI,MS,L ) ( _Os ( OP,L),_r_X( R ,MD,MB,MI,MS),_sL(L) )
|
||||
#define _O_X_B( OP ,MD,MB,MI,MS,B ) ( _O_r_X_B( OP ,0 ,MD,MB,MI,MS ,B) )
|
||||
#define _O_X_W( OP ,MD,MB,MI,MS,W ) ( _O_r_X_W( OP ,0 ,MD,MB,MI,MS ,W) )
|
||||
#define _O_X_L( OP ,MD,MB,MI,MS,L ) ( _O_r_X_L( OP ,0 ,MD,MB,MI,MS ,L) )
|
||||
#define _wO( OP ) (_d16(), _O( OP ) )
|
||||
#define _wOr( OP,R ) (_d16(), _Or( OP,R ) )
|
||||
#define _wOr_W( OP,R ,W ) (_d16(), _Or_W( OP,R ,W) )
|
||||
#define _wOs_sW( OP ,W ) (_d16(), _Os_sW( OP ,W) )
|
||||
#define _wO_Mrm( OP ,MO,R,M ) (_d16(), _O_Mrm( OP ,MO,R,M ) )
|
||||
#define _wOO_Mrm( OP ,MO,R,M ) (_d16(),_OO_Mrm( OP ,MO,R,M ) )
|
||||
#define _wO_Mrm_B( OP ,MO,R,M ,B ) (_d16(), _O_Mrm_B( OP ,MO,R,M ,B) )
|
||||
#define _wOO_Mrm_B( OP ,MO,R,M ,B ) (_d16(),_OO_Mrm_B( OP ,MO,R,M ,B) )
|
||||
#define _wO_Mrm_W( OP ,MO,R,M ,W ) (_d16(), _O_Mrm_W( OP ,MO,R,M ,W) )
|
||||
#define _wOs_Mrm_sW(OP ,MO,R,M ,W ) (_d16(), _Os_Mrm_sW(OP ,MO,R,M ,W) )
|
||||
#define _wO_X_W( OP ,MD,MB,MI,MS,W ) (_d16(), _O_X_W( OP ,MD,MB,MI,MS ,W) )
|
||||
#define _wO_r_X( OP ,R ,MD,MB,MI,MS ) (_d16(), _O_r_X( OP ,R ,MD,MB,MI,MS ) )
|
||||
#define _wOO_r_X( OP ,R ,MD,MB,MI,MS ) (_d16(),_OO_r_X( OP ,R ,MD,MB,MI,MS ) )
|
||||
#define _wO_r_X_B( OP ,R ,MD,MB,MI,MS,B ) (_d16(), _O_r_X_B( OP ,R ,MD,MB,MI,MS ,B) )
|
||||
#define _wOO_r_X_B( OP ,R ,MD,MB,MI,MS,B ) (_d16(),_OO_r_X_B( OP ,R ,MD,MB,MI,MS ,B) )
|
||||
#define _wO_r_X_W( OP ,R ,MD,MB,MI,MS,W ) (_d16(), _O_r_X_W( OP ,R ,MD,MB,MI,MS ,W) )
|
||||
#define _wOs_r_X_sW(OP ,R ,MD,MB,MI,MS,W ) (_d16(), _Os_r_X_sW(OP ,R ,MD,MB,MI,MS ,W) )
|
||||
|
||||
/* +++ fully-qualified intrinsic instructions */
|
||||
|
||||
/* _format Opcd ,Mod ,r ,m ,mem=dsp+sib ,imm... */
|
||||
|
||||
#define ADCBrr(RS, RD) _O_Mrm (0x10 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define ADCBmr(MD, MB, MI, MS, RD) _O_r_X (0x12 ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define ADCBrm(RS, MD, MB, MI, MS) _O_r_X (0x10 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define ADCBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b010 ,_r1(RD) ,_su8(IM))
|
||||
#define ADCBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b010 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define ADCWrr(RS, RD) _wO_Mrm (0x11 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define ADCWmr(MD, MB, MI, MS, RD) _wO_r_X (0x13 ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define ADCWrm(RS, MD, MB, MI, MS) _wO_r_X (0x11 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define ADCWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b010 ,_r2(RD) ,_su16(IM))
|
||||
#define ADCWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b010 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define ADCLrr(RS, RD) _O_Mrm (0x11 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define ADCLmr(MD, MB, MI, MS, RD) _O_r_X (0x13 ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define ADCLrm(RS, MD, MB, MI, MS) _O_r_X (0x11 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define ADCLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b010 ,_r4(RD) ,IM )
|
||||
#define ADCLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b010 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define ADDBrr(RS, RD) _O_Mrm (0x00 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define ADDBmr(MD, MB, MI, MS, RD) _O_r_X (0x02 ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define ADDBrm(RS, MD, MB, MI, MS) _O_r_X (0x00 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define ADDBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b000 ,_r1(RD) ,_su8(IM))
|
||||
#define ADDBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b000 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define ADDWrr(RS, RD) _wO_Mrm (0x01 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define ADDWmr(MD, MB, MI, MS, RD) _wO_r_X (0x03 ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define ADDWrm(RS, MD, MB, MI, MS) _wO_r_X (0x01 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define ADDWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b000 ,_r2(RD) ,_su16(IM))
|
||||
#define ADDWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b000 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define ADDLrr(RS, RD) _O_Mrm (0x01 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define ADDLmr(MD, MB, MI, MS, RD) _O_r_X (0x03 ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define ADDLrm(RS, MD, MB, MI, MS) _O_r_X (0x01 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define ADDLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b000 ,_r4(RD) ,IM )
|
||||
#define ADDLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b000 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define ANDBrr(RS, RD) _O_Mrm (0x20 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define ANDBmr(MD, MB, MI, MS, RD) _O_r_X (0x22 ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define ANDBrm(RS, MD, MB, MI, MS) _O_r_X (0x20 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define ANDBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b100 ,_r1(RD) ,_su8(IM))
|
||||
#define ANDBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b100 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define ANDWrr(RS, RD) _wO_Mrm (0x21 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define ANDWmr(MD, MB, MI, MS, RD) _wO_r_X (0x23 ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define ANDWrm(RS, MD, MB, MI, MS) _wO_r_X (0x21 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define ANDWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b100 ,_r2(RD) ,_su16(IM))
|
||||
#define ANDWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b100 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define ANDLrr(RS, RD) _O_Mrm (0x21 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define ANDLmr(MD, MB, MI, MS, RD) _O_r_X (0x23 ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define ANDLrm(RS, MD, MB, MI, MS) _O_r_X (0x21 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define ANDLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b100 ,_r4(RD) ,IM )
|
||||
#define ANDLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b100 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define BSWAPLr(R) _OOr (0x0fc8,_r4(R) )
|
||||
|
||||
|
||||
#define BTWir(IM,RD) _wOO_Mrm_B (0x0fba ,_b11,_b100 ,_r2(RD) ,_u8(IM))
|
||||
#define BTWim(IM,MD,MB,MI,MS) _wOO_r_X_B (0x0fba ,_b100 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTWrr(RS,RD) _wOO_Mrm (0x0fa3 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define BTWrm(RS,MD,MB,MI,MS) _wOO_r_X (0x0fa3 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define BTLir(IM,RD) _OO_Mrm_B (0x0fba ,_b11,_b100 ,_r4(RD) ,_u8(IM))
|
||||
#define BTLim(IM,MD,MB,MI,MS) _OO_r_X_B (0x0fba ,_b100 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTLrr(RS,RD) _OO_Mrm (0x0fa3 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define BTLrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fa3 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define BTCWir(IM,RD) _wOO_Mrm_B (0x0fba ,_b11,_b111 ,_r2(RD) ,_u8(IM))
|
||||
#define BTCWim(IM,MD,MB,MI,MS) _wOO_r_X_B (0x0fba ,_b111 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTCWrr(RS,RD) _wOO_Mrm (0x0fbb ,_b11,_r2(RS),_r2(RD) )
|
||||
#define BTCWrm(RS,MD,MB,MI,MS) _wOO_r_X (0x0fbb ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define BTCLir(IM,RD) _OO_Mrm_B (0x0fba ,_b11,_b111 ,_r4(RD) ,_u8(IM))
|
||||
#define BTCLim(IM,MD,MB,MI,MS) _OO_r_X_B (0x0fba ,_b111 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTCLrr(RS,RD) _OO_Mrm (0x0fbb ,_b11,_r4(RS),_r4(RD) )
|
||||
#define BTCLrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fbb ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define BTRWir(IM,RD) _wOO_Mrm_B (0x0fba ,_b11,_b110 ,_r2(RD) ,_u8(IM))
|
||||
#define BTRWim(IM,MD,MB,MI,MS) _wOO_r_X_B (0x0fba ,_b110 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTRWrr(RS,RD) _wOO_Mrm (0x0fb3 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define BTRWrm(RS,MD,MB,MI,MS) _wOO_r_X (0x0fb3 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define BTRLir(IM,RD) _OO_Mrm_B (0x0fba ,_b11,_b110 ,_r4(RD) ,_u8(IM))
|
||||
#define BTRLim(IM,MD,MB,MI,MS) _OO_r_X_B (0x0fba ,_b110 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTRLrr(RS,RD) _OO_Mrm (0x0fb3 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define BTRLrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fb3 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define BTSWir(IM,RD) _wOO_Mrm_B (0x0fba ,_b11,_b101 ,_r2(RD) ,_u8(IM))
|
||||
#define BTSWim(IM,MD,MB,MI,MS) _wOO_r_X_B (0x0fba ,_b101 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTSWrr(RS,RD) _wOO_Mrm (0x0fab ,_b11,_r2(RS),_r2(RD) )
|
||||
#define BTSWrm(RS,MD,MB,MI,MS) _wOO_r_X (0x0fab ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define BTSLir(IM,RD) _OO_Mrm_B (0x0fba ,_b11,_b101 ,_r4(RD) ,_u8(IM))
|
||||
#define BTSLim(IM,MD,MB,MI,MS) _OO_r_X_B (0x0fba ,_b101 ,MD,MB,MI,MS ,_u8(IM))
|
||||
#define BTSLrr(RS,RD) _OO_Mrm (0x0fab ,_b11,_r4(RS),_r4(RD) )
|
||||
#define BTSLrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fab ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define CALLm(D,B,I,S) ((_r0P(B) && _r0P(I)) ? _O_D32 (0xe8 ,(int)(D) ) : \
|
||||
JITFAIL("illegal mode in direct jump"))
|
||||
|
||||
#define CALLsr(R) _O_Mrm (0xff ,_b11,_b010,_r4(R) )
|
||||
|
||||
#define CALLsm(D,B,I,S) _O_r_X (0xff ,_b010 ,(int)(D),B,I,S )
|
||||
|
||||
#define CBW() _O (0x98 )
|
||||
#define CLC() _O (0xf8 )
|
||||
#define CLTD() _O (0x99 )
|
||||
#define CMC() _O (0xf5 )
|
||||
|
||||
|
||||
#define CMPBrr(RS, RD) _O_Mrm (0x38 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define CMPBmr(MD, MB, MI, MS, RD) _O_r_X (0x3a ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define CMPBrm(RS, MD, MB, MI, MS) _O_r_X (0x38 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define CMPBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b111 ,_r1(RD) ,_su8(IM))
|
||||
#define CMPBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b111 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define CMPWrr(RS, RD) _wO_Mrm (0x39 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define CMPWmr(MD, MB, MI, MS, RD) _wO_r_X (0x3b ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define CMPWrm(RS, MD, MB, MI, MS) _wO_r_X (0x39 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define CMPWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b111 ,_r2(RD) ,_su16(IM))
|
||||
#define CMPWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b111 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define CMPLrr(RS, RD) _O_Mrm (0x39 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define CMPLmr(MD, MB, MI, MS, RD) _O_r_X (0x3b ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define CMPLrm(RS, MD, MB, MI, MS) _O_r_X (0x39 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define CMPLir(IM, RD) _O_Mrm_L (0x81 ,_b11,_b111 ,_r4(RD) ,IM )
|
||||
#define CMPLim(IM, MD, MB, MI, MS) _O_r_X_L (0x81 ,_b111 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define CWD() _O (0x99 )
|
||||
|
||||
|
||||
#define CMPXCHGBrr(RS,RD) _OO_Mrm (0x0fb0 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define CMPXCHGBrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fb0 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define CMPXCHGWrr(RS,RD) _wOO_Mrm (0x0fb1 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define CMPXCHGWrm(RS,MD,MB,MI,MS) _wOO_r_X (0x0fb1 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define CMPXCHGLrr(RS,RD) _OO_Mrm (0x0fb1 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define CMPXCHGLrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fb1 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define DECBr(RD) _O_Mrm (0xfe ,_b11,_b001 ,_r1(RD) )
|
||||
#define DECBm(MD,MB,MI,MS) _O_r_X (0xfe ,_b001 ,MD,MB,MI,MS )
|
||||
|
||||
#define DECWr(RD) _wOr (0x48,_r2(RD) )
|
||||
#define DECWm(MD,MB,MI,MS) _wO_r_X (0xff ,_b001 ,MD,MB,MI,MS )
|
||||
|
||||
#define DECLr(RD) _Or (0x48,_r4(RD) )
|
||||
#define DECLm(MD,MB,MI,MS) _O_r_X (0xff ,_b001 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define DIVBr(RS) _O_Mrm (0xf6 ,_b11,_b110 ,_r1(RS) )
|
||||
#define DIVBm(MD,MB,MI,MS) _O_r_X (0xf6 ,_b110 ,MD,MB,MI,MS )
|
||||
|
||||
#define DIVWr(RS) _wO_Mrm (0xf7 ,_b11,_b110 ,_r2(RS) )
|
||||
#define DIVWm(MD,MB,MI,MS) _wO_r_X (0xf7 ,_b110 ,MD,MB,MI,MS )
|
||||
|
||||
#define DIVLr(RS) _O_Mrm (0xf7 ,_b11,_b110 ,_r4(RS) )
|
||||
#define DIVLm(MD,MB,MI,MS) _O_r_X (0xf7 ,_b110 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define ENTERii(W, B) _O_W_B (0xc8 ,_su16(W),_su8(B))
|
||||
#define HLT() _O (0xf4 )
|
||||
|
||||
|
||||
#define IDIVBr(RS) _O_Mrm (0xf6 ,_b11,_b111 ,_r1(RS) )
|
||||
#define IDIVBm(MD,MB,MI,MS) _O_r_X (0xf6 ,_b111 ,MD,MB,MI,MS )
|
||||
|
||||
#define IDIVWr(RS) _wO_Mrm (0xf7 ,_b11,_b111 ,_r2(RS) )
|
||||
#define IDIVWm(MD,MB,MI,MS) _wO_r_X (0xf7 ,_b111 ,MD,MB,MI,MS )
|
||||
|
||||
#define IDIVLr(RS) _O_Mrm (0xf7 ,_b11,_b111 ,_r4(RS) )
|
||||
#define IDIVLm(MD,MB,MI,MS) _O_r_X (0xf7 ,_b111 ,MD,MB,MI,MS )
|
||||
|
||||
#define IMULBr(RS) _O_Mrm (0xf6 ,_b11,_b101 ,_r1(RS) )
|
||||
#define IMULBm(MD,MB,MI,MS) _O_r_X (0xf6 ,_b101 ,MD,MB,MI,MS )
|
||||
|
||||
#define IMULWr(RS) _wO_Mrm (0xf7 ,_b11,_b101 ,_r2(RS) )
|
||||
#define IMULWm(MD,MB,MI,MS) _wO_r_X (0xf7 ,_b101 ,MD,MB,MI,MS )
|
||||
|
||||
#define IMULLr(RS) _O_Mrm (0xf7 ,_b11,_b101 ,_r4(RS) )
|
||||
#define IMULLm(MD,MB,MI,MS) _O_r_X (0xf7 ,_b101 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define IMULWrr(RS,RD) _wOO_Mrm (0x0faf ,_b11,_r2(RS),_r2(RD) )
|
||||
#define IMULWmr(MD,MB,MI,MS,RD) _wOO_r_X (0x0faf ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define IMULWirr(IM,RS,RD) _wOs_Mrm_sW (0x69 ,_b11,_r2(RS),_r2(RD) ,_su16(IM) )
|
||||
#define IMULWimr(IM,MD,MB,MI,MS,RD) _wOs_r_X_sW (0x69 ,_r2(RD) ,MD,MB,MI,MS ,_su16(IM) )
|
||||
|
||||
#define IMULLir(IM,RD) _Os_Mrm_sL (0x69 ,_b11,_r4(RD),_r4(RD) ,IM )
|
||||
#define IMULLrr(RS,RD) _OO_Mrm (0x0faf ,_b11,_r4(RD),_r4(RS) )
|
||||
#define IMULLmr(MD,MB,MI,MS,RD) _OO_r_X (0x0faf ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define IMULLirr(IM,RS,RD) _Os_Mrm_sL (0x69 ,_b11,_r4(RS),_r4(RD) ,IM )
|
||||
#define IMULLimr(IM,MD,MB,MI,MS,RD) _Os_r_X_sL (0x69 ,_r4(RD) ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define INCBr(RD) _O_Mrm (0xfe ,_b11,_b000 ,_r1(RD) )
|
||||
#define INCBm(MD,MB,MI,MS) _O_r_X (0xfe ,_b000 ,MD,MB,MI,MS )
|
||||
|
||||
#define INCWr(RD) _wOr (0x40,_r2(RD) )
|
||||
#define INCWm(MD,MB,MI,MS) _wO_r_X (0xff ,_b000 ,MD,MB,MI,MS )
|
||||
|
||||
#define INCLr(RD) _Or (0x40,_r4(RD) )
|
||||
#define INCLm(MD,MB,MI,MS) _O_r_X (0xff ,_b000 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define INVD() _OO (0x0f08 )
|
||||
#define INVLPGm(MD, MB, MI, MS) _OO_r_X (0x0f01 ,_b111 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define JCCSim(CC,D,B,I,S) ((_r0P(B) && _r0P(I)) ? _O_D8 (0x70|(CC) ,(int)(D) ) : \
|
||||
JITFAIL("illegal mode in conditional jump"))
|
||||
|
||||
#define JOSm(D,B,I,S) JCCSim(0x0,D,B,I,S)
|
||||
#define JNOSm(D,B,I,S) JCCSim(0x1,D,B,I,S)
|
||||
#define JBSm(D,B,I,S) JCCSim(0x2,D,B,I,S)
|
||||
#define JNAESm(D,B,I,S) JCCSim(0x2,D,B,I,S)
|
||||
#define JNBSm(D,B,I,S) JCCSim(0x3,D,B,I,S)
|
||||
#define JAESm(D,B,I,S) JCCSim(0x3,D,B,I,S)
|
||||
#define JESm(D,B,I,S) JCCSim(0x4,D,B,I,S)
|
||||
#define JZSm(D,B,I,S) JCCSim(0x4,D,B,I,S)
|
||||
#define JNESm(D,B,I,S) JCCSim(0x5,D,B,I,S)
|
||||
#define JNZSm(D,B,I,S) JCCSim(0x5,D,B,I,S)
|
||||
#define JBESm(D,B,I,S) JCCSim(0x6,D,B,I,S)
|
||||
#define JNASm(D,B,I,S) JCCSim(0x6,D,B,I,S)
|
||||
#define JNBESm(D,B,I,S) JCCSim(0x7,D,B,I,S)
|
||||
#define JASm(D,B,I,S) JCCSim(0x7,D,B,I,S)
|
||||
#define JSSm(D,B,I,S) JCCSim(0x8,D,B,I,S)
|
||||
#define JNSSm(D,B,I,S) JCCSim(0x9,D,B,I,S)
|
||||
#define JPSm(D,B,I,S) JCCSim(0xa,D,B,I,S)
|
||||
#define JPESm(D,B,I,S) JCCSim(0xa,D,B,I,S)
|
||||
#define JNPSm(D,B,I,S) JCCSim(0xb,D,B,I,S)
|
||||
#define JPOSm(D,B,I,S) JCCSim(0xb,D,B,I,S)
|
||||
#define JLSm(D,B,I,S) JCCSim(0xc,D,B,I,S)
|
||||
#define JNGESm(D,B,I,S) JCCSim(0xc,D,B,I,S)
|
||||
#define JNLSm(D,B,I,S) JCCSim(0xd,D,B,I,S)
|
||||
#define JGESm(D,B,I,S) JCCSim(0xd,D,B,I,S)
|
||||
#define JLESm(D,B,I,S) JCCSim(0xe,D,B,I,S)
|
||||
#define JNGSm(D,B,I,S) JCCSim(0xe,D,B,I,S)
|
||||
#define JNLESm(D,B,I,S) JCCSim(0xf,D,B,I,S)
|
||||
#define JGSm(D,B,I,S) JCCSim(0xf,D,B,I,S)
|
||||
|
||||
#define JCCim(CC,D,B,I,S) ((_r0P(B) && _r0P(I)) ? _OO_D32 (0x0f80|(CC) ,(int)(D) ) : \
|
||||
JITFAIL("illegal mode in conditional jump"))
|
||||
|
||||
#define JOm(D,B,I,S) JCCim(0x0,D,B,I,S)
|
||||
#define JNOm(D,B,I,S) JCCim(0x1,D,B,I,S)
|
||||
#define JBm(D,B,I,S) JCCim(0x2,D,B,I,S)
|
||||
#define JNAEm(D,B,I,S) JCCim(0x2,D,B,I,S)
|
||||
#define JNBm(D,B,I,S) JCCim(0x3,D,B,I,S)
|
||||
#define JAEm(D,B,I,S) JCCim(0x3,D,B,I,S)
|
||||
#define JEm(D,B,I,S) JCCim(0x4,D,B,I,S)
|
||||
#define JZm(D,B,I,S) JCCim(0x4,D,B,I,S)
|
||||
#define JNEm(D,B,I,S) JCCim(0x5,D,B,I,S)
|
||||
#define JNZm(D,B,I,S) JCCim(0x5,D,B,I,S)
|
||||
#define JBEm(D,B,I,S) JCCim(0x6,D,B,I,S)
|
||||
#define JNAm(D,B,I,S) JCCim(0x6,D,B,I,S)
|
||||
#define JNBEm(D,B,I,S) JCCim(0x7,D,B,I,S)
|
||||
#define JAm(D,B,I,S) JCCim(0x7,D,B,I,S)
|
||||
#define JSm(D,B,I,S) JCCim(0x8,D,B,I,S)
|
||||
#define JNSm(D,B,I,S) JCCim(0x9,D,B,I,S)
|
||||
#define JPm(D,B,I,S) JCCim(0xa,D,B,I,S)
|
||||
#define JPEm(D,B,I,S) JCCim(0xa,D,B,I,S)
|
||||
#define JNPm(D,B,I,S) JCCim(0xb,D,B,I,S)
|
||||
#define JPOm(D,B,I,S) JCCim(0xb,D,B,I,S)
|
||||
#define JLm(D,B,I,S) JCCim(0xc,D,B,I,S)
|
||||
#define JNGEm(D,B,I,S) JCCim(0xc,D,B,I,S)
|
||||
#define JNLm(D,B,I,S) JCCim(0xd,D,B,I,S)
|
||||
#define JGEm(D,B,I,S) JCCim(0xd,D,B,I,S)
|
||||
#define JLEm(D,B,I,S) JCCim(0xe,D,B,I,S)
|
||||
#define JNGm(D,B,I,S) JCCim(0xe,D,B,I,S)
|
||||
#define JNLEm(D,B,I,S) JCCim(0xf,D,B,I,S)
|
||||
#define JGm(D,B,I,S) JCCim(0xf,D,B,I,S)
|
||||
|
||||
|
||||
#define JMPSm(D,B,I,S) ((_r0P(B) && _r0P(I)) ? _O_D8 (0xeb ,(int)(D) ) : \
|
||||
JITFAIL("illegal mode in short jump"))
|
||||
|
||||
#define JMPm(D,B,I,S) ((_r0P(B) && _r0P(I)) ? _O_D32 (0xe9 ,(int)(D) ) : \
|
||||
JITFAIL("illegal mode in direct jump"))
|
||||
|
||||
#define JMPsr(R) _O_Mrm (0xff ,_b11,_b100,_r4(R) )
|
||||
|
||||
#define JMPsm(D,B,I,S) _O_r_X (0xff ,_b100 ,(int)(D),B,I,S )
|
||||
|
||||
|
||||
#define LAHF() _O (0x9f )
|
||||
#define LEALmr(MD, MB, MI, MS, RD) _O_r_X (0x8d ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define LEAVE() _O (0xc9 )
|
||||
|
||||
|
||||
#define LMSWr(RS) _OO_Mrm (0x0f01 ,_b11,_b110,_r4(RS) )
|
||||
#define LMSWm(MD,MB,MI,MS) _OO_r_X (0x0f01 ,_b110 ,MD,MB,MI,MS )
|
||||
|
||||
#define LOOPm(MD,MB,MI,MS) ((_r0P(MB) && _r0P(MI)) ? _O_D8 (0xe2 ,MD ) : \
|
||||
JITFAIL("illegal mode in loop"))
|
||||
|
||||
#define LOOPEm(MD,MB,MI,MS) ((_r0P(MB) && _r0P(MI)) ? _O_D8 (0xe1 ,MD ) : \
|
||||
JITFAIL("illegal mode in loope"))
|
||||
|
||||
#define LOOPZm(MD,MB,MI,MS) ((_r0P(MB) && _r0P(MI)) ? _O_D8 (0xe1 ,MD ) : \
|
||||
JITFAIL("illegal mode in loopz"))
|
||||
|
||||
#define LOOPNEm(MD,MB,MI,MS) ((_r0P(MB) && _r0P(MI)) ? _O_D8 (0xe0 ,MD ) : \
|
||||
JITFAIL("illegal mode in loopne"))
|
||||
|
||||
#define LOOPNZm(MD,MB,MI,MS) ((_r0P(MB) && _r0P(MI)) ? _O_D8 (0xe0 ,MD ) : \
|
||||
JITFAIL("illegal mode in loopnz"))
|
||||
|
||||
|
||||
#define MOVBrr(RS, RD) _O_Mrm (0x80 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define MOVBmr(MD, MB, MI, MS, RD) _O_r_X (0x8a ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define MOVBrm(RS, MD, MB, MI, MS) _O_r_X (0x88 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define MOVBir(IM, R) _Or_B (0xb0,_r1(R) ,_su8(IM))
|
||||
#define MOVBim(IM, MD, MB, MI, MS) _O_X_B (0xc6 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define MOVWrr(RS, RD) _wO_Mrm (0x89 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define MOVWmr(MD, MB, MI, MS, RD) _wO_r_X (0x8b ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define MOVWrm(RS, MD, MB, MI, MS) _wO_r_X (0x89 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define MOVWir(IM, R) _wOr_W (0xb8,_r2(R) ,_su16(IM))
|
||||
#define MOVWim(IM, MD, MB, MI, MS) _wO_X_W (0xc7 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define MOVLrr(RS, RD) _O_Mrm (0x89 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define MOVLmr(MD, MB, MI, MS, RD) _O_r_X (0x8b ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define MOVLrm(RS, MD, MB, MI, MS) _O_r_X (0x89 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define MOVLir(IM, R) _Or_L (0xb8,_r4(R) ,IM )
|
||||
#define MOVLim(IM, MD, MB, MI, MS) _O_X_L (0xc7 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define MULBr(RS) _O_Mrm (0xf6 ,_b11,_b100 ,_r1(RS) )
|
||||
#define MULBm(MD,MB,MI,MS) _O_r_X (0xf6 ,_b100 ,MD,MB,MI,MS )
|
||||
|
||||
#define MULWr(RS) _wO_Mrm (0xf7 ,_b11,_b100 ,_r2(RS) )
|
||||
#define MULWm(MD,MB,MI,MS) _wO_r_X (0xf7 ,_b100 ,MD,MB,MI,MS )
|
||||
|
||||
#define MULLr(RS) _O_Mrm (0xf7 ,_b11,_b100 ,_r4(RS) )
|
||||
#define MULLm(MD,MB,MI,MS) _O_r_X (0xf7 ,_b100 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define NEGBr(RD) _O_Mrm (0xf6 ,_b11,_b011 ,_r1(RD) )
|
||||
#define NEGBm(MD,MB,MI,MS) _O_r_X (0xf6 ,_b011 ,MD,MB,MI,MS )
|
||||
|
||||
#define NEGWr(RD) _wO_Mrm (0xf7 ,_b11,_b011 ,_r2(RD) )
|
||||
#define NEGWm(MD,MB,MI,MS) _wO_r_X (0xf7 ,_b011 ,MD,MB,MI,MS )
|
||||
|
||||
#define NEGLr(RD) _O_Mrm (0xf7 ,_b11,_b011 ,_r4(RD) )
|
||||
#define NEGLm(MD,MB,MI,MS) _O_r_X (0xf7 ,_b011 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define NOP() _O (0x90 )
|
||||
|
||||
|
||||
#define NOTBr(RD) _O_Mrm (0xf6 ,_b11,_b010 ,_r1(RD) )
|
||||
#define NOTBm(MD,MB,MI,MS) _O_r_X (0xf6 ,_b010 ,MD,MB,MI,MS )
|
||||
|
||||
#define NOTWr(RD) _wO_Mrm (0xf7 ,_b11,_b010 ,_r2(RD) )
|
||||
#define NOTWm(MD,MB,MI,MS) _wO_r_X (0xf7 ,_b010 ,MD,MB,MI,MS )
|
||||
|
||||
#define NOTLr(RD) _O_Mrm (0xf7 ,_b11,_b010 ,_r4(RD) )
|
||||
#define NOTLm(MD,MB,MI,MS) _O_r_X (0xf7 ,_b010 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define ORBrr(RS, RD) _O_Mrm (0x08 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define ORBmr(MD, MB, MI, MS, RD) _O_r_X (0x0a ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define ORBrm(RS, MD, MB, MI, MS) _O_r_X (0x08 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define ORBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b001 ,_r1(RD) ,_su8(IM))
|
||||
#define ORBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b001 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define ORWrr(RS, RD) _wO_Mrm (0x09 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define ORWmr(MD, MB, MI, MS, RD) _wO_r_X (0x0b ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define ORWrm(RS, MD, MB, MI, MS) _wO_r_X (0x09 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define ORWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b001 ,_r2(RD) ,_su16(IM))
|
||||
#define ORWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b001 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define ORLrr(RS, RD) _O_Mrm (0x09 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define ORLmr(MD, MB, MI, MS, RD) _O_r_X (0x0b ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define ORLrm(RS, MD, MB, MI, MS) _O_r_X (0x09 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define ORLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b001 ,_r4(RD) ,IM )
|
||||
#define ORLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b001 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define POPWr(RD) _wOr (0x58,_r2(RD) )
|
||||
#define POPWm(MD,MB,MI,MS) _wO_r_X (0x8f ,_b000 ,MD,MB,MI,MS )
|
||||
|
||||
#define POPLr(RD) _Or (0x58,_r4(RD) )
|
||||
#define POPLm(MD,MB,MI,MS) _O_r_X (0x8f ,_b000 ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define POPA() _wO (0x61 )
|
||||
#define POPAD() _O (0x61 )
|
||||
|
||||
#define POPF() _wO (0x9d )
|
||||
#define POPFD() _O (0x9d )
|
||||
|
||||
|
||||
#define PUSHWr(R) _wOr (0x50,_r2(R) )
|
||||
#define PUSHWm(MD,MB,MI,MS) _wO_r_X (0xff, ,_b110 ,MD,MB,MI,MS )
|
||||
#define PUSHWi(IM) _wOs_sW (0x68 ,IM )
|
||||
|
||||
#define PUSHLr(R) _Or (0x50,_r4(R) )
|
||||
#define PUSHLm(MD,MB,MI,MS) _O_r_X (0xff ,_b110 ,MD,MB,MI,MS )
|
||||
#define PUSHLi(IM) _Os_sL (0x68 ,IM )
|
||||
|
||||
|
||||
#define PUSHA() _wO (0x60 )
|
||||
#define PUSHAD() _O (0x60 )
|
||||
|
||||
#define PUSHF() _O (0x9c )
|
||||
#define PUSHFD() _wO (0x9c )
|
||||
|
||||
#define RET() _O (0xc3 )
|
||||
#define RETi(IM) _O_W (0xc2 ,_su16(IM))
|
||||
|
||||
|
||||
#define ROLBir(IM,RD) (((IM)==1) ? _O_Mrm (0xd0 ,_b11,_b000,_r1(RD) ) : \
|
||||
_O_Mrm_B (0xc0 ,_b11,_b000,_r1(RD) ,_u8(IM) ) )
|
||||
#define ROLBim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd0 ,_b000 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc0 ,_b000 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define ROLBrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd2 ,_b11,_b000,_r1(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define ROLBrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd2 ,_b000 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define ROLWir(IM,RD) (((IM)==1) ? _wO_Mrm (0xd1 ,_b11,_b000,_r2(RD) ) : \
|
||||
_wO_Mrm_B (0xc1 ,_b11,_b000,_r2(RD) ,_u8(IM) ) )
|
||||
#define ROLWim(IM,MD,MB,MS,MI) (((IM)==1) ? _wO_r_X (0xd1 ,_b000 ,MD,MB,MI,MS ) : \
|
||||
_wO_r_X_B (0xc1 ,_b000 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define ROLWrr(RS,RD) (((RS)==_CL) ? _wO_Mrm (0xd3 ,_b11,_b000,_r2(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define ROLWrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _wO_r_X (0xd3 ,_b000 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define ROLLir(IM,RD) (((IM)==1) ? _O_Mrm (0xd1 ,_b11,_b000,_r4(RD) ) : \
|
||||
_O_Mrm_B (0xc1 ,_b11,_b000,_r4(RD) ,_u8(IM) ) )
|
||||
#define ROLLim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd1 ,_b000 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc1 ,_b000 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define ROLLrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd3 ,_b11,_b000,_r4(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define ROLLrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd3 ,_b000 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
|
||||
#define RORBir(IM,RD) (((IM)==1) ? _O_Mrm (0xd0 ,_b11,_b001,_r1(RD) ) : \
|
||||
_O_Mrm_B (0xc0 ,_b11,_b001,_r1(RD) ,_u8(IM) ) )
|
||||
#define RORBim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd0 ,_b001 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc0 ,_b001 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define RORBrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd2 ,_b11,_b001,_r1(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define RORBrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd2 ,_b001 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define RORWir(IM,RD) (((IM)==1) ? _wO_Mrm (0xd1 ,_b11,_b001,_r2(RD) ) : \
|
||||
_wO_Mrm_B (0xc1 ,_b11,_b001,_r2(RD) ,_u8(IM) ) )
|
||||
#define RORWim(IM,MD,MB,MS,MI) (((IM)==1) ? _wO_r_X (0xd1 ,_b001 ,MD,MB,MI,MS ) : \
|
||||
_wO_r_X_B (0xc1 ,_b001 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define RORWrr(RS,RD) (((RS)==_CL) ? _wO_Mrm (0xd3 ,_b11,_b001,_r2(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define RORWrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _wO_r_X (0xd3 ,_b001 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define RORLir(IM,RD) (((IM)==1) ? _O_Mrm (0xd1 ,_b11,_b001,_r4(RD) ) : \
|
||||
_O_Mrm_B (0xc1 ,_b11,_b001,_r4(RD) ,_u8(IM) ) )
|
||||
#define RORLim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd1 ,_b001 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc1 ,_b001 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define RORLrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd3 ,_b11,_b001,_r4(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define RORLrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd3 ,_b001 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
|
||||
#define SAHF() _O (0x9e )
|
||||
|
||||
|
||||
#define SALBir SHLBir
|
||||
#define SALBim SHLBim
|
||||
#define SALBrr SHLBrr
|
||||
#define SALBrm SHLBrm
|
||||
#define SALWir SHLWir
|
||||
#define SALWim SHLWim
|
||||
#define SALWrr SHLWrr
|
||||
#define SALWrm SHLWrm
|
||||
#define SALLir SHLLir
|
||||
#define SALLim SHLLim
|
||||
#define SALLrr SHLLrr
|
||||
#define SALLrm SHLLrm
|
||||
|
||||
|
||||
#define SARBir(IM,RD) (((IM)==1) ? _O_Mrm (0xd0 ,_b11,_b111,_r1(RD) ) : \
|
||||
_O_Mrm_B (0xc0 ,_b11,_b111,_r1(RD) ,_u8(IM) ) )
|
||||
#define SARBim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd0 ,_b111 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc0 ,_b111 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SARBrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd2 ,_b11,_b111,_r1(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SARBrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd2 ,_b111 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define SARWir(IM,RD) (((IM)==1) ? _wO_Mrm (0xd1 ,_b11,_b111,_r2(RD) ) : \
|
||||
_wO_Mrm_B (0xc1 ,_b11,_b111,_r2(RD) ,_u8(IM) ) )
|
||||
#define SARWim(IM,MD,MB,MS,MI) (((IM)==1) ? _wO_r_X (0xd1 ,_b111 ,MD,MB,MI,MS ) : \
|
||||
_wO_r_X_B (0xc1 ,_b111 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SARWrr(RS,RD) (((RS)==_CL) ? _wO_Mrm (0xd3 ,_b11,_b111,_r2(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SARWrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _wO_r_X (0xd3 ,_b111 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define SARLir(IM,RD) (((IM)==1) ? _O_Mrm (0xd1 ,_b11,_b111,_r4(RD) ) : \
|
||||
_O_Mrm_B (0xc1 ,_b11,_b111,_r4(RD) ,_u8(IM) ) )
|
||||
#define SARLim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd1 ,_b111 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc1 ,_b111 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SARLrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd3 ,_b11,_b111,_r4(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SARLrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd3 ,_b111 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
|
||||
#define SBBBrr(RS, RD) _O_Mrm (0x18 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define SBBBmr(MD, MB, MI, MS, RD) _O_r_X (0x1a ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define SBBBrm(RS, MD, MB, MI, MS) _O_r_X (0x18 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define SBBBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b011 ,_r1(RD) ,_su8(IM))
|
||||
#define SBBBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b011 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define SBBWrr(RS, RD) _wO_Mrm (0x19 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define SBBWmr(MD, MB, MI, MS, RD) _wO_r_X (0x1b ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define SBBWrm(RS, MD, MB, MI, MS) _wO_r_X (0x19 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define SBBWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b011 ,_r2(RD) ,_su16(IM))
|
||||
#define SBBWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b011 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define SBBLrr(RS, RD) _O_Mrm (0x19 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define SBBLmr(MD, MB, MI, MS, RD) _O_r_X (0x1b ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define SBBLrm(RS, MD, MB, MI, MS) _O_r_X (0x19 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define SBBLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b011 ,_r4(RD) ,IM )
|
||||
#define SBBLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b011 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define SETCCir(CC,RD) _OO_Mrm (0x0f90|(CC) ,_b11,_b000,_r1(RD) )
|
||||
|
||||
#define SETOr(RD) SETCCir(0x0,RD)
|
||||
#define SETNOr(RD) SETCCir(0x1,RD)
|
||||
#define SETBr(RD) SETCCir(0x2,RD)
|
||||
#define SETNAEr(RD) SETCCir(0x2,RD)
|
||||
#define SETNBr(RD) SETCCir(0x3,RD)
|
||||
#define SETAEr(RD) SETCCir(0x3,RD)
|
||||
#define SETEr(RD) SETCCir(0x4,RD)
|
||||
#define SETZr(RD) SETCCir(0x4,RD)
|
||||
#define SETNEr(RD) SETCCir(0x5,RD)
|
||||
#define SETNZr(RD) SETCCir(0x5,RD)
|
||||
#define SETBEr(RD) SETCCir(0x6,RD)
|
||||
#define SETNAr(RD) SETCCir(0x6,RD)
|
||||
#define SETNBEr(RD) SETCCir(0x7,RD)
|
||||
#define SETAr(RD) SETCCir(0x7,RD)
|
||||
#define SETSr(RD) SETCCir(0x8,RD)
|
||||
#define SETNSr(RD) SETCCir(0x9,RD)
|
||||
#define SETPr(RD) SETCCir(0xa,RD)
|
||||
#define SETPEr(RD) SETCCir(0xa,RD)
|
||||
#define SETNPr(RD) SETCCir(0xb,RD)
|
||||
#define SETPOr(RD) SETCCir(0xb,RD)
|
||||
#define SETLr(RD) SETCCir(0xc,RD)
|
||||
#define SETNGEr(RD) SETCCir(0xc,RD)
|
||||
#define SETNLr(RD) SETCCir(0xd,RD)
|
||||
#define SETGEr(RD) SETCCir(0xd,RD)
|
||||
#define SETLEr(RD) SETCCir(0xe,RD)
|
||||
#define SETNGr(RD) SETCCir(0xe,RD)
|
||||
#define SETNLEr(RD) SETCCir(0xf,RD)
|
||||
#define SETGr(RD) SETCCir(0xf,RD)
|
||||
|
||||
#define SETCCim(CC,MD,MB,MI,MS) _OO_r_X (0x0f90|(CC) ,_b000 ,MD,MB,MI,MS )
|
||||
|
||||
#define SETOm(D,B,I,S) SETCCim(0x0,D,B,I,S)
|
||||
#define SETNOm(D,B,I,S) SETCCim(0x1,D,B,I,S)
|
||||
#define SETBm(D,B,I,S) SETCCim(0x2,D,B,I,S)
|
||||
#define SETNAEm(D,B,I,S) SETCCim(0x2,D,B,I,S)
|
||||
#define SETNBm(D,B,I,S) SETCCim(0x3,D,B,I,S)
|
||||
#define SETAEm(D,B,I,S) SETCCim(0x3,D,B,I,S)
|
||||
#define SETEm(D,B,I,S) SETCCim(0x4,D,B,I,S)
|
||||
#define SETZm(D,B,I,S) SETCCim(0x4,D,B,I,S)
|
||||
#define SETNEm(D,B,I,S) SETCCim(0x5,D,B,I,S)
|
||||
#define SETNZm(D,B,I,S) SETCCim(0x5,D,B,I,S)
|
||||
#define SETBEm(D,B,I,S) SETCCim(0x6,D,B,I,S)
|
||||
#define SETNAm(D,B,I,S) SETCCim(0x6,D,B,I,S)
|
||||
#define SETNBEm(D,B,I,S) SETCCim(0x7,D,B,I,S)
|
||||
#define SETAm(D,B,I,S) SETCCim(0x7,D,B,I,S)
|
||||
#define SETSm(D,B,I,S) SETCCim(0x8,D,B,I,S)
|
||||
#define SETNSm(D,B,I,S) SETCCim(0x9,D,B,I,S)
|
||||
#define SETPm(D,B,I,S) SETCCim(0xa,D,B,I,S)
|
||||
#define SETPEm(D,B,I,S) SETCCim(0xa,D,B,I,S)
|
||||
#define SETNPm(D,B,I,S) SETCCim(0xb,D,B,I,S)
|
||||
#define SETPOm(D,B,I,S) SETCCim(0xb,D,B,I,S)
|
||||
#define SETLm(D,B,I,S) SETCCim(0xc,D,B,I,S)
|
||||
#define SETNGEm(D,B,I,S) SETCCim(0xc,D,B,I,S)
|
||||
#define SETNLm(D,B,I,S) SETCCim(0xd,D,B,I,S)
|
||||
#define SETGEm(D,B,I,S) SETCCim(0xd,D,B,I,S)
|
||||
#define SETLEm(D,B,I,S) SETCCim(0xe,D,B,I,S)
|
||||
#define SETNGm(D,B,I,S) SETCCim(0xe,D,B,I,S)
|
||||
#define SETNLEm(D,B,I,S) SETCCim(0xf,D,B,I,S)
|
||||
#define SETGm(D,B,I,S) SETCCim(0xf,D,B,I,S)
|
||||
|
||||
|
||||
#define SHLBir(IM,RD) (((IM)==1) ? _O_Mrm (0xd0 ,_b11,_b100,_r1(RD) ) : \
|
||||
_O_Mrm_B (0xc0 ,_b11,_b100,_r1(RD) ,_u8(IM) ) )
|
||||
#define SHLBim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd0 ,_b100 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc0 ,_b100 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SHLBrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd2 ,_b11,_b100,_r1(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SHLBrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd2 ,_b100 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define SHLWir(IM,RD) (((IM)==1) ? _wO_Mrm (0xd1 ,_b11,_b100,_r2(RD) ) : \
|
||||
_wO_Mrm_B (0xc1 ,_b11,_b100,_r2(RD) ,_u8(IM) ) )
|
||||
#define SHLWim(IM,MD,MB,MS,MI) (((IM)==1) ? _wO_r_X (0xd1 ,_b100 ,MD,MB,MI,MS ) : \
|
||||
_wO_r_X_B (0xc1 ,_b100 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SHLWrr(RS,RD) (((RS)==_CL) ? _wO_Mrm (0xd3 ,_b11,_b100,_r2(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SHLWrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _wO_r_X (0xd3 ,_b100 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define SHLLir(IM,RD) (((IM)==1) ? _O_Mrm (0xd1 ,_b11,_b100,_r4(RD) ) : \
|
||||
_O_Mrm_B (0xc1 ,_b11,_b100,_r4(RD) ,_u8(IM) ) )
|
||||
#define SHLLim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd1 ,_b100 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc1 ,_b100 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SHLLrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd3 ,_b11,_b100,_r4(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SHLLrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd3 ,_b100 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
|
||||
#define SHRBir(IM,RD) (((IM)==1) ? _O_Mrm (0xd0 ,_b11,_b101,_r1(RD) ) : \
|
||||
_O_Mrm_B (0xc0 ,_b11,_b101,_r1(RD) ,_u8(IM) ) )
|
||||
#define SHRBim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd0 ,_b101 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc0 ,_b101 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SHRBrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd2 ,_b11,_b101,_r1(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SHRBrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd2 ,_b101 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define SHRWir(IM,RD) (((IM)==1) ? _wO_Mrm (0xd1 ,_b11,_b101,_r2(RD) ) : \
|
||||
_wO_Mrm_B (0xc1 ,_b11,_b101,_r2(RD) ,_u8(IM) ) )
|
||||
#define SHRWim(IM,MD,MB,MS,MI) (((IM)==1) ? _wO_r_X (0xd1 ,_b101 ,MD,MB,MI,MS ) : \
|
||||
_wO_r_X_B (0xc1 ,_b101 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SHRWrr(RS,RD) (((RS)==_CL) ? _wO_Mrm (0xd3 ,_b11,_b101,_r2(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SHRWrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _wO_r_X (0xd3 ,_b101 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
#define SHRLir(IM,RD) (((IM)==1) ? _O_Mrm (0xd1 ,_b11,_b101,_r4(RD) ) : \
|
||||
_O_Mrm_B (0xc1 ,_b11,_b101,_r4(RD) ,_u8(IM) ) )
|
||||
#define SHRLim(IM,MD,MB,MS,MI) (((IM)==1) ? _O_r_X (0xd1 ,_b101 ,MD,MB,MI,MS ) : \
|
||||
_O_r_X_B (0xc1 ,_b101 ,MD,MB,MI,MS ,_u8(IM) ) )
|
||||
#define SHRLrr(RS,RD) (((RS)==_CL) ? _O_Mrm (0xd3 ,_b11,_b101,_r4(RD) ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
#define SHRLrm(RS,MD,MB,MS,MI) (((RS)==_CL) ? _O_r_X (0xd3 ,_b101 ,MD,MB,MI,MS ) : \
|
||||
JITFAIL ("source register must be CL" ) )
|
||||
|
||||
|
||||
#define STC() _O (0xf9 )
|
||||
|
||||
|
||||
#define SUBBrr(RS, RD) _O_Mrm (0x28 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define SUBBmr(MD, MB, MI, MS, RD) _O_r_X (0x2a ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define SUBBrm(RS, MD, MB, MI, MS) _O_r_X (0x28 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define SUBBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b101 ,_r1(RD) ,_su8(IM))
|
||||
#define SUBBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b101 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define SUBWrr(RS, RD) _wO_Mrm (0x29 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define SUBWmr(MD, MB, MI, MS, RD) _wO_r_X (0x2b ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define SUBWrm(RS, MD, MB, MI, MS) _wO_r_X (0x29 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define SUBWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b101 ,_r2(RD) ,_su16(IM))
|
||||
#define SUBWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b101 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define SUBLrr(RS, RD) _O_Mrm (0x29 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define SUBLmr(MD, MB, MI, MS, RD) _O_r_X (0x2b ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define SUBLrm(RS, MD, MB, MI, MS) _O_r_X (0x29 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define SUBLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b101 ,_r4(RD) ,IM )
|
||||
#define SUBLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b101 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define TESTBrr(RS, RD) _O_Mrm (0x84 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define TESTBrm(RS, MD, MB, MI, MS) _O_r_X (0x84 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define TESTBir(IM, RD) _O_Mrm_B (0xf6 ,_b11,_b000 ,_r1(RD) ,_u8(IM))
|
||||
#define TESTBim(IM, MD, MB, MI, MS) _O_r_X_B (0xf6 ,_b000 ,MD,MB,MI,MS ,_u8(IM))
|
||||
|
||||
#define TESTWrr(RS, RD) _wO_Mrm (0x85 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define TESTWrm(RS, MD, MB, MI, MS) _wO_r_X (0x85 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define TESTWir(IM, RD) _wO_Mrm_W (0xf7 ,_b11,_b000 ,_r2(RD) ,_u16(IM))
|
||||
#define TESTWim(IM, MD, MB, MI, MS) _wO_r_X_W (0xf7 ,_b000 ,MD,MB,MI,MS ,_u16(IM))
|
||||
|
||||
#define TESTLrr(RS, RD) _O_Mrm (0x85 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define TESTLrm(RS, MD, MB, MI, MS) _O_r_X (0x85 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define TESTLir(IM, RD) _O_Mrm_L (0xf7 ,_b11,_b000 ,_r4(RD) ,IM )
|
||||
#define TESTLim(IM, MD, MB, MI, MS) _O_r_X_L (0xf7 ,_b000 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
#define XADDBrr(RS,RD) _OO_Mrm (0x0fc0 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define XADDBrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fc0 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define XADDWrr(RS,RD) _wOO_Mrm (0x0fc1 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define XADDWrm(RS,MD,MB,MI,MS) _wOO_r_X (0x0fc1 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define XADDLrr(RS,RD) _OO_Mrm (0x0fc1 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define XADDLrm(RS,MD,MB,MI,MS) _OO_r_X (0x0fc1 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define XCHGBrr(RS,RD) _O_Mrm (0x86 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define XCHGBrm(RS,MD,MB,MI,MS) _O_r_X (0x86 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define XCHGWrr(RS,RD) _wO_Mrm (0x87 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define XCHGWrm(RS,MD,MB,MI,MS) _wO_r_X (0x87 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
|
||||
#define XCHGLrr(RS,RD) _O_Mrm (0x87 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define XCHGLrm(RS,MD,MB,MI,MS) _O_r_X (0x87 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
|
||||
|
||||
#define XORBrr(RS, RD) _O_Mrm (0x30 ,_b11,_r1(RS),_r1(RD) )
|
||||
#define XORBmr(MD, MB, MI, MS, RD) _O_r_X (0x32 ,_r1(RD) ,MD,MB,MI,MS )
|
||||
#define XORBrm(RS, MD, MB, MI, MS) _O_r_X (0x30 ,_r1(RS) ,MD,MB,MI,MS )
|
||||
#define XORBir(IM, RD) _O_Mrm_B (0x80 ,_b11,_b110 ,_r1(RD) ,_su8(IM))
|
||||
#define XORBim(IM, MD, MB, MI, MS) _O_r_X_B (0x80 ,_b110 ,MD,MB,MI,MS ,_su8(IM))
|
||||
|
||||
#define XORWrr(RS, RD) _wO_Mrm (0x31 ,_b11,_r2(RS),_r2(RD) )
|
||||
#define XORWmr(MD, MB, MI, MS, RD) _wO_r_X (0x33 ,_r2(RD) ,MD,MB,MI,MS )
|
||||
#define XORWrm(RS, MD, MB, MI, MS) _wO_r_X (0x31 ,_r2(RS) ,MD,MB,MI,MS )
|
||||
#define XORWir(IM, RD) _wOs_Mrm_sW (0x81 ,_b11,_b110 ,_r2(RD) ,_su16(IM))
|
||||
#define XORWim(IM, MD, MB, MI, MS) _wOs_r_X_sW (0x81 ,_b110 ,MD,MB,MI,MS ,_su16(IM))
|
||||
|
||||
#define XORLrr(RS, RD) _O_Mrm (0x31 ,_b11,_r4(RS),_r4(RD) )
|
||||
#define XORLmr(MD, MB, MI, MS, RD) _O_r_X (0x33 ,_r4(RD) ,MD,MB,MI,MS )
|
||||
#define XORLrm(RS, MD, MB, MI, MS) _O_r_X (0x31 ,_r4(RS) ,MD,MB,MI,MS )
|
||||
#define XORLir(IM, RD) _Os_Mrm_sL (0x81 ,_b11,_b110 ,_r4(RD) ,IM )
|
||||
#define XORLim(IM, MD, MB, MI, MS) _Os_r_X_sL (0x81 ,_b110 ,MD,MB,MI,MS ,IM )
|
||||
|
||||
|
||||
/* N byte NOPs */
|
||||
#define _NOPi(N) ((( (N) >= 8) ? (_B(0x8d),_B(0xb4),_B(0x26),_L(0x00),_B(0x90)) : (void) 0), \
|
||||
(( ((N)&7) == 7) ? (_B(0x8d),_B(0xb4),_B(0x26),_L(0x00)) : \
|
||||
( ((N)&7) == 6) ? (_B(0x8d),_B(0xb6),_L(0x00)) : \
|
||||
( ((N)&7) == 5) ? (_B(0x90),_B(0x8d),_B(0x74),_B(0x26),_B(0x00)) : \
|
||||
/* leal 0(,%esi), %esi */ ( ((N)&7) == 4) ? (_B(0x8d),_B(0x74),_B(0x26),_B(0x00)) : \
|
||||
/* leal (,%esi), %esi */ ( ((N)&7) == 3) ? (_B(0x8d),_B(0x76),_B(0x00)) : \
|
||||
/* movl %esi, %esi */ ( ((N)&7) == 2) ? (_B(0x89),_B(0xf6)) : \
|
||||
( ((N)&7) == 1) ? (_B(0x90)) : \
|
||||
( ((N)&7) == 0) ? 0 : \
|
||||
JITFAIL(".align argument too large")))
|
||||
|
||||
|
||||
/*** References: */
|
||||
/* */
|
||||
/* [1] "Intel Architecture Software Developer's Manual Volume 1: Basic Architecture", */
|
||||
/* Intel Corporation 1997. */
|
||||
/* */
|
||||
/* [2] "Intel Architecture Software Developer's Manual Volume 2: Instruction Set Reference", */
|
||||
/* Intel Corporation 1997. */
|
||||
|
||||
#endif /* __lightning_asm_h */
|
||||
421
lightning/i386/core.h
Normal file
421
lightning/i386/core.h
Normal file
|
|
@ -0,0 +1,421 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer (i386 version)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_core_h
|
||||
#define __lightning_core_h
|
||||
|
||||
#define JIT_R0 _EAX
|
||||
#define JIT_R1 _ECX
|
||||
#define JIT_R2 _EDX
|
||||
#define JIT_V0 _EBX
|
||||
#define JIT_V1 _ESI
|
||||
#define JIT_V2 _EDI
|
||||
#define JIT_FP _EBP
|
||||
#define JIT_SP _ESP
|
||||
#define JIT_RET _EAX
|
||||
|
||||
struct jit_local_state {
|
||||
int framesize;
|
||||
int argssize;
|
||||
};
|
||||
|
||||
/* 3-parameter operation */
|
||||
#define jit_opr_(d, s1, s2, op1d, op2d) \
|
||||
( (s2 == d) ? op1d : \
|
||||
( ((s1 == d) ? (void)0 : (void)MOVLrr(s1, d)), op2d ) \
|
||||
)
|
||||
|
||||
/* 3-parameter operation, with immediate */
|
||||
#define jit_op_(d, s1, op2d) \
|
||||
((s1 == d) ? op2d : (MOVLrr(s1, d), op2d)) \
|
||||
|
||||
/* 3-parameter operation, optimizable */
|
||||
#define jit_opo_(d, s1, s2, op1d, op2d, op12d) \
|
||||
((s2 == d) ? op2d : \
|
||||
((s1 == d) ? op1d : op12d))
|
||||
|
||||
/* 3-parameter operation, optimizable, with immediate */
|
||||
#define jit_opi_(d, rs, opdi, opdri) \
|
||||
((rs == d) ? opdi : opdri)
|
||||
|
||||
/* An operand is forced into a register */
|
||||
#define jit_replace(rd, rs, forced, op) \
|
||||
((rd == forced) ? JITSORRY("Register conflict for " # op) : \
|
||||
(rs == forced) ? op : (PUSHLr(forced), MOVLrr(rs, forced), op, POPLr(forced)))
|
||||
|
||||
/* For LT, LE, ... */
|
||||
#define jit_bool_r(d, s1, s2, op) \
|
||||
(CMPLrr(s2, s1), op, ANDLir(1, d))
|
||||
|
||||
#define jit_bool_i(d, rs, is, op) \
|
||||
(CMPLir(is, rs), op, ANDLir(1, d))
|
||||
|
||||
/* When CMP with 0 can be replaced with TEST */
|
||||
#define jit_bool_i0(d, rs, is, op, op0) \
|
||||
( ((is) != 0 ? (CMPLir(is, rs), op) : (TESTLrr(rs, rs), op0)), \
|
||||
ANDLir(1, d))
|
||||
|
||||
/* For BLT, BLE, ... */
|
||||
#define jit_bra_r(s1, s2, op) (CMPLrr(s2, s1), op, _jit.pc)
|
||||
#define jit_bra_i(rs, is, op) (CMPLir(is, rs), op, _jit.pc)
|
||||
|
||||
/* When CMP with 0 can be replaced with TEST */
|
||||
#define jit_bra_i0(rs, is, op, op0) \
|
||||
( (is) == 0 ? (TESTLrr(rs, rs), op0, _jit.pc) : (CMPLir(is, rs), op, _jit.pc))
|
||||
|
||||
/* Used to implement ldc, stc, ... */
|
||||
#define jit_check8(rs) ( (rs) <= _EBX )
|
||||
#define jit_reg8(rs) ( ((rs) & _BH) | _AL )
|
||||
#define jit_reg16(rs) ( ((rs) & _BH) | _AX )
|
||||
|
||||
#define jit_movbmr(sd, sb, si, ss, d, ext) \
|
||||
((jit_check8(d) \
|
||||
? MOVBmr(sd, sb, si, ss, jit_reg8(d)) \
|
||||
: MOVWmr(sd, sb, si, ss, jit_reg16(d))), ext)
|
||||
|
||||
/* In jit_replace below, _EBX is dummy */
|
||||
#define jit_movbrm(rs, dd, db, di, ds) \
|
||||
(jit_check8(rs) \
|
||||
? MOVBrm(jit_reg8(rs), dd, db, di, ds) \
|
||||
: jit_replace(_EBX, rs, _EAX, MOVBrm(_AL, dd, db, di, ds)))
|
||||
|
||||
/* Reduce arguments of XOR/OR/TEST */
|
||||
#define jit_reduce_(op) op
|
||||
#define jit_reduce(op, is, rs) \
|
||||
(_u8P(is) && jit_check8(rs) ? jit_reduce_(op##Bir(is, jit_reg8(rs))) : \
|
||||
(_u16P(is) ? jit_reduce_(op##Wir(is, jit_reg16(rs))) : \
|
||||
jit_reduce_(op##Lir(is, rs)) ))
|
||||
|
||||
/* Helper macros for MUL/DIV/IDIV */
|
||||
#define jit_might(d, s1, op) \
|
||||
((s1 == d) ? (void)0 : (void)op)
|
||||
|
||||
#define jit_mulr_ui_(s1, s2) jit_opr_(_EAX, s1, s2, MULLr(s1), MULLr(s2))
|
||||
#define jit_mulr_i_(s1, s2) jit_opr_(_EAX, s1, s2, IMULLr(s1), IMULLr(s2))
|
||||
|
||||
|
||||
#define jit_muli_i_(is, rs) \
|
||||
(MOVLir(is, rs == _EAX ? _EDX : _EAX), \
|
||||
IMULLr(rs == _EAX ? _EDX : rs))
|
||||
|
||||
#define jit_muli_ui_(is, rs) \
|
||||
(MOVLir(is, rs == _EAX ? _EDX : _EAX), \
|
||||
IMULLr(rs == _EAX ? _EDX : rs))
|
||||
|
||||
#define jit_divi_i_(result, d, rs, is) \
|
||||
(jit_might (d, _EAX, PUSHLr(_EAX)), \
|
||||
jit_might (d, _ECX, PUSHLr(_ECX)), \
|
||||
jit_might (d, _EDX, PUSHLr(_EDX)), \
|
||||
jit_might (rs, _EAX, MOVLrr(rs, _EAX)), \
|
||||
jit_might (rs, _EDX, MOVLrr(rs, _EDX)), \
|
||||
MOVLir(is, _ECX), \
|
||||
SARLir(31, _EDX), \
|
||||
IDIVLr(_ECX), \
|
||||
jit_might(d, result, MOVLrr(result, d)), \
|
||||
jit_might(d, _EDX, POPLr(_EDX)), \
|
||||
jit_might(d, _ECX, POPLr(_ECX)), \
|
||||
jit_might(d, _EAX, POPLr(_EAX)))
|
||||
|
||||
#define jit_divr_i_(result, d, s1, s2) \
|
||||
(jit_might (d, _EAX, PUSHLr(_EAX)), \
|
||||
jit_might (d, _ECX, PUSHLr(_ECX)), \
|
||||
jit_might (d, _EDX, PUSHLr(_EDX)), \
|
||||
((s1 == _ECX) ? PUSHLr(_ECX) : 0), \
|
||||
jit_might (s2, _ECX, MOVLrr(s2, _ECX)), \
|
||||
((s1 == _ECX) ? POPLr(_EDX) : \
|
||||
jit_might (s1, _EDX, MOVLrr(s1, _EDX))), \
|
||||
MOVLrr(_EDX, _EAX), \
|
||||
SARLir(31, _EDX), \
|
||||
IDIVLr(_ECX), \
|
||||
jit_might(d, result, MOVLrr(result, d)), \
|
||||
jit_might(d, _EDX, POPLr(_EDX)), \
|
||||
jit_might(d, _ECX, POPLr(_ECX)), \
|
||||
jit_might(d, _EAX, POPLr(_EAX)))
|
||||
|
||||
#define jit_divi_ui_(result, d, rs, is) \
|
||||
(jit_might (d, _EAX, PUSHLr(_EAX)), \
|
||||
jit_might (d, _ECX, PUSHLr(_ECX)), \
|
||||
jit_might (d, _EDX, PUSHLr(_EDX)), \
|
||||
jit_might (rs, _EAX, MOVLrr(rs, _EAX)), \
|
||||
MOVLir(is, _ECX), \
|
||||
XORLrr(_EDX, _EDX), \
|
||||
DIVLr(_ECX), \
|
||||
jit_might(d, result, MOVLrr(result, d)), \
|
||||
jit_might(d, _EDX, POPLr(_EDX)), \
|
||||
jit_might(d, _ECX, POPLr(_ECX)), \
|
||||
jit_might(d, _EAX, POPLr(_EAX)))
|
||||
|
||||
#define jit_divr_ui_(result, d, s1, s2) \
|
||||
(jit_might (d, _EAX, PUSHLr(_EAX)), \
|
||||
jit_might (d, _ECX, PUSHLr(_ECX)), \
|
||||
jit_might (d, _EDX, PUSHLr(_EDX)), \
|
||||
((s1 == _ECX) ? PUSHLr(_ECX) : 0), \
|
||||
jit_might (s2, _ECX, MOVLrr(s2, _ECX)), \
|
||||
((s1 == _ECX) ? POPLr(_EAX) : \
|
||||
jit_might (s1, _EAX, MOVLrr(s1, _EAX))), \
|
||||
XORLrr(_EDX, _EDX), \
|
||||
DIVLr(_ECX), \
|
||||
jit_might(d, result, MOVLrr(result, d)), \
|
||||
jit_might(d, _EDX, POPLr(_EDX)), \
|
||||
jit_might(d, _ECX, POPLr(_ECX)), \
|
||||
jit_might(d, _EAX, POPLr(_EAX)))
|
||||
|
||||
|
||||
/* ALU */
|
||||
#define jit_addi_i(d, rs, is) jit_opi_((d), (rs), ADDLir((is), (d)), LEALmr((is), (rs), 0, 0, (d)) )
|
||||
#define jit_addr_i(d, s1, s2) jit_opo_((d), (s1), (s2), ADDLrr((s2), (d)), ADDLrr((s1), (d)), LEALmr(0, (s1), (s2), 1, (d)) )
|
||||
#define jit_addci_i(d, rs, is) jit_op_ ((d), (rs), ADDLir((is), (d)) )
|
||||
#define jit_addcr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ADDLrr((s1), (d)), ADDLrr((s2), (d)) )
|
||||
#define jit_addxi_i(d, rs, is) jit_op_ ((d), (rs), ADCLir((is), (d)) )
|
||||
#define jit_addxr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ADCLrr((s1), (d)), ADCLrr((s2), (d)) )
|
||||
#define jit_andi_i(d, rs, is) jit_op_ ((d), (rs), ANDLir((is), (d)) )
|
||||
#define jit_andr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ANDLrr((s1), (d)), ANDLrr((s2), (d)) )
|
||||
#define jit_orr_i(d, s1, s2) jit_opr_((d), (s1), (s2), ORLrr((s1), (d)), ORLrr((s2), (d)) )
|
||||
#define jit_subr_i(d, s1, s2) jit_opr_((d), (s1), (s2), (SUBLrr((s1), (d)), NEGLr(d)), SUBLrr((s2), (d)) )
|
||||
#define jit_subcr_i(d, s1, s2) jit_subr_i((d), (s1), (s2))
|
||||
#define jit_subxr_i(d, s1, s2) jit_opr_((d), (s1), (s2), SBBLrr((s1), (d)), SBBLrr((s2), (d)) )
|
||||
#define jit_subxi_i(d, rs, is) jit_op_ ((d), (rs), SBBLir((is), (d)) )
|
||||
#define jit_xorr_i(d, s1, s2) jit_opr_((d), (s1), (s2), XORLrr((s1), (d)), XORLrr((s2), (d)) )
|
||||
|
||||
/* These can sometimes use byte or word versions! */
|
||||
#define jit_ori_i(d, rs, is) jit_op_ ((d), (rs), jit_reduce(OR, (is), (d)) )
|
||||
#define jit_xori_i(d, rs, is) jit_op_ ((d), (rs), jit_reduce(XOR, (is), (d)) )
|
||||
|
||||
#define jit_muli_i(d, rs, is) jit_op_ ((d), (rs), IMULLir((is), (d)) )
|
||||
#define jit_mulr_i(d, s1, s2) jit_opr_((d), (s1), (s2), IMULLrr((s1), (d)), IMULLrr((s2), (d)) )
|
||||
#define jit_muli_ui(d, rs, is) jit_op_ ((d), (rs), IMULLir((is), (d)) )
|
||||
#define jit_mulr_ui(d, s1, s2) jit_opr_((d), (s1), (s2), IMULLrr((s1), (d)), IMULLrr((s2), (d)) )
|
||||
|
||||
/* As far as low bits are concerned, signed and unsigned multiplies are
|
||||
* exactly the same. */
|
||||
#ifdef not_needed
|
||||
#undef jit_muli_i
|
||||
#undef jit_muli_ui
|
||||
|
||||
#define jit_muli_ui(d, rs, is) \
|
||||
((d) == _EDX ? ( PUSHLr(_EAX), MOVLir((is), _EAX), MULLr(rs), MOVLrr(_EAX, _EDX), POPLr(_EAX) ) : \
|
||||
((d) == _EAX ? (PUSHLr(_EDX), MOVLir((is), _EAX), MULLr(rs), POPLr(_EDX) ) : \
|
||||
(PUSHLr(_EDX), PUSHLr(_EAX), MOVLir((is), _EAX), MULLr(rs), MOVLrr(_EAX, (d)), POPLr(_EAX), POPLr(_EDX) )))
|
||||
|
||||
#define jit_mulr_ui(d, s1, s2) \
|
||||
((d) == _EDX ? ( PUSHLr(_EAX), jit_mulr_ui_((s1), (s2)), MOVLrr(_EAX, _EDX), POPLr(_EAX) ) : \
|
||||
((d) == _EAX ? (PUSHLr(_EDX), jit_mulr_ui_((s1), (s2)), POPLr(_EDX) ) : \
|
||||
(PUSHLr(_EDX), PUSHLr(_EAX), jit_mulr_ui_((s1), (s2)), MOVLrr(_EAX, (d)), POPLr(_EAX), POPLr(_EDX) )))
|
||||
#endif /* not_needed */
|
||||
|
||||
#define jit_hmuli_i(d, rs, is) \
|
||||
((d) == _EDX ? ( PUSHLr(_EAX), jit_muli_i_((is), (rs)), POPLr(_EAX) ) : \
|
||||
((d) == _EAX ? (PUSHLr(_EDX), jit_muli_i_((is), (rs)), MOVLrr(_EDX, _EAX), POPLr(_EDX) ) : \
|
||||
(PUSHLr(_EDX), PUSHLr(_EAX), jit_muli_i_((is), (rs)), MOVLrr(_EDX, (d)), POPLr(_EAX), POPLr(_EDX) )))
|
||||
|
||||
#define jit_hmulr_i(d, s1, s2) \
|
||||
((d) == _EDX ? ( PUSHLr(_EAX), jit_mulr_i_((s1), (s2)), POPLr(_EAX) ) : \
|
||||
((d) == _EAX ? (PUSHLr(_EDX), jit_mulr_i_((s1), (s2)), MOVLrr(_EDX, _EAX), POPLr(_EDX) ) : \
|
||||
(PUSHLr(_EDX), PUSHLr(_EAX), jit_mulr_i_((s1), (s2)), MOVLrr(_EDX, (d)), POPLr(_EAX), POPLr(_EDX) )))
|
||||
|
||||
#define jit_hmuli_ui(d, rs, is) \
|
||||
((d) == _EDX ? ( PUSHLr(_EAX), jit_muli_ui_((is), (rs)), POPLr(_EAX) ) : \
|
||||
((d) == _EAX ? (PUSHLr(_EDX), jit_muli_ui_((is), (rs)), MOVLrr(_EDX, _EAX), POPLr(_EDX) ) : \
|
||||
(PUSHLr(_EDX), PUSHLr(_EAX), jit_muli_ui_((is), (rs)), MOVLrr(_EDX, (d)), POPLr(_EAX), POPLr(_EDX) )))
|
||||
|
||||
#define jit_hmulr_ui(d, s1, s2) \
|
||||
((d) == _EDX ? ( PUSHLr(_EAX), jit_mulr_ui_((s1), (s2)), POPLr(_EAX) ) : \
|
||||
((d) == _EAX ? (PUSHLr(_EDX), jit_mulr_ui_((s1), (s2)), MOVLrr(_EDX, _EAX), POPLr(_EDX) ) : \
|
||||
(PUSHLr(_EDX), PUSHLr(_EAX), jit_mulr_ui_((s1), (s2)), MOVLrr(_EDX, (d)), POPLr(_EAX), POPLr(_EDX) )))
|
||||
|
||||
#define jit_divi_i(d, rs, is) jit_divi_i_(_EAX, (d), (rs), (is))
|
||||
#define jit_divi_ui(d, rs, is) jit_divi_ui_(_EAX, (d), (rs), (is))
|
||||
#define jit_modi_i(d, rs, is) jit_divi_i_(_EDX, (d), (rs), (is))
|
||||
#define jit_modi_ui(d, rs, is) jit_divi_ui_(_EDX, (d), (rs), (is))
|
||||
#define jit_divr_i(d, s1, s2) jit_divr_i_(_EAX, (d), (s1), (s2))
|
||||
#define jit_divr_ui(d, s1, s2) jit_divr_ui_(_EAX, (d), (s1), (s2))
|
||||
#define jit_modr_i(d, s1, s2) jit_divr_i_(_EDX, (d), (s1), (s2))
|
||||
#define jit_modr_ui(d, s1, s2) jit_divr_ui_(_EDX, (d), (s1), (s2))
|
||||
|
||||
|
||||
/* Shifts */
|
||||
#define jit_lshi_i(d, rs, is) ((is) <= 3 ? LEALmr(0, 0, (rs), 1 << (is), (d)) : jit_op_ ((d), (rs), SHLLir((is), (d)) ))
|
||||
#define jit_rshi_i(d, rs, is) jit_op_ ((d), (rs), SARLir((is), (d)) )
|
||||
#define jit_rshi_ui(d, rs, is) jit_op_ ((d), (rs), SHRLir((is), (d)) )
|
||||
#define jit_lshr_i(d, r1, r2) jit_replace((r1), (r2), _ECX, jit_op_ ((d), (r1), SHLLrr(_CL, (d)) ))
|
||||
#define jit_rshr_i(d, r1, r2) jit_replace((r1), (r2), _ECX, jit_op_ ((d), (r1), SARLrr(_CL, (d)) ))
|
||||
#define jit_rshr_ui(d, r1, r2) jit_replace((r1), (r2), _ECX, jit_op_ ((d), (r1), SHRLrr(_CL, (d)) ))
|
||||
|
||||
/* Stack */
|
||||
#define jit_pushr_i(rs) PUSHLr(rs)
|
||||
#define jit_popr_i(rs) POPLr(rs)
|
||||
#define jit_prolog(n) (_jitl.framesize = 8, PUSHLr(_EBP), MOVLrr(_ESP, _EBP), PUSHLr(_EBX), PUSHLr(_ESI), PUSHLr(_EDI))
|
||||
|
||||
/* The += allows for stack pollution */
|
||||
|
||||
#define jitfp_prepare(ni,nf,nd) ((void) (_jitl.argssize += (ni) + (nf) + 2*(nd)))
|
||||
#define jit_pusharg_i(rs) PUSHLr(rs)
|
||||
#define jit_finish(sub) (jit_calli((sub)), ADDLir(4 * _jitl.argssize, JIT_SP), _jitl.argssize = 0)
|
||||
#define jit_retval(rd) ((void) ( (rd) == _EAX ? 0 : MOVLrr(_EAX, (rd)) ))
|
||||
|
||||
#define jit_arg_c() ((_jitl.framesize += sizeof(int)) - sizeof(int))
|
||||
#define jit_arg_uc() ((_jitl.framesize += sizeof(int)) - sizeof(int))
|
||||
#define jit_arg_s() ((_jitl.framesize += sizeof(int)) - sizeof(int))
|
||||
#define jit_arg_us() ((_jitl.framesize += sizeof(int)) - sizeof(int))
|
||||
#define jit_arg_i() ((_jitl.framesize += sizeof(int)) - sizeof(int))
|
||||
#define jit_arg_ui() ((_jitl.framesize += sizeof(int)) - sizeof(int))
|
||||
#define jit_arg_l() ((_jitl.framesize += sizeof(long)) - sizeof(long))
|
||||
#define jit_arg_ul() ((_jitl.framesize += sizeof(long)) - sizeof(long))
|
||||
#define jit_arg_p() ((_jitl.framesize += sizeof(long)) - sizeof(long))
|
||||
|
||||
#define jit_arg_f() ((_jitl.framesize += sizeof(float)) - sizeof(float))
|
||||
#define jit_arg_d() ((_jitl.framesize += sizeof(double)) - sizeof(double))
|
||||
|
||||
/* Unary */
|
||||
#define jit_negr_i(d, rs) jit_opi_((d), (rs), NEGLr(d), (XORLrr((d), (d)), SUBLrr((rs), (d))) )
|
||||
#define jit_negr_l(d, rs) jit_opi_((d), (rs), NEGLr(d), (XORLrr((d), (d)), SUBLrr((rs), (d))) )
|
||||
|
||||
#define jit_movr_i(d, rs) MOVLrr((rs), (d))
|
||||
#define jit_movi_i(d, is) ((is) ? MOVLir((is), (d)) : XORLrr ((d), (d)) )
|
||||
|
||||
#define jit_ntoh_ui(d, rs) jit_op_((d), (rs), BSWAPLr(d))
|
||||
#define jit_ntoh_us(d, rs) jit_op_((d), (rs), RORWir(8, d))
|
||||
|
||||
/* Boolean */
|
||||
#define jit_ltr_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETLr(jit_reg8(d)) )
|
||||
#define jit_ler_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETLEr(jit_reg8(d)) )
|
||||
#define jit_gtr_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETGr(jit_reg8(d)) )
|
||||
#define jit_ger_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETGEr(jit_reg8(d)) )
|
||||
#define jit_eqr_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETEr(jit_reg8(d)) )
|
||||
#define jit_ner_i(d, s1, s2) jit_bool_r((d), (s1), (s2), SETNEr(jit_reg8(d)) )
|
||||
#define jit_ltr_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETBr(jit_reg8(d)) )
|
||||
#define jit_ler_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETBEr(jit_reg8(d)) )
|
||||
#define jit_gtr_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETAr(jit_reg8(d)) )
|
||||
#define jit_ger_ui(d, s1, s2) jit_bool_r((d), (s1), (s2), SETAEr(jit_reg8(d)) )
|
||||
|
||||
#define jit_lti_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETLr(jit_reg8(d)), SETSr(jit_reg8(d)) )
|
||||
#define jit_lei_i(d, rs, is) jit_bool_i ((d), (rs), (is), SETLEr(jit_reg8(d)) )
|
||||
#define jit_gti_i(d, rs, is) jit_bool_i ((d), (rs), (is), SETGr(jit_reg8(d)) )
|
||||
#define jit_gei_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETGEr(jit_reg8(d)), SETNSr(jit_reg8(d)) )
|
||||
#define jit_eqi_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETEr(jit_reg8(d)), SETEr(jit_reg8(d)) )
|
||||
#define jit_nei_i(d, rs, is) jit_bool_i0((d), (rs), (is), SETNEr(jit_reg8(d)), SETNEr(jit_reg8(d)) )
|
||||
#define jit_lti_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETBr(jit_reg8(d)), XORLrr((d), (d)) )
|
||||
#define jit_lei_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETBEr(jit_reg8(d)), SETEr(jit_reg8(d)) )
|
||||
#define jit_gti_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETAr(jit_reg8(d)), SETNEr(jit_reg8(d)) )
|
||||
#define jit_gei_ui(d, rs, is) jit_bool_i0((d), (rs), (is), SETAEr(jit_reg8(d)), INCLr((d)) )
|
||||
|
||||
/* Jump */
|
||||
#define jit_bltr_i(label, s1, s2) jit_bra_r((s1), (s2), JLm(label, 0,0,0) )
|
||||
#define jit_bler_i(label, s1, s2) jit_bra_r((s1), (s2), JLEm(label,0,0,0) )
|
||||
#define jit_bgtr_i(label, s1, s2) jit_bra_r((s1), (s2), JGm(label, 0,0,0) )
|
||||
#define jit_bger_i(label, s1, s2) jit_bra_r((s1), (s2), JGEm(label,0,0,0) )
|
||||
#define jit_beqr_i(label, s1, s2) jit_bra_r((s1), (s2), JEm(label, 0,0,0) )
|
||||
#define jit_bner_i(label, s1, s2) jit_bra_r((s1), (s2), JNEm(label,0,0,0) )
|
||||
#define jit_bltr_ui(label, s1, s2) jit_bra_r((s1), (s2), JBm(label, 0,0,0) )
|
||||
#define jit_bler_ui(label, s1, s2) jit_bra_r((s1), (s2), JBEm(label,0,0,0) )
|
||||
#define jit_bgtr_ui(label, s1, s2) jit_bra_r((s1), (s2), JAm(label, 0,0,0) )
|
||||
#define jit_bger_ui(label, s1, s2) jit_bra_r((s1), (s2), JAEm(label,0,0,0) )
|
||||
#define jit_bmsr_i(label, s1, s2) (TESTLrr((s1), (s2)), JNZm(label,0,0,0), _jit.pc)
|
||||
#define jit_bmcr_i(label, s1, s2) (TESTLrr((s1), (s2)), JZm(label,0,0,0), _jit.pc)
|
||||
#define jit_boaddr_i(label, s1, s2) (ADDLrr((s2), (s1)), JOm(label,0,0,0), _jit.pc)
|
||||
#define jit_bosubr_i(label, s1, s2) (SUBLrr((s2), (s1)), JOm(label,0,0,0), _jit.pc)
|
||||
#define jit_boaddr_ui(label, s1, s2) (ADDLrr((s2), (s1)), JCm(label,0,0,0), _jit.pc)
|
||||
#define jit_bosubr_ui(label, s1, s2) (SUBLrr((s2), (s1)), JCm(label,0,0,0), _jit.pc)
|
||||
|
||||
#define jit_blti_i(label, rs, is) jit_bra_i0((rs), (is), JLm(label, 0,0,0), JSm(label, 0,0,0) )
|
||||
#define jit_blei_i(label, rs, is) jit_bra_i ((rs), (is), JLEm(label,0,0,0) )
|
||||
#define jit_bgti_i(label, rs, is) jit_bra_i ((rs), (is), JGm(label, 0,0,0) )
|
||||
#define jit_bgei_i(label, rs, is) jit_bra_i0((rs), (is), JGEm(label,0,0,0), JNSm(label,0,0,0) )
|
||||
#define jit_beqi_i(label, rs, is) jit_bra_i0((rs), (is), JEm(label, 0,0,0), JEm(label, 0,0,0) )
|
||||
#define jit_bnei_i(label, rs, is) jit_bra_i0((rs), (is), JNEm(label,0,0,0), JNEm(label,0,0,0) )
|
||||
#define jit_blti_ui(label, rs, is) jit_bra_i ((rs), (is), JLm(label, 0,0,0) )
|
||||
#define jit_blei_ui(label, rs, is) jit_bra_i0((rs), (is), JLEm(label,0,0,0), JEm(label, 0,0,0) )
|
||||
#define jit_bgti_ui(label, rs, is) jit_bra_i0((rs), (is), JGm(label, 0,0,0), JNEm(label,0,0,0) )
|
||||
#define jit_bgei_ui(label, rs, is) jit_bra_i ((rs), (is), JGEm(label,0,0,0) )
|
||||
#define jit_boaddi_i(label, rs, is) (ADDLir((is), (rs)), JOm(label,0,0,0), _jit.pc)
|
||||
#define jit_bosubi_i(label, rs, is) (SUBLir((is), (rs)), JOm(label,0,0,0), _jit.pc)
|
||||
#define jit_boaddi_ui(label, rs, is) (ADDLir((is), (rs)), JCm(label,0,0,0), _jit.pc)
|
||||
#define jit_bosubi_ui(label, rs, is) (SUBLir((is), (rs)), JCm(label,0,0,0), _jit.pc)
|
||||
|
||||
#define jit_bmsi_i(label, rs, is) (jit_reduce(TEST, (is), (rs)), JNZm(label,0,0,0), _jit.pc)
|
||||
#define jit_bmci_i(label, rs, is) (jit_reduce(TEST, (is), (rs)), JZm(label,0,0,0), _jit.pc)
|
||||
|
||||
#define jit_jmpi(label) (JMPm( ((unsigned long) (label)), 0, 0, 0), _jit.pc)
|
||||
#define jit_calli(label) (CALLm( ((unsigned long) (label)), 0, 0, 0), _jit.pc)
|
||||
#define jit_jmpr(reg) JMPsr(reg)
|
||||
#define jit_patch(jump_pc) (*_PSL((jump_pc) - 4) = _SL(_jit.pc - (jump_pc)))
|
||||
#define jit_ret() (POPLr(_EDI), POPLr(_ESI), POPLr(_EBX), POPLr(_EBP), RET())
|
||||
|
||||
/* Memory */
|
||||
#define jit_ldi_c(d, is) jit_movbmr((is), 0, 0, 0, (d), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldr_c(d, rs) jit_movbmr(0, (rs), 0, 0, (d), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldxr_c(d, s1, s2) jit_movbmr(0, (s1), (s2), 1, (d), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldxi_c(d, rs, is) jit_movbmr((is), (rs), 0, 0, (d), jit_extr_c_i((d), (d)))
|
||||
|
||||
#define jit_ldi_uc(d, is) jit_movbmr((is), 0, 0, 0, (d), jit_extr_uc_ui((d), (d)))
|
||||
#define jit_ldr_uc(d, rs) jit_movbmr(0, (rs), 0, 0, (d), jit_extr_uc_ui((d), (d)))
|
||||
#define jit_ldxr_uc(d, s1, s2) jit_movbmr(0, (s1), (s2), 1, (d), jit_extr_uc_ui((d), (d)))
|
||||
#define jit_ldxi_uc(d, rs, is) jit_movbmr((is), (rs), 0, 0, (d), jit_extr_uc_ui((d), (d)))
|
||||
|
||||
#define jit_sti_c(id, rs) jit_movbrm((rs), (id), 0, 0, 0)
|
||||
#define jit_str_c(rd, rs) jit_movbrm((rs), 0, (rd), 0, 0)
|
||||
#define jit_stxr_c(d1, d2, rs) jit_movbrm((rs), 0, (d1), (d2), 1)
|
||||
#define jit_stxi_c(id, rd, rs) jit_movbrm((rs), (id), (rd), 0, 0)
|
||||
|
||||
#define jit_ldi_s(d, is) (MOVWmr((is), 0, 0, 0, jit_reg16(d)), jit_extr_s_i((d), (d)))
|
||||
#define jit_ldr_s(d, rs) (MOVWmr(0, (rs), 0, 0, jit_reg16(d)), jit_extr_s_i((d), (d)))
|
||||
#define jit_ldxr_s(d, s1, s2) (MOVWmr(0, (s1), (s2), 1, jit_reg16(d)), jit_extr_s_i((d), (d)))
|
||||
#define jit_ldxi_s(d, rs, is) (MOVWmr((is), (rs), 0, 0, jit_reg16(d)), jit_extr_s_i((d), (d)))
|
||||
|
||||
#define jit_ldi_us(d, is) (XORLrr((d), (d)), MOVWmr((is), 0, 0, 0, jit_reg16(d)))
|
||||
#define jit_ldr_us(d, rs) (XORLrr((d), (d)), MOVWmr(0, (rs), 0, 0, jit_reg16(d)))
|
||||
#define jit_ldxr_us(d, s1, s2) (XORLrr((d), (d)), MOVWmr(0, (s1), (s2), 1, jit_reg16(d)))
|
||||
#define jit_ldxi_us(d, rs, is) (XORLrr((d), (d)), MOVWmr((is), (rs), 0, 0, jit_reg16(d)))
|
||||
|
||||
#define jit_sti_s(id, rs) MOVWrm(jit_reg16(rs), (id), 0, 0, 0)
|
||||
#define jit_str_s(rd, rs) MOVWrm(jit_reg16(rs), 0, (rd), 0, 0)
|
||||
#define jit_stxr_s(d1, d2, rs) MOVWrm(jit_reg16(rs), 0, (d1), (d2), 1)
|
||||
#define jit_stxi_s(id, rd, rs) MOVWrm(jit_reg16(rs), (id), (rd), 0, 0)
|
||||
|
||||
#define jit_ldi_i(d, is) MOVLmr((is), 0, 0, 0, (d))
|
||||
#define jit_ldr_i(d, rs) MOVLmr(0, (rs), 0, 0, (d))
|
||||
#define jit_ldxr_i(d, s1, s2) MOVLmr(0, (s1), (s2), 1, (d))
|
||||
#define jit_ldxi_i(d, rs, is) MOVLmr((is), (rs), 0, 0, (d))
|
||||
|
||||
#define jit_sti_i(id, rs) MOVLrm((rs), (id), 0, 0, 0)
|
||||
#define jit_str_i(rd, rs) MOVLrm((rs), 0, (rd), 0, 0)
|
||||
#define jit_stxr_i(d1, d2, rs) MOVLrm((rs), 0, (d1), (d2), 1)
|
||||
#define jit_stxi_i(id, rd, rs) MOVLrm((rs), (id), (rd), 0, 0)
|
||||
|
||||
/* Extra */
|
||||
#define jit_nop() NOP()
|
||||
|
||||
#define _jit_alignment(pc, n) (((pc ^ _MASK(4)) + 1) & _MASK(n))
|
||||
#define jit_align(n) _NOPi(_jit_alignment(_UL(_jit.pc), (n)))
|
||||
|
||||
#endif /* __lightning_core_h */
|
||||
205
lightning/i386/fp.h
Normal file
205
lightning/i386/fp.h
Normal file
|
|
@ -0,0 +1,205 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler & support macros for the i386 math coprocessor
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
#ifndef __lightning_asm_fp_h
|
||||
#define __lightning_asm_fp_h
|
||||
|
||||
#define ESCmi(D,B,I,S,OP) _O_r_X(0xd8|(OP & 7), (OP >> 3), D,B,I,S)
|
||||
|
||||
#define FLDSm(D,B,I,S) ESCmi(D,B,I,S,001) /* fld m32real */
|
||||
#define FILDLm(D,B,I,S) ESCmi(D,B,I,S,003) /* fild m32int */
|
||||
#define FLDLm(D,B,I,S) ESCmi(D,B,I,S,005) /* fld m64real */
|
||||
#define FILDWm(D,B,I,S) ESCmi(D,B,I,S,007) /* fild m16int */
|
||||
#define FSTSm(D,B,I,S) ESCmi(D,B,I,S,021) /* fst m32real */
|
||||
#define FISTLm(D,B,I,S) ESCmi(D,B,I,S,023) /* fist m32int */
|
||||
#define FSTLm(D,B,I,S) ESCmi(D,B,I,S,025) /* fst m64real */
|
||||
#define FISTWm(D,B,I,S) ESCmi(D,B,I,S,027) /* fist m16int */
|
||||
#define FSTPSm(D,B,I,S) ESCmi(D,B,I,S,031) /* fstp m32real */
|
||||
#define FISTPLm(D,B,I,S) ESCmi(D,B,I,S,033) /* fistp m32int */
|
||||
#define FSTPLm(D,B,I,S) ESCmi(D,B,I,S,035) /* fstp m64real */
|
||||
#define FISTPWm(D,B,I,S) ESCmi(D,B,I,S,037) /* fistp m16int */
|
||||
#define FLDTm(D,B,I,S) ESCmi(D,B,I,S,053) /* fld m80real */
|
||||
#define FILDQm(D,B,I,S) ESCmi(D,B,I,S,057) /* fild m64int */
|
||||
#define FSTPTm(D,B,I,S) ESCmi(D,B,I,S,073) /* fstp m80real */
|
||||
#define FISTPQm(D,B,I,S) ESCmi(D,B,I,S,077) /* fistp m64int */
|
||||
|
||||
|
||||
#define jit_add_two(reg0) _OO(0xdec1) /* faddp */
|
||||
#define jit_sub_two(reg0) _OO(0xdee9) /* fsubp */
|
||||
#define jit_mul_two(reg0) _OO(0xdec9) /* fmulp */
|
||||
#define jit_div_two(reg0) _OO(0xdef9) /* fdivp */
|
||||
|
||||
#define jit_abs(reg0) _OO(0xd9e1) /* fabs */
|
||||
#define jit_sqr(reg0) _OO(0xdcc8) /* fmul st */
|
||||
#define jit_sqrt(reg0) _OO(0xd9fa) /* fsqrt */
|
||||
|
||||
#define jit_exti_d(reg0, rs) (PUSHLr((rs)), FILDLm(0, _ESP, 0, 0), POPLr((rs)))
|
||||
|
||||
#define jit_neg(reg0) _OO(0xd9e0) /* fchs */
|
||||
|
||||
#define jit_ldxr_f(reg0, s1, s2) FLDSm(0, (s1), (s2), 1)
|
||||
#define jit_ldxi_f(reg0, rs, is) FLDSm((is), (rs), 0, 0)
|
||||
#define jit_ldxr_f(reg0, s1, s2) FLDSm(0, (s1), (s2), 1)
|
||||
#define jit_ldxi_d(reg0, rs, is) FLDLm((is), (rs), 0, 0)
|
||||
#define jit_ldxr_d(reg0, s1, s2) FLDLm(0, (s1), (s2), 1)
|
||||
#define jit_ldi_f(reg0, is) FLDSm((is), 0, 0, 0)
|
||||
#define jit_ldr_f(reg0, rs) FLDSm(0, (rs), 0, 0)
|
||||
#define jit_ldi_d(reg0, is) FLDLm((is), 0, 0, 0)
|
||||
#define jit_ldr_d(reg0, rs) FLDLm(0, (rs), 0, 0)
|
||||
#define jit_stxi_f(id, rd, reg0) FSTPSm((id), (rd), 0, 0)
|
||||
#define jit_stxr_f(d1, d2, reg0) FSTPSm(0, (d1), (d2), 1)
|
||||
#define jit_stxi_d(id, rd, reg0) FSTPLm((id), (rd), 0, 0)
|
||||
#define jit_stxr_d(d1, d2, reg0) FSTPLm(0, (d1), (d2), 1)
|
||||
#define jit_sti_f(id, reg0) FSTPSm((id), 0, 0, 0)
|
||||
#define jit_str_f(rd, reg0) FSTPSm(0, (rd), 0, 0)
|
||||
#define jit_sti_d(id, reg0) FSTPLm((id), 0, 0, 0)
|
||||
#define jit_str_d(rd, reg0) FSTPLm(0, (rd), 0, 0)
|
||||
|
||||
#define jit_fpimm(reg0, first, second) \
|
||||
(PUSHLi(second), \
|
||||
PUSHLi(first), \
|
||||
FLDLm(0, _ESP, 0, 0), \
|
||||
ADDLir(8, _ESP))
|
||||
|
||||
|
||||
/* Assume round to near mode */
|
||||
#define jit_floor(rd, reg0) \
|
||||
jit_floor2((rd), ((rd) == _EDX ? _EAX : _EDX))
|
||||
|
||||
#define jit_ceil(rd, reg0) \
|
||||
jit_ceil2((rd), ((rd) == _EDX ? _EAX : _EDX))
|
||||
|
||||
#define jit_trunc(rd, reg0) \
|
||||
jit_trunc2((rd), ((rd) == _EDX ? _EAX : _EDX))
|
||||
|
||||
#define jit_calc_diff(ofs) \
|
||||
FISTLm(ofs, _ESP, 0, 0), \
|
||||
FILDLm(ofs, _ESP, 0, 0), \
|
||||
_OO(0xdee9), /* fsubp */ \
|
||||
FSTPSm(4+ofs, _ESP, 0, 0) \
|
||||
|
||||
/* The real meat */
|
||||
#define jit_floor2(rd, aux) \
|
||||
(PUSHLr(aux), \
|
||||
SUBLir(8, _ESP), \
|
||||
jit_calc_diff(0), \
|
||||
POPLr(rd), /* floor in rd */ \
|
||||
POPLr(aux), /* x-round(x) in aux */ \
|
||||
ADDLir(0x7FFFFFFF, aux), /* carry if x-round(x) < -0 */ \
|
||||
SBBLir(0, rd), /* subtract 1 if carry */ \
|
||||
POPLr(aux))
|
||||
|
||||
#define jit_ceil2(rd, aux) \
|
||||
(PUSHLr(aux), \
|
||||
SUBLir(8, _ESP), \
|
||||
jit_calc_diff(0), \
|
||||
POPLr(rd), /* floor in rd */ \
|
||||
POPLr(aux), /* x-round(x) in aux */ \
|
||||
TESTLrr(aux, aux), \
|
||||
SETGr(jit_reg8(aux)), \
|
||||
SHRLir(1, aux), \
|
||||
ADCLir(0, rd), \
|
||||
POPLr(aux))
|
||||
|
||||
/* a mingling of the two above */
|
||||
#define jit_trunc2(rd, aux) \
|
||||
(PUSHLr(aux), \
|
||||
SUBLir(12, _ESP), \
|
||||
FSTSm(0, _ESP, 0, 0), \
|
||||
jit_calc_diff(4), \
|
||||
POPLr(aux), \
|
||||
POPLr(rd), \
|
||||
TESTLrr(aux, aux), \
|
||||
POPLr(aux), \
|
||||
JSSm(_jit.pc + 11, 0, 0, 0), \
|
||||
ADDLir(0x7FFFFFFF, aux), /* 6 */ \
|
||||
SBBLir(0, rd), /* 3 */ \
|
||||
JMPSm(_jit.pc + 10, 0, 0, 0), /* 2 */ \
|
||||
TESTLrr(aux, aux), /* 2 */ \
|
||||
SETGr(jit_reg8(aux)), /* 3 */ \
|
||||
SHRLir(1, aux), /* 2 */ \
|
||||
ADCLir(0, rd), /* 3 */ \
|
||||
POPLr(aux))
|
||||
|
||||
/* the easy one */
|
||||
#define jit_round(rd, reg0) \
|
||||
(PUSHLr(_EAX), \
|
||||
FISTPLm(0, _ESP, 0, 0), \
|
||||
POPLr((rd)))
|
||||
|
||||
#define jit_cmp(le, ge, reg0) ( \
|
||||
((le) == _EAX || (ge) == _EAX ? 0 : PUSHLr(_EAX)), \
|
||||
_OO(0xd8d0), /* fcom st(0) */ \
|
||||
_d16(), _OO(0xdfe0), /* fnstsw ax */ \
|
||||
TESTBir(0x40, _AH), \
|
||||
MOVBir(0, ((le) & 15) | 0x10), \
|
||||
MOVBir(0, ((ge) & 15) | 0x10), \
|
||||
JZSm(_jit.pc + 12, 0, 0, 0), \
|
||||
_OO(0xd9e4), /* ftst */ /* 2 */ \
|
||||
_d16(), _OO(0xdfe0), /* fnstsw ax */ /* 3 */ \
|
||||
SAHF(), /* 1 */ \
|
||||
SETLEr( ((le) & 15) | 0x10), /* 3 */ \
|
||||
SETGEr( ((ge) & 15) | 0x10), /* 3 */ \
|
||||
ANDLir( 1, (le)), \
|
||||
ANDLir( 1, (ge)), \
|
||||
((le) == _EAX || (ge) == _EAX ? 0 : POPLr(_EAX)) )
|
||||
|
||||
#define jitfp_getarg_f(ofs) jitfp_ldxi_f(JIT_FP,(ofs))
|
||||
#define jitfp_getarg_d(ofs) jitfp_ldxi_d(JIT_FP,(ofs))
|
||||
#define jitfp_pusharg_d(op1) (jit_subi_i(JIT_SP,JIT_SP,sizeof(double)), jitfp_str_d(JIT_SP,(op1)))
|
||||
#define jitfp_pusharg_f(op1) (jit_subi_i(JIT_SP,JIT_SP,sizeof(float)), jitfp_str_f(JIT_SP,(op1)))
|
||||
#define jitfp_retval(op1) _jit_emit(&_jit, (op1), JIT_NULL, 0, 0, 0)
|
||||
|
||||
#ifdef JIT_TRANSCENDENTAL
|
||||
#define jit_sin(reg0) _OO(0xd9fe) /* fsin */
|
||||
#define jit_cos(reg0) _OO(0xd9ff) /* fcos */
|
||||
#define jit_tan(reg0) (_OO(0xd9f2), /* fptan */ \
|
||||
_OO(0xddd8)) /* fstp st */
|
||||
#define jit_atn(reg0) (_OO(0xd9e8), /* fld1 */ \
|
||||
_OO(0xd9f3)) /* fpatan */
|
||||
#define jit_exp(reg0) (_OO(0xd9ea), /* fldl2e */ \
|
||||
_OO(0xdec9), /* fmulp */ \
|
||||
_OO(0xd9c0), /* fld st */ \
|
||||
_OO(0xd9fc), /* frndint */ \
|
||||
_OO(0xdce9), /* fsubr */ \
|
||||
_OO(0xd9c9), /* fxch st(1) */ \
|
||||
_OO(0xd9f0), /* f2xm1 */ \
|
||||
_OO(0xd9e8), /* fld1 */ \
|
||||
_OO(0xdec1), /* faddp */ \
|
||||
_OO(0xd9fd), /* fscale */ \
|
||||
_OO(0xddd9)) /* fstp st(1) */
|
||||
#define jit_log(reg0) (_OO(0xd9ed), /* fldln2 */ \
|
||||
_OO(0xd9c9), /* fxch st(1) */ \
|
||||
_OO(0xd9f1)) /* fyl2x */
|
||||
#endif
|
||||
|
||||
#endif /* __lightning_asm_h */
|
||||
39
lightning/i386/funcs.h
Normal file
39
lightning/i386/funcs.h
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer inline functions (i386)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_funcs_h
|
||||
#define __lightning_funcs_h
|
||||
|
||||
#define jit_flush_code(dest, end)
|
||||
|
||||
#endif /* __lightning_funcs_h */
|
||||
65
lightning/lightning.h
Normal file
65
lightning/lightning.h
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* lightning main include file
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_h
|
||||
#define __lightning_h
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <lightning/asm-common.h>
|
||||
#include <lightning/funcs-common.h>
|
||||
|
||||
#ifndef LIGHTNING_DEBUG
|
||||
#include <lightning/asm.h>
|
||||
#endif
|
||||
|
||||
#include <lightning/core.h>
|
||||
#include <lightning/core-common.h>
|
||||
#include <lightning/funcs.h>
|
||||
#include <lightning/fp.h>
|
||||
|
||||
#ifdef jit_cmp
|
||||
#include <lightning/fp-common.h>
|
||||
#endif
|
||||
|
||||
#ifndef JIT_R0
|
||||
#error GNU lightning does not support the current target
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __lightning_h */
|
||||
597
lightning/ppc/asm.h
Normal file
597
lightning/ppc/asm.h
Normal file
|
|
@ -0,0 +1,597 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler for the PowerPC
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 1999, 2000, 2001, 2002 Ian Piumarta
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
#ifndef __lightning_asm_h
|
||||
#define __lightning_asm_h
|
||||
|
||||
/* <imm> = [0-9]+ | (.+) -> add i, one parameter (imm)
|
||||
* <reg> = r<imm> -> add r, one parameter (imm)
|
||||
* <mem> = <imm>(<reg>) -> add m, two parameters (imm,reg)
|
||||
* <idx> = <reg>(<reg>) -> add x, two parameters (reg,reg)
|
||||
*
|
||||
* `x' operands have two forms. For example `stwu source, rega(regb)'
|
||||
* could be written as either
|
||||
* STWUrx(source, rega, regb)
|
||||
* or
|
||||
* STWUXrrr(source, rega, regb)
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*** a brief NOTE about halfwords and "shifted" operands
|
||||
*
|
||||
* LOGICAL insns require UNSIGNED args in 0..65535, whether or not shifted
|
||||
*
|
||||
* ARITHMETIC insns require SIGNED args in -32768..32767, even when shifted
|
||||
*
|
||||
* as a special case: "lis/addis" also accepts UNSIGNED arguments in
|
||||
* 0..65535 since it is often used immediately before "ori" to load a 32-bit
|
||||
* constant (this is consistent with the GNU rs/6000 and PowerPC assemblers)
|
||||
*
|
||||
* thus: lis rD, expression@hi
|
||||
* ori rD, rD, expression@lo ; load 32-bit constant
|
||||
*/
|
||||
|
||||
typedef unsigned int jit_insn;
|
||||
|
||||
#define _cr0 0
|
||||
#define _cr1 1
|
||||
#define _cr2 2
|
||||
#define _cr3 3
|
||||
#define _cr4 4
|
||||
#define _cr5 5
|
||||
#define _cr6 6
|
||||
#define _cr7 7
|
||||
|
||||
#define _lt 0
|
||||
#define _gt 1
|
||||
#define _eq 2
|
||||
#define _so 3
|
||||
#define _un 3
|
||||
|
||||
#define _d16(D) (_ck_d(16,(_UL(D)-_UL(_jit.pc))) & ~3)
|
||||
#define _d26(D) (_ck_d(26,(_UL(D)-_UL(_jit.pc))) & ~3)
|
||||
|
||||
/* primitive instruction forms [1, Section A.4] */
|
||||
|
||||
#define _FB( OP, BD,AA,LK ) _I((_u6(OP)<<26)| _d26(BD)| (_u1(AA)<<1)|_u1(LK))
|
||||
#define _FBA( OP, BD,AA,LK ) _I((_u6(OP)<<26)| (_u26(BD)&~3)| (_u1(AA)<<1)|_u1(LK))
|
||||
#define _BB( OP,BO,BI, BD,AA,LK ) _I((_u6(OP)<<26)|(_u5(BO)<<21)|(_u5(BI)<<16)| _d16(BD)| (_u1(AA)<<1)|_u1(LK))
|
||||
#define _D( OP,RD,RA, DD ) _I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _s16(DD) )
|
||||
#define _Du( OP,RD,RA, DD ) _I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _u16(DD) )
|
||||
#define _Ds( OP,RD,RA, DD ) _I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)| _su16(DD) )
|
||||
#define _X( OP,RD,RA,RB, XO,RC ) _I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)| (_u10(XO)<<1)|_u1(RC))
|
||||
#define _XL( OP,BO,BI, XO,LK ) _I((_u6(OP)<<26)|(_u5(BO)<<21)|(_u5(BI)<<16)|( _u5(00)<<11)| (_u10(XO)<<1)|_u1(LK))
|
||||
#define _XFX( OP,RD, SR,XO ) _I((_u6(OP)<<26)|(_u5(RD)<<21)| (_u10(SR)<<11)| (_u10(XO)<<1)|_u1(00))
|
||||
#define _XO( OP,RD,RA,RB,OE,XO,RC ) _I((_u6(OP)<<26)|(_u5(RD)<<21)|(_u5(RA)<<16)|( _u5(RB)<<11)|(_u1(OE)<<10)|( _u9(XO)<<1)|_u1(RC))
|
||||
#define _M( OP,RS,RA,SH,MB,ME,RC ) _I((_u6(OP)<<26)|(_u5(RS)<<21)|(_u5(RA)<<16)|( _u5(SH)<<11)|(_u5(MB)<< 6)|( _u5(ME)<<1)|_u1(RC))
|
||||
|
||||
/* special purpose registers (form XFX) [1, Section 8.2, page 8-138] */
|
||||
|
||||
#define SPR_LR ((8<<5)|(0))
|
||||
|
||||
/* +++ intrinsic instructions */
|
||||
|
||||
#define ADDrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 0)
|
||||
#define ADD_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 1)
|
||||
#define ADDCrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 10, 0)
|
||||
#define ADDC_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 10, 1)
|
||||
#define ADDErrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 138, 0)
|
||||
#define ADDE_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 138, 1)
|
||||
#define ADDOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 0)
|
||||
#define ADDO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 1)
|
||||
#define ADDIrri(RD, RA, IMM) _D (14, RD, RA, IMM)
|
||||
#define ADDICrri(RD, RA, IMM) _D (12, RD, RA, IMM)
|
||||
#define ADDIC_rri(RD, RA, IMM) _D (13, RD, RA, IMM)
|
||||
#define ADDISrri(RD, RA, IMM) _Ds (15, RD, RA, IMM)
|
||||
|
||||
#define ANDrrr(RA, RS, RB) _X (31, RS, RA, RB, 28, 0)
|
||||
#define AND_rrr(RA, RS, RB) _X (31, RS, RA, RB, 28, 1)
|
||||
#define ANDCrrr(RA, RS, RB) _X (31, RS, RA, RB, 60, 0)
|
||||
#define ANDC_rrr(RA, RS, RB) _X (31, RS, RA, RB, 60, 1)
|
||||
#define ANDI_rri(RA, RS, IMM) _Du (28, RS, RA, IMM)
|
||||
#define ANDIS_rri(RA, RS, IMM) _Du (29, RS, RA, IMM)
|
||||
|
||||
#define Bi(BD) _FB (18, BD, 0, 0)
|
||||
#define BAi(BD) _FBA (18, BD, 1, 0)
|
||||
#define BLi(BD) _FB (18, BD, 0, 1)
|
||||
#define BLAi(BD) _FBA (18, BD, 1, 1)
|
||||
|
||||
#define BCiii(BO,BI,BD) _BB (16, BO, BI, BD, 0, 0)
|
||||
#define BCAiii(BO,BI,BD) _BB (16, BO, BI, BD, 1, 0)
|
||||
#define BCLiii(BO,BI,BD) _BB (16, BO, BI, BD, 0, 1)
|
||||
#define BCLAiii(BO,BI,BD) _BB (16, BO, BI, BD, 1, 1)
|
||||
|
||||
#define BCCTRii(BO,BI) _XL (19, BO, BI, 528, 0)
|
||||
#define BCCTRLii(BO,BI) _XL (19, BO, BI, 528, 1)
|
||||
|
||||
#define BCLRii(BO,BI) _XL (19, BO, BI, 16, 0)
|
||||
#define BCLRLii(BO,BI) _XL (19, BO, BI, 16, 1)
|
||||
|
||||
#define CMPiirr(CR, LL, RA, RB) _X (31, ((CR)<<2)|(LL), RA, RB, 0, 0)
|
||||
#define CMPIiiri(CR, LL, RA, IMM) _D (11, ((CR)<<2)|(LL), RA, IMM)
|
||||
|
||||
#define CMPLiirr(CR, LL, RA, RB) _X (31, ((CR)<<2)|(LL), RA, RB, 32, 0)
|
||||
#define CMPLIiiri(CR, LL, RA, IMM) _D (10, ((CR)<<2)|(LL), RA, IMM)
|
||||
|
||||
#define CRANDiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 257, 0)
|
||||
#define CRANDCiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 129, 0)
|
||||
#define CREQViii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 289, 0)
|
||||
#define CRNANDiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 225, 0)
|
||||
#define CRNORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 33, 0)
|
||||
#define CRORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 449, 0)
|
||||
#define CRORCiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 417, 0)
|
||||
#define CRXORiii(CRD,CRA,CRB) _X (19, CRD, CRA, CRB, 193, 0)
|
||||
|
||||
#define DCBSTrr(RA,RB) _X (31, 00, RA, RB, 54, 0)
|
||||
|
||||
#define DIVWrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 491, 0)
|
||||
#define DIVW_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 491, 1)
|
||||
#define DIVWOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 491, 0)
|
||||
#define DIVWO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 491, 1)
|
||||
|
||||
#define DIVWUrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 459, 0)
|
||||
#define DIVWU_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 459, 1)
|
||||
#define DIVWUOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 459, 0)
|
||||
#define DIVWUO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 459, 1)
|
||||
|
||||
#define EQVrrr(Ra,RS,RB) _X (31, RS, RA, RB, 284, 0)
|
||||
#define EQV_rrr(Ra,RS,RB) _X (31, RS, RA, RB, 284, 1)
|
||||
|
||||
#define EXTSBrr(RA,RS) _X (31, RS, RA, 0, 954, 0)
|
||||
#define EXTSB_rr(RA,RS) _X (31, RS, RA, 0, 954, 1)
|
||||
|
||||
#define EXTSHrr(RA,RS) _X (31, RS, RA, 0, 922, 0)
|
||||
#define EXTSH_rr(RA,RS) _X (31, RS, RA, 0, 922, 1)
|
||||
|
||||
#define ICBIrr(RA,RB) _X (31, 00, RA, RB, 982, 0)
|
||||
|
||||
#define ISYNC() _X (19, 00, 00, 00, 150, 0)
|
||||
|
||||
#define LBZrm(RD,ID,RA) _D (34, RD, RA, ID)
|
||||
#define LBZUrm(RD,ID,RA) _D (35, RD, RA, ID)
|
||||
#define LBZUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 119, 0)
|
||||
#define LBZXrrr(RD,RA,RB) _X (31, RD, RA, RB, 87, 0)
|
||||
|
||||
#define LHArm(RD,ID,RA) _D (42, RD, RA, ID)
|
||||
#define LHAUrm(RD,ID,RA) _D (43, RD, RA, ID)
|
||||
#define LHAUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 375, 0)
|
||||
#define LHAXrrr(RD,RA,RB) _X (31, RD, RA, RB, 343, 0)
|
||||
#define LHBRXrrr(RD,RA,RB) _X (31, RD, RA, RB, 790, 0)
|
||||
|
||||
#define LHZrm(RD,ID,RA) _D (40, RD, RA, ID)
|
||||
#define LHZUrm(RD,ID,RA) _D (41, RD, RA, ID)
|
||||
#define LHZUXrrr(RD,RA,RB) _X (31, RD, RA, RB, 311, 0)
|
||||
#define LHZXrrr(RD,RA,RB) _X (31, RD, RA, RB, 279, 0)
|
||||
|
||||
#define LMWrm(RD,ID,RA) _D (46, RD, RA, ID)
|
||||
|
||||
#define LWBRXrrr(RD,RA,RB) _X (31, RD, RA, RB, 534, 0)
|
||||
|
||||
#define LWZrm(RD, DISP, RA) _D (32, RD, RA, DISP)
|
||||
#define LWZUrm(RD, DISP, RA) _D (33, RD, RA, DISP)
|
||||
#define LWZUXrrr(RD, RA, RB) _X (31, RD, RA, RB, 56, 0)
|
||||
#define LWZXrrr(RD, RA, RB) _X (31, RD, RA, RB, 23, 0)
|
||||
|
||||
#define MCRFii(CD,CS) _X (19, ((CD)<<2), ((CS)<<2), 0, 0, 0)
|
||||
|
||||
#define MFCRr(RD) _X (31, RD, 0, 0, 19, 0)
|
||||
#define MCRXRi(RD) _XFX (31, (RD)<<2, 0, 512)
|
||||
|
||||
#define MFSPRri(RD, SPR) _XFX (31, RD, (SPR)<<5, 339)
|
||||
#define MTSPRir(SPR, RS) _XFX (31, RS, (SPR)<<5, 467)
|
||||
|
||||
#define MULHWrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 75, 0)
|
||||
#define MULHW_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 75, 1)
|
||||
#define MULHWUrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 11, 0)
|
||||
#define MULHWU_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 11, 1)
|
||||
|
||||
#define MULLIrri(RD,RA,IM) _D (07, RD, RA, IM)
|
||||
|
||||
#define MULLWrrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 235, 0)
|
||||
#define MULLW_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 0, 235, 1)
|
||||
#define MULLWOrrr(RD,RA,RB) _XO (31, RD, RA, RB, 1, 235, 0)
|
||||
#define MULLWO_rrr(RD,RA,RB) _XO (31, RD, RA, RB, 1, 235, 1)
|
||||
|
||||
#define NANDrrr(RA,RS,RB) _X (31, RS, RA, RB, 476, 0)
|
||||
#define NAND_rrr(RA,RS,RB) _X (31, RS, RA, RB, 476, 1)
|
||||
|
||||
#define NEGrr(RD,RA) _XO (31, RD, RA, 0, 0, 104, 0)
|
||||
#define NEG_rr(RD,RA) _XO (31, RD, RA, 0, 0, 104, 1)
|
||||
#define NEGOrr(RD,RA) _XO (31, RD, RA, 0, 1, 104, 0)
|
||||
#define NEGO_rr(RD,RA) _XO (31, RD, RA, 0, 1, 104, 1)
|
||||
|
||||
#define NORrrr(RA,RS,RB) _X (31, RS, RA, RB, 124, 0)
|
||||
#define NOR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 124, 1)
|
||||
|
||||
#define ORrrr(RA,RS,RB) _X (31, RS, RA, RB, 444, 0)
|
||||
#define OR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 444, 1)
|
||||
#define ORCrrr(RA,RS,RB) _X (31, RS, RA, RB, 412, 0)
|
||||
#define ORC_rrr(RA,RS,RB) _X (31, RS, RA, RB, 412, 1)
|
||||
#define ORIrri(RA,RS,IM) _Du (24, RS, RA, IM)
|
||||
#define ORISrri(RA,RS,IM) _Du (25, RS, RA, IM)
|
||||
|
||||
#define RLWIMIrriii(RA,RS,SH,MB,ME) _M (20, RS, RA, SH, MB, ME, 0)
|
||||
#define RLWIMI_rriii(RA,RS,SH,MB,ME) _M (20, RS, RA, SH, MB, ME, 1)
|
||||
|
||||
#define RLWINMrriii(RA,RS,SH,MB,ME) _M (21, RS, RA, SH, MB, ME, 0)
|
||||
#define RLWINM_rriii(RA,RS,SH,MB,ME) _M (21, RS, RA, SH, MB, ME, 1)
|
||||
|
||||
#define RLWNMrrrii(RA,RS,RB,MB,ME) _M (23, RS, RA, RB, MB, ME, 0)
|
||||
#define RLWNM_rrrii(RA,RS,RB,MB,ME) _M (23, RS, RA, RB, MB, ME, 1)
|
||||
|
||||
#define SLWrrr(RA,RS,RB) _X (31, RS, RA, RB, 24, 0)
|
||||
#define SLW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 24, 1)
|
||||
|
||||
#define SRAWrrr(RA,RS,RB) _X (31, RS, RA, RB, 792, 0)
|
||||
#define SRAW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 792, 1)
|
||||
|
||||
#define SRAWIrri(RD, RS, SH) _X (31, RS, RD, SH, 824, 0)
|
||||
#define SRAWI_rri(RD, RS, SH) _X (31, RS, RD, SH, 824, 1)
|
||||
|
||||
#define SRWrrr(RA,RS,RB) _X (31, RS, RA, RB, 536, 0)
|
||||
#define SRW_rrr(RA,RS,RB) _X (31, RS, RA, RB, 536, 1)
|
||||
|
||||
#define STBrm(RS,ID,RA) _D (38, RS, RA, ID)
|
||||
#define STBUrm(RS,ID,RA) _D (39, RS, RA, ID)
|
||||
#define STBUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 247, 0)
|
||||
#define STBXrrr(RS,RA,RB) _X (31, RS, RA, RB, 215, 0)
|
||||
|
||||
#define STHrm(RS,ID,RA) _D (44, RS, RA, ID)
|
||||
#define STHUrm(RS,ID,RA) _D (45, RS, RA, ID)
|
||||
#define STHBRXrrr(RS,RA,RB) _X (31, RS, RA, RB, 918, 0)
|
||||
#define STHUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 439, 0)
|
||||
#define STHXrrr(RS,RA,RB) _X (31, RS, RA, RB, 407, 0)
|
||||
|
||||
#define STMWrm(RS,ID,RA) _D (47, RS, RA, ID)
|
||||
|
||||
#define STWrm(RS,ID,RA) _D (36, RS, RA, ID)
|
||||
#define STWBRXrrr(RS,RA,RB) _X (31, RS, RA, RB, 662, 0)
|
||||
#define STWCXrrr(RS,RA,RB) _X (31, RS, RA, RB, 150, 0)
|
||||
#define STWCX_rrr(RS,RA,RB) _X (31, RS, RA, RB, 150, 1)
|
||||
#define STWUrm(RS,ID,RA) _D (37, RS, RA, ID)
|
||||
#define STWUXrrr(RS,RA,RB) _X (31, RS, RA, RB, 183, 0)
|
||||
#define STWXrrr(RS,RA,RB) _X (31, RS, RA, RB, 151, 0)
|
||||
|
||||
#define SUBFrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 0)
|
||||
#define SUBF_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 1)
|
||||
#define SUBFrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 0)
|
||||
#define SUBF_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 40, 1)
|
||||
#define SUBFErrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 136, 0)
|
||||
#define SUBFE_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 136, 1)
|
||||
#define SUBFCrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 8, 0)
|
||||
#define SUBFC_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 8, 1)
|
||||
#define SUBFCOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 8, 0)
|
||||
#define SUBFCO_rrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 8, 1)
|
||||
#define SUBFICrri(RD, RA, IMM) _D (8, RD, RA, IMM)
|
||||
|
||||
#define ADDrrr(RD, RA, RB) _XO (31, RD, RA, RB, 0, 266, 0)
|
||||
#define ADDOrrr(RD, RA, RB) _XO (31, RD, RA, RB, 1, 266, 0)
|
||||
#define ADDIrri(RD, RA, IMM) _D (14, RD, RA, IMM)
|
||||
#define ADDISrri(RD, RA, IMM) _Ds (15, RD, RA, IMM)
|
||||
|
||||
#define SYNC() _X (31, 00, 00, 00, 598, 0)
|
||||
|
||||
#define TWirr(TO,RA,RB) _X (31, TO, RA, RB, 4, 0)
|
||||
#define TWIiri(TO,RA,IM) _D (03, TO, RA, IM)
|
||||
|
||||
#define XORrrr(RA,RS,RB) _X (31, RS, RA, RB, 316, 0)
|
||||
#define XOR_rrr(RA,RS,RB) _X (31, RS, RA, RB, 316, 1)
|
||||
#define XORIrri(RA,RS,IM) _Du (26, RS, RA, IM)
|
||||
#define XORISrri(RA,RS,IM) _Du (27, RS, RA, IM)
|
||||
|
||||
/* simplified mnemonics [1, Appendix F] */
|
||||
|
||||
#define MOVEIri2(R,H,L) (LISri(R,H), (L ? ORIrri(R,R,L) : 0))
|
||||
#define MOVEIri(R,I) (_siP(16,I) ? LIri(R,I) : \
|
||||
MOVEIri2(R, _HI(I), _LO(I)) )
|
||||
|
||||
#define SUBIrri(RD,RA,IM) ADDIrri(RD,RA,-_L((IM))) /* [1, Section F.2.1] */
|
||||
#define SUBISrri(RD,RA,IM) ADDISrri(RD,RA,-_L((IM)))
|
||||
#define SUBICrri(RD,RA,IM) ADDICrri(RD,RA,-_L((IM)))
|
||||
#define SUBIC_rri(RD,RA,IM) ADDIC_rri(RD,RA,-_L((IM)))
|
||||
|
||||
#define SUBrrr(RD,RA,RB) SUBFrrr(RD,RB,RA) /* [1, Section F.2.2] */
|
||||
#define SUBOrrr(RD,RA,RB) SUBFOrrr(RD,RB,RA)
|
||||
#define SUB_rrr(RD,RA,RB) SUBF_rrr(RD,RB,RA)
|
||||
#define SUBCrrr(RD,RA,RB) SUBFCrrr(RD,RB,RA)
|
||||
#define SUBCOrrr(RD,RA,RB) SUBFCOrrr(RD,RB,RA)
|
||||
#define SUBC_rrr(RD,RA,RB) SUBFC_rrr(RD,RB,RA)
|
||||
#define SUBErrr(RD,RA,RB) SUBFErrr(RD,RB,RA)
|
||||
#define SUBE_rrr(RD,RA,RB) SUBFE_rrr(RD,RB,RA)
|
||||
|
||||
#define CMPWIiri(C,RA,IM) CMPIiiri(C,0,RA,IM) /* [1, Table F-2] */
|
||||
#define CMPWirr(C,RA,RB) CMPiirr(C,0,RA,RB)
|
||||
#define CMPLWIiri(C,RA,IM) CMPLIiiri(C,0,RA,IM)
|
||||
#define CMPLWirr(C,RA,RB) CMPLiirr(C,0,RA,RB)
|
||||
|
||||
#define CMPWIri(RA,IM) CMPWIiri(0,RA,IM) /* with implicit _cr0 */
|
||||
#define CMPWrr(RA,RB) CMPWirr(0,RA,RB)
|
||||
#define CMPLWIri(RA,IM) CMPLWIiri(0,RA,IM)
|
||||
#define CMPLWrr(RA,RB) CMPLWirr(0,RA,RB)
|
||||
|
||||
#define EXTLWIrrii(RA,RS,N,B) RLWINMrriii(RA, RS, B, 0, (N)-1) /* [1, Table F-3] */
|
||||
#define EXTRWIrrii(RA,RS,N,B) RLWINMrriii(RA, RS, (B)+(N), 32-(N), 31)
|
||||
#define INSLWIrrii(RA,RS,N,B) RLWIMIrriii(RA, RS, 32-(B), B, (B)+(N)-1)
|
||||
#define INSRWIrrii(RA,RS,N,B) RLWIMIrriii(RA, RS, 32-((B)+(N)), B, (B)+(N)-1)
|
||||
#define ROTLWIrri(RA,RS,N) RLWINMrriii(RA, RS, N, 0, 31)
|
||||
#define ROTRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 32-(N), 0, 31)
|
||||
#define ROTLWrrr(RA,RS,RB) RLWNMrrrii( RA, RS, RB, 0, 31)
|
||||
#define SLWIrri(RA,RS,N) RLWINMrriii(RA, RS, N, 0, 31-(N))
|
||||
#define SRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 32-(N), N, 31)
|
||||
#define CLRLWIrri(RA,RS,N) RLWINMrriii(RA, RS, 0, N, 31)
|
||||
#define CLRRWIrri(RA,RS,N) RLWINMrriii(RA, RS, 0, 0, 31-(N))
|
||||
#define CLRLSLWIrrii(RA,RS,B,N) RLWINMrriii(RA, RS, N, (B)-(N), 31-(N))
|
||||
|
||||
/* 9 below inverts the branch condition and the branch prediction.
|
||||
* This has an incestuous knowledge of the fact that register 26
|
||||
* is used as auxiliary!!! */
|
||||
#define BC_EXT(A, C, D) (_siP(16, _UL(D)-_UL(_jit.pc)) \
|
||||
? BCiii((A), (C), (D)) \
|
||||
: (BCiii((A)^9, (C), _jit.pc+5), LISri(26,_HI(D)), ORIrri(26,26,_LO(D)), \
|
||||
MTLRr(26), BLR() ))
|
||||
|
||||
#define B_EXT(D) (_siP(16, _UL(D)-_UL(_jit.pc)) \
|
||||
? Bi((D)) \
|
||||
: (LISri(26,_HI(D)), ORIrri(26,26,_LO(D)), MTLRr(26), BLR()) )
|
||||
|
||||
#define BTii(C,D) BC_EXT(12, C, D) /* [1, Table F-5] */
|
||||
#define BFii(C,D) BC_EXT( 4, C, D)
|
||||
#define BDNZi(D) BCiii(16, 0, D)
|
||||
#define BDNZTii(C,D) BC_EXT( 8, C, D)
|
||||
#define BDNZFii(C,D) BC_EXT( 0, C, D)
|
||||
#define BDZi(D) BCiii(18, 0, D)
|
||||
#define BDZTii(C,D) BC_EXT(10, C, D)
|
||||
#define BDZFii(C,D) BC_EXT( 2, C, D)
|
||||
|
||||
#define BCTR() BCCTRii(20, 0) /* [1, Table F-6] */
|
||||
#define BCTRL() BCCTRLii(20, 0)
|
||||
|
||||
#define BLR() BCLRii(20, 0) /* [1, Table F-6] */
|
||||
#define BLRL() BCLRLii(20, 0)
|
||||
|
||||
|
||||
#define BLTLRi(CR) BCLRii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLELRi(CR) BCLRii( 4 ((CR)<<2)+1)
|
||||
#define BEQLRi(CR) BCLRii(12, ((CR)<<2)+2)
|
||||
#define BGELRi(CR) BCLRii( 4, ((CR)<<2)+0)
|
||||
#define BGTLRi(CR) BCLRii(12, ((CR)<<2)+1)
|
||||
#define BNLLRi(CR) BCLRii( 4, ((CR)<<2)+0)
|
||||
#define BNELRi(CR) BCLRii( 4, ((CR)<<2)+2)
|
||||
#define BNGLRi(CR) BCLRii( 4, ((CR)<<2)+1)
|
||||
#define BSOLRi(CR) BCLRii(12, ((CR)<<2)+3)
|
||||
#define BNSLRi(CR) BCLRii( 4, ((CR)<<2)+3)
|
||||
#define BUNLRi(CR) BCLRii(12, ((CR)<<2)+3)
|
||||
#define BNULRi(CR) BCLRii( 4, ((CR)<<2)+3)
|
||||
|
||||
#define BLTLRLi(CR) BCLRLii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLELRLi(CR) BCLRLii( 4, ((CR)<<2)+1)
|
||||
#define BEQLRLi(CR) BCLRLii(12, ((CR)<<2)+2)
|
||||
#define BGELRLi(CR) BCLRLii( 4, ((CR)<<2)+0)
|
||||
#define BGTLRLi(CR) BCLRLii(12, ((CR)<<2)+1)
|
||||
#define BNLLRLi(CR) BCLRLii( 4, ((CR)<<2)+0)
|
||||
#define BNELRLi(CR) BCLRLii( 4, ((CR)<<2)+2)
|
||||
#define BNGLRLi(CR) BCLRLii( 4, ((CR)<<2)+1)
|
||||
#define BSOLRLi(CR) BCLRLii(12, ((CR)<<2)+3)
|
||||
#define BNSLRLi(CR) BCLRLii( 4, ((CR)<<2)+3)
|
||||
#define BUNLRLi(CR) BCLRLii(12, ((CR)<<2)+3)
|
||||
#define BNULRLi(CR) BCLRLii( 4, ((CR)<<2)+3)
|
||||
|
||||
#define BLTCTRi(CR) BCCTRii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLECTRi(CR) BCCTRii( 4 ((CR)<<2)+1)
|
||||
#define BEQCTRi(CR) BCCTRii(12, ((CR)<<2)+2)
|
||||
#define BGECTRi(CR) BCCTRii( 4, ((CR)<<2)+0)
|
||||
#define BGTCTRi(CR) BCCTRii(12, ((CR)<<2)+1)
|
||||
#define BNLCTRi(CR) BCCTRii( 4, ((CR)<<2)+0)
|
||||
#define BNECTRi(CR) BCCTRii( 4, ((CR)<<2)+2)
|
||||
#define BNGCTRi(CR) BCCTRii( 4, ((CR)<<2)+1)
|
||||
#define BSOCTRi(CR) BCCTRii(12, ((CR)<<2)+3)
|
||||
#define BNSCTRi(CR) BCCTRii( 4, ((CR)<<2)+3)
|
||||
#define BUNCTRi(CR) BCCTRii(12, ((CR)<<2)+3)
|
||||
#define BNUCTRi(CR) BCCTRii( 4, ((CR)<<2)+3)
|
||||
|
||||
#define BLTCTRLi(CR) BCCTRLii(12, ((CR)<<2)+0) /* [1, Table F-10] */
|
||||
#define BLECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+1)
|
||||
#define BEQCTRLi(CR) BCCTRLii(12, ((CR)<<2)+2)
|
||||
#define BGECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+0)
|
||||
#define BGTCTRLi(CR) BCCTRLii(12, ((CR)<<2)+1)
|
||||
#define BNLCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+0)
|
||||
#define BNECTRLi(CR) BCCTRLii( 4, ((CR)<<2)+2)
|
||||
#define BNGCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+1)
|
||||
#define BSOCTRLi(CR) BCCTRLii(12, ((CR)<<2)+3)
|
||||
#define BNSCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+3)
|
||||
#define BUNCTRLi(CR) BCCTRLii(12, ((CR)<<2)+3)
|
||||
#define BNUCTRLi(CR) BCCTRLii( 4, ((CR)<<2)+3)
|
||||
|
||||
|
||||
#define BLTLR() BLTLRi(0) /* with implicit _cr0 */
|
||||
#define BLELR() BLELRi(0)
|
||||
#define BEQLR() BEQLRi(0)
|
||||
#define BGELR() BGELRi(0)
|
||||
#define BGTLR() BGTLRi(0)
|
||||
#define BNLLR() BNLLRi(0)
|
||||
#define BNELR() BNELRi(0)
|
||||
#define BNGLR() BNGLRi(0)
|
||||
#define BSOLR() BSOLRi(0)
|
||||
#define BNSLR() BNSLRi(0)
|
||||
#define BUNLR() BUNLRi(0)
|
||||
#define BNULR() BNULRi(0)
|
||||
|
||||
#define BLTLRL() BLTLRLi(0)
|
||||
#define BLELRL() BLELRLi(0)
|
||||
#define BEQLRL() BEQLRLi(0)
|
||||
#define BGELRL() BGELRLi(0)
|
||||
#define BGTLRL() BGTLRLi(0)
|
||||
#define BNLLRL() BNLLRLi(0)
|
||||
#define BNELRL() BNELRLi(0)
|
||||
#define BNGLRL() BNGLRLi(0)
|
||||
#define BSOLRL() BSOLRLi(0)
|
||||
#define BNSLRL() BNSLRLi(0)
|
||||
#define BUNLRL() BUNLRLi(0)
|
||||
#define BNULRL() BNULRLi(0)
|
||||
|
||||
#define BLTCTR() BLTCTRi(0)
|
||||
#define BLECTR() BLECTRi(0)
|
||||
#define BEQCTR() BEQCTRi(0)
|
||||
#define BGECTR() BGECTRi(0)
|
||||
#define BGTCTR() BGTCTRi(0)
|
||||
#define BNLCTR() BNLCTRi(0)
|
||||
#define BNECTR() BNECTRi(0)
|
||||
#define BNGCTR() BNGCTRi(0)
|
||||
#define BSOCTR() BSOCTRi(0)
|
||||
#define BNSCTR() BNSCTRi(0)
|
||||
#define BUNCTR() BUNCTRi(0)
|
||||
#define BNUCTR() BNUCTRi(0)
|
||||
|
||||
#define BLTCTRL() BLTCTRLi(0)
|
||||
#define BLECTRL() BLECTRLi(0)
|
||||
#define BEQCTRL() BEQCTRLi(0)
|
||||
#define BGECTRL() BGECTRLi(0)
|
||||
#define BGTCTRL() BGTCTRLi(0)
|
||||
#define BNLCTRL() BNLCTRLi(0)
|
||||
#define BNECTRL() BNECTRLi(0)
|
||||
#define BNGCTRL() BNGCTRLi(0)
|
||||
#define BSOCTRL() BSOCTRLi(0)
|
||||
#define BNSCTRL() BNSCTRLi(0)
|
||||
#define BUNCTRL() BUNCTRLi(0)
|
||||
#define BNUCTRL() BNUCTRLi(0)
|
||||
|
||||
|
||||
#define BLTii(C,D) BC_EXT(12, ((C)<<2)+0, D) /* [1, Table F-11] */
|
||||
#define BNLii(C,D) BC_EXT( 4, ((C)<<2)+0, D)
|
||||
#define BGEii(C,D) BC_EXT( 4, ((C)<<2)+0, D)
|
||||
#define BGTii(C,D) BC_EXT(12, ((C)<<2)+1, D)
|
||||
#define BNGii(C,D) BC_EXT( 4, ((C)<<2)+1, D)
|
||||
#define BLEii(C,D) BC_EXT( 4, ((C)<<2)+1, D)
|
||||
#define BEQii(C,D) BC_EXT(12, ((C)<<2)+2, D)
|
||||
#define BNEii(C,D) BC_EXT( 4, ((C)<<2)+2, D)
|
||||
#define BSOii(C,D) BC_EXT(12, ((C)<<2)+3, D)
|
||||
#define BNSii(C,D) BC_EXT( 4, ((C)<<2)+3, D)
|
||||
#define BUNii(C,D) BC_EXT(12, ((C)<<2)+3, D)
|
||||
#define BNUii(C,D) BC_EXT( 4, ((C)<<2)+3, D)
|
||||
|
||||
#define BLTi(D) BLTii(0,D) /* with implicit _cr0 */
|
||||
#define BLEi(D) BLEii(0,D)
|
||||
#define BEQi(D) BEQii(0,D)
|
||||
#define BGEi(D) BGEii(0,D)
|
||||
#define BGTi(D) BGTii(0,D)
|
||||
#define BNLi(D) BNLii(0,D)
|
||||
#define BNEi(D) BNEii(0,D)
|
||||
#define BNGi(D) BNGii(0,D)
|
||||
#define BSOi(D) BSOii(0,D)
|
||||
#define BNSi(D) BNSii(0,D)
|
||||
#define BUNi(D) BUNii(0,D)
|
||||
#define BNUi(D) BNUii(0,D)
|
||||
|
||||
#define BLTLii(C,D) BCLiii(12, ((C)<<2)+0, D) /* [1, Table F-??] */
|
||||
#define BLELii(C,D) BCLiii( 4 ((C)<<2)+1, D)
|
||||
#define BEQLii(C,D) BCLiii(12, ((C)<<2)+2, D)
|
||||
#define BGELii(C,D) BCLiii( 4, ((C)<<2)+0, D)
|
||||
#define BGTLii(C,D) BCLiii(12, ((C)<<2)+1, D)
|
||||
#define BNLLii(C,D) BCLiii( 4, ((C)<<2)+0, D)
|
||||
#define BNELii(C,D) BCLiii( 4, ((C)<<2)+2, D)
|
||||
#define BNGLii(C,D) BCLiii( 4, ((C)<<2)+1, D)
|
||||
#define BSOLii(C,D) BCLiii(12, ((C)<<2)+3, D)
|
||||
#define BNSLii(C,D) BCLiii( 4, ((C)<<2)+3, D)
|
||||
#define BUNLii(C,D) BCLiii(12, ((C)<<2)+3, D)
|
||||
#define BNULii(C,D) BCLiii( 4, ((C)<<2)+3, D)
|
||||
|
||||
#define BLTLi(D) BLTLii(0,D) /* with implicit _cr0 */
|
||||
#define BLELi(D) BLELii(0,D)
|
||||
#define BEQLi(D) BEQLii(0,D)
|
||||
#define BGELi(D) BGELii(0,D)
|
||||
#define BGTLi(D) BGTLii(0,D)
|
||||
#define BNLLi(D) BNLLii(0,D)
|
||||
#define BNELi(D) BNELii(0,D)
|
||||
#define BNGLi(D) BNGLii(0,D)
|
||||
#define BSOLi(D) BSOLii(0,D)
|
||||
#define BNSLi(D) BNSLii(0,D)
|
||||
#define BUNLi(D) BUNLii(0,D)
|
||||
#define BNULi(D) BNULii(0,D)
|
||||
|
||||
/* Note: there are many tens of other simplified branches that are not (yet?) defined here */
|
||||
|
||||
#define CRSETi(BX) CREQViii(BX, BX, BX) /* [1, Table F-15] */
|
||||
#define CRCLRi(BX) CRXORiii(BX, BX, BX)
|
||||
#define CRMOVEii(BX,BY) CRORiii(BX, BY, BY)
|
||||
#define CRNOTii(BX,BY) CRNORiii(BX, BY, BY)
|
||||
|
||||
#define MTLRr(RS) MTSPRir(8, RS) /* [1, Table F-20] */
|
||||
#define MFLRr(RD) MFSPRri(RD, 8)
|
||||
#define MTCTRr(RS) MTSPRir(9, RS)
|
||||
#define MFCTRr(RD) MFSPRri(RD, 9)
|
||||
#define MTXERr(RS) MTSPRir(1, RS)
|
||||
#define MFXERr(RD) MFSPRri(RD, 1)
|
||||
|
||||
#define NOP() ORIrri(0, 0, 0) /* [1, Section F.9] */
|
||||
#define LIri(RD,IM) ADDIrri(RD, 0, IM)
|
||||
#define LISri(RD,IM) ADDISrri(RD, 0, IM)
|
||||
#define LArm(RD,D,RA) ADDIrri(RD, RA, D)
|
||||
#define LArrr(RD,RB,RA) ADDIrrr(RD, RA, RB)
|
||||
#define MRrr(RA,RS) ORrrr(RA, RS, RS)
|
||||
#define NOTrr(RA,RS) NORrrr(RA, RS, RS)
|
||||
|
||||
/* alternative parenthesised forms of extended indexed load/store insns */
|
||||
|
||||
#define LBZUrx(RD,RA,RB) LBZUXrrr(RD,RA,RB)
|
||||
#define LBZrx(RD,RA,RB) LBZXrrr(RD,RA,RB)
|
||||
#define LHAUrx(RD,RA,RB) LHAUXrrr(RD,RA,RB)
|
||||
#define LHArx(RD,RA,RB) LHAXrrr(RD,RA,RB)
|
||||
#define LHBRrx(RD,RA,RB) LHBRXrrr(RD,RA,RB)
|
||||
#define LHZUrx(RD,RA,RB) LHZUXrrr(RD,RA,RB)
|
||||
#define LHZrx(RD,RA,RB) LHZXrrr(RD,RA,RB)
|
||||
#define LWBRrx(RD,RA,RB) LWBRXrrr(RD,RA,RB)
|
||||
#define LWZUrx(RD, RA, RB) LWZUXrrr(RD, RA, RB)
|
||||
#define LWZrx(RD, RA, RB) LWZXrrr(RD, RA, RB)
|
||||
#define STBUrx(RD,RA,RB) STBUXrrr(RD,RA,RB)
|
||||
#define STBrx(RD,RA,RB) STBXrrr(RD,RA,RB)
|
||||
#define STHBRrx(RS,RA,RB) STHBRXrrr(RS,RA,RB)
|
||||
#define STHUrx(RS,RA,RB) STHUXrrr(RS,RA,RB)
|
||||
#define STHrx(RS,RA,RB) STHXrrr(RS,RA,RB)
|
||||
#define STWBRrx(RS,RA,RB) STWBRXrrr(RS,RA,RB)
|
||||
#define STWCrx(RS,RA,RB) STWCXrrr(RS,RA,RB)
|
||||
#define STWCX_rx(RS,RA,RB) STWCX_rrr(RS,RA,RB)
|
||||
#define STWUrx(RS,RA,RB) STWUXrrr(RS,RA,RB)
|
||||
#define STWrx(RS,RA,RB) STWXrrr(RS,RA,RB)
|
||||
#define LArx(RD,RB,RA) LArrr(RD,RB,RA)
|
||||
|
||||
|
||||
#define _LO(I) (_UL(I) & _MASK(16))
|
||||
#define _HI(I) (_UL(I) >> (16))
|
||||
|
||||
|
||||
|
||||
/*** References:
|
||||
*
|
||||
* [1] "PowerPC Microprocessor Family: The Programming Environments For 32-Bit Microprocessors", Motorola, 1997.
|
||||
*/
|
||||
|
||||
|
||||
#endif /* __ccg_asm_ppc_h */
|
||||
276
lightning/ppc/core.h
Normal file
276
lightning/ppc/core.h
Normal file
|
|
@ -0,0 +1,276 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer (PowerPC version)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_core_h
|
||||
#define __lightning_core_h
|
||||
|
||||
struct jit_local_state {
|
||||
int nextarg_put; /* Next r3-r8 reg. to be written */
|
||||
int nextarg_putfp; /* Next r3-r8 reg. to be written */
|
||||
int nextarg_get; /* Next r20-r25 reg. to be read */
|
||||
};
|
||||
|
||||
#define JIT_SP 1
|
||||
#define JIT_RET 3
|
||||
#define JIT_R0 9
|
||||
#define JIT_R1 10
|
||||
#define JIT_R2 30 /* using r8 would limit argument passing */
|
||||
#define JIT_V0 29
|
||||
#define JIT_V1 28
|
||||
#define JIT_V2 27
|
||||
#define JIT_AUX 26 /* for 32-bit operands & shift counts */
|
||||
|
||||
/* If possible, use the `small' instruction (rd, rs, imm)
|
||||
* else load imm into r26 and use the `big' instruction (rd, rs, r26)
|
||||
*/
|
||||
#define jit_chk_ims(imm, small, big) (_siP(16,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) )
|
||||
#define jit_chk_imu(imm, small, big) (_uiP(16,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) )
|
||||
#define jit_chk_imu15(imm, small, big) (_uiP(15,(imm)) ? (small) : (MOVEIri(JIT_AUX, imm), (big)) )
|
||||
|
||||
/* Helper macros for branches */
|
||||
#define jit_s_brai(rs, is, jmp) (jit_chk_ims (is, CMPWIri(rs, is), CMPWrr(rs, JIT_AUX)), jmp, _jit.pc)
|
||||
#define jit_s_brar(s1, s2, jmp) ( CMPWrr(s1, s2), jmp, _jit.pc)
|
||||
#define jit_u_brai(rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), jmp, _jit.pc)
|
||||
#define jit_u_brar(s1, s2, jmp) ( CMPLWrr(s1, s2), jmp, _jit.pc)
|
||||
|
||||
/* Helper macros for boolean tests. */
|
||||
#define jit_sbooli(d, rs, is, jmp) (jit_chk_ims (is, CMPWIri (rs, is), CMPWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_sboolr(d, s1, s2, jmp) ( CMPWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_sbooli2(d, rs, is, jmp) (jit_chk_ims (is, CMPWIri (rs, is), CMPWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
#define jit_sboolr2(d, s1, s2, jmp) ( CMPWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
#define jit_ubooli(d, rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_uboolr(d, s1, s2, jmp) ( CMPLWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)))
|
||||
#define jit_ubooli2(d, rs, is, jmp) (jit_chk_imu (is, CMPLWIri(rs, is), CMPLWrr(rs, JIT_AUX)), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
#define jit_uboolr2(d, s1, s2, jmp) ( CMPLWrr (s1, s2), MFCRr((d)), EXTRWIrrii((d), (d), 1, (jmp)), XORIrri((d), (d), 1))
|
||||
|
||||
/* modulus with immediate
|
||||
* movei r26, imm
|
||||
* mtlr r31
|
||||
* divw r31, rs, r26 (or divwu)
|
||||
* mullw r31, r31, r26
|
||||
* sub rs, rs, r26
|
||||
* mflr r31
|
||||
*/
|
||||
|
||||
#define _jit_mod(div, rs, imm) (MOVEIri(JIT_AUX, (imm)), MTLRr(31), (div), \
|
||||
MULLWrrr(31, 31, JIT_AUX), SUBrrr((rs), (rs), JIT_AUX), \
|
||||
MFLRr(31))
|
||||
|
||||
/* Emit a 2-instruction MOVEI, even if a 1-instruction one is possible
|
||||
* (it is a rare case for branches, and a fixed sequence of instructions
|
||||
* is easier to patch). */
|
||||
#define jit_movei(reg, imm) (LISri(reg,_HI(imm)), ORIrri((reg),(reg),_LO(imm)))
|
||||
|
||||
/* Patch a movei instruction made of a LIS at lis_pc and an ORI at ori_pc. */
|
||||
#define jit_patch_movei(lis_pc, ori_pc) \
|
||||
(*(lis_pc) &= ~_MASK(16), *lis_pc |= _HI(_jit.pc), \
|
||||
*(ori_pc) &= ~_MASK(16), *ori_pc |= _LO(_jit.pc)) \
|
||||
|
||||
/* Patch a branch instruction */
|
||||
#define jit_patch_branch(jump_pc) \
|
||||
(*(jump_pc) &= ~_MASK(16) | 3, \
|
||||
*(jump_pc) |= (_UL(_jit.pc) - _UL(jump_pc)) & _MASK(16))
|
||||
|
||||
#define _jit_blr_encoding ((19 << 26) | (20 << 21) | (00 << 16) | (00 << 11) | (16 << 1))
|
||||
|
||||
#define jit_patch(jump_pc) ( \
|
||||
((*(jump_pc - 1) & ~1) == _jit_blr_encoding) \
|
||||
? jit_patch_movei(((jump_pc) - 4), ((jump_pc) - 3)) \
|
||||
: jit_patch_branch((jump_pc) - 1))
|
||||
|
||||
|
||||
#define jit_arg_c() (_jitl.nextarg_get--)
|
||||
#define jit_arg_i() (_jitl.nextarg_get--)
|
||||
#define jit_arg_l() (_jitl.nextarg_get--)
|
||||
#define jit_arg_p() (_jitl.nextarg_get--)
|
||||
#define jit_arg_s() (_jitl.nextarg_get--)
|
||||
#define jit_arg_uc() (_jitl.nextarg_get--)
|
||||
#define jit_arg_ui() (_jitl.nextarg_get--)
|
||||
#define jit_arg_ul() (_jitl.nextarg_get--)
|
||||
#define jit_arg_us() (_jitl.nextarg_get--)
|
||||
#define jit_addi_i(d, rs, is) jit_chk_ims((is), ADDICrri((d), (rs), (is)), ADDrrr((d), (rs), JIT_AUX))
|
||||
#define jit_addr_i(d, s1, s2) ADDrrr((d), (s1), (s2))
|
||||
#define jit_addci_i(d, rs, is) jit_chk_ims((is), ADDICrri((d), (rs), (is)), ADDCrrr((d), (rs), JIT_AUX))
|
||||
#define jit_addcr_i(d, s1, s2) ADDCrrr((d), (s1), (s2))
|
||||
#define jit_addxi_i(d, rs, is) (MOVEIri(JIT_AUX, (is)), ADDErrr((d), (rs), JIT_AUX))
|
||||
#define jit_addxr_i(d, s1, s2) ADDErrr((d), (s1), (s2))
|
||||
#define jit_andi_i(d, rs, is) jit_chk_imu((is), ANDI_rri((d), (rs), (is)), ANDrrr((d), (rs), JIT_AUX))
|
||||
#define jit_andr_i(d, s1, s2) ANDrrr((d), (s1), (s2))
|
||||
#define jit_bmsi_i(label, rs, is) (jit_chk_imu((is), ANDI_rri(JIT_AUX, (rs), (is)), AND_rrr(JIT_AUX, (rs), JIT_AUX)), BGTi((label)), _jit.pc)
|
||||
#define jit_bmci_i(label, rs, is) (jit_chk_imu((is), ANDI_rri(JIT_AUX, (rs), (is)), AND_rrr(JIT_AUX, (rs), JIT_AUX)), BEQi((label)), _jit.pc)
|
||||
#define jit_bmsr_i(label, s1, s2) ( AND_rrr(JIT_AUX, (s1), (s2)), BGTi((label)), _jit.pc)
|
||||
#define jit_bmcr_i(label, s1, s2) ( AND_rrr(JIT_AUX, (s1), (s2)), BEQi((label)), _jit.pc)
|
||||
#define jit_beqi_i(label, rs, is) jit_s_brai((rs), (is), BEQi((label)) )
|
||||
#define jit_beqr_i(label, s1, s2) jit_s_brar((s1), (s2), BEQi((label)) )
|
||||
#define jit_bgei_i(label, rs, is) jit_s_brai((rs), (is), BGEi((label)) )
|
||||
#define jit_bgei_ui(label, rs, is) jit_u_brai((rs), (is), BGEi((label)) )
|
||||
#define jit_bger_i(label, s1, s2) jit_s_brar((s1), (s2), BGEi((label)) )
|
||||
#define jit_bger_ui(label, s1, s2) jit_u_brar((s1), (s2), BGEi((label)) )
|
||||
#define jit_bgti_i(label, rs, is) jit_s_brai((rs), (is), BGTi((label)) )
|
||||
#define jit_bgti_ui(label, rs, is) jit_u_brai((rs), (is), BGTi((label)) )
|
||||
#define jit_bgtr_i(label, s1, s2) jit_s_brar((s1), (s2), BGTi((label)) )
|
||||
#define jit_bgtr_ui(label, s1, s2) jit_u_brar((s1), (s2), BGTi((label)) )
|
||||
#define jit_blei_i(label, rs, is) jit_s_brai((rs), (is), BLEi((label)) )
|
||||
#define jit_blei_ui(label, rs, is) jit_u_brai((rs), (is), BLEi((label)) )
|
||||
#define jit_bler_i(label, s1, s2) jit_s_brar((s1), (s2), BLEi((label)) )
|
||||
#define jit_bler_ui(label, s1, s2) jit_u_brar((s1), (s2), BLEi((label)) )
|
||||
#define jit_blti_i(label, rs, is) jit_s_brai((rs), (is), BLTi((label)) )
|
||||
#define jit_blti_ui(label, rs, is) jit_u_brai((rs), (is), BLTi((label)) )
|
||||
#define jit_bltr_i(label, s1, s2) jit_s_brar((s1), (s2), BLTi((label)) )
|
||||
#define jit_bltr_ui(label, s1, s2) jit_u_brar((s1), (s2), BLTi((label)) )
|
||||
#define jit_bnei_i(label, rs, is) jit_s_brai((rs), (is), BNEi((label)) )
|
||||
#define jit_bner_i(label, s1, s2) jit_s_brar((s1), (s2), BNEi((label)) )
|
||||
#define jit_boaddi_i(label, rs, is) (MOVEIri(JIT_AUX, (is)), ADDOrrr((rs), (rs), JIT_AUX), MCRXRi(0), BGTi((label)), _jit.pc) /* GT = bit 1 of XER = OV */
|
||||
#define jit_bosubi_i(label, rs, is) (MOVEIri(JIT_AUX, (is)), SUBCOrrr((rs), (rs), JIT_AUX), MCRXRi(0), BGTi((label)), _jit.pc)
|
||||
#define jit_boaddr_i(label, s1, s2) ( ADDOrrr((s1), (s1), (s2)), MCRXRi(0), BGTi((label)), _jit.pc)
|
||||
#define jit_bosubr_i(label, s1, s2) ( SUBCOrrr((s1), (s1), (s2)), MCRXRi(0), BGTi((label)), _jit.pc)
|
||||
#define jit_boaddi_ui(label, rs, is) (jit_chk_ims ((is), ADDICri((rs), (rs), is), ADDCrr((rs), JIT_AUX)), MCRXRi(0), BEQi((label)), _jit.pc) /* EQ = bit 2 of XER = CA */
|
||||
#define jit_bosubi_ui(label, rs, is) (jit_chk_ims ((is), SUBICri((rs), (rs), is), SUBCrr((rs), JIT_AUX)), MCRXRi(0), BEQi((label)), _jit.pc)
|
||||
#define jit_boaddr_ui(label, s1, s2) ( ADDCrr((s1), (s1), (s2)), MCRXRi(0), BEQi((label)), _jit.pc)
|
||||
#define jit_bosubr_ui(label, s1, s2) ( SUBCrr((s1), (s1), (s2)), MCRXRi(0), BEQi((label)), _jit.pc)
|
||||
#define jit_calli(label) (jit_movei(JIT_AUX, (label)), MTLRr(JIT_AUX), BLRL(), _jit.pc)
|
||||
#define jit_divi_i(d, rs, is) jit_chk_ims(1111111, 0, DIVWrrr ((d), (rs), JIT_AUX))
|
||||
#define jit_divi_ui(d, rs, is) jit_chk_imu(1111111, 0, DIVWUrrr((d), (rs), JIT_AUX))
|
||||
#define jit_divr_i(d, s1, s2) DIVWrrr ((d), (s1), (s2))
|
||||
#define jit_divr_ui(d, s1, s2) DIVWUrrr((d), (s1), (s2))
|
||||
#define jit_eqi_i(d, rs, is) (jit_chk_ims((is), SUBIrri(JIT_AUX, (rs), (is)), SUBrrr(JIT_AUX, (rs), JIT_AUX)), SUBFICrri((d), JIT_AUX, 0), ADDErrr((d), (d), JIT_AUX))
|
||||
#define jit_eqr_i(d, s1, s2) (SUBrrr(JIT_AUX, (s1), (s2)), SUBFICrri((d), JIT_AUX, 0), ADDErrr((d), (d), JIT_AUX))
|
||||
#define jit_extr_c_i(d, rs) EXTSBrr((d), (rs))
|
||||
#define jit_extr_s_i(d, rs) EXTSHrr((d), (rs))
|
||||
#define jit_gei_i(d, rs, is) jit_sbooli2((d), (rs), (is), _lt)
|
||||
#define jit_gei_ui(d, rs, is) jit_ubooli2((d), (rs), (is), _lt)
|
||||
#define jit_ger_i(d, s1, s2) jit_sboolr2((d), (s1), (s2), _lt)
|
||||
#define jit_ger_ui(d, s1, s2) jit_uboolr2((d), (s1), (s2), _lt)
|
||||
#define jit_gti_i(d, rs, is) jit_sbooli ((d), (rs), (is), _gt)
|
||||
#define jit_gti_ui(d, rs, is) jit_ubooli ((d), (rs), (is), _gt)
|
||||
#define jit_gtr_i(d, s1, s2) jit_sboolr ((d), (s1), (s2), _gt)
|
||||
#define jit_gtr_ui(d, s1, s2) jit_uboolr ((d), (s1), (s2), _gt)
|
||||
#define jit_hmuli_i(d, rs, is) jit_chk_ims(1111111, 0, MULHWrrr ((d), (rs), JIT_AUX))
|
||||
#define jit_hmuli_ui(d, rs, is) jit_chk_imu(1111111, 0, MULHWUrrr((d), (rs), JIT_AUX))
|
||||
#define jit_hmulr_i(d, s1, s2) MULHWrrr ((d), (s1), (s2))
|
||||
#define jit_hmulr_ui(d, s1, s2) MULHWUrrr((d), (s1), (s2))
|
||||
#define jit_jmpi(label) (B_EXT((label)), _jit.pc)
|
||||
#define jit_jmpr(reg) (MTLRr(reg), BLR())
|
||||
#define jit_ldxi_c(d, rs, is) (jit_ldxi_uc((d), (rs), (is)), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldxr_c(d, s1, s2) (jit_ldxr_uc((d), (s1), (s2)), jit_extr_c_i((d), (d)))
|
||||
#define jit_ldxi_i(d, rs, is) jit_chk_ims((d), LWZrm((d), (is), (rs)), LWZrx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxi_s(d, rs, is) jit_chk_ims((d), LHArm((d), (is), (rs)), LHArx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxi_uc(d, rs, is) jit_chk_ims((d), LBZrm((d), (is), (rs)), LBZrx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxi_us(d, rs, is) jit_chk_ims((d), LHZrm((d), (is), (rs)), LHZrx((d), JIT_AUX, (rs)))
|
||||
#define jit_ldxr_i(d, s1, s2) LWZrx((d), (s1), (s2))
|
||||
#define jit_ldxr_s(d, s1, s2) LHArx((d), (s1), (s2))
|
||||
#define jit_ldxr_uc(d, s1, s2) LBZrx((d), (s1), (s2))
|
||||
#define jit_ldxr_us(d, s1, s2) LHZrx((d), (s1), (s2))
|
||||
#define jit_lei_i(d, rs, is) jit_sbooli2((d), (rs), (is), _gt )
|
||||
#define jit_lei_ui(d, rs, is) jit_ubooli2((d), (rs), (is), _gt )
|
||||
#define jit_ler_i(d, s1, s2) jit_sboolr2((d), (s1), (s2), _gt )
|
||||
#define jit_ler_ui(d, s1, s2) jit_uboolr2((d), (s1), (s2), _gt )
|
||||
#define jit_lshi_i(d, rs, is) SLWIrri((d), (rs), (is))
|
||||
#define jit_lshr_i(d, s1, s2) (ANDIrri(JIT_AUX, (s2), 31), SLWrrr ((d), (s1), JIT_AUX))
|
||||
#define jit_lti_i(d, rs, is) jit_sbooli ((d), (rs), (is), _lt )
|
||||
#define jit_lti_ui(d, rs, is) jit_ubooli ((d), (rs), (is), _lt )
|
||||
#define jit_ltr_i(d, s1, s2) jit_sboolr ((d), (s1), (s2), _lt )
|
||||
#define jit_ltr_ui(d, s1, s2) jit_uboolr ((d), (s1), (s2), _lt )
|
||||
#define jit_modi_i(d, rs, is) _jit_mod(jit_divi_i (31, (rs), JIT_AUX), (is))
|
||||
#define jit_modi_ui(d, rs, is) _jit_mod(jit_divi_ui(31, (rs), JIT_AUX), (irs))
|
||||
#define jit_modr_i(d, s1, s2) (DIVWrrr(JIT_AUX, (s1), (s2)), MULLWrrr(JIT_AUX, JIT_AUX, (s2)), SUBrrr((d), (s1), JIT_AUX))
|
||||
#define jit_modr_ui(d, s1, s2) (DIVWUrrr(JIT_AUX, (s1), (s2)), MULLWrrr(JIT_AUX, JIT_AUX, (s2)), SUBrrr((d), (s1), JIT_AUX))
|
||||
#define jit_movi_i(d, is) MOVEIri((d), (is))
|
||||
#define jit_movr_i(d, rs) MRrr((d), (rs))
|
||||
#define jit_muli_i(d, rs, is) jit_chk_ims ((is), MULLIrri((d), (rs), (is)), MULLWrrr((d), (rs), JIT_AUX))
|
||||
#define jit_muli_ui(d, rs, is) jit_chk_imu15((is), MULLIrri((d), (rs), (is)), MULLWrrr((d), (rs), JIT_AUX))
|
||||
#define jit_mulr_i(d, s1, s2) MULLWrrr((d), (s1), (s2))
|
||||
#define jit_mulr_ui(d, s1, s2) MULLWrrr((d), (s1), (s2))
|
||||
#define jit_nei_i(d, rs, is) (jit_chk_ims((is), SUBIrri(JIT_AUX, (rs), (is)), SUBrrr(JIT_AUX, (rs), JIT_AUX)), ADDICrri((d), JIT_AUX, -1), SUBFErrr((d), (d), JIT_AUX))
|
||||
#define jit_ner_i(d, s1, s2) (SUBrrr(JIT_AUX, (s1), (s2)), ADDICrri((d), JIT_AUX, -1), SUBFErrr((d), (d), JIT_AUX))
|
||||
#define jit_nop() NOP()
|
||||
#define jit_ori_i(d, rs, is) jit_chk_imu((is), ORIrri((d), (rs), (is)), ORrrr((d), (rs), JIT_AUX))
|
||||
#define jit_orr_i(d, s1, s2) ORrrr((d), (s1), (s2))
|
||||
#define jit_popr_i(rs) (LWZrm((rs), 0, 1), ADDIrri(1, 1, 4))
|
||||
#define jitfp_prepare(numi, numf, numd) (_jitl.nextarg_put = 3 + (numi) + (numf) + 2*(numd))
|
||||
#define jit_prolog(n) _jit_prolog(&_jit, (n))
|
||||
#define jit_pushr_i(rs) STWUrm((rs), -4, 1)
|
||||
#define jit_pusharg_i(rs) (--_jitl.nextarg_put, MRrr(_jitl.nextarg_put, (rs)))
|
||||
#define jit_ret() jit_jmpr(31)
|
||||
#define jit_retval(rd) MRrr((rd), 3)
|
||||
#define jit_rsbi_i(d, rs, is) jit_chk_ims((is), SUBFICrri((d), (rs), (is)), SUBFCrrr((d), (rs), JIT_AUX))
|
||||
#define jit_rshi_i(d, rs, is) SRAWIrri((d), (rs), (is))
|
||||
#define jit_rshi_ui(d, rs, is) SRWIrri ((d), (rs), (is))
|
||||
#define jit_rshr_i(d, s1, s2) (ANDIrrr(JIT_AUX, (s2), 31), SRAWrrr ((d), (s1), JIT_AUX))
|
||||
#define jit_rshr_ui(d, s1, s2) (ANDIrrr(JIT_AUX, (s2), 31), SRWrrr ((d), (s1), JIT_AUX))
|
||||
#define jit_stxi_c(id, rd, rs) jit_chk_ims((id), STBrm((rs), (id), (rd)), STBrx((rs), (rd), JIT_AUX))
|
||||
#define jit_stxi_i(id, rd, rs) jit_chk_ims((id), STWrm((rs), (id), (rd)), STWrx((rs), (rd), JIT_AUX))
|
||||
#define jit_stxi_s(id, rd, rs) jit_chk_ims((id), STHrm((rs), (id), (rd)), STHrx((rs), (rd), JIT_AUX))
|
||||
#define jit_stxr_c(d1, d2, rs) STBrx((rs), (d1), (d2))
|
||||
#define jit_stxr_i(d1, d2, rs) STWrx((rs), (d1), (d2))
|
||||
#define jit_stxr_s(d1, d2, rs) STHrx((rs), (d1), (d2))
|
||||
#define jit_subr_i(d, s1, s2) SUBrrr((d), (s1), (s2))
|
||||
#define jit_subcr_i(d, s1, s2) SUBCrrr((d), (s1), (s2))
|
||||
#define jit_subxi_i(d, rs, is) jit_chk_ims(111111111, 0, SUBErrr((d), (rs), JIT_AUX))
|
||||
#define jit_subxr_i(d, s1, s2) SUBErrr((d), (s1), (s2))
|
||||
#define jit_xori_i(d, rs, is) jit_chk_imu((is), XORIrri((d), (rs), (is)), XORrrr((d), (rs), JIT_AUX))
|
||||
#define jit_xorr_i(d, s1, s2) XORrrr((d), (s1), (s2))
|
||||
|
||||
/* Cannot use JIT_RZERO because having 0 in a register field on the PowerPC
|
||||
* does not mean `a register whose value is 0', but rather `no register at
|
||||
* all' */
|
||||
|
||||
#define jit_negr_i(d, rs) jit_rsbi_i((d), (rs), 0)
|
||||
#define jit_negr_l(d, rs) jit_rsbi_l((d), (rs), 0)
|
||||
#define jit_ldr_c(rd, rs) jit_ldxr_c((rd), 0, (rs))
|
||||
#define jit_str_c(rd, rs) jit_stxr_c(0, (rd), (rs))
|
||||
#define jit_ldr_s(rd, rs) jit_ldxr_s((rd), 0, (rs))
|
||||
#define jit_str_s(rd, rs) jit_stxr_s(0, (rd), (rs))
|
||||
#define jit_ldr_i(rd, rs) jit_ldxr_i((rd), 0, (rs))
|
||||
#define jit_str_i(rd, rs) jit_stxr_i(0, (rd), (rs))
|
||||
#define jit_ldr_uc(rd, rs) jit_ldxr_uc((rd), 0, (rs))
|
||||
#define jit_ldr_us(rd, rs) jit_ldxr_us((rd), 0, (rs))
|
||||
|
||||
/* e.g.
|
||||
* 0x01234567 _HA << 16 = 0x01230000 _LA = 0x00004567 _HA << 16 + LA = 0x01234567
|
||||
* 0x89abcdef _HA << 16 = 0x89ac0000 _LA = 0xffffcdef _HA << 16 + LA = 0x89abcdef
|
||||
*/
|
||||
#define _HA(addr) ((_UL(addr) >> 16) + (_US(_UL(addr)) >> 15))
|
||||
#define _LA(addr) (_UL(addr) - (_HA(addr) << 16))
|
||||
|
||||
#define jit_ldi_c(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_c((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_sti_c(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_c(_LA(id), JIT_AUX, (rs)))
|
||||
#define jit_ldi_s(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_s((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_sti_s(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_s(_LA(id), JIT_AUX, (rs)))
|
||||
#define jit_ldi_i(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_i((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_sti_i(id, rs) (LISri(JIT_AUX, _HA(id)), jit_stxi_i(_LA(id), JIT_AUX, (rs)))
|
||||
#define jit_ldi_uc(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_uc((rd), JIT_AUX, _LA(is)))
|
||||
#define jit_ldi_us(rd, is) (LISri(JIT_AUX, _HA(is)), jit_ldxi_us((rd), JIT_AUX, _LA(is)))
|
||||
|
||||
#endif /* __lightning_core_h */
|
||||
104
lightning/ppc/fp.h
Normal file
104
lightning/ppc/fp.h
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler & support macros for the Sparc math unit
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_asm_fp_h
|
||||
#define __lightning_asm_fp_h
|
||||
|
||||
#if 0
|
||||
|
||||
/* dummy for now */
|
||||
|
||||
#define jit_add_two(reg0) FADDrrr(13 - (reg0), 13 - (reg0), 12 - (reg0))
|
||||
#define jit_sub_two(reg0) FSUBrrr(13 - (reg0), 13 - (reg0), 12 - (reg0))
|
||||
#define jit_mul_two(reg0) FMULrrr(13 - (reg0), 13 - (reg0), 12 - (reg0))
|
||||
#define jit_div_two(reg0) FDIVrrr(13 - (reg0), 13 - (reg0), 12 - (reg0))
|
||||
|
||||
#define jit_abs(reg0) FABSr(13 - (reg0))
|
||||
#define jit_sqrt(reg0) FSQRTr(13 - (reg0))
|
||||
#define jit_neg(reg0) FNEGr(13 - (reg0))
|
||||
|
||||
#define jit_ldxi_f(reg0, rs, is) 0
|
||||
#define jit_ldxr_f(reg0, s1, s2) 0
|
||||
#define jit_ldxi_d(reg0, rs, is) 0
|
||||
#define jit_ldxr_d(reg0, s1, s2) 0
|
||||
#define jit_ldi_f(reg0, is) 0
|
||||
#define jit_ldr_f(reg0, rs) 0
|
||||
#define jit_ldi_d(reg0, is) 0
|
||||
#define jit_ldr_d(reg0, rs) 0
|
||||
#define jit_stxi_f(id, rd, reg0) 0
|
||||
#define jit_stxr_f(d1, d2, reg0) 0
|
||||
#define jit_stxi_d(id, rd, reg0) 0
|
||||
#define jit_stxr_d(d1, d2, reg0) 0
|
||||
#define jit_sti_f(id, reg0) 0
|
||||
#define jit_str_f(rd, reg0) 0
|
||||
#define jit_sti_d(id, reg0) 0
|
||||
#define jit_str_d(rd, reg0) 0
|
||||
|
||||
/* Make space for 1 or 2 words, store address in REG */
|
||||
#define jit_data(REG, D1) (_FBA (18, 8, 0, 1), _L(D1), MFLRr(REG))
|
||||
#define jit_data2(REG, D1, D2) (_FBA (18, 12, 0, 1), _L(D1), _L(D2), MFLRr(REG))
|
||||
|
||||
#define jit_fpimm(reg0, first, second) \
|
||||
(jit_data2(JIT_AUX, (first), (second)), \
|
||||
jit_ldxi_d((reg0), JIT_AUX, 0))
|
||||
|
||||
#define jit_floor(rd, reg0) jit_call_fp((rd), (reg0), floor)
|
||||
#define jit_ceil(rd, reg0) jit_call_fp((rd), (reg0), ceil)
|
||||
|
||||
#define jit_call_fp(rd, reg0, fn) \
|
||||
jit_fail(#fn " not supported", __FILE__, __LINE__, __FUNCTION__)
|
||||
/* pass reg0 as first parameter of rd
|
||||
bl fn
|
||||
mr r3, rd */
|
||||
|
||||
#define jit_trunc(rd, reg0) (jit_data((rd), 0), \
|
||||
FCTIWZrr(13 - (reg0), 13 - (reg0)), \
|
||||
STFIWXrrr(13 - (reg0), 0, (rd)), \
|
||||
LWZrm((rd), 0, (rd)))
|
||||
|
||||
#define jit_round(rd, reg0) (jit_data((rd), 0), \
|
||||
FCTIWrr(13 - (reg0), 13 - (reg0)), \
|
||||
STFIWXrrr(13 - (reg0), 0, (rd)), \
|
||||
LWZrm((rd), 0, (rd)))
|
||||
|
||||
#define jit_cmp(le, ge, reg0) (FCMPOirr(7, 13 - (reg0), 0), \
|
||||
CRORiii(28 + _gt, 28 + _gt, 28 + _eq), \
|
||||
CRORiii(28 + _lt, 28 + _lt, 28 + _eq), \
|
||||
MFCRr((ge)), \
|
||||
EXTRWIrrii((le), (ge), 1, 28 + _lt), \
|
||||
EXTRWIrrii((ge), (ge), 1, 28 + _gt))
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* __lightning_asm_h */
|
||||
169
lightning/ppc/funcs.h
Normal file
169
lightning/ppc/funcs.h
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer inline functions (PowerPC)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_funcs_h
|
||||
#define __lightning_funcs_h
|
||||
|
||||
#if !defined(__GNUC__) && !defined(__GNUG__)
|
||||
#error Go get GNU C, I do not know how to flush the cache
|
||||
#error with this compiler.
|
||||
#else
|
||||
/* Why doesn't this compile?!?
|
||||
* static void
|
||||
* jit_flush_code(start, end)
|
||||
* void *start;
|
||||
* void *end;
|
||||
*/
|
||||
|
||||
static void
|
||||
jit_flush_code(void* start, void* end)
|
||||
{
|
||||
#ifndef LIGHTNING_CROSS
|
||||
static int cache_line_size, cache_line_shift;
|
||||
register char *ddest, *idest;
|
||||
register int n, dcache_lines, icache_lines;
|
||||
|
||||
if (cache_line_size == 0) {
|
||||
char buffer[8192];
|
||||
int i, probe;
|
||||
|
||||
/* Find out the size of a cache line by zeroing one */
|
||||
memset(buffer, 0xFF, 8192);
|
||||
__asm__ __volatile__ ("dcbz 0,%0" : : "r"(buffer + 4096));
|
||||
|
||||
/* Probe for the beginning of the cache line. */
|
||||
for(i = 0, probe = 4096; probe; probe >>= 1)
|
||||
if (buffer[i | probe] != 0x00)
|
||||
i |= probe;
|
||||
|
||||
/* i is now just before the start of the cache line */
|
||||
i++;
|
||||
for(cache_line_shift = 0, cache_line_size = 1;
|
||||
i + cache_line_size < 8192; cache_line_shift++, cache_line_size <<= 1)
|
||||
if (buffer[i + cache_line_size] != 0x00)
|
||||
break;
|
||||
}
|
||||
|
||||
n = ((char *) end) - ((char *)start);
|
||||
dcache_lines = icache_lines = (n + cache_line_size - 1) >> cache_line_shift;
|
||||
|
||||
/* Force data cache write-backs */
|
||||
for (ddest = start; dcache_lines--; ddest += cache_line_size) {
|
||||
__asm__ __volatile__ ("dcbst 0,%0" : : "r"(ddest));
|
||||
}
|
||||
__asm__ __volatile__ ("sync" : : );
|
||||
|
||||
/* Now invalidate the instruction cache */
|
||||
for (idest = start; icache_lines--; idest += cache_line_size) {
|
||||
__asm__ __volatile__ ("icbi 0,%0; isync" : : "r"(idest));
|
||||
}
|
||||
__asm__ __volatile__ ("isync" : : );
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#define _jit (*jit)
|
||||
|
||||
/* Emit a trampoline for a function.
|
||||
* Upon entrance to the trampoline:
|
||||
* - R0 = return address for the function
|
||||
* - LR = address where the real code for the function lies
|
||||
* - R3-R8 = parameters
|
||||
* After jumping to the address pointed to by R10:
|
||||
* - LR = address where the epilog lies (the function must return there)
|
||||
* - R25-R20 = parameters (order is reversed, 1st argument is R25)
|
||||
*/
|
||||
static jit_insn *
|
||||
_jit_trampoline(jit, n)
|
||||
register jit_state *jit;
|
||||
register int n;
|
||||
{
|
||||
static jit_insn trampolines[200];
|
||||
static jit_insn *p_trampolines[6], *free = trampolines;
|
||||
register int i, ofs, frame_size;
|
||||
|
||||
if (!p_trampolines[n]) {
|
||||
_jit.pc = p_trampolines[n] = free;
|
||||
|
||||
frame_size = 24 + (6 + n) * 4; /* r26..r31 + args */
|
||||
frame_size += 15; /* the stack must be quad-word */
|
||||
frame_size &= ~15; /* aligned */
|
||||
|
||||
STWUrm(1, -frame_size, 1); /* stwu r1, -x(r1) */
|
||||
|
||||
for (ofs = frame_size - (6 + n) * 4, i = 26 - n; i <= 31; ofs += 4, i++) {
|
||||
STWrm(i, ofs, 1); /* stw rI, ofs(r1) */
|
||||
}
|
||||
STWrm(0, ofs+4, 1); /* stw r0, x(r1) */
|
||||
for (i = 0; i < n; i++) {
|
||||
MRrr(25-i, 3+i); /* save parameters in r25..r20 */
|
||||
}
|
||||
BLRL(); /* blrl */
|
||||
LWZrm(0, ofs+4, 1); /* lwz r0, x(r1) (ret.addr.) */
|
||||
MTLRr(0); /* mtspr LR, r0 */
|
||||
|
||||
for (ofs = frame_size - (6 + n) * 4, i = 26 - n; i <= 31; ofs += 4, i++) {
|
||||
LWZrm(i, ofs, 1); /* lwz rI, ofs(r1) */
|
||||
}
|
||||
ADDIrri(1, 1, frame_size); /* addi r1, r1, x */
|
||||
BLR(); /* blr */
|
||||
|
||||
jit_flush_code(p_trampolines[n], _jit.pc);
|
||||
free = _jit.pc;
|
||||
}
|
||||
|
||||
return p_trampolines[n];
|
||||
}
|
||||
|
||||
static void
|
||||
_jit_prolog(jit, n)
|
||||
register jit_state *jit;
|
||||
register int n;
|
||||
{
|
||||
register jit_insn *save_pc, *trampo;
|
||||
|
||||
save_pc = _jit.pc;
|
||||
trampo = _jit_trampoline(jit, n);
|
||||
_jit.pc = save_pc;
|
||||
|
||||
_jitl.nextarg_get = 25;
|
||||
MFLRr(0);
|
||||
MOVEIri(10, trampo);
|
||||
MTLRr(10);
|
||||
BLRL(); /* blrl */
|
||||
MFLRr(31); /* mflr r31 */
|
||||
}
|
||||
|
||||
#undef _jit
|
||||
|
||||
#endif /* __lightning_funcs_h */
|
||||
303
lightning/sparc/asm.h
Normal file
303
lightning/sparc/asm.h
Normal file
|
|
@ -0,0 +1,303 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler for the SPARC
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 1999, 2000, 2001, 2002 Ian Piumarta
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_asm_h
|
||||
#define __lightning_asm_h
|
||||
|
||||
|
||||
/* <imm> = [0-9]+ -> add i, one parameter (imm)
|
||||
* <reg> = %<imm> -> add r, one parameter (imm or _Rr(imm) )
|
||||
* %g<imm> -> add r, one parameter (imm or _Rg(imm) )
|
||||
* %o<imm> -> add r, one parameter (imm+8 or _Ro(imm) )
|
||||
* %l<imm> -> add r, one parameter (imm+16 or _Rl(imm) )
|
||||
* %i<imm> -> add r, one parameter (imm+24 or _Ri(imm) )
|
||||
* <mem> = <imm>(<reg>) -> add m, two parameters (reg,imm)
|
||||
* <idx> = <reg>(<reg>) -> add x, two parameters (reg,reg)
|
||||
*/
|
||||
|
||||
|
||||
typedef unsigned int jit_insn;
|
||||
|
||||
#define _d30(BD) ((_UL(BD) - _UL(_jit.pc))>>2)
|
||||
#define _d22(BD) _ck_d(22, _d30(BD))
|
||||
|
||||
#define _HI(I) (_UL(I) >> (10))
|
||||
#define _LO(I) (_UL(I) & _MASK(10))
|
||||
|
||||
/* register names */
|
||||
|
||||
#define _y 0
|
||||
#define _psr 1
|
||||
|
||||
#define _Rr(N) ( 0+(N))
|
||||
#define _Rg(N) ( 0+(N))
|
||||
#define _Ro(N) ( 8+(N))
|
||||
#define _Rl(N) (16+(N))
|
||||
#define _Ri(N) (24+(N))
|
||||
|
||||
/* instruction formats -- Figure 5-1, page 44 in */
|
||||
/* SPARC International, "The SPARC Architecture Manual, Version 8", Prentice-Hall, 1992. */
|
||||
|
||||
#define _0i(RD, OP2, IMM) _I((0<<30)| (_u5(RD)<<25)|(_u3(OP2)<<22)| _u22(IMM))
|
||||
#define _0( A, CC, OP2, DSP) _I((0<<30)|(_u1(A)<<29)|(_u4(CC)<<25)|(_u3(OP2)<<22)| _d22(DSP))
|
||||
#define _0d( A, CC, OP2, DSP) _I((0<<30)|(_u1(A)<<29)|(_u4(CC)<<25)|(_u3(OP2)<<22)| _u22(DSP))
|
||||
|
||||
#define _1( DSP) _I((1<<30)| _d30(DSP))
|
||||
|
||||
#define _2( RD, OP3, RS1, I, ASI, RS2) _I((2<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)|(_u8(ASI)<<5)|_u5 (RS2))
|
||||
#define _2i(RD, OP3, RS1, I, IMM) _I((2<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)| _s13(IMM))
|
||||
#define _2f(RD, OP3, RS1, OPF, RS2) _I((2<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)| (_u9(OPF)<<5)|_u5 (RS2))
|
||||
|
||||
#define _3( RD, OP3, RS1, I, ASI, RS2) _I((3<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)|(_u8(ASI)<<5)|_u5 (RS2))
|
||||
#define _3i(RD, OP3, RS1, I, IMM) _I((3<<30)| (_u5(RD)<<25)|(_u6(OP3)<<19)|(_u5(RS1)<<14)|(_u1(I)<<13)| _s13(IMM))
|
||||
|
||||
/* basic instructions [Section B, page 87] */
|
||||
|
||||
#define ADDrrr(RS1, RS2, RD) _2 ((RD), 0, (RS1), 0, 0, (RS2))
|
||||
#define ADDrir(RS1, IMM, RD) _2i ((RD), 0, (RS1), 1, (IMM))
|
||||
#define ADDCCrrr(RS1, RS2, RD) _2 ((RD), 16, (RS1), 0, 0, (RS2))
|
||||
#define ADDCCrir(RS1, IMM, RD) _2i ((RD), 16, (RS1), 1, (IMM))
|
||||
#define ADDXrrr(RS1, RS2, RD) _2 ((RD), 8, (RS1), 0, 0, (RS2))
|
||||
#define ADDXrir(RS1, IMM, RD) _2i ((RD), 8, (RS1), 1, (IMM))
|
||||
#define ADDXCCrrr(RS1, RS2, RD) _2 ((RD), 24, (RS1), 0, 0, (RS2))
|
||||
#define ADDXCCrir(RS1, IMM, RD) _2i ((RD), 24, (RS1), 1, (IMM))
|
||||
#define ANDrrr(RS1, RS2, RD) _2 ((RD), 1, (RS1), 0, 0, (RS2))
|
||||
#define ANDrir(RS1, IMM, RD) _2i ((RD), 1, (RS1), 1, (IMM))
|
||||
#define ANDCCrrr(RS1, RS2, RD) _2 ((RD), 17, (RS1), 0, 0, (RS2))
|
||||
#define ANDCCrir(RS1, IMM, RD) _2i ((RD), 17, (RS1), 1, (IMM))
|
||||
|
||||
#define BNi(DISP) _0 (0, 0, 2, (DISP))
|
||||
#define BN_Ai(DISP) _0 (1, 0, 2, (DISP))
|
||||
#define BEi(DISP) _0 (0, 1, 2, (DISP))
|
||||
#define BE_Ai(DISP) _0 (1, 1, 2, (DISP))
|
||||
#define BLEi(DISP) _0 (0, 2, 2, (DISP))
|
||||
#define BLE_Ai(DISP) _0 (1, 2, 2, (DISP))
|
||||
#define BLi(DISP) _0 (0, 3, 2, (DISP))
|
||||
#define BL_Ai(DISP) _0 (1, 3, 2, (DISP))
|
||||
#define BLEUi(DISP) _0 (0, 4, 2, (DISP))
|
||||
#define BLEU_Ai(DISP) _0 (1, 4, 2, (DISP))
|
||||
#define BCSi(DISP) _0 (0, 5, 2, (DISP))
|
||||
#define BCS_Ai(DISP) _0 (1, 5, 2, (DISP))
|
||||
#define BNEGi(DISP) _0 (0, 6, 2, (DISP))
|
||||
#define BNEG_Ai(DISP) _0 (1, 6, 2, (DISP))
|
||||
#define BVSi(DISP) _0 (0, 7, 2, (DISP))
|
||||
#define BVS_Ai(DISP) _0 (1, 7, 2, (DISP))
|
||||
#define BAi(DISP) _0 (0, 8, 2, (DISP))
|
||||
#define BA_Ai(DISP) _0 (1, 8, 2, (DISP))
|
||||
#define BNEi(DISP) _0 (0, 9, 2, (DISP))
|
||||
#define BNE_Ai(DISP) _0 (1, 9, 2, (DISP))
|
||||
#define BGi(DISP) _0 (0, 10, 2, (DISP))
|
||||
#define BG_Ai(DISP) _0 (1, 10, 2, (DISP))
|
||||
#define BGEi(DISP) _0 (0, 11, 2, (DISP))
|
||||
#define BGE_Ai(DISP) _0 (1, 11, 2, (DISP))
|
||||
#define BGUi(DISP) _0 (0, 12, 2, (DISP))
|
||||
#define BGU_Ai(DISP) _0 (1, 12, 2, (DISP))
|
||||
#define BCCi(DISP) _0 (0, 13, 2, (DISP))
|
||||
#define BCC_Ai(DISP) _0 (1, 13, 2, (DISP))
|
||||
#define BPOSi(DISP) _0 (0, 14, 2, (DISP))
|
||||
#define BPOS_Ai(DISP) _0 (1, 14, 2, (DISP))
|
||||
#define BVCi(DISP) _0 (0, 15, 2, (DISP))
|
||||
#define BVC_Ai(DISP) _0 (1, 15, 2, (DISP))
|
||||
|
||||
#define CALLi(DISP) _1 ((DISP))
|
||||
|
||||
#define FLUSHrr(RS1, RS2) _2 (0, 0x3b, (RS1), 0, 0, (RS2))
|
||||
#define FLUSHir(IMM, RS1) _2i (0, 0x3b, (RS1), 1, (IMM))
|
||||
|
||||
#define JMPLxr(RS1, RS2, RD) _2 ((RD), 56, (RS1), 0, 0, (RS2))
|
||||
#define JMPLmr(RS1, IMM, RD) _2i ((RD), 56, (RS1), 1, (IMM))
|
||||
|
||||
#define LDxr(RS1, RS2, RD) _3 ((RD), 0, (RS1), 0, 0, (RS2))
|
||||
#define LDmr(RS1, IMM, RD) _3i ((RD), 0, (RS1), 1, (IMM))
|
||||
#define LDUBxr(RS1, RS2, RD) _3 ((RD), 1, (RS1), 0, 0, (RS2))
|
||||
#define LDUBmr(RS1, IMM, RD) _3i ((RD), 1, (RS1), 1, (IMM))
|
||||
#define LDUHxr(RS1, RS2, RD) _3 ((RD), 2, (RS1), 0, 0, (RS2))
|
||||
#define LDUHmr(RS1, IMM, RD) _3i ((RD), 2, (RS1), 1, (IMM))
|
||||
#define LDDxr(RS1, RS2, RD) _3 ((RD), 3, (RS1), 0, 0, (RS2))
|
||||
#define LDDmr(RS1, IMM, RD) _3i ((RD), 3, (RS1), 1, (IMM))
|
||||
#define LDSBxr(RS1, RS2, RD) _3 ((RD), 9, (RS1), 0, 0, (RS2))
|
||||
#define LDSBmr(RS1, IMM, RD) _3i ((RD), 9, (RS1), 1, (IMM))
|
||||
#define LDSHxr(RS1, RS2, RD) _3 ((RD), 10, (RS1), 0, 0, (RS2))
|
||||
#define LDSHmr(RS1, IMM, RD) _3i ((RD), 10, (RS1), 1, (IMM))
|
||||
|
||||
#define ORrrr(RS1, RS2, RD) _2 ((RD), 2, (RS1), 0, 0, (RS2))
|
||||
#define ORrir(RS1, IMM, RD) _2i ((RD), 2, (RS1), 1, (IMM))
|
||||
#define ORCCrrr(RS1, RS2, RD) _2 ((RD), 18, (RS1), 0, 0, (RS2))
|
||||
#define ORCCrir(RS1, IMM, RD) _2i ((RD), 18, (RS1), 1, (IMM))
|
||||
|
||||
#define RDir(RS, RD) _2 ((RD), (RS)|0x28, 0, 0, 0,0)
|
||||
#define RESTORErrr(RS1, RS2, RD) _2 ((RD), 61, (RS1), 0, 0, (RS2))
|
||||
#define RESTORErir(RS1, IMM, RD) _2i ((RD), 61, (RS1), 1, (IMM))
|
||||
|
||||
#define SAVErrr(RS1, RS2, RD) _2 ((RD), 60, (RS1), 0, 0, (RS2))
|
||||
#define SAVErir(RS1, IMM, RD) _2i ((RD), 60, (RS1), 1, (IMM))
|
||||
#define SDIVrrr(RS1, RS2, RD) _2 ((RD), 15, (RS1), 0, 0, (RS2))
|
||||
#define SDIVrir(RS1, IMM, RD) _2i ((RD), 15, (RS1), 1, (IMM))
|
||||
#define SDIVCCrrr(RS1, RS2, RD) _2 ((RD), 31, (RS1), 0, 0, (RS2))
|
||||
#define SDIVCCrir(RS1, IMM, RD) _2i ((RD), 31, (RS1), 1, (IMM))
|
||||
#define SETHIir(IMM, RD) _0i ((RD), 4, (IMM))
|
||||
#define SLLrrr(RS1, RS2, RD) _2 ((RD), 37, (RS1), 0, 0, (RS2))
|
||||
#define SLLrir(RS1, IMM, RD) _2i ((RD), 37, (RS1), 1, (IMM))
|
||||
#define SMULrrr(RS1, RS2, RD) _2 ((RD), 11, (RS1), 0, 0, (RS2))
|
||||
#define SMULrir(RS1, IMM, RD) _2i ((RD), 11, (RS1), 1, (IMM))
|
||||
#define SMULCCrrr(RS1, RS2, RD) _2 ((RD), 27, (RS1), 0, 0, (RS2))
|
||||
#define SMULCCrir(RS1, IMM, RD) _2i ((RD), 27, (RS1), 1, (IMM))
|
||||
#define SRArrr(RS1, RS2, RD) _2 ((RD), 39, (RS1), 0, 0, (RS2))
|
||||
#define SRArir(RS1, IMM, RD) _2i ((RD), 39, (RS1), 1, (IMM))
|
||||
#define SRLrrr(RS1, RS2, RD) _2 ((RD), 38, (RS1), 0, 0, (RS2))
|
||||
#define SRLrir(RS1, IMM, RD) _2i ((RD), 38, (RS1), 1, (IMM))
|
||||
#define STrx(RS, RD1, RD2) _3 ((RS), 4, (RD1), 0, 0, (RD2))
|
||||
#define STrm(RS, RD, IMM) _3i ((RS), 4, (RD), 1, (IMM))
|
||||
#define STBrx(RS, RD1, RD2) _3 ((RS), 5, (RD1), 0, 0, (RD2))
|
||||
#define STBrm(RS, RD, IMM) _3i ((RS), 5, (RD), 1, (IMM))
|
||||
#define STBAR() _0i (0, 0x28, 15, 0, 0)
|
||||
#define STHrx(RS, RD1, RD2) _3 ((RS), 6, (RD1), 0, 0, (RD2))
|
||||
#define STHrm(RS, RD, IMM) _3i ((RS), 6, (RD), 1, (IMM))
|
||||
#define STDrx(RS, RD1, RD2) _3 ((RS), 7, (RD1), 0, 0, (RD2))
|
||||
#define STDrm(RS, RD, IMM) _3i ((RS), 7, (RD), 1, (IMM))
|
||||
#define SUBrrr(RS1, RS2, RD) _2 ((RD), 4, (RS1), 0, 0, (RS2))
|
||||
#define SUBrir(RS1, IMM, RD) _2i ((RD), 4, (RS1), 1, (IMM))
|
||||
#define SUBCCrrr(RS1, RS2, RD) _2 ((RD), 20, (RS1), 0, 0, (RS2))
|
||||
#define SUBCCrir(RS1, IMM, RD) _2i ((RD), 20, (RS1), 1, (IMM))
|
||||
#define SUBXrrr(RS1, RS2, RD) _2 ((RD), 12, (RS1), 0, 0, (RS2))
|
||||
#define SUBXrir(RS1, IMM, RD) _2i ((RD), 12, (RS1), 1, (IMM))
|
||||
#define SUBXCCrrr(RS1, RS2, RD) _2 ((RD), 28, (RS1), 0, 0, (RS2))
|
||||
#define SUBXCCrir(RS1, IMM, RD) _2i ((RD), 28, (RS1), 1, (IMM))
|
||||
|
||||
#define UDIVrrr(RS1, RS2, RD) _2 ((RD), 14, (RS1), 0, 0, (RS2))
|
||||
#define UDIVrir(RS1, IMM, RD) _2i ((RD), 14, (RS1), 1, (IMM))
|
||||
#define UDIVCCrrr(RS1, RS2, RD) _2 ((RD), 30, (RS1), 0, 0, (RS2))
|
||||
#define UDIVCCrir(RS1, IMM, RD) _2i ((RD), 30, (RS1), 1, (IMM))
|
||||
#define UMULrrr(RS1, RS2, RD) _2 ((RD), 10, (RS1), 0, 0, (RS2))
|
||||
#define UMULrir(RS1, IMM, RD) _2i ((RD), 10, (RS1), 1, (IMM))
|
||||
#define UMULCCrrr(RS1, RS2, RD) _2 ((RD), 26, (RS1), 0, 0, (RS2))
|
||||
#define UMULCCrir(RS1, IMM, RD) _2i ((RD), 26, (RS1), 1, (IMM))
|
||||
|
||||
#define WRrri(RS1, RS2, RD) _2 (0, (RD)|0x30, RS1, 0, 0, (RS2))
|
||||
#define WRrii(RS1, IMM, RD) _2i (0, (RD)|0x30, RS1, 1, (IMM))
|
||||
|
||||
#define XORrrr(RS1, RS2, RD) _2 ((RD), 3, (RS1), 0, 0, (RS2))
|
||||
#define XORrir(RS1, IMM, RD) _2i ((RD), 3, (RS1), 1, (IMM))
|
||||
#define XORCCrrr(RS1, RS2, RD) _2 ((RD), 19, (RS1), 0, 0, (RS2))
|
||||
#define XORCCrir(RS1, IMM, RD) _2i ((RD), 19, (RS1), 1, (IMM))
|
||||
|
||||
/* synonyms */
|
||||
|
||||
#define Bi(DISP) BAi((DISP))
|
||||
#define B_Ai(DISP) BA_Ai((DISP))
|
||||
#define BNZi(DISP) BNEi((DISP))
|
||||
#define BNZ_Ai(DISP) BNE_Ai((DISP))
|
||||
#define BZi(DISP) BEi((DISP))
|
||||
#define BZ_Ai(DISP) BE_Ai((DISP))
|
||||
#define BGEUi(DISP) BCCi((DISP))
|
||||
#define BGEU_Ai(DISP) BCC_Ai((DISP))
|
||||
#define BLUi(DISP) BCSi((DISP))
|
||||
#define BLU_Ai(DISP) BCS_Ai((DISP))
|
||||
|
||||
#define LDUWxr(RS1, RS2, RD) LDxr((RS1), (RS2), (RD))
|
||||
#define LDUWmr(RS1, IMM, RD) LDmr((RS1), (IMM), (RD))
|
||||
#define LDSWxr(RS1, RS2, RD) LDxr((RS1), (RS2), (RD))
|
||||
#define LDSWmr(RS1, IMM, RD) LDmr((RS1), (IMM), (RD))
|
||||
|
||||
#define STWrx(RS, RD1, RD2) STrx((RS), (RD1), (RD2))
|
||||
#define STWrm(RS, RD, IMM) STrm((RS), (RD), (IMM))
|
||||
|
||||
/* synthetic instructions [Table A-1, page 85] */
|
||||
|
||||
#define BCLRrr(R,S) ANDNrrr((R), (S), (S))
|
||||
#define BCLRir(I,R) ANDNrir((R), (I), (R))
|
||||
#define BSETrr(R,S) ORrrr((R), (S), (S))
|
||||
#define BSETir(I,R) ORrir((R), (I), (R))
|
||||
#define BTOGrr(R,S) XORrrr((R), (S), (S))
|
||||
#define BTOGir(I,R) XORrir((R), (I), (R))
|
||||
#define BTSTrr(R,S) ANDCCrrr((R), (S), 0)
|
||||
#define BTSTir(I,R) ANDCCrir((R), (I), 0)
|
||||
|
||||
#define CALLm(R,I) JMPLmr((R), (I), _Ro(7))
|
||||
#define CALLx(R,S) JMPLxr((R), (S), _Ro(7))
|
||||
|
||||
#define CLRr(R) ORrrr(0, 0, (R))
|
||||
#define CLRBm(R,I) STBrm(0, (R), (I))
|
||||
#define CLRBx(R,S) STBrm(0, (R), (S))
|
||||
#define CLRHm(R,I) STHrm(0, (R), (I))
|
||||
#define CLRHx(R,S) STHrm(0, (R), (S))
|
||||
#define CLRm(R,I) STrm(0, (R), (I))
|
||||
#define CLRx(R,S) STrm(0, (R), (S))
|
||||
|
||||
#define CMPrr(RS1, RS2) SUBCCrrr((RS1), (RS2), 0)
|
||||
#define CMPri(RS1, IMM) SUBCCrir((RS1), (IMM), 0)
|
||||
|
||||
#define DECr(R) SUBrir((R), 1, (R))
|
||||
#define DECir(I,R) SUBrir((R), (I), (R))
|
||||
#define DECCCr(R) SUBCCrir((R), 1, (R))
|
||||
#define DECCCir(I,R) SUBCCrir((R), (I), (R))
|
||||
|
||||
#define INCr(R) ADDrir((R), 1, (R))
|
||||
#define INCir(I,R) ADDrir((R), (I), (R))
|
||||
#define INCCCr(R) ADDCCrir((R), 1, (R))
|
||||
#define INCCCir(I,R) ADDCCrir((R), (I), (R))
|
||||
|
||||
#define JMPm(R,I) JMPLmr((R), (I), 0)
|
||||
#define JMPx(R,S) JMPLxr((R), (S), 0)
|
||||
|
||||
#define MOVrr(R,S) ORrrr(0, (R), (S))
|
||||
#define MOVir(I, R) ORrir(0, (I), (R))
|
||||
|
||||
#define NEGrr(R,S) SUBrrr(0, (R), (S))
|
||||
#define NEGr(R) SUBrrr(0, (R), (R))
|
||||
#define NOP() SETHIir(0, 0)
|
||||
|
||||
#define NOTrr(R,S) XNORrrr((R), 0, (S))
|
||||
#define NOTr(R) XNORrrr((R), 0, (R))
|
||||
|
||||
#define RESTORE() RESTORErrr(0, 0, 0)
|
||||
#define RET() JMPLmr(_Ri(7),8 ,0)
|
||||
#define RETL() JMPLmr(_Ro(7),8 ,0)
|
||||
|
||||
#define SAVE() SAVErrr(0, 0, 0)
|
||||
#define SETir(I,R) (_siP(13,(I)) ? MOVir((I),(R)) : SETir2(_HI(I), _LO(I), (R)))
|
||||
#define SETir2(H,L,R) (SETHIir(H,R), (L ? ORrir(R,L,R) : 0))
|
||||
|
||||
/* BNZ,a executes the delay instruction if NZ (so skips if Z)
|
||||
* BZ,a executes the delay instruction if Z (so skips if NZ). */
|
||||
#define SKIPZ() _0d (1, 9, 2, 2) /* BNZ,a .+8 */
|
||||
#define SKIPNZ() _0d (1, 1, 2, 2) /* BZ,a .+8 */
|
||||
#define SKIP() _0d (1, 0, 2, 0) /* BN,a . */
|
||||
|
||||
#define TSTr(R) ORCCrrr(0, (R), 0)
|
||||
|
||||
#define WRii(IMM, RD) WRrii(0, (IMM), (RD))
|
||||
#define WRri(RS2, RD) WRrri(0, (RS2), (RD))
|
||||
|
||||
#endif /* __ccg_asm_sparc_h */
|
||||
283
lightning/sparc/core.h
Normal file
283
lightning/sparc/core.h
Normal file
|
|
@ -0,0 +1,283 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer (Sparc version)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
#ifndef __lightning_core_h
|
||||
#define __lightning_core_h
|
||||
|
||||
#define JIT_R0 _Rl(0)
|
||||
#define JIT_R1 _Rl(1)
|
||||
#define JIT_R2 _Rl(2)
|
||||
#define JIT_V0 _Rl(3)
|
||||
#define JIT_V1 _Rl(4)
|
||||
#define JIT_V2 _Rl(5)
|
||||
#define JIT_BIG _Rg(1) /* %g1 used to make 32-bit operands */
|
||||
#define JIT_BIG2 _Rg(2) /* %g2 used to make 32-bit compare operands */
|
||||
#define JIT_SP _Ro(6)
|
||||
#define JIT_RZERO _Rg(0)
|
||||
#define JIT_RET _Ri(0)
|
||||
|
||||
/* Delay slot scheduling: jmp generates branches with annulled delay
|
||||
* slots; we toggle the annul bit if we can fill the slot. CALLs and
|
||||
* cond. branches have a different meaning for the annul bit, so we
|
||||
* automatically generate a NOP and eventually copy the delay insn onto
|
||||
* it. Delay slots in RET are already used for RESTORE, so we don't
|
||||
* schedule them.
|
||||
*
|
||||
* ,--- _jit.pc
|
||||
* insn X X before
|
||||
* cmp branch insn X X after (branch)
|
||||
* `--- _jit.pc
|
||||
* call insn insn X after (call)
|
||||
* `--- _jit.pc
|
||||
*/
|
||||
|
||||
struct jit_local_state {
|
||||
int nextarg_put; /* Next %o reg. to be written */
|
||||
int nextarg_get; /* Next %i reg. to be read */
|
||||
jit_insn delay;
|
||||
};
|
||||
|
||||
#define jit_fill_delay_after(branch) (_jitl.delay = *--_jit.pc, \
|
||||
((branch) == _jit.pc /* check if NOP was inserted */ \
|
||||
? (_jit.pc[-1] ^= 1<<29) /* no if branch, toggle annul bit */ \
|
||||
: (_jit.pc[-1] = _jitl.delay)), /* yes if call, replace NOP with delay insn */ \
|
||||
*_jit.pc = _jitl.delay, _jit.pc - 1) /* return addr of delay insn */
|
||||
|
||||
/* If possible, use the `small' instruction (rs, imm, rd)
|
||||
* else load imm into %l6 and use the `big' instruction (rs, %l6, rd)
|
||||
* jit_chk_imm2 uses %l7 instead of %l6 to avoid conflicts when using delay slots
|
||||
*/
|
||||
#define jit_chk_imm(imm, small, big) (_siP(13,(imm)) ? (small) : (SETir((imm), JIT_BIG), (big)) )
|
||||
#define jit_chk_imm2(imm, small, big) (_siP(13,(imm)) ? (small) : (SETir((imm), JIT_BIG2), (big)) )
|
||||
|
||||
/* Helper macros for branches */
|
||||
#define jit_branchi(rs, is, jmp, nop) (jit_chk_imm2(is, CMPri(rs, is), CMPrr(rs, JIT_BIG2)), jmp, nop, _jit.pc - 1)
|
||||
#define jit_branchr(s1, s2, jmp, nop) ( CMPrr(s1, s2), jmp, nop, _jit.pc - 1)
|
||||
|
||||
/* Helper macros for boolean tests -- delay slot sets d to 1;
|
||||
* taken branch leaves it to 1, not-taken branch resets it to 0 */
|
||||
#define jit_booli(d, rs, is, jmp) (jit_chk_imm (is, CMPri(rs, is), CMPrr(rs, JIT_BIG)), jmp, MOVir(1, (d)), MOVir(0, (d)))
|
||||
#define jit_boolr(d, s1, s2, jmp) ( CMPrr(s1, s2), jmp, MOVir(1, (d)), MOVir(0, (d)))
|
||||
|
||||
/* Helper macros for division
|
||||
* The architecture specifies that there must be 3 instructions between *
|
||||
* a y register write and a use of it for correct results. */
|
||||
#define jit_prepare_y(rs, is) (SRArir(rs, 31, JIT_BIG), WRri(JIT_BIG, _y), NOP(), NOP(), NOP(), _jit.pc -= jit_immsize(is))
|
||||
#define jit_clr_y(rs, is) ( WRri(0, _y), NOP(), NOP(), NOP(), _jit.pc -= jit_immsize(is))
|
||||
|
||||
/* How many instruction are needed by `set imm, %l6' */
|
||||
#define jit_immsize(imm) (_siP(13, (imm)) ? 0 : \
|
||||
((imm) & 0x3ff ? 2 : 1))
|
||||
|
||||
|
||||
/* branch instructions return the address of the *delay* instruction -- this
|
||||
* is just a helper macro that makes jit_patch more readable.
|
||||
*/
|
||||
#define jit_patch_(jump_pc) \
|
||||
(*jump_pc &= ~_MASK(22), \
|
||||
*jump_pc |= ((_UL(_jit.pc) - _UL(jump_pc)) >> 2) & _MASK(22))
|
||||
|
||||
/* helper macros for remainder -- it is said that _rem and _urem
|
||||
* trash the output registers
|
||||
*
|
||||
* jit_modr jit_modi
|
||||
*-----------------------------------------------------------------------------
|
||||
* mov %o0, %l7 mov %o0, %l7 ! save o0
|
||||
* mov s1, %o0 mov rs, %o0
|
||||
* mov %o1, %l6 ! save o1
|
||||
* mov s2, %o1
|
||||
* save %sp, -96, %sp save %sp, -96, %sp ! switch window
|
||||
* mov %i1, %o1 set is, %o1 ! transfer/set divisor
|
||||
* call f ! call the function
|
||||
* mov %i0, %o0 mov %i0, %o0 ! transfer dividend
|
||||
* mov %o0, %i0 mov %o0, %i0 ! transfer result
|
||||
* restore restore ! switch to old window
|
||||
* mov %o0, d mov %o0, d ! store result
|
||||
* mov %l7, %o0 mov %o0, %l7 ! restore o0
|
||||
* mov %l6, %o1 ! restore o1
|
||||
*/
|
||||
#define jit_mod(d, rs, f, before_save, set_o1, at_end) ( \
|
||||
MOVrr(_Ro(0), _Rl(7)), \
|
||||
MOVrr(rs, _Ro(0)), \
|
||||
before_save, \
|
||||
SAVErir(JIT_SP, -96, JIT_SP), \
|
||||
set_o1, \
|
||||
CALLi( (unsigned long) f), \
|
||||
MOVrr(_Ri(0), _Ro(0)), \
|
||||
MOVrr(_Ro(0), _Ri(0)), \
|
||||
RESTORE(), \
|
||||
MOVrr(_Ro(0), d), \
|
||||
MOVrr(_Rl(7), _Ro(0)), \
|
||||
at_end) \
|
||||
|
||||
#define jit_modi(d, rs, is, f) jit_mod(d, s1, f, 0, SETir((is), _Ro(1)), 0)
|
||||
#define jit_modr(d, s1, s2, f) jit_mod(d, s1, f, (MOVrr(_Ro(1), _Rl(6)), MOVrr(s2, _Ro(1)), MOVrr(_Ri(1), _Ro(1)), MOVrr(_Rl(6), _Ro(1)) ))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define jit_arg_c() (_jitl.nextarg_get++)
|
||||
#define jit_arg_i() (_jitl.nextarg_get++)
|
||||
#define jit_arg_l() (_jitl.nextarg_get++)
|
||||
#define jit_arg_p() (_jitl.nextarg_get++)
|
||||
#define jit_arg_s() (_jitl.nextarg_get++)
|
||||
#define jit_arg_uc() (_jitl.nextarg_get++)
|
||||
#define jit_arg_ui() (_jitl.nextarg_get++)
|
||||
#define jit_arg_ul() (_jitl.nextarg_get++)
|
||||
#define jit_arg_us() (_jitl.nextarg_get++)
|
||||
#define jit_addi_i(d, rs, is) jit_chk_imm((is), ADDrir((rs), (is), (d)), ADDrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_addr_i(d, s1, s2) ADDrrr((s1), (s2), (d))
|
||||
#define jit_addci_i(d, rs, is) jit_chk_imm((is), ADDCCrir((rs), (is), (d)), ADDCCrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_addcr_i(d, s1, s2) ADDCCrrr((s1), (s2), (d))
|
||||
#define jit_addxi_i(d, rs, is) jit_chk_imm((is), ADDXCCrir((rs), (is), (d)), ADDXCCrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_addxr_i(d, s1, s2) ADDXCCrrr((s1), (s2), (d))
|
||||
#define jit_andi_i(d, rs, is) jit_chk_imm((is), ANDrir((rs), (is), (d)), ANDrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_andr_i(d, s1, s2) ANDrrr((s1), (s2), (d))
|
||||
#define jit_beqi_i(label, rs, is) jit_branchi((rs), (is), BEi((label)), NOP() )
|
||||
#define jit_beqr_i(label, s1, s2) jit_branchr((s1), (s2), BEi((label)), NOP() )
|
||||
#define jit_bgei_i(label, rs, is) jit_branchi((rs), (is), BGEi((label)), NOP() )
|
||||
#define jit_bgei_ui(label, rs, is) jit_branchi((rs), (is), BGEUi((label)), NOP() )
|
||||
#define jit_bger_i(label, s1, s2) jit_branchr((s1), (s2), BGEi((label)), NOP() )
|
||||
#define jit_bger_ui(label, s1, s2) jit_branchr((s1), (s2), BGEUi((label)), NOP() )
|
||||
#define jit_bgti_i(label, rs, is) jit_branchi((rs), (is), BGi((label)), NOP() )
|
||||
#define jit_bgti_ui(label, rs, is) jit_branchi((rs), (is), BGUi((label)), NOP() )
|
||||
#define jit_bgtr_i(label, s1, s2) jit_branchr((s1), (s2), BGi((label)), NOP() )
|
||||
#define jit_bgtr_ui(label, s1, s2) jit_branchr((s1), (s2), BGUi((label)), NOP() )
|
||||
#define jit_blei_i(label, rs, is) jit_branchi((rs), (is), BLEi((label)), NOP() )
|
||||
#define jit_blei_ui(label, rs, is) jit_branchi((rs), (is), BLEUi((label)), NOP() )
|
||||
#define jit_bler_i(label, s1, s2) jit_branchr((s1), (s2), BLEi((label)), NOP() )
|
||||
#define jit_bler_ui(label, s1, s2) jit_branchr((s1), (s2), BLEUi((label)), NOP() )
|
||||
#define jit_blti_i(label, rs, is) jit_branchi((rs), (is), BLi((label)), NOP() )
|
||||
#define jit_blti_ui(label, rs, is) jit_branchi((rs), (is), BLUi((label)), NOP() )
|
||||
#define jit_bltr_i(label, s1, s2) jit_branchr((s1), (s2), BLi((label)), NOP() )
|
||||
#define jit_bltr_ui(label, s1, s2) jit_branchr((s1), (s2), BLUi((label)), NOP() )
|
||||
#define jit_bnei_i(label, rs, is) jit_branchi((rs), (is), BNEi((label)), NOP() )
|
||||
#define jit_bner_i(label, s1, s2) jit_branchr((s1), (s2), BNEi((label)), NOP() )
|
||||
#define jit_bmsi_i(label, rs, is) (jit_chk_imm((is), BTSTir((is), (rs)), BTSTrr((rs), JIT_BIG)), BNEi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bmci_i(label, rs, is) (jit_chk_imm((is), BTSTir((is), (rs)), BTSTrr((rs), JIT_BIG)), BEi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bmsr_i(label, s1, s2) ( BTSTrr((s1), (s2)), BNEi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bmcr_i(label, s1, s2) ( BTSTrr((s1), (s2)), BEi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_boaddi_i(label, rs, is) (jit_chk_imm((is), ADDCCrir((rs), (is), (rs)), ADDCCrrr((rs), JIT_BIG, (rs))), BVSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bosubi_i(label, rs, is) (jit_chk_imm((is), SUBCCrir((rs), (is), (rs)), SUBCCrrr((rs), JIT_BIG, (rs))), BVSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_boaddr_i(label, s1, s2) ( ADDCCrrr((s1), (s2), (s1)), BVSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bosubr_i(label, s1, s2) ( SUBCCrrr((s1), (s2), (s1)), BVSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_boaddi_ui(label, rs, is) (jit_chk_imm((is), ADDCCrir((rs), (is), (rs)), ADDCCrrr((rs), JIT_BIG, (rs))), BCSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bosubi_ui(label, rs, is) (jit_chk_imm((is), SUBCCrir((rs), (is), (rs)), SUBCCrrr((rs), JIT_BIG, (rs))), BCSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_boaddr_ui(label, s1, s2) ( ADDCCrrr((s1), (s2), (s1)), BCSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_bosubr_ui(label, s1, s2) ( SUBCCrrr((s1), (s2), (s1)), BCSi((label)), NOP(), _jit.pc - 1)
|
||||
#define jit_calli(label) (CALLi(label), NOP(), _jit.pc - 1)
|
||||
#define jit_divi_i(d, rs, is) (jit_prepare_y((rs), (is)), jit_chk_imm((is), SDIVrir((rs), (is), (d)), SDIVrrr((rs), JIT_BIG, (d))) )
|
||||
#define jit_divi_ui(d, rs, is) (jit_clr_y((rs)), (is)), jit_chk_imm((is), UDIVrir((rs), (is), (d)), UDIVrrr((rs), JIT_BIG, (d))) )
|
||||
#define jit_divr_i(d, s1, s2) (jit_prepare_y((s1), 3), SDIVrrr((s1), (s2), (d)))
|
||||
#define jit_divr_ui(d, s1, s2) (jit_clr_y((s1), 3), UDIVrrr((s1), (s2), (d)))
|
||||
#define jit_eqi_i(d, rs, is) jit_chk_imm((is), \
|
||||
(SUBCCrir((rs), (is), (d)), ADDXCCrir((d), -1, JIT_BIG), SUBXrir(0,-1,(d))),\
|
||||
jit_eqr_i(d, rs, JIT_BIG))
|
||||
#define jit_eqr_i(d, s1, s2) (SUBCCrrr((s1), (s2), (d)), ADDXCCrir((d), -1, JIT_BIG), SUBXrir(0,-1,(d)))
|
||||
#define jit_nei_i(d, rs, is) jit_chk_imm((is), \
|
||||
(SUBCCrir((rs), (is), (d)), ADDXCCrir((d), -1, JIT_BIG), ADDXrrr(0,0,(d))),\
|
||||
jit_ner_i(d, rs, JIT_BIG))
|
||||
#define jit_ner_i(d, s1, s2) (SUBCCrrr((s1), (s2), (d)), ADDXCCrir((d), -1, JIT_BIG), ADDXrrr(0,0,(d)))
|
||||
#define jit_gei_i(d, rs, is) jit_booli ((d), (rs), (is), BGEi(_jit.pc + 3) )
|
||||
#define jit_gei_ui(d, rs, is) jit_booli ((d), (rs), (is), BGEUi(_jit.pc + 3))
|
||||
#define jit_ger_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BGEi(_jit.pc + 3) )
|
||||
#define jit_ger_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BGEUi(_jit.pc + 3))
|
||||
#define jit_gti_i(d, rs, is) jit_booli ((d), (rs), (is), BGi(_jit.pc + 3) )
|
||||
#define jit_gti_ui(d, rs, is) jit_booli ((d), (rs), (is), BGUi(_jit.pc + 3) )
|
||||
#define jit_gtr_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BGi(_jit.pc + 3) )
|
||||
#define jit_gtr_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BGUi(_jit.pc + 3) )
|
||||
#define jit_hmuli_i(d, rs, is) (jit_muli_i (JIT_BIG, (rs), (is)), RDir (_y, (d)))
|
||||
#define jit_hmuli_ui(d, rs, is) (jit_muli_ui(JIT_BIG, (rs), (is)), RDir (_y, (d)))
|
||||
#define jit_hmulr_i(d, s1, s2) (jit_mulr_i (JIT_BIG, (s1), (s2)), RDir (_y, (d)))
|
||||
#define jit_hmulr_ui(d, s1, s2) (jit_mulr_ui(JIT_BIG, (s1), (s2)), RDir (_y, (d)))
|
||||
#define jit_jmpi(label) (BA_Ai((label)), _jit.pc)
|
||||
#define jit_jmpr(reg) (JMPx(JIT_RZERO, (reg)), NOP(), _jit.pc - 1)
|
||||
#define jit_ldxi_c(d, rs, is) jit_chk_imm((is), LDSBmr((rs), (is), (d)), LDSBxr((rs), JIT_BIG, (d)))
|
||||
#define jit_ldxi_i(d, rs, is) jit_chk_imm((is), LDSWmr((rs), (is), (d)), LDSWxr((rs), JIT_BIG, (d)))
|
||||
#define jit_ldxi_s(d, rs, is) jit_chk_imm((is), LDSHmr((rs), (is), (d)), LDSHxr((rs), JIT_BIG, (d)))
|
||||
#define jit_ldxi_uc(d, rs, is) jit_chk_imm((is), LDUBmr((rs), (is), (d)), LDUBxr((rs), JIT_BIG, (d)))
|
||||
#define jit_ldxi_us(d, rs, is) jit_chk_imm((is), LDUHmr((rs), (is), (d)), LDUHxr((rs), JIT_BIG, (d)))
|
||||
#define jit_ldxr_c(d, s1, s2) LDSBxr((s1), (s2), (d))
|
||||
#define jit_ldxr_i(d, s1, s2) LDSWxr((s1), (s2), (d))
|
||||
#define jit_ldxr_s(d, s1, s2) LDSHxr((s1), (s2), (d))
|
||||
#define jit_ldxr_uc(d, s1, s2) LDUBxr((s1), (s2), (d))
|
||||
#define jit_ldxr_us(d, s1, s2) LDUHxr((s1), (s2), (d))
|
||||
#define jit_lei_i(d, rs, is) jit_booli ((d), (rs), (is), BLEi(_jit.pc + 3) )
|
||||
#define jit_lei_ui(d, rs, is) jit_booli ((d), (rs), (is), BLEUi(_jit.pc + 3))
|
||||
#define jit_ler_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BLEi(_jit.pc + 3) )
|
||||
#define jit_ler_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BLEUi(_jit.pc + 3))
|
||||
#define jit_lshi_i(d, rs, is) SLLrir((rs), (is), (d))
|
||||
#define jit_lshr_i(d, r1, r2) SLLrrr((r1), (r2), (d))
|
||||
#define jit_lti_i(d, rs, is) jit_booli ((d), (rs), (is), BLi(_jit.pc + 3) )
|
||||
#define jit_lti_ui(d, rs, is) jit_booli ((d), (rs), (is), BLUi(_jit.pc + 3) )
|
||||
#define jit_ltr_i(d, s1, s2) jit_boolr ((d), (s1), (s2), BLi(_jit.pc + 3) )
|
||||
#define jit_ltr_ui(d, s1, s2) jit_boolr ((d), (s1), (s2), BLUi(_jit.pc + 3) )
|
||||
#define jit_modi_i(d, rs, is) jit_modi((d), (rs), (is), _rem)
|
||||
#define jit_modi_ui(d, rs, is) jit_modi((d), (rs), (is), _urem)
|
||||
#define jit_modr_i(d, s1, s2) jit_modr((d), (s1), (s2), _rem)
|
||||
#define jit_modr_ui(d, s1, s2) jit_modr((d), (s1), (s2), _urem)
|
||||
#define jit_movi_i(d, is) SETir((is), (d))
|
||||
#define jit_movr_i(d, rs) MOVrr((rs), (d))
|
||||
#define jit_muli_i(d, rs, is) jit_chk_imm((is), SMULrir((rs), (is), (d)), SMULrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_muli_ui(d, rs, is) jit_chk_imm((is), UMULrir((rs), (is), (d)), UMULrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_mulr_i(d, s1, s2) SMULrrr((s1), (s2), (d))
|
||||
#define jit_mulr_ui(d, s1, s2) UMULrrr((s1), (s2), (d))
|
||||
#define jit_nop() NOP()
|
||||
#define jit_ori_i(d, rs, is) jit_chk_imm((is), ORrir((rs), (is), (d)), ORrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_orr_i(d, s1, s2) ORrrr((s1), (s2), (d))
|
||||
#define jit_patch(delay_pc) jit_patch_ ( ((delay_pc) - 1) )
|
||||
#define jit_popr_i(rs) (LDmr(JIT_SP, 0, (rs)), ADDrir(JIT_SP, 8, JIT_SP))
|
||||
#define jitfp_prepare(numargs, nf, nd) (_jitl.nextarg_put = (numargs))
|
||||
#define jit_prolog(numargs) (SAVErir(JIT_SP, -96, JIT_SP), _jitl.nextarg_get = _Ri(0))
|
||||
#define jit_pushr_i(rs) (STrm((rs), JIT_SP, -8), SUBrir(JIT_SP, 8, JIT_SP))
|
||||
#define jit_pusharg_i(rs) (--_jitl.nextarg_put, MOVrr((rs), _Ro(_jitl.nextarg_put)))
|
||||
#define jit_ret() (RET(), RESTORE())
|
||||
#define jit_retval(rd) MOVrr(_Ro(0), (rd))
|
||||
#define jit_rshi_i(d, rs, is) SRArir((rs), (is), (d))
|
||||
#define jit_rshi_ui(d, rs, is) SRLrir((rs), (is), (d))
|
||||
#define jit_rshr_i(d, r1, r2) SRArrr((r1), (r2), (d))
|
||||
#define jit_rshr_ui(d, r1, r2) SRLrrr((r1), (r2), (d))
|
||||
#define jit_stxi_c(id, rd, rs) jit_chk_imm((id), STBrm((rs), (rd), (id)), STBrx((rs), (rd), JIT_BIG))
|
||||
#define jit_stxi_i(id, rd, rs) jit_chk_imm((id), STWrm((rs), (rd), (id)), STWrx((rs), (rd), JIT_BIG))
|
||||
#define jit_stxi_s(id, rd, rs) jit_chk_imm((id), STHrm((rs), (rd), (id)), STHrx((rs), (rd), JIT_BIG))
|
||||
#define jit_stxr_c(d1, d2, rs) STBrx((rs), (d1), (d2))
|
||||
#define jit_stxr_i(d1, d2, rs) STWrx((rs), (d1), (d2))
|
||||
#define jit_stxr_s(d1, d2, rs) STHrx((rs), (d1), (d2))
|
||||
#define jit_subr_i(d, s1, s2) SUBrrr((s1), (s2), (d))
|
||||
#define jit_subcr_i(d, s1, s2) SUBCCrrr((s1), (s2), (d))
|
||||
#define jit_subxi_i(d, rs, is) jit_chk_imm((is), SUBXCCrir((rs), (is), (d)), SUBXCCrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_subxr_i(d, s1, s2) SUBXCCrrr((s1), (s2), (d))
|
||||
#define jit_xori_i(d, rs, is) jit_chk_imm((is), XORrir((rs), (is), (d)), XORrrr((rs), JIT_BIG, (d)))
|
||||
#define jit_xorr_i(d, s1, s2) XORrrr((s1), (s2), (d))
|
||||
|
||||
#endif /* __lightning_core_h */
|
||||
163
lightning/sparc/fp.h
Normal file
163
lightning/sparc/fp.h
Normal file
|
|
@ -0,0 +1,163 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Run-time assembler & support macros for the PowerPC math unit
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_asm_fp_h
|
||||
#define __lightning_asm_fp_h
|
||||
|
||||
#if 0
|
||||
|
||||
/* dummy for now */
|
||||
|
||||
#define _FP1(RD, RS1, OPF, RS2) _2f((RD), 52, (RS1), (OPF), (RS2))
|
||||
#define _FP2(RD, RS1, OPF, RS2) _2f((RD), 53, (RS1), (OPF), (RS2))
|
||||
|
||||
#define FITODrr(FRS, FRD) _FP1((FRD), 0, 200, (FRS))
|
||||
#define FDTOIrr(FRS, FRD) _FP1((FRD), 0, 210, (FRS))
|
||||
#define FSTODrr(FRS, FRD) _FP1((FRD), 0, 201, (FRS))
|
||||
#define FDTOSrr(FRS, FRD) _FP1((FRD), 0, 198, (FRS))
|
||||
#define FMOVSrr(FRS, FRD) _FP1((FRD), 0, 1, (FRS))
|
||||
#define FNEGSrr(FRS, FRD) _FP1((FRD), 0, 5, (FRS))
|
||||
#define FABSSrr(FRS, FRD) _FP1((FRD), 0, 9, (FRS))
|
||||
#define FSQRTDrr(FRS, FRD) _FP1((FRD), 0, 74, (FRS))
|
||||
|
||||
#define FADDDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 66, (FRS2))
|
||||
#define FSUBDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 70, (FRS2))
|
||||
#define FMULDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 82, (FRS2))
|
||||
#define FDIVDrrr(FRS1, FRS2, FRD) _FP1((FRD), (FRS1), 86, (FRS2))
|
||||
|
||||
#define FCMPDrr(FRS1, FRS2) _FP2(0, (FRS1), 82, (FRS2))
|
||||
|
||||
#define LDFxr(RS1, RS2, RD) _3 ((RD), 32, (RS1), 0, 0, (RS2))
|
||||
#define LDFmr(RS1, IMM, RD) _3i ((RD), 32, (RS1), 1, (IMM))
|
||||
#define LDDFxr(RS1, RS2, RD) _3 ((RD), 35, (RS1), 0, 0, (RS2))
|
||||
#define LDDFmr(RS1, IMM, RD) _3i ((RD), 35, (RS1), 1, (IMM))
|
||||
#define STFrx(RS, RD1, RD2) _3 ((RS), 36, (RD1), 0, 0, (RD2))
|
||||
#define STFrm(RS, RD1, IMM) _3i ((RS), 36, (RD1), 1, (IMM))
|
||||
#define STDFrx(RS, RD1, RD2) _3 ((RS), 39, (RD1), 0, 0, (RD2))
|
||||
#define STDFrm(RS, RD1, IMM) _3i ((RS), 39, (RD1), 1, (IMM))
|
||||
|
||||
#define FBNi(DISP) _0 (0, 0, 6, (DISP))
|
||||
#define FBN_Ai(DISP) _0 (1, 0, 6, (DISP))
|
||||
#define FBNEi(DISP) _0 (0, 1, 6, (DISP))
|
||||
#define FBNE_Ai(DISP) _0 (1, 1, 6, (DISP))
|
||||
#define FBLGi(DISP) _0 (0, 2, 6, (DISP))
|
||||
#define FBLG_Ai(DISP) _0 (1, 2, 6, (DISP))
|
||||
#define FBULi(DISP) _0 (0, 3, 6, (DISP))
|
||||
#define FBUL_Ai(DISP) _0 (1, 3, 6, (DISP))
|
||||
#define FBLi(DISP) _0 (0, 4, 6, (DISP))
|
||||
#define FBL_Ai(DISP) _0 (1, 4, 6, (DISP))
|
||||
#define FBUGi(DISP) _0 (0, 5, 6, (DISP))
|
||||
#define FBUG_Ai(DISP) _0 (1, 5, 6, (DISP))
|
||||
#define FBGi(DISP) _0 (0, 6, 6, (DISP))
|
||||
#define FBG_Ai(DISP) _0 (1, 6, 6, (DISP))
|
||||
#define FBUi(DISP) _0 (0, 7, 6, (DISP))
|
||||
#define FBU_Ai(DISP) _0 (1, 7, 6, (DISP))
|
||||
#define FBAi(DISP) _0 (0, 8, 6, (DISP))
|
||||
#define FBA_Ai(DISP) _0 (1, 8, 6, (DISP))
|
||||
#define FBEi(DISP) _0 (0, 9, 6, (DISP))
|
||||
#define FBE_Ai(DISP) _0 (1, 9, 6, (DISP))
|
||||
#define FBUEi(DISP) _0 (0, 10, 6, (DISP))
|
||||
#define FBUE_Ai(DISP) _0 (1, 10, 6, (DISP))
|
||||
#define FBGEi(DISP) _0 (0, 11, 6, (DISP))
|
||||
#define FBGE_Ai(DISP) _0 (1, 11, 6, (DISP))
|
||||
#define FBUGEi(DISP) _0 (0, 12, 6, (DISP))
|
||||
#define FBUGE_Ai(DISP) _0 (1, 12, 6, (DISP))
|
||||
#define FBLEi(DISP) _0 (0, 13, 6, (DISP))
|
||||
#define FBLE_Ai(DISP) _0 (1, 13, 6, (DISP))
|
||||
#define FBULEi(DISP) _0 (0, 14, 6, (DISP))
|
||||
#define FBULE_Ai(DISP) _0 (1, 14, 6, (DISP))
|
||||
#define FBOi(DISP) _0 (0, 15, 6, (DISP))
|
||||
#define FBO_Ai(DISP) _0 (1, 15, 6, (DISP))
|
||||
|
||||
#define FSKIPUG() _0d (1, 13, 6, 2) /* fble,a .+8 */
|
||||
#define FSKIPUL() _0d (1, 11, 6, 2) /* fbge,a .+8 */
|
||||
|
||||
#define jit_add_two(reg0) FADDDrrr(30 - (reg0) * 2, 28 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
#define jit_sub_two(reg0) FSUBDrrr(30 - (reg0) * 2, 28 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
#define jit_mul_two(reg0) FMULDrrr(30 - (reg0) * 2, 28 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
#define jit_div_two(reg0) FDIVDrrr(30 - (reg0) * 2, 28 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
|
||||
#define jit_abs(reg0) FABSSrr(30 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
#define jit_neg(reg0) FNEGSrr(30 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
#define jit_sqrt(reg0) FSQRTDrr(30 - (reg0) * 2, 30 - (reg0) * 2)
|
||||
|
||||
#define jit_fpimm(reg0, first, second) \
|
||||
(_1(4), NOP(), _L(first), _L(second), \
|
||||
jit_ldxi_d((reg0), _Ro(7), 8))
|
||||
|
||||
#define jit_ldxi_f(reg0, rs, is) (jit_chk_imm((is), LDFmr((rs), (is), 30 - (reg0) * 2), LDFxr((rs), JIT_BIG, 30 - (reg0) * 2)), FSTODrr(30 - (reg0) * 2, 30 - (reg0) * 2))
|
||||
#define jit_ldxi_d(reg0, rs, is) jit_chk_imm((is), LDDFmr((rs), (is), 30 - (reg0) * 2), LDDFxr((rs), JIT_BIG, 30 - (reg0) * 2))
|
||||
#define jit_ldxr_f(reg0, s1, s2) (LDFxr((s1), (s2), 30 - (reg0) * 2), FSTODrr(30 - (reg0) * 2, 30 - (reg0) * 2))
|
||||
#define jit_ldxr_d(reg0, s1, s2) LDDFxr((s1), (s2), 30 - (reg0) * 2)
|
||||
#define jit_stxi_f(id, rd, reg0) (FDTOSrr(30 - (reg0) * 2, 30 - (reg0) * 2), jit_chk_imm((id), STFrm(30 - (reg0) * 2, (rd), (id)), STFrx(30 - (reg0) * 2, (rd), JIT_BIG)))
|
||||
#define jit_stxi_d(id, rd, reg0) jit_chk_imm((id), STDFrm(30 - (reg0) * 2, (rd), (id)), STDFrx(30 - (reg0) * 2, (rd), JIT_BIG))
|
||||
#define jit_stxr_f(d1, d2, reg0) (FDTOSrr(30 - (reg0) * 2, 30 - (reg0) * 2), STFrx (30 - (reg0) * 2, (d1), (d2)))
|
||||
#define jit_stxr_d(d1, d2, reg0) STDFrx(30 - (reg0) * 2, (d1), (d2))
|
||||
|
||||
|
||||
#define jit_do_round(mode, rd, freg) ( \
|
||||
_1(3), \
|
||||
SETHIir(_HI(mode << 29), JIT_BIG), \
|
||||
NOP(), \
|
||||
STFSRm(_Ro(7), 8), /* store fsr */ \
|
||||
LDmr(_Ro(7), 8, rd), \
|
||||
XORrrr(rd, JIT_BIG, JIT_BIG), /* adjust mode */ \
|
||||
STrm(JIT_BIG, _Ro(7), 8), \
|
||||
LDFSRm(_Ro(7), 8), /* load fsr */ \
|
||||
FDTOIrr(freg, freg), /* truncate */ \
|
||||
STrm(rd, _Ro(7), 8), /* load old fsr */ \
|
||||
LDFSRm(_Ro(7), 8), \
|
||||
STFrm(freg, _Ro(7), 8), /* store truncated value */ \
|
||||
LDmr(_Ro(7), 8, rd)) /* load it into rd */
|
||||
|
||||
|
||||
/* call delay slot data ,--- call lands here */
|
||||
#define jit_exti_d(reg0, rs) (_1(3), NOP(), NOP(), STrm((rs), _Ro(7), 8), LDFmr(_Ro(7), 8, 30 - (reg0) * 2), FITODrr(30 - (reg0) * 2, 30 - (reg0) * 2))
|
||||
#define jit_round(rd, reg0) (_1(3), FDTOIrr(30 - (reg0) * 2, 30 - (reg0) * 2), NOP(), STFrm(30 - (reg0) * 2, _Ro(7), 8), LDmr(_Ro(7), 8, (rd)))
|
||||
#define jit_floor(rd, reg0) jit_do_round(3, (rd), (30 - (reg0) * 2))
|
||||
#define jit_ceil(rd, reg0) jit_do_round(2, (rd), (30 - (reg0) * 2))
|
||||
#define jit_trunc(rd, reg0) jit_do_round(1, (rd), (30 - (reg0) * 2))
|
||||
|
||||
static double jit_zero = 0.0;
|
||||
|
||||
#define jit_cmp(le, ge, reg0) (SETHIir(_HI(_UL(&jit_zero)), (le)), \
|
||||
LDDFmr((le), _LO(_UL(&jit_zero)), 28 - (reg0) * 2), \
|
||||
FCMPDrr(30 - (reg0) * 2, 28 - (reg0) * 2), \
|
||||
MOVir(0, (le)), MOVir(0, (ge)), \
|
||||
FSKIPUL(), MOVir(1, (ge)), \
|
||||
FSKIPUG(), MOVir(1, (le)))
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* __lightning_asm_fp_h */
|
||||
65
lightning/sparc/funcs.h
Normal file
65
lightning/sparc/funcs.h
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/******************************** -*- C -*- ****************************
|
||||
*
|
||||
* Platform-independent layer inline functions (Sparc)
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
|
||||
* Written by Paolo Bonzini.
|
||||
*
|
||||
* This file is part of GNU lightning.
|
||||
*
|
||||
* GNU lightning is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU Lesser General Public License as published
|
||||
* by the Free Software Foundation; either version 2.1, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* GNU lightning is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||
* License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with GNU lightning; see the file COPYING.LESSER; if not, write to the
|
||||
* Free Software Foundation, 59 Temple Place - Suite 330, Boston,
|
||||
* MA 02111-1307, USA.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
|
||||
|
||||
#ifndef __lightning_funcs_h
|
||||
#define __lightning_funcs_h
|
||||
|
||||
#if !defined(__GNUC__) && !defined(__GNUG__)
|
||||
#error Go get GNU C, I do not know how to flush the cache
|
||||
#error with this compiler.
|
||||
#else
|
||||
/* Why doesn't this compile?!?
|
||||
* static void
|
||||
* jit_flush_code(start, end)
|
||||
* void *start;
|
||||
* void *end;
|
||||
*/
|
||||
|
||||
static void
|
||||
jit_flush_code(void* start, void* end)
|
||||
{
|
||||
#ifndef LIGHTNING_CROSS
|
||||
register char *dest;
|
||||
|
||||
__asm__ __volatile__ ("stbar");
|
||||
for (dest = (char *)start; dest <= (char *)end; dest += 4) {
|
||||
__asm__ __volatile__ ("flush %0"::"r"(dest));
|
||||
}
|
||||
|
||||
/* [SPARC Architecture Manual v8, page 139, implementation note #5] */
|
||||
__asm__ __volatile__ ("nop; nop; nop; nop; nop");
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __lightning_core_h */
|
||||
|
|
@ -194,7 +194,7 @@ void *create_closure(void *func, size_t *argsizes, unsigned int *mapping, ...)
|
|||
}
|
||||
jit_finish(func);
|
||||
jit_ret();
|
||||
jit_flush_code(codeBuffer, jit_get_ip().ptr);
|
||||
jit_flush_code(codeBuf, jit_get_ip().ptr);
|
||||
|
||||
return closure;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue