preserve-emulation/simple64
1
0 Fork 0
mirror of https://github.com/simple64/simple64.git synced 2026-11-13 22:38:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

update parallel rsp

Browse Source
This commit is contained in:
Logan McNaughton committed 2022-08-19 20:39:48 -06:00
1 parent 94abbaa612
commit e55c90c04d
181 files changed
+1314 -18772
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

parallel-rsp/CMakeLists.txt
+2 -2
View File
@@ -97,8 +97,8 @@ if (PARALLEL_RSP_BAKED_LIGHTNING)
target_sources(lightning PRIVATE win32/mman/sys/mman.c)
target_include_directories(lightning PRIVATE win32/mman)
endif()
target_compile_options(lightning PRIVATE -march=x86-64-v3)
target_link_options(lightning PRIVATE -march=x86-64-v3)
target_compile_options(lightning PRIVATE -march=x86-64-v3 -DHAVE_MMAP)
target_link_options(lightning PRIVATE -march=x86-64-v3 -DHAVE_MMAP)
endif()
target_link_options(${NAME_PLUGIN_M64P} PRIVATE -march=x86-64-v3)
target_link_libraries(${NAME_PLUGIN_M64P} PUBLIC lightning)
parallel-rsp/lightning/.gitignore
+16 -5
View File
@@ -1,4 +1,15 @@
/build-aux
+*
*.o
*.lo
*.la
.libs/
.deps/
*/.libs/
*/.deps/
autom4te.cache
aclocal.m4
depcomp
@@ -20,14 +31,14 @@ missing
size
stamp-h1
test-driver
check/.deps
doc/.deps
lib/.deps
m4/libtool.m4
m4/lt~obsolete.m4
m4/ltoptions.m4
m4/ltsugar.m4
m4/ltversion.m4
doc/mdate-sh
doc/texinfo.tex
lightning.pc
include/lightning.h
build-aux/
parallel-rsp/lightning/.gitrepo
-12
View File
@@ -1,12 +0,0 @@
; DO NOT EDIT (unless you know what you are doing)
;
; This subdirectory is a git "subrepo", and this file is maintained by the
; git-subrepo command. See https://github.com/git-commands/git-subrepo#readme
;
[subrepo]
remote = https://git.savannah.gnu.org/git/lightning.git
branch = master
commit = b0b8eb5e856c0d29053dc842e1919a2eb58c8cda
parent = 9f797430963d9cf0fcef7d963466f9cac7026de2
method = merge
cmdver = 0.4.1
parallel-rsp/lightning/ChangeLog
+74 -13
View File
@@ -1,3 +1,64 @@
2022-08-12 Marc Nieper-Wißkirchen <marc@nieper-wisskirchen.de>
Document jit_align.
* doc/body.texi: Add documentation for jit_align.
2022-05-14 Paulo Andrade <pcpa@gnu.org>
* include/lightning.h.in: Reorder jit_mov{n,z}r in instruction list.
* lib/jit_alpha.c, lib/jit_alpha-cpu.c, lib/jit_hppa.c,
lib/jit_hppa-cpu.c, lib/jit_ia64.c, lib/jit_ia64-cpu.c,
lib/jit_riscv.c, lib/jit_riscv-cpu.c, lib/jit_s390.c,
lib/jit_s390-cpu.c, lib/jit_sparc.c, lib/jit_sparc-cpu.c:
Implement fallback jit_mov{n,z}r. These are a somewhat cheap
implementation, but should be reviewed for the arches that already
have a proper conditional move.
* lib/jit_arm-sz.c, lib/jit_mips-sz.c: Add missing maximum size
estimative and reorder.
* lib/jit_aarch64-sz.c, lib/jit_x86-sz.c, lib/jit_ppc-sz.c:
Reorder entry to match definition order.
* lib/jit_aarch64-sz.c, lib/jit_alpha-sz.c, lib/jit_hppa-sz.c,
lib/jit_ia64-sz.c, lib/jit_riscv-sz.c, lib/jit_s390-sz.c,
lib/jit_sparc-sz.c: Add heuristic value, basically the sum of
the cost of a movr + beqr.
* lib/jit_names.c: Add entries for debug output of mov{n,z}r.
* lib/lightning.c: Use proper bitmask in jit_classify.
2021-04-03 Marc Nieper-Wißkirchen <marc@nieper-wisskirchen.de>
* check/Makefile.am: Add test for the live instruction.
* check/live.ok: New file.
* check/live.tst: New file.
* doc/body.texi: Add documentation for the live instruction and
for jit_get_reg/jit_get_unreg. Fix menu entries.
* include/lightning.h.in (jit_get_reg, jit_unget_reg): Expose the
macros in the public header file.
* include/lightning/jit_private.h (jit_get_reg, jit_unget_reg):
Remove the macros from the private header file.
2021-04-03 Marc Nieper-Wißkirchen <marc@nieper-wisskirchen.de>
* Makefile.am, check/Makefile.am, doc/Makefile.am,
lib/Makefile.am: Include $(top_builddir)/include in include paths
for the autoconf-generated header file lightning.h.
2021-04-03 Marc Nieper-Wißkirchen <marc@nieper-wisskirchen.de>
* doc/.gitignore: Add version.texi to list of ignored files.
* doc/version.texi: Remove file from version control.
2020-18-04 Paulo Andrade <pcpa@gnu.org>
* lib/jit_x86-cpu.c, lib/jit_x86.c: Implement %rip relative
calls and jumps on x86_64. Currently very conservative, assuming
a jit block can be larger than 2G, so, if a jump or call is in
the same jit generation, but target is unknown, use an indirect
branch (could have an option to assume a jit code block is
never larger than 2G). Also a deoptimization is that now does
not always generate ip relative jmpi; previously implicitly
assumed jmpi would never be larger than 2G. Overall still an
optimization.
2020-23-01 Paulo Andrade <pcpa@gnu.org>
* lib/lightning.c: Add a proper fix to the condition of considering
@@ -26,7 +87,7 @@
to the set of registers to scan for live range, what might
consume a lot of cpu time, doing nothing.
2019-09-16 Marc Nieper-WiÃkirchen <marc@nieper-wisskirchen.de>
2019-09-16 Marc Nieper-Wißkirchen <marc@nieper-wisskirchen.de>
* include/lightning/jit_x86.h, lib/jit_x86.c: Correct x86_64
backend, made %r12 a callee-save register as dictated by the
@@ -65,7 +126,7 @@
https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=925129
* THANKS: update.
2019-08-29 Marc Nieper-WiÃkirchen <marc@nieper-wisskirchen.de>
2019-08-29 Marc Nieper-Wißkirchen <marc@nieper-wisskirchen.de>
* include/lightning/jit_private.h: Move definition of offsetof
from the public header file here.
@@ -1415,7 +1476,7 @@
* include/lightning/jit_arm.h: Correct wrong jit_f macro
definition.
* include/lightning/jit_ia64.h, include/lightning/jit_ppc.h:
* include/lightning/jit_ia64.h, include/lightning/jit_ppc.h:
Correct wrong jit_r macro definition.
* lib/jit_x86-x87.c, lib/jit_x86.c: Actually use the
@@ -1884,7 +1945,7 @@
divr_f and divrd_d implementation.
* check/lightning.c: Add __ia64__ preprocessor define
on Itanium.
on Itanium.
* check/alu.inc, check/clobber.tst, check/float.tst: Define
several macros conditionally to __ia64__. This is required
@@ -2991,7 +3052,7 @@
* include/lightning/jit_x86.h: Correct typo in macro name.
* lib/jit_arm.c, lib/jit_arm-cpu.c, lib/jit_mips.c,
lib/jit_mips-cpu.c, lib/jit_ppc.c, lib/jit_ppc-cpu.c,
lib/jit_mips-cpu.c, lib/jit_ppc.c, lib/jit_ppc-cpu.c,
lib/jit_x86.c, lib/jit_x86-cpu.c: Correct wrong code to get
current jit function pointer.
@@ -3225,7 +3286,7 @@
* lightning/i386/core.h (jit_ldr_c, jit_ldxr_c, jit_ldr_s,
jit_ldxr_s): Move...
* lightning/i386/core-32.h: ... here.
* lightning/i386/core-64.h (jit_ldr_c, jit_ldxr_c, jit_ldr_s,
* lightning/i386/core-64.h (jit_ldr_c, jit_ldxr_c, jit_ldr_s):
Use movsbq and movswq.
2010-08-10 Paulo César Pereira de Andrade <pcpa@mandriva.com.br>
@@ -3306,11 +3367,11 @@
* lightning/ppc/funcs.h (jit_flush_code): modified the computation
of start/end. The pointer arithmetic was done without casting. It
prevented compilation with recent gcc versions.
prevented compilation with recent gcc versions.
* lightning/ppc/core.h (jit_pushr_i): The offset for the store was
incorrect. Should have been 4 bytes below SP (not above).
* lightning/ppc/core.h (jit_popr_i): The offset for the load was
incorrect. Should have been 0 (not +8).
* lightning/ppc/core.h (jit_popr_i): The offset for the load was
incorrect. Should have been 0 (not +8).
2008-06-17 Paolo Bonzini <bonzini@gnu.org>
@@ -3589,7 +3650,7 @@
* lightning/i386/fp-32.h: ... here.
* lightning/i386/fp-64.h: Write the code.
* lightning/sparc/fp.h: Fix jit_extr_{f_d,d_f} register order.
2006-11-22 Paolo Bonzini <bonzini@gnu.org>
* lightning/i386/asm-i386.h: Move x86-64 instructions...
@@ -3803,7 +3864,7 @@
2006-01-23 Paolo Bonzini <bonzini@gnu.org>
* configure.ac: Fix comments in config.h.in.
2005-11-25 Paolo Bonzini <bonzini@gnu.org>
* lightning/sparc/fp.h: Fix header comment.
@@ -4123,7 +4184,7 @@
* lightning/ppc/funcs.h: correctly align stack pointer
No changelogs for the assemblers (lightning directory) until 1.0
2003-03-27 Paolo Bonzini <bonzini@gnu.org>
* tests/printf2.c: new test
@@ -4135,7 +4196,7 @@ No changelogs for the assemblers (lightning directory) until 1.0
2001-01-19 Paolo Bonzini <bonzini@gnu.org>
* configure.in: support cross-assembling
* disass/bfd.h, disass/dis-asm.h, disass/dis-buf.c,
disass/i386-dis.c, disass/i386.h, disass/ppc-dis.c,
disass/ppc.h, disass/ppc-opc.c, disass/sparc-dis.c,
parallel-rsp/lightning/Makefile.am
+5 -1
View File
@@ -17,18 +17,22 @@
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = \
gnulib-lib \
check \
doc \
include \
lib
EXTRA_DIST = m4/gnulib-cache.m4
pkgconfiglibdir = $(libdir)/pkgconfig
pkgconfiglib_DATA = lightning.pc
if get_jit_size
JIT_SIZE_PATH = "$(top_builddir)/jit_$(cpu)-sz.c"
AM_CPPFLAGS=-DGET_JIT_SIZE=1 -DJIT_SIZE_PATH='$(JIT_SIZE_PATH)'
AM_CFLAGS = -I$(top_srcdir)/include -D_GNU_SOURCE $(LIGHTNING_CFLAGS)
AM_CFLAGS = -I$(top_builddir)/include -I$(top_srcdir)/include \
-D_GNU_SOURCE $(LIGHTNING_CFLAGS)
noinst_PROGRAMS = size
size_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
parallel-rsp/lightning/README
+2
View File
@@ -1,3 +1,5 @@
GNU lightning is a library to aid in making portable programs
that compile assembly code at run time. For more information,
look at the info documentation.
For help building lightning, see README-hacking.
parallel-rsp/lightning/check/3to2.ok
-22
View File
@@ -1,22 +0,0 @@
0
1
1
1
0
1
1
1
0
1
1
0
1
1
1
0
1
1
1
0
1
1
parallel-rsp/lightning/check/3to2.tst
-118
View File
@@ -1,118 +0,0 @@
.data 32
dfmt:
.c "%1.0f\n"
ifmt:
.c "%d\n"
.code
jmpi main
#define def_test_double(a, b, c) \
name test_double_##a##_##b##_##c \
test_double_##a##_##b##_##c: \
prolog \
arg_d $d0 \
arg_d $d1 \
getarg_d %b $d0 \
getarg_d %c $d1 \
subr_d %a %b %c \
retr_d %a \
epilog
#define test_double(a, b, c, x, y) \
prepare \
pushargi_d x \
pushargi_d y \
finishi test_double_##a##_##b##_##c \
retval_d %f0 \
prepare \
pushargi dfmt \
ellipsis \
pushargr_d %f0 \
finishi @printf
#define def_test_int(a, b, c) \
name test_int_##a##_##b##_##c \
test_int_##a##_##b##_##c: \
prolog \
arg $i0 \
arg $i1 \
getarg %b $i0 \
getarg %c $i1 \
subr %a %b %c \
retr %a \
epilog
#define test_int(a, b, c, x, y) \
prepare \
pushargi x \
pushargi y \
finishi test_int_##a##_##b##_##c \
retval %r0 \
prepare \
pushargi ifmt \
ellipsis \
pushargr %r0 \
finishi @printf
def_test_double(f0, f0, f0)
def_test_double(f0, f0, f1)
def_test_double(f0, f1, f0)
def_test_double(f0, f1, f2)
def_test_double(f3, f3, f3)
def_test_double(f3, f3, f1)
def_test_double(f3, f1, f3)
def_test_double(f3, f1, f2)
def_test_double(f3, f0, f0)
def_test_double(f3, f0, f3)
def_test_double(f3, f3, f0)
def_test_int(r0, r0, r0)
def_test_int(r0, r0, r1)
def_test_int(r0, r1, r0)
def_test_int(r0, r1, r2)
def_test_int(v0, v0, v0)
def_test_int(v0, v0, r1)
def_test_int(v0, r1, v0)
def_test_int(v0, r1, r2)
def_test_int(v0, r0, r0)
def_test_int(v0, r0, v0)
def_test_int(v0, v0, r0)
name main
main:
prolog
test_double(f0, f0, f0, 3.0, 2.0)
test_double(f0, f0, f1, 3.0, 2.0)
test_double(f0, f1, f0, 3.0, 2.0)
test_double(f0, f1, f2, 3.0, 2.0)
test_double(f3, f3, f3, 3.0, 2.0)
test_double(f3, f3, f1, 3.0, 2.0)
test_double(f3, f1, f3, 3.0, 2.0)
test_double(f3, f1, f2, 3.0, 2.0)
test_double(f3, f0, f0, 3.0, 2.0)
test_double(f3, f0, f3, 3.0, 2.0)
test_double(f3, f3, f0, 3.0, 2.0)
test_int(r0, r0, r0, 3, 2)
test_int(r0, r0, r1, 3, 2)
test_int(r0, r1, r0, 3, 2)
test_int(r0, r1, r2, 3, 2)
test_int(v0, v0, v0, 3, 2)
test_int(v0, v0, r1, 3, 2)
test_int(v0, r1, v0, 3, 2)
test_int(v0, r1, r2, 3, 2)
test_int(v0, r0, r0, 3, 2)
test_int(v0, r0, v0, 3, 2)
test_int(v0, v0, r0, 3, 2)
ret
epilog
parallel-rsp/lightning/check/Makefile.am
-318
View File
@@ -1,318 +0,0 @@
#
# Copyright 2012-2019 Free Software Foundation, Inc.
#
# 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 3, 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.
#
AM_CFLAGS = -I$(top_srcdir)/include -D_GNU_SOURCE
check_PROGRAMS = lightning ccall self setcode nodata ctramp carg cva_list
lightning_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
lightning_SOURCES = lightning.c
ccall_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
ccall_SOURCES = ccall.c
self_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
self_SOURCES = self.c
setcode_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
setcode_SOURCES = setcode.c
nodata_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
nodata_SOURCES = nodata.c
ctramp_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
ctramp_SOURCES = ctramp.c
carg_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
carg_SOURCES = carg.c
cva_list_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB)
cva_list_SOURCES = cva_list.c
$(top_builddir)/lib/liblightning.la:
cd $(top_builddir)/lib; $(MAKE) $(AM_MAKEFLAGS) liblightning.la
EXTRA_DIST = \
3to2.tst 3to2.ok \
add.tst add.ok \
align.tst align.ok \
allocai.tst allocai.ok \
allocar.tst allocar.ok \
bp.tst bp.ok \
divi.tst divi.ok \
fib.tst fib.ok \
rpn.tst rpn.ok \
ldst.inc \
ldstr.tst ldstr.ok \
ldsti.tst ldsti.ok \
ldstxr.tst ldstxr.ok \
ldstxi.tst ldstxi.ok \
ldstr-c.tst ldstr-c.ok \
ldstxr-c.tst ldstxr-c.ok \
ldstxi-c.tst ldstxi-c.ok \
cvt.tst cvt.ok \
hton.tst hton.ok \
branch.tst branch.ok \
alu.inc \
alu_add.tst alu_add.ok \
alux_add.tst alux_add.ok \
alu_sub.tst alu_sub.ok \
alux_sub.tst alux_sub.ok \
alu_rsb.tst alu_rsb.ok \
alu_mul.tst alu_mul.ok \
alu_div.tst alu_div.ok \
alu_rem.tst alu_rem.ok \
alu_and.tst alu_and.ok \
alu_or.tst alu_or.ok \
alu_xor.tst alu_xor.ok \
alu_lsh.tst alu_lsh.ok \
alu_rsh.tst alu_rsh.ok \
alu_com.tst alu_com.ok \
alu_neg.tst alu_neg.ok \
fop_abs.tst fop_abs.ok \
fop_sqrt.tst fop_sqrt.ok \
varargs.tst varargs.ok \
stack.tst stack.ok \
clobber.tst clobber.ok \
carry.tst carry.ok \
call.tst call.ok \
float.tst float.ok \
jmpr.tst jmpr.ok \
put.tst put.ok \
qalu.inc \
qalu_mul.tst qalu_mul.ok \
qalu_div.tst qalu_div.ok \
range.tst range.ok \
ranger.tst ranger.ok \
ret.tst ret.ok \
tramp.tst tramp.ok \
va_list.tst va_list.ok \
check.sh \
check.x87.sh \
check.arm.sh check.swf.sh \
check.arm.swf.sh \
check.arm4.swf.sh \
check.nodata.sh \
check.x87.nodata.sh \
run-test all.tst
base_TESTS = \
3to2 add align allocai \
allocar bp divi fib rpn \
ldstr ldsti \
ldstxr ldstxi \
ldstr-c ldstxr-c ldstxi-c \
cvt hton branch \
alu_add alux_add \
alu_sub alux_sub alu_rsb \
alu_mul alu_div alu_rem \
alu_and alu_or alu_xor \
alu_lsh alu_rsh \
alu_com alu_neg \
fop_abs fop_sqrt \
varargs stack \
clobber carry call \
float jmpr put \
qalu_mul qalu_div \
range ranger ret tramp \
va_list
$(base_TESTS): check.sh
$(LN_S) $(srcdir)/check.sh $@
TESTS = $(base_TESTS)
if test_x86_x87
#x87_TESTS = $(addsuffix .x87, $(base_TESTS))
x87_TESTS = \
3to2.x87 add.x87 allocai.x87 \
allocar.x87 bp.x87 divi.x87 fib.x87 \
rpn.x87 ldstr.x87 ldsti.x87 \
ldstxr.x87 ldstxi.x87 \
ldstr-c.x87 ldstxr-c.x87 ldstxi-c.x87 \
cvt.x87 branch.x87 \
alu_add.x87 alux_add.x87 \
alu_sub.x87 alux_sub.x87 alu_rsb.x87 \
alu_mul.x87 alu_div.x87 alu_rem.x87 \
alu_and.x87 alu_or.x87 alu_xor.x87 \
alu_lsh.x87 alu_rsh.x87 \
alu_com.x87 alu_neg.x87 \
fop_abs.x87 fop_sqrt.x87 \
varargs.x87 stack.x87 \
clobber.x87 carry.x87 call.x87 \
float.x87 jmpr.x87 put.x87 \
va_list.x87
$(x87_TESTS): check.x87.sh
$(LN_S) $(srcdir)/check.x87.sh $@
TESTS += $(x87_TESTS)
#x87_nodata_TESTS = $(addsuffix .x87.nodata, $(base_TESTS))
x87_nodata_TESTS = \
3to2.x87.nodata add.x87.nodata allocai.x87.nodata \
allocar.x87.nodata bp.x87.nodata divi.x87.nodata fib.x87.nodata \
rpn.x87.nodata ldstr.x87.nodata ldsti.x87.nodata \
ldstxr.x87.nodata ldstxi.x87.nodata \
ldstr-c.x87.nodata ldstxr-c.x87.nodata ldstxi-c.x87.nodata \
cvt.x87.nodata branch.x87.nodata \
alu_add.x87.nodata alux_add.x87.nodata \
alu_sub.x87.nodata alux_sub.x87.nodata alu_rsb.x87.nodata \
alu_mul.x87.nodata alu_div.x87.nodata alu_rem.x87.nodata \
alu_and.x87.nodata alu_or.x87.nodata alu_xor.x87.nodata \
alu_lsh.x87.nodata alu_rsh.x87.nodata \
alu_com.x87.nodata alu_neg.x87.nodata \
fop_abs.x87.nodata fop_sqrt.x87.nodata \
varargs.x87.nodata stack.x87.nodata \
clobber.x87.nodata carry.x87.nodata call.x87.nodata \
float.x87.nodata jmpr.x87.nodata put.x87.nodata \
va_list.x87.nodata
$(x87_nodata_TESTS): check.x87.nodata.sh
$(LN_S) $(srcdir)/check.x87.nodata.sh $@
TESTS += $(x87_nodata_TESTS)
endif
if test_arm_arm
#arm_TESTS = $(addsuffix .arm, $(base_TESTS))
arm_TESTS = \
3to2.arm add.arm align.arm allocai.arm \
allocar.arm bp.arm divi.arm fib.arm \
rpn.arm ldstr.arm ldsti.arm \
ldstxr.arm ldstxi.arm \
ldstr-c.arm ldstxr-c.arm ldstxi-c.arm \
cvt.arm hton.arm branch.arm \
alu_add.arm alux_add.arm \
alu_sub.arm alux_sub.arm alu_rsb.arm \
alu_mul.arm alu_div.arm alu_rem.arm \
alu_and.arm alu_or.arm alu_xor.arm \
alu_lsh.arm alu_rsh.arm \
alu_com.arm alu_neg.arm \
fop_abs.arm fop_sqrt.arm \
varargs.arm stack.arm \
clobber.arm carry.arm call.arm \
float.arm jmpr.arm tramp.arm range.arm \
ranger.arm put.arm va_list.arm
$(arm_TESTS): check.arm.sh
$(LN_S) $(srcdir)/check.arm.sh $@
TESTS += $(arm_TESTS)
endif
if test_arm_swf
#swf_TESTS = $(addsuffix .swf, $(base_TESTS))
swf_TESTS = \
3to2.swf add.swf allocai.swf \
allocar.swf bp.swf divi.swf fib.swf \
rpn.swf ldstr.swf ldsti.swf \
ldstxr.swf ldstxi.swf \
ldstr-c.swf ldstxr-c.swf ldstxi-c.swf \
cvt.swf hton.swf branch.swf \
alu_add.swf alux_add.swf \
alu_sub.swf alux_sub.swf alu_rsb.swf \
alu_mul.swf alu_div.swf alu_rem.swf \
alu_and.swf alu_or.swf alu_xor.swf \
alu_lsh.swf alu_rsh.swf \
alu_com.swf alu_neg.swf \
fop_abs.swf fop_sqrt.swf \
varargs.swf stack.swf \
clobber.swf carry.swf call.swf \
float.swf jmpr.swf tramp.swf range.swf \
ranger.swf put.swf va_list.swf
$(swf_TESTS): check.swf.sh
$(LN_S) $(srcdir)/check.swf.sh $@
TESTS += $(swf_TESTS)
if test_arm_arm
#arm_swf_TESTS = $(addsuffix .arm.swf, $(base_TESTS))
arm_swf_TESTS = \
3to2.arm.swf add.arm.swf allocai.arm.swf \
allocar.arm.swf bp.arm.swf divi.arm.swf fib.arm.swf \
rpn.arm.swf ldstr.arm.swf ldsti.arm.swf \
ldstxr.arm.swf ldstxi.arm.swf \
ldstr-c.arm.swf ldstxr-c.arm.swf ldstxi-c.arm.swf \
cvt.arm.swf hton.arm.swf branch.arm.swf \
alu_add.arm.swf alux_add.arm.swf \
alu_sub.arm.swf alux_sub.arm.swf alu_rsb.arm.swf \
alu_mul.arm.swf alu_div.arm.swf alu_rem.arm.swf \
alu_and.arm.swf alu_or.arm.swf alu_xor.arm.swf \
alu_lsh.arm.swf alu_rsh.arm.swf \
alu_com.arm.swf alu_neg.arm.swf \
fop_abs.arm.swf fop_sqrt.arm.swf \
varargs.arm.swf stack.arm.swf \
clobber.arm.swf carry.arm.swf call.arm.swf \
float.arm.swf jmpr.arm.swf tramp.arm.swf range.arm.swf \
ranger.arm.swf put.arm.swf va_list.arm.swf
$(arm_swf_TESTS): check.arm.swf.sh
$(LN_S) $(srcdir)/check.arm.swf.sh $@
TESTS += $(arm_swf_TESTS)
endif
if test_arm_arm
#arm4_swf_TESTS = $(addsuffix .arm4.swf, $(base_TESTS))
arm4_swf_TESTS = \
3to2.arm4.swf add.arm4.swf allocai.arm4.swf \
allocar.arm4.swf bp.arm4.swf divi.arm4.swf fib.arm4.swf \
rpn.arm4.swf ldstr.arm4.swf ldsti.arm4.swf \
ldstxr.arm4.swf ldstxi.arm4.swf \
ldstr-c.arm4.swf ldstxr-c.arm4.swf ldstxi-c.arm4.swf \
cvt.arm4.swf hton.arm4.swf branch.arm4.swf \
alu_add.arm4.swf alux_add.arm4.swf \
alu_sub.arm4.swf alux_sub.arm4.swf alu_rsb.arm4.swf \
alu_mul.arm4.swf alu_div.arm4.swf alu_rem.arm4.swf \
alu_and.arm4.swf alu_or.arm4.swf alu_xor.arm4.swf \
alu_lsh.arm4.swf alu_rsh.arm4.swf \
alu_com.arm4.swf alu_neg.arm4.swf \
fop_abs.arm4.swf fop_sqrt.arm4.swf \
varargs.arm4.swf stack.arm4.swf \
clobber.arm4.swf carry.arm4.swf call.arm4.swf \
float.arm4.swf jmpr.arm4.swf tramp.arm4.swf \
range.arm4.swf ranger.arm4.swf put.arm4.swf \
va_list.arm4.swf
$(arm4_swf_TESTS): check.arm4.swf.sh
$(LN_S) $(srcdir)/check.arm4.swf.sh $@
TESTS += $(arm4_swf_TESTS)
endif
endif
if test_nodata
#nodata_TESTS = $(addsuffix .nodata, $(base_TESTS))
nodata_TESTS = \
3to2.nodata add.nodata allocai.nodata \
allocar.nodata bp.nodata divi.nodata fib.nodata \
rpn.nodata ldstr.nodata ldsti.nodata \
ldstxr.nodata ldstxi.nodata \
ldstr-c.nodata ldstxr-c.nodata ldstxi-c.nodata \
cvt.nodata branch.nodata \
alu_add.nodata alux_add.nodata \
alu_sub.nodata alux_sub.nodata alu_rsb.nodata \
alu_mul.nodata alu_div.nodata alu_rem.nodata \
alu_and.nodata alu_or.nodata alu_xor.nodata \
alu_lsh.nodata alu_rsh.nodata \
alu_com.nodata alu_neg.nodata \
fop_abs.nodata fop_sqrt.nodata \
varargs.nodata stack.nodata \
clobber.nodata carry.nodata call.nodata \
float.nodata jmpr.nodata tramp.nodata \
range.nodata ranger.nodata put.nodata \
va_list.nodata
$(nodata_TESTS): check.nodata.sh
$(LN_S) $(srcdir)/check.nodata.sh $@
TESTS += $(nodata_TESTS)
endif
TESTS += ccall self setcode nodata ctramp carg cva_list
CLEANFILES = $(TESTS)
#TESTS_ENVIRONMENT=$(srcdir)/run-test;
debug: lightning
$(LIBTOOL) --mode=execute gdb lightning
parallel-rsp/lightning/check/add.ok
-1
View File
@@ -1 +0,0 @@
5 + 4 = 9
parallel-rsp/lightning/check/add.tst
-35
View File
@@ -1,35 +0,0 @@
.data 32
fmt:
.c "%d + %d = %d\n"
.code
jmpi main
name test
test:
prolog
arg $i0
arg $i1
getarg %r0 $i0
getarg %r1 $i1
addr %r0 %r0 %r1
retr %r0
epilog
name main
main:
prolog
prepare
pushargi 5
pushargi 4
finishi test
retval %r0
prepare
pushargi fmt
ellipsis
pushargi 5
pushargi 4
pushargr %r0
finishi @printf
ret
epilog
parallel-rsp/lightning/check/align.ok
-1
View File
@@ -1 +0,0 @@
10
parallel-rsp/lightning/check/align.tst
-28
View File
@@ -1,28 +0,0 @@
.data 32
fmt:
.c "%d\n"
.code
prolog
movi %r0 1
jmpi L1 /* should not generate this */
align $(__WORDSIZE / 8) /* possible nops */
L1:
bgei L4 %r0 10
addi %r0 %r0 1
jmpi L2
movr %r1 %r0 /* to force jump generation */
align $(__WORDSIZE / 8) /* possible nops */
L2:
bgti L4 %r0 10 /* never executed */
align $(__WORDSIZE / 8) /* possible nops */
L3:
jmpi L1
align $(__WORDSIZE / 8) /* possible nops */
L4:
prepare
pushargi fmt
ellipsis
pushargr %r0
finishi @printf
ret
epilog
parallel-rsp/lightning/check/all.tst
-415
View File
@@ -1,415 +0,0 @@
.disasm // only disassemble
.code
prolog
allocai 32 $buf
arg $c
arg $uc
arg $s
arg $us
arg $i
#if __WORDSIZE == 64
arg $ui
arg $l
#endif
getarg_c %r0 $c
getarg_uc %r0 $uc
getarg_s %r0 $s
getarg_us %r0 $us
getarg_i %r0 $i
#if __WORDSIZE == 64
getarg_ui %r0 $ui
getarg_l %r0 $l
#endif
addr %r0 %r1 %r2
addi %r0 %r1 2
addcr %r0 %r1 %r2
addci %r0 %r1 2
addxr %r0 %r1 %r2
addxi %r0 %r1 2
subr %r0 %r1 %r2
subi %r0 %r1 2
subcr %r0 %r1 %r2
subci %r0 %r1 2
subxr %r0 %r1 %r2
subxi %r0 %r1 2
mulr %r0 %r1 %r2
muli %r0 %r1 2
qmulr %r0 %r1 %r2 %v0
qmuli %r0 %r1 %r2 3
qmulr_u %r0 %r1 %r2 %v0
qmuli_u %r0 %r1 %r2 3
divr %r0 %r1 %r2
divi %r0 %r1 2
divr_u %r0 %r1 %r2
divi_u %r0 %r1 2
qdivr %r0 %r1 %r2 %v0
qdivi %r0 %r1 %r2 3
qdivr_u %r0 %r1 %r2 %v0
qdivi_u %r0 %r1 %r2 3
remr %r0 %r1 %r2
remi %r0 %r1 2
remr_u %r0 %r1 %r2
remi_u %r0 %r1 2
andr %r0 %r1 %r2
andi %r0 %r1 2
orr %r0 %r1 %r2
ori %r0 %r1 2
xorr %r0 %r1 %r2
xori %r0 %r1 2
lshr %r0 %r1 %r2
lshi %r0 %r1 2
rshr %r0 %r1 %r2
rshi %r0 %r1 2
rshr_u %r0 %r1 %r2
rshi_u %r0 %r1 2
negr %r0 %r1
comr %r0 %r1
ltr %r0 %r1 %r2
lti %r0 %r1 2
ltr_u %r0 %r1 %r2
lti_u %r0 %r1 2
ler %r0 %r1 %r2
lei %r0 %r1 2
ler_u %r0 %r1 %r2
lei_u %r0 %r1 2
eqr %r0 %r1 %r2
eqi %r0 %r1 2
ger %r0 %r1 %r2
gei %r0 %r1 2
ger_u %r0 %r1 %r2
gei_u %r0 %r1 2
gtr %r0 %r1 %r2
gti %r0 %r1 2
gtr_u %r0 %r1 %r2
gti_u %r0 %r1 2
ner %r0 %r1 %r2
nei %r0 %r1 2
movr %r0 %r1
movi %r0 1
extr_c %r0 %r1
extr_uc %r0 %r1
extr_s %r0 %r1
extr_us %r0 %r1
#if __WORDSIZE == 64
extr_i %r0 %r1
extr_ui %r0 %r1
#endif
htonr %r0 %r1
ntohr %r0 %r1
ldr_c %r0 %r1
ldi_c %r0 0x80000000
ldr_uc %r0 %r1
ldi_uc %r0 0x80000000
ldr_s %r0 %r1
ldi_s %r0 0x80000000
ldr_us %r0 %r1
ldi_us %r0 0x80000000
ldr_i %r0 %r1
ldi_i %r0 0x80000000
#if __WORDSIZE == 64
ldr_ui %r0 %r1
ldi_ui %r0 0x80000000
ldr_l %r0 %r1
ldi_l %r0 0x80000000
#endif
ldxr_c %r0 %r1 %r2
ldxi_c %r0 %r1 1
ldxr_uc %r0 %r1 %r2
ldxi_uc %r0 %r1 1
ldxr_s %r0 %r1 %r2
ldxi_s %r0 %r1 2
ldxr_us %r0 %r1 %r2
ldxi_us %r0 %r1 2
ldxr_i %r0 %r1 %r2
ldxi_i %r0 %r1 4
#if __WORDSIZE == 64
ldxr_ui %r0 %r1 %r2
ldxi_ui %r0 %r1 4
ldxr_l %r0 %r1 %r2
ldxi_l %r0 %r1 8
#endif
str_c %r1 %r0
sti_c 0x80000000 %r1
str_s %r1 %r0
sti_s 0x80000000 %r1
str_i %r1 %r0
sti_i 0x80000000 %r1
#if __WORDSIZE == 64
str_l %r1 %r0
sti_l 0x80000000 %r1
#endif
stxr_c %r2 %r1 %r0
stxi_c 1 %r1 %r0
stxr_s %r2 %r1 %r0
stxi_s 2 %r1 %r0
stxr_i %r2 %r1 %r0
stxi_i 4 %r1 %r0
#if __WORDSIZE == 64
stxr_l %r2 %r1 %r0
stxi_l 8 %r1 %r0
#endif
cond:
bltr cond %r0 %r1
condi:
blti condi %r0 1
condu:
bltr_u condu %r0 %r1
condiu:
blti_u condiu %r0 1
bler cond %r0 %r1
blei condi %r0 1
bler_u condu %r0 %r1
blei_u condiu %r0 1
bool:
beqr bool %r0 %r1
booli:
beqi booli %r0 1
bger cond %r0 %r1
bgei condi %r0 1
bger_u condu %r0 %r1
bgei_u condiu %r0 1
bgtr cond %r0 %r1
bgti condi %r0 1
bgtr_u condu %r0 %r1
bgti_u condiu %r0 1
bner bool %r0 %r1
bnei booli %r0 1
mask:
bmsr mask %r0 %r1
maski:
bmsi maski %r0 1
bmcr mask %r0 %r1
bmci maski %r0 1
as:
boaddr as %r0 %r1
asi:
boaddi asi %r0 1
asu:
boaddr_u as %r0 %r1
boaddi_u asi %r0 1
bxaddr as %r0 %r1
bxaddi asi %r0 1
bxaddr_u as %r0 %r1
bxaddi_u asi %r0 1
bosubr as %r0 %r1
bosubi asi %r0 1
bosubr_u as %r0 %r1
bosubi_u asi %r0 1
bxsubr as %r0 %r1
bxsubi asi %r0 1
bxsubr_u as %r0 %r1
bxsubi_u asi %r0 1
label:
jmpr %r0
jmpi label
callr %r0
calli label
prepare
pushargr %r0
finishr %r0
prepare
pushargi 1
ellipsis
finishi 0x80000000
ret
retr %r1
reti 2
retval_c %r1
retval_uc %r1
retval_s %r1
retval_us %r1
retval_i %r1
#if __WORDSIZE == 64
retval_ui %r1
retval_l %r1
#endif
arg_f $f
getarg_f %f1 $f
addr_f %f0 %f1 %f2
addi_f %f0 %f1 0.5
subr_f %f0 %f1 %f2
subi_f %f0 %f1 0.5
mulr_f %f0 %f1 %f2
muli_f %f0 %f1 0.5
divr_f %f0 %f1 %f2
divi_f %f0 %f1 0.5
negr_f %f0 %f1
absr_f %f0 %f1
sqrtr_f %f0 %f1
ltr_f %r0 %f0 %f1
lti_f %r0 %f0 0.5
ler_f %r0 %f0 %f1
lei_f %r0 %f0 0.5
eqr_f %r0 %f0 %f1
eqi_f %r0 %f0 0.5
ger_f %r0 %f0 %f1
gei_f %r0 %f0 0.5
gtr_f %r0 %f0 %f1
gti_f %r0 %f0 0.5
ner_f %r0 %f0 %f1
nei_f %r0 %f0 0.5
unltr_f %r0 %f0 %f1
unlti_f %r0 %f0 0.5
unler_f %r0 %f0 %f1
unlei_f %r0 %f0 0.5
uneqr_f %r0 %f0 %f1
uneqi_f %r0 %f0 0.5
unger_f %r0 %f0 %f1
ungei_f %r0 %f0 0.5
ungtr_f %r0 %f0 %f1
ungti_f %r0 %f0 0.5
ltgtr_f %r0 %f0 %f1
ltgti_f %r0 %f0 0.5
ordr_f %r0 %f0 %f1
ordi_f %r0 %f0 0.5
unordr_f %r0 %f0 %f1
unordi_f %r0 %f0 0.5
truncr_f_i %r0 %f0
#if __WORDSIZE == 64
truncr_f_l %r0 %f0
#endif
extr_f %f0 %r0
extr_d_f %f0 %f1
movr_f %f0 %f1
movi_f %f0 1.5
ldr_f %f0 %r0
ldi_f %f0 0x80000000
ldxr_f %f0 %r0 %r1
ldxi_f %f0 %r0 4
str_f %r0 %f0
sti_f 0x80000000 %f0
stxr_f %r1 %r0 %f0
stxi_f 4 %r0 %f0
/* FIXME the bordr_d at the end will cause an assertion on riscv due to
* too distant jump (does not fit in a 12 bit signed int) */
ord:
bltr_f ord %f0 %f1
ordi:
blti_f ordi %f0 0.5
bler_f ord %f0 %f1
blei_f ordi %f0 0.5
beqr_f ord %f0 %f1
beqi_f ordi %f0 0.5
bger_f ord %f0 %f1
bgei_f ordi %f0 0.5
bgtr_f ord %f0 %f1
bgti_f ordi %f0 0.5
bner_f ord %f0 %f1
bnei_f ordi %f0 0.5
unord:
bunltr_f unord %f0 %f1
unordi:
bunlti_f unordi %f0 0.5
bunler_f unord %f0 %f1
bunlei_f unordi %f0 0.5
buneqr_f unord %f0 %f1
buneqi_f unordi %f0 0.5
bunger_f unord %f0 %f1
bungei_f unordi %f0 0.5
bungtr_f unord %f0 %f1
bungti_f unordi %f0 0.5
bltgtr_f unord %f0 %f1
bltgti_f unordi %f0 0.5
bordr_f unord %f0 %f1
bordi_f unordi %f0 0.5
bunordr_f unord %f0 %f1
bunordi_f unordi %f0 0.5
prepare
pushargr_f %f1
pushargi_f 0.5
finishi 0x80000000
retr_f %f1
reti_f 0.5
retval_f %f1
arg_d $f
getarg_d %f1 $f
addr_d %f0 %f1 %f2
addi_d %f0 %f1 0.5
subr_d %f0 %f1 %f2
subi_d %f0 %f1 0.5
mulr_d %f0 %f1 %f2
muli_d %f0 %f1 0.5
divr_d %f0 %f1 %f2
divi_d %f0 %f1 0.5
negr_d %f0 %f1
absr_d %f0 %f1
sqrtr_d %f0 %f1
ltr_d %r0 %f0 %f1
lti_d %r0 %f0 0.5
ler_d %r0 %f0 %f1
lei_d %r0 %f0 0.5
eqr_d %r0 %f0 %f1
eqi_d %r0 %f0 0.5
ger_d %r0 %f0 %f1
gei_d %r0 %f0 0.5
gtr_d %r0 %f0 %f1
gti_d %r0 %f0 0.5
ner_d %r0 %f0 %f1
nei_d %r0 %f0 0.5
unltr_d %r0 %f0 %f1
unlti_d %r0 %f0 0.5
unler_d %r0 %f0 %f1
unlei_d %r0 %f0 0.5
uneqr_d %r0 %f0 %f1
uneqi_d %r0 %f0 0.5
unger_d %r0 %f0 %f1
ungei_d %r0 %f0 0.5
ungtr_d %r0 %f0 %f1
ungti_d %r0 %f0 0.5
ltgtr_d %r0 %f0 %f1
ltgti_d %r0 %f0 0.5
ordr_d %r0 %f0 %f1
ordi_d %r0 %f0 0.5
unordr_d %r0 %f0 %f1
unordi_d %r0 %f0 0.5
truncr_d_i %r0 %f0
#if __WORDSIZE == 64
truncr_d_l %r0 %f0
#endif
extr_d %f0 %r0
extr_f_d %f0 %f1
movr_d %f0 %f1
movi_d %f0 1.5
ldr_d %f0 %r0
ldi_d %f0 0x80000000
ldxr_d %f0 %r0 %r1
ldxi_d %f0 %r0 8
str_d %r0 %f0
sti_d 0x80000000 %f0
stxr_d %r1 %r0 %f0
stxi_d 8 %r0 %f0
bltr_d ord %f0 %f1
blti_d ordi %f0 0.5
bler_d ord %f0 %f1
blei_d ordi %f0 0.5
beqr_d ord %f0 %f1
beqi_d ordi %f0 0.5
bger_d ord %f0 %f1
bgei_d ordi %f0 0.5
bgtr_d ord %f0 %f1
bgti_d ordi %f0 0.5
bner_d ord %f0 %f1
bnei_d ordi %f0 0.5
bunltr_d unord %f0 %f1
bunlti_d unordi %f0 0.5
bunler_d unord %f0 %f1
bunlei_d unordi %f0 0.5
buneqr_d unord %f0 %f1
buneqi_d unordi %f0 0.5
bunger_d unord %f0 %f1
bungei_d unordi %f0 0.5
bungtr_d unord %f0 %f1
bungti_d unordi %f0 0.5
bltgtr_d unord %f0 %f1
bltgti_d unordi %f0 0.5
bordr_d unord %f0 %f1
bordi_d unordi %f0 0.5
bunordr_d unord %f0 %f1
bunordi_d unordi %f0 0.5
prepare
pushargr_d %f1
pushargi_d 0.5
finishi 0x80000000
retr_d %f1
reti_d 0.5
retval_d %f1
parallel-rsp/lightning/check/allocai.ok
-2
View File
@@ -1,2 +0,0 @@
received 7777
succeeded
parallel-rsp/lightning/check/allocai.tst
-100
View File
@@ -1,100 +0,0 @@
.data 128
idfmt:
.c "received %d\n"
failure_message:
.c "numbers don't add up to zero\n"
report_message:
.c "failed: got %i instead of %i\n"
succeeded_message:
.c "succeeded\n"
.code
jmpi main
/*
static int
identity (int arg)
{
printf ("received %i\n", arg);
return arg;
}
*/
name identify
identify:
prolog
arg $i
getarg %v0 $i
prepare
pushargi idfmt
ellipsis
pushargr %v0
finishi @printf
retr %v0
epilog
name identity_func
identity_func:
prolog
arg $i
getarg %r1 $i
/* Store the argument on the stack. */
allocai $(__WORDSIZE >> 3) $off
stxi $off %fp %r1
/* Store the negative of the argument on the stack. */
allocai $(__WORDSIZE >> 3) $neg
negr %r2 %r1
stxi $neg %fp %r2
/* Invoke FUNC. */
prepare
pushargr %r1
finishi identify
/* Ignore the result. */
/* Restore the negative and the argument from the stack. */
ldxi %r2 %fp $neg
ldxi %v1 %fp $off
/* Make sure they still add to zero. */
addr %r0 %v1 %r2
bnei branch %r0 0
/* Return it. */
retr %v1
/* Display a failure message. */
branch:
prepare
pushargi failure_message
ellipsis
finishi @printf
/* Leave. */
retr %v1
epilog
name main
main:
prolog
prepare
pushargi 7777
finishi identity_func
retval %r0
beqi succeeded %r0 7777
prepare
pushargi report_message
ellipsis
pushargr %r0
pushargi 7777
finishi @printf
reti 1
succeeded:
prepare
pushargi succeeded_message
ellipsis
finishi @printf
reti 0
epilog
parallel-rsp/lightning/check/allocar.ok
-4
View File
@@ -1,4 +0,0 @@
1 2 3
3 4 5
5 6 7
7 8 9
parallel-rsp/lightning/check/allocar.tst
-403
View File
@@ -1,403 +0,0 @@
#define szof_c 1
#define szof_uc szof_c
#define szof_s 2
#define szof_us szof_s
#define szof_i 4
#if __WORDSIZE == 64
# define szof_ui szof_i
# define szof_l 8
#endif
#define szof_f 4
#define szof_d 8
#define FILL(T) \
name fill##T \
fill##T: \
prolog \
arg $argp \
getarg %v0 $argp \
arg $argi \
getarg %r0 $argi \
muli %r0 %r0 szof##T \
addr %v1 %v0 %r0 \
movi %r0 0 \
fill##T##loop: \
bger fill##T##done %v0 %v1 \
str##T %v0 %r0 \
addi %r0 %r0 1 \
addi %v0 %v0 szof##T \
jmpi fill##T##loop \
fill##T##done: \
ret \
epilog
#define FILLF(T) \
name fill##T \
fill##T: \
prolog \
arg $argp \
getarg %v0 $argp \
arg $argi \
getarg %r0 $argi \
muli %r0 %r0 szof##T \
addr %v1 %v0 %r0 \
movi##T %f0 0.0 \
fill##T##loop: \
bger fill##T##done %v0 %v1 \
str##T %v0 %f0 \
addi##T %f0 %f0 1.0 \
addi %v0 %v0 szof##T \
jmpi fill##T##loop \
fill##T##done: \
ret \
epilog
#define fill_uc fill_c
#define fill_us fill_s
#define fill_ui fill_i
#define ARG( T, N) arg $arg##T##N
#define ARGF( T, N) arg##T $arg##T##N
#define ARG1( K, T) ARG##K(T, 0)
#define ARG2( K, T) ARG1( K, T) ARG##K(T, 1)
#define ARG3( K, T) ARG2( K, T) ARG##K(T, 2)
#define ARG4( K, T) ARG3( K, T) ARG##K(T, 3)
#define ARG5( K, T) ARG4( K, T) ARG##K(T, 4)
#define ARG6( K, T) ARG5( K, T) ARG##K(T, 5)
#define ARG7( K, T) ARG6( K, T) ARG##K(T, 6)
#define ARG8( K, T) ARG7( K, T) ARG##K(T, 7)
#define ARG9( K, T) ARG8( K, T) ARG##K(T, 8)
#define ARG10(K, T) ARG9( K, T) ARG##K(T, 9)
#define ARG11(K, T) ARG10(K, T) ARG##K(T, 10)
#define ARG12(K, T) ARG11(K, T) ARG##K(T, 11)
#define ARG13(K, T) ARG12(K, T) ARG##K(T, 12)
#define ARG14(K, T) ARG13(K, T) ARG##K(T, 13)
#define ARG15(K, T) ARG14(K, T) ARG##K(T, 14)
#define ARG16(K, T) ARG15(K, T) ARG##K(T, 15)
#define ARG_c(N) ARG##N( , _c)
#define ARG_uc(N) ARG##N( , _uc)
#define ARG_s(N) ARG##N( , _s)
#define ARG_us(N) ARG##N( , _us)
#define ARG_i(N) ARG##N( , _i)
#define ARG_ui(N) ARG##N( , _ui)
#define ARG_l(N) ARG##N( , _l)
#define ARG_f(N) ARG##N(F, _f)
#define ARG_d(N) ARG##N(F, _d)
#define CHK(N, T, V) \
getarg %r0 $arg##T##V \
ldxi##T %r1 %v0 $(V * szof##T) \
beqr N##T##V %r0 %r1 \
calli @abort \
N##T##V:
#define CHKF(N, T, V) \
getarg##T %f0 $arg##T##V \
ldxi##T %f1 %v0 $(V * szof##T) \
beqr##T N##T##V %f0 %f1 \
calli @abort \
N##T##V:
#define GET1( K, N, T, V) CHK##K(N, T, 0)
#define GET2( K, N, T, V) GET1( K, N, T, V) CHK##K(N, T, 1)
#define GET3( K, N, T, V) GET2( K, N, T, V) CHK##K(N, T, 2)
#define GET4( K, N, T, V) GET3( K, N, T, V) CHK##K(N, T, 3)
#define GET5( K, N, T, V) GET4( K, N, T, V) CHK##K(N, T, 4)
#define GET6( K, N, T, V) GET5( K, N, T, V) CHK##K(N, T, 5)
#define GET7( K, N, T, V) GET6( K, N, T, V) CHK##K(N, T, 6)
#define GET8( K, N, T, V) GET7( K, N, T, V) CHK##K(N, T, 7)
#define GET9( K, N, T, V) GET8( K, N, T, V) CHK##K(N, T, 8)
#define GET10(K, N, T, V) GET9( K, N, T, V) CHK##K(N, T, 9)
#define GET11(K, N, T, V) GET10(K, N, T, V) CHK##K(N, T, 10)
#define GET12(K, N, T, V) GET11(K, N, T, V) CHK##K(N, T, 11)
#define GET13(K, N, T, V) GET12(K, N, T, V) CHK##K(N, T, 12)
#define GET14(K, N, T, V) GET13(K, N, T, V) CHK##K(N, T, 13)
#define GET15(K, N, T, V) GET14(K, N, T, V) CHK##K(N, T, 14)
#define GET16(K, N, T, V) GET15(K, N, T, V) CHK##K(N, T, 15)
#define GET_c(N, M) GET##N( , c##N, _c, M)
#define GET_uc(N, M) GET##N( , uc##N, _uc, M)
#define GET_s(N, M) GET##N( , s##N, _s, M)
#define GET_us(N, M) GET##N( , us##N, _us, M)
#define GET_i(N, M) GET##N( , i##N, _i, M)
#define GET_ui(N, M) GET##N( , ui##N, _ui, M)
#define GET_l(N, M) GET##N( , l##N, _l, M)
#define GET_f(N, M) GET##N(F, f##N, _f, M)
#define GET_d(N, M) GET##N(F, d##N, _d, M)
#define PUSH( T, V) pushargi V
#define PUSHF( T, V) pushargi##T V
#define PUSH0( K, T) /**/
#define PUSH1( K, T) PUSH##K(T, 0)
#define PUSH2( K, T) PUSH1( K, T) PUSH##K(T, 1)
#define PUSH3( K, T) PUSH2( K, T) PUSH##K(T, 2)
#define PUSH4( K, T) PUSH3( K, T) PUSH##K(T, 3)
#define PUSH5( K, T) PUSH4( K, T) PUSH##K(T, 4)
#define PUSH6( K, T) PUSH5( K, T) PUSH##K(T, 5)
#define PUSH7( K, T) PUSH6( K, T) PUSH##K(T, 6)
#define PUSH8( K, T) PUSH7( K, T) PUSH##K(T, 7)
#define PUSH9( K, T) PUSH8( K, T) PUSH##K(T, 8)
#define PUSH10(K, T) PUSH9( K, T) PUSH##K(T, 9)
#define PUSH11(K, T) PUSH10(K, T) PUSH##K(T, 10)
#define PUSH12(K, T) PUSH11(K, T) PUSH##K(T, 11)
#define PUSH13(K, T) PUSH12(K, T) PUSH##K(T, 12)
#define PUSH14(K, T) PUSH13(K, T) PUSH##K(T, 13)
#define PUSH15(K, T) PUSH14(K, T) PUSH##K(T, 14)
#define PUSH16(K, T) PUSH15(K, T) PUSH##K(T, 15)
#define PUSH_c( N) PUSH##N( , _c)
#define PUSH_uc(N) PUSH##N( , _uc)
#define PUSH_s( N) PUSH##N( , _s)
#define PUSH_us(N) PUSH##N( , _us)
#define PUSH_i( N) PUSH##N( , _i)
#define PUSH_ui(N) PUSH##N( , _ui)
#define PUSH_l( N) PUSH##N( , _l)
#define PUSH_f( N) PUSH##N(F, _f)
#define PUSH_d( N) PUSH##N(F, _d)
/* bottom function */
#define DEF0(T) \
name test##T##_0 \
test##T##_0: \
prolog \
ret \
epilog
#define DEFN(N, M, T) \
name test##T##_##N \
test##T##_##N: \
prolog \
arg $argp \
/* stack buffer in %v0 */ \
getarg %v0 $argp \
ARG##T(N) \
/* validate arguments */ \
GET##T(N, M) \
/* heap buffer in %v1 */ \
prepare \
pushargi $(N * szof##T) \
finishi @malloc \
retval %v1 \
/* copy stack bufer to heap buffer */ \
prepare \
pushargr %v1 \
pushargr %v0 \
pushargi $(N * szof##T) \
finishi MEMCPY \
/* stack buffer for next function in %v2 */ \
movi %r0 $(M * szof##T) \
allocar %v2 %r0 \
addr %v2 %v2 %fp \
/* fill stack buffer for next function */ \
prepare \
pushargr %v2 \
pushargi M \
finishi fill##T \
/* call next function */ \
prepare \
pushargr %v2 \
PUSH##T(M) \
finishi test##T##_##M \
/* validate stack buffer */ \
prepare \
pushargr %v1 \
pushargr %v0 \
pushargi $(N * szof##T) \
finishi @memcmp \
retval %r0 \
beqi test##T##_##N##_done %r0 0 \
calli @abort \
test##T##_##N##_done: \
/* release heap bufer */ \
prepare \
pushargr %v1 \
finishi @free \
ret \
epilog
/* top function */
#define DEFX(T) \
name test##T##_17 \
test##T##_17: \
prolog \
/* heap buffer in %v1 */ \
prepare \
pushargi $(16 * szof##T) \
finishi @malloc \
retval %v1 \
/* stack buffer for next function in %v2 */ \
movi %r0 $(16 * szof##T) \
allocar %v2 %r0 \
addr %v2 %v2 %fp \
/* fill stack buffer for next function */ \
prepare \
pushargr %v2 \
pushargi 16 \
finishi fill##T \
/* copy stack buffer to heap buffer */ \
prepare \
pushargr %v1 \
pushargr %v2 \
pushargi $(16 * szof##T) \
finishi MEMCPY \
/* call next function */ \
prepare \
pushargr %v2 \
PUSH##T(16) \
finishi test##T##_16 \
/* validate stack buffer */ \
prepare \
pushargr %v1 \
pushargr %v2 \
pushargi $(16 * szof##T) \
finishi @memcmp \
retval %r0 \
beqi test##T##_17_done %r0 0 \
calli @abort \
test##T##_17_done: \
/* release heap bufer */ \
prepare \
pushargr %v1 \
finishi @free \
ret \
epilog
#define DEF( T) \
DEF0( T) \
DEFN( 1, 0, T) \
DEFN( 2, 1, T) \
DEFN( 3, 2, T) \
DEFN( 4, 3, T) \
DEFN( 5, 4, T) \
DEFN( 6, 5, T) \
DEFN( 7, 6, T) \
DEFN( 8, 7, T) \
DEFN( 9, 8, T) \
DEFN(10, 9, T) \
DEFN(11, 10, T) \
DEFN(12, 11, T) \
DEFN(13, 12, T) \
DEFN(14, 13, T) \
DEFN(15, 14, T) \
DEFN(16, 15, T) \
DEFX(T)
#define CALL(T) calli test##T##_17
.data 16
fmt:
.c "%d %d %d\n"
.code
jmpi main
#if _AIX
# define MEMCPY memcpy
/* error: Function not implemented (memcpy) */
name memcpy
memcpy:
prolog
arg $dst
arg $src
arg $len
getarg %r0 $dst
getarg %r1 $src
getarg %r2 $len
movr %v1 %r0
blti memcpy_done %r2 1
memcpy_loop:
subi %r2 %r2 1
ldxr_c %v0 %r1 %r2
stxr_c %r2 %r0 %v0
bgti memcpy_loop %r2 0
memcpy_done:
retr %v1
epilog
#else
# define MEMCPY @memcpy
#endif
FILL(_c)
FILL(_s)
FILL(_i)
#if __WORDSIZE == 64
FILL(_l)
#endif
FILLF(_f)
FILLF(_d)
DEF(_c)
DEF(_uc)
DEF(_s)
DEF(_us)
DEF(_i)
#if __WORDSIZE == 64
DEF(_ui)
DEF(_l)
#endif
DEF(_f)
DEF(_d)
name main
main:
prolog
CALL(_c)
CALL(_uc)
CALL(_s)
CALL(_us)
CALL(_i)
#if __WORDSIZE == 64
CALL(_ui)
CALL(_l)
#endif
CALL(_f)
CALL(_d)
// loop control
movi %v2 1
// loop a few times calling allocar
loop:
// allocate 12 bytes
movi %r0 12
allocar %v0 %r0
// offset
movr %v1 %v0
// 1
stxr_i %v1 %fp %v2
// 2
addi %v2 %v2 1
addi %v1 %v1 4
stxr_i %v1 %fp %v2
// 3
addi %v2 %v2 1
addi %v1 %v1 4
stxr_i %v1 %fp %v2
// reload
movr %v1 %v0
// 1
ldxr_i %r0 %fp %v1
// 2
addi %v1 %v1 4
ldxr_i %r1 %fp %v1
// 3
addi %v1 %v1 4
ldxr_i %r2 %fp %v1
prepare
pushargi fmt
ellipsis
pushargr %r0
pushargr %r1
pushargr %r2
finishi @printf
blti loop %v2 9
ret
epilog
parallel-rsp/lightning/check/alu.inc
-360
View File
@@ -1,360 +0,0 @@
.data 8
ok:
.c "ok\n"
/* ia64 code generation is not optimized for size, and also some
* codes generate quite long sequences due to need for stops causing
* no code template match and needing to add nops, and other cases
* are division/remainder that needs function calls, or float division
* that requires a quite long sequence.
* (the brute force tests of all register combinations can easily
* generate several GB of jit).
*/
/* 3 operand */
/* reg0 = reg1 op reg2 */
#define ALUR(N, T, OP, I0, I1, V, R0, R1, R2) \
movi %R1 I0 \
movi %R2 I1 \
OP##r##T %R0 %R1 %R2 \
beqi OP##T##N##r_##R0##R1##R2 %R0 V \
calli @abort \
OP##T##N##r_##R0##R1##R2:
/* reg0 = reg1 op im */
#define ALUI(N, T, OP, I0, I1, V, R0, R1, R2) \
movi %R1 I0 \
movi %R2 V \
OP##i##T %R0 %R1 I1 \
beqr OP##T##N##i_##R0##R1##R2 %R0 %R2 \
calli @abort \
OP##T##N##i_##R0##R1##R2:
/* reg0 = reg0 op reg1 */
#define ALUR0(N, T, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I0 \
movi %R1 I1 \
movi %R2 V \
OP##r##T %R0 %R0 %R1 \
beqr OP##T##N##r_0##R0##R1##R2 %R0 %R2 \
calli @abort \
OP##T##N##r_0##R0##R1##R2:
/* reg0 = reg1 op reg0 */
#define ALUR1(N, T, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I1 \
movi %R1 I0 \
movi %R2 V \
OP##r##T %R0 %R1 %R0 \
beqr OP##T##N##r_1##R0##R1##R2 %R0 %R2 \
calli @abort \
OP##T##N##r_1##R0##R1##R2:
/* reg0 = reg0 op im */
#define ALUI0(N, T, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I0 \
movi %R1 V \
OP##i##T %R0 %R0 I1 \
beqr OP##T##N##i_0##R0##R1##R2 %R0 %R1 \
calli @abort \
OP##T##N##i_0##R0##R1##R2:
#define ALU3(N, T, OP, I0, I1, V, R0, R1, R2) \
ALUR(N, T, OP, I0, I1, V, R0, R1, R2) \
ALUI(N, T, OP, I0, I1, V, R0, R1, R2) \
ALUR0(N, T, OP, I0, I1, V, R0, R1, R2) \
ALUR1(N, T, OP, I0, I1, V, R0, R1, R2) \
ALUI0(N, T, OP, I0, I1, V, R0, R1, R2)
#define ALU2(N, T, OP, I0, I1, V, R0, R1, R2) \
ALU3(N, T, OP, I0, I1, V, R0, R1, R2) \
ALU3(N, T, OP, I0, I1, V, R0, R2, R1)
#define ALU1(N, T, OP, I0, I1, V, R0, R1, R2) \
ALU2(N, T, OP, I0, I1, V, R0, R1, R2) \
ALU2(N, T, OP, I0, I1, V, R1, R0, R2) \
ALU2(N, T, OP, I0, I1, V, R2, R1, R0)
#if __ia64__
# define ALU(N, T, OP, I0, I1, V) \
ALU3(N, T, OP, I0, I1, V, r0, r1, r2) \
ALU3(N, T, OP, I0, I1, V, v0, v1, v2)
#else
# define ALU(N, T, OP, I0, I1, V) \
ALU1(N, T, OP, I0, I1, V, v0, v1, v2) \
ALU1(N, T, OP, I0, I1, V, v0, v1, r0) \
ALU1(N, T, OP, I0, I1, V, v0, v1, r1) \
ALU1(N, T, OP, I0, I1, V, v0, v1, r2) \
ALU1(N, T, OP, I0, I1, V, v1, v2, r1) \
ALU1(N, T, OP, I0, I1, V, v1, v2, r2) \
ALU1(N, T, OP, I0, I1, V, v2, r0, r1) \
ALU1(N, T, OP, I0, I1, V, v2, r0, r2) \
ALU1(N, T, OP, I0, I1, V, r0, r1, r2)
#endif
/* 3 carry set/propagate */
/*
* r0 = i0
* r1 = i1
* r2 = 0
* r0 = r0 opc r1 <only want carry>
* r2 = r2 opx r2 <r2 must match v>
*/
#define ALUXII(N, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I0 \
movi %R2 0 \
OP##ci %R0 %R0 I1 \
OP##xi %R2 %R2 0 \
beqi OP##N##ii##R0##R1##R2 %R2 V \
calli @abort \
OP##N##ii##R0##R1##R2:
#define ALUXIR(N, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I0 \
movi %R2 0 \
OP##ci %R0 %R0 I1 \
OP##xr %R2 %R2 %R2 \
beqi OP##N##ir##R0##R1##R2 %R2 V \
calli @abort \
OP##N##ir##R0##R1##R2:
#define ALUXRI(N, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I0 \
movi %R1 I1 \
movi %R2 0 \
OP##cr %R0 %R0 %R1 \
OP##xi %R2 %R2 0 \
beqi OP##N##ri##R0##R1##R2 %R2 V \
calli @abort \
OP##N##ri##R0##R1##R2:
#define ALUXRR(N, OP, I0, I1, V, R0, R1, R2) \
movi %R0 I0 \
movi %R1 I1 \
movi %R2 0 \
OP##cr %R0 %R0 %R1 \
OP##xr %R2 %R2 %R2 \
beqi OP##N##rr##R0##R1##R2 %R2 V \
calli @abort \
OP##N##rr##R0##R1##R2:
#define ALUX2(N, OP, I0, I1, V, R0, R1, R2) \
ALUXII(N, OP, I0, I1, V, R0, R1, R2) \
ALUXIR(N, OP, I0, I1, V, R0, R1, R2) \
ALUXRI(N, OP, I0, I1, V, R0, R1, R2) \
ALUXRR(N, OP, I0, I1, V, R0, R1, R2)
#define ALUX1(N, OP, I0, I1, V, R0, R1, R2) \
ALUX2(N, OP, I0, I1, V, R0, R1, R2) \
ALUX2(N, OP, I0, I1, V, R0, R2, R1)
#define ALUX0(N, OP, I0, I1, V, R0, R1, R2) \
ALUX1(N, OP, I0, I1, V, R0, R1, R2) \
ALUX1(N, OP, I0, I1, V, R1, R0, R2) \
ALUX1(N, OP, I0, I1, V, R2, R1, R0)
#if __ia64__
# define ALUX(N, OP, I0, I1, V) \
ALUX2(N, OP, I0, I1, V, r0, r1, r2) \
ALUX2(N, OP, I0, I1, V, v0, v1, v2)
#else
# define ALUX(N, OP, I0, I1, V) \
ALUX0(N, OP, I0, I1, V, v0, v1, v2) \
ALUX0(N, OP, I0, I1, V, v0, v1, r0) \
ALUX0(N, OP, I0, I1, V, v0, v1, r1) \
ALUX0(N, OP, I0, I1, V, v0, v1, r2) \
ALUX0(N, OP, I0, I1, V, v1, v2, r0) \
ALUX0(N, OP, I0, I1, V, v1, v2, r1) \
ALUX0(N, OP, I0, I1, V, v1, v2, r2) \
ALUX0(N, OP, I0, I1, V, v2, r0, r1) \
ALUX0(N, OP, I0, I1, V, v2, r0, r2) \
ALUX0(N, OP, I0, I1, V, r0, r1, r2)
#endif
/* unary int */
#define UNR(N, OP, I, V, R0, R1) \
movi %R1 I \
OP##r %R0 %R1 \
beqi OP##N##R0##R1 %R0 V \
calli @abort \
OP##N##R0##R1:
#define UNRC(N, OP, I, V, R0, R1) \
movi %R0 I \
OP##r %R0 %R0 \
beqi OP##N##c##R0##R1 %R0 V \
calli @abort \
OP##N##c##R0##R1:
#define UN2(N, OP, I, V, R0, R1) \
UNR(N, OP, I, V, R0, R1) \
UNRC(N, OP, I, V, R0, R1)
#define UN1(N, OP, I, V, R0, R1) \
UN2(N, OP, I, V, R0, R1) \
UN2(N, OP, I, V, R1, R0)
#if __ia64__
# define UN(N, OP, I, V) \
UN2(N, OP, I, V, r0, r1) \
UN2(N, OP, I, V, v0, v1)
#else
# define UN(N, OP, I, V) \
UN1(N, OP, I, V, v0, v1) \
UN1(N, OP, I, V, v0, v2) \
UN1(N, OP, I, V, v0, r0) \
UN1(N, OP, I, V, v0, r1) \
UN1(N, OP, I, V, v0, r2) \
UN1(N, OP, I, V, v1, v2) \
UN1(N, OP, I, V, v1, r0) \
UN1(N, OP, I, V, v1, r1) \
UN1(N, OP, I, V, v1, r2) \
UN1(N, OP, I, V, v2, r0) \
UN1(N, OP, I, V, v2, r1) \
UN1(N, OP, I, V, v2, r2) \
UN1(N, OP, I, V, r0, r1) \
UN1(N, OP, I, V, r0, r2) \
UN1(N, OP, I, V, r1, r2)
#endif
/* reg0 = reg1 op reg2 */
#define FOPR(N, T, OP, I0, I1, V, F0, F1, F2) \
movi##T %F1 I0 \
movi##T %F2 I1 \
OP##r##T %F0 %F1 %F2 \
beqi##T OP##T##N##F0##F1##F2 %F0 V \
calli @abort \
OP##T##N##F0##F1##F2:
/* reg0 = reg0 op reg1 */
#define FOPR0(N, T, OP, I0, I1, V, F0, F1, F2) \
movi##T %F0 I0 \
movi##T %F1 I1 \
OP##r##T %F0 %F0 %F1 \
beqi##T OP##T##N##0##F0##F1##F2 %F0 V \
calli @abort \
OP##T##N##0##F0##F1##F2:
/* reg1 = reg0 op reg1 */
#define FOPR1(N, T, OP, I0, I1, V, F0, F1, F2) \
movi##T %F0 I0 \
movi##T %F1 I1 \
OP##r##T %F1 %F0 %F1 \
beqi##T OP##T##N##1##F0##F1##F2 %F1 V \
calli @abort \
OP##T##N##1##F0##F1##F2:
/* reg0 = reg1 op im */
#define FOPI(N, T, OP, I0, I1, V, F0, F1, F2) \
movi##T %F1 I0 \
movi##T %F2 V \
OP##i##T %F0 %F1 I1 \
beqr##T OP##T##N##i##F0##F1##F2 %F0 %F2 \
calli @abort \
OP##T##N##i##F0##F1##F2:
/* reg0 = reg0 op im */
#define FOPI0(N, T, OP, I0, I1, V, F0, F1, F2) \
movi##T %F0 I0 \
movi##T %F2 V \
OP##i##T %F0 %F0 I1 \
beqr##T OP##T##N##i0##F0##F1##F2 %F0 %F2 \
calli @abort \
OP##T##N##i0##F0##F1##F2:
#define FOP1(N, T, OP, I0, I1, V, F0, F1, F2) \
FOPR(N, T, OP, I0, I1, V, F0, F1, F2) \
FOPR0(N, T, OP, I0, I1, V, F0, F1, F2) \
FOPR1(N, T, OP, I0, I1, V, F0, F1, F2) \
FOPI(N, T, OP, I0, I1, V, F0, F1, F2) \
FOPI0(N, T, OP, I0, I1, V, F0, F1, F2)
#if __ia64__
# define FOP(N, T, OP, I0, I1, V) \
FOP1(N, T, OP, I0, I1, V, f0, f1, f2)
#else
# define FOP(N, T, OP, I0, I1, V) \
FOP1(N, T, OP, I0, I1, V, f0, f1, f2) \
FOP1(N, T, OP, I0, I1, V, f0, f2, f3) \
FOP1(N, T, OP, I0, I1, V, f0, f3, f4) \
FOP1(N, T, OP, I0, I1, V, f0, f5, f1)
#endif
/* unary float */
#define FUNR(N, T, OP, I, V, R0, R1) \
movi##T %R1 I \
OP##r##T %R0 %R1 \
beqi##T OP##N##T##R0##R1 %R0 V \
calli @abort \
OP##N##T##R0##R1:
#define FUNRC(N, T, OP, I, V, R0, R1) \
movi##T %R0 I \
OP##r##T %R0 %R0 \
beqi##T OP##N##T##c##R0##R1 %R0 V \
calli @abort \
OP##N##T##c##R0##R1:
#define FUN2(N, T, OP, I, V, R0, R1) \
FUNR(N, T, OP, I, V, R0, R1) \
FUNRC(N, T, OP, I, V, R0, R1)
#define FUN1(N, T, OP, I, V, R0, R1) \
FUN2(N, T, OP, I, V, R0, R1) \
FUN2(N, T, OP, I, V, R1, R0)
#if __ia64__
# define FUN(N, T, OP, I, V) \
FUN2(N, T, OP, I, V, f0, f1)
#else
# define FUN(N, T, OP, I, V) \
FUN1(N, T, OP, I, V, f0, f1) \
FUN1(N, T, OP, I, V, f0, f2) \
FUN1(N, T, OP, I, V, f0, f3) \
FUN1(N, T, OP, I, V, f0, f4) \
FUN1(N, T, OP, I, V, f0, f5)
#endif
/* unordered comparison unary float */
#define UFUNR(N, T, OP, I, V, R0, R1) \
movi##T %R1 I \
OP##r##T %R0 %R1 \
buneqi##T OP##N##T##u##R0##R1 %R0 V \
calli @abort \
OP##N##T##u##R0##R1:
#define UFUNRC(N, T, OP, I, V, R0, R1) \
movi##T %R0 I \
OP##r##T %R0 %R0 \
buneqi##T OP##N##T##uc##R0##R1 %R0 V \
calli @abort \
OP##N##T##uc##R0##R1:
#define UFUN2(N, T, OP, I, V, R0, R1) \
UFUNR(N, T, OP, I, V, R0, R1) \
UFUNRC(N, T, OP, I, V, R0, R1)
#define UFUN1(N, T, OP, I, V, R0, R1) \
UFUN2(N, T, OP, I, V, R0, R1) \
UFUN2(N, T, OP, I, V, R1, R0)
#if __ia64__
# define UFUN(N, T, OP, I, V) \
UFUN2(N, T, OP, I, V, f0, f1)
#else
# define UFUN(N, T, OP, I, V) \
UFUN1(N, T, OP, I, V, f0, f1) \
UFUN1(N, T, OP, I, V, f0, f2) \
UFUN1(N, T, OP, I, V, f0, f3) \
UFUN1(N, T, OP, I, V, f0, f4) \
UFUN1(N, T, OP, I, V, f0, f5)
#endif
. $( $NaN = 0.0/0.0)
. $( $Inf = 1.0/0.0)
. $($nInf = -1.0/0.0)
parallel-rsp/lightning/check/alu_add.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_add.tst
-47
View File
@@ -1,47 +0,0 @@
#include "alu.inc"
.code
prolog
#define ADD(N, I0, I1, V) ALU(N, , add, I0, I1, V)
ADD(0, 0x7fffffff, 1, 0x80000000)
ADD(1, 1, 0x7fffffff, 0x80000000)
ADD(2, 0x80000000, 1, 0x80000001)
ADD(3, 1, 0x80000000, 0x80000001)
ADD(4, 0x7fffffff, 0x80000000, 0xffffffff)
ADD(5, 0x80000000, 0x7fffffff, 0xffffffff)
ADD(6, 0x7fffffff, 0, 0x7fffffff)
ADD(7, 0, 0x7fffffff, 0x7fffffff)
#if __WORDSIZE == 32
ADD(8, 0x7fffffff, 0xffffffff, 0x7ffffffe)
ADD(9, 0xffffffff, 0x7fffffff, 0x7ffffffe)
ADD(10, 0xffffffff, 0xffffffff, 0xfffffffe)
#else
ADD(8, 0x7fffffff, 0xffffffff, 0x17ffffffe)
ADD(9, 0xffffffff, 0x7fffffff, 0x17ffffffe)
ADD(10, 0xffffffff, 0xffffffff, 0x1fffffffe)
ADD(11, 0x7fffffffffffffff, 1, 0x8000000000000000)
ADD(12, 1, 0x7fffffffffffffff, 0x8000000000000000)
ADD(13, 0x8000000000000000, 1, 0x8000000000000001)
ADD(14, 1, 0x8000000000000000, 0x8000000000000001)
ADD(15, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff)
ADD(16, 0x8000000000000000, 0x7fffffffffffffff, 0xffffffffffffffff)
ADD(17, 0x7fffffffffffffff, 0xffffffffffffffff, 0x7ffffffffffffffe)
ADD(18, 0x7fffffffffffffff, 0x7fffffffffffffff, 0xfffffffffffffffe)
ADD(19, 0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffffe)
#endif
#undef ADD
#define ADD(N, T, I0, I1, V) FOP(N, T, add, I0, I1, V)
ADD(0, _f, -0.5, 0.5, 0.0)
ADD(1, _f, 0.25, 0.75, 1.0)
ADD(0, _d, -0.5, 0.5, 0.0)
ADD(1, _d, 0.25, 0.75, 1.0)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_and.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_and.tst
-36
View File
@@ -1,36 +0,0 @@
#include "alu.inc"
.code
prolog
#define AND(N, I0, I1, V) ALU(N, , and, I0, I1, V)
AND(0, 0x7fffffff, 1, 1)
AND(1, 1, 0x7fffffff, 1)
AND(2, 0x80000000, 1, 0)
AND(3, 1, 0x80000000, 0)
AND(4, 0x7fffffff, 0x80000000, 0)
AND(5, 0x80000000, 0x7fffffff, 0)
AND(6, 0x7fffffff, 0xffffffff, 0x7fffffff)
AND(7, 0xffffffff, 0x7fffffff, 0x7fffffff)
AND(8, 0xffffffff, 0xffffffff, 0xffffffff)
AND(9, 0x7fffffff, 0, 0)
AND(10, 0, 0x7fffffff, 0)
#if __WORDSIZE == 64
AND(11, 0x7fffffffffffffff, 1, 1)
AND(12, 1, 0x7fffffffffffffff, 1)
AND(13, 0x8000000000000000, 1, 0)
AND(14, 1, 0x8000000000000000, 0)
AND(15, 0x7fffffffffffffff, 0x8000000000000000, 0)
AND(16, 0x8000000000000000, 0x7fffffffffffffff, 0)
AND(17, 0x7fffffffffffffff, 0xffffffffffffffff, 0x7fffffffffffffff)
AND(18, 0xffffffffffffffff, 0x7fffffffffffffff, 0x7fffffffffffffff)
AND(19, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_com.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_com.tst
-33
View File
@@ -1,33 +0,0 @@
#include "alu.inc"
.code
prolog
#define COM(N, I0, V) UN(N, com, I0, V)
#if __WORDSIZE == 32
COM(0, 0, 0xffffffff)
COM(1, 1, 0xfffffffe)
COM(2, 0xffffffff, 0)
COM(3, 0x80000000, 0x7fffffff)
COM(4, 0x7fffffff, 0x80000000)
COM(5, 0x80000001, 0x7ffffffe)
#else
COM(0, 0, 0xffffffffffffffff)
COM(1, 1, 0xfffffffffffffffe)
COM(2, 0xffffffff, 0xffffffff00000000)
COM(3, 0x80000000, 0xffffffff7fffffff)
COM(4, 0x7fffffff, 0xffffffff80000000)
COM(5, 0x80000001, 0xffffffff7ffffffe)
COM(6, 0xffffffffffffffff, 0)
COM(7, 0x8000000000000000, 0x7fffffffffffffff)
COM(8, 0x7fffffffffffffff, 0x8000000000000000)
COM(9, 0x8000000000000001, 0x7ffffffffffffffe)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_div.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_div.tst
-83
View File
@@ -1,83 +0,0 @@
#include "alu.inc"
.code
prolog
#define DIV(N, I0, I1, V) ALU(N, , div, I0, I1, V)
#define UDIV(N, I0, I1, V) ALU(N, _u, div, I0, I1, V)
DIV(0, 0x7fffffff, 1, 0x7fffffff)
DIV(1, 1, 0x7fffffff, 0)
DIV(2, 0x80000000, 1, 0x80000000)
DIV(3, 1, 0x80000000, 0)
DIV(4, 0x7fffffff, 2, 0x3fffffff)
DIV(5, 2, 0x7fffffff, 0)
DIV(6, 2, 0x80000000, 0)
DIV(7, 0x7fffffff, 0x80000000, 0)
DIV(8, 0, 0x7fffffff, 0)
DIV(9, 0xffffffff, 0xffffffff, 1)
UDIV(0, 0x7fffffff, 1, 0x7fffffff)
UDIV(1, 1, 0x7fffffff, 0)
UDIV(2, 0x80000000, 1, 0x80000000)
UDIV(3, 1, 0x80000000, 0)
UDIV(4, 0x7fffffff, 2, 0x3fffffff)
UDIV(5, 2, 0x7fffffff, 0)
UDIV(6, 0x80000000, 2, 0x40000000)
UDIV(7, 2, 0x80000000, 0)
UDIV(8, 0x7fffffff, 0x80000000, 0)
UDIV(9, 0x80000000, 0x7fffffff, 1)
UDIV(10,0, 0x7fffffff, 0)
UDIV(11,0x7fffffff, 0xffffffff, 0)
UDIV(12,0xffffffff, 0x7fffffff, 2)
UDIV(13,0xffffffff, 0xffffffff, 1)
#if __WORDSIZE == 32
DIV(10, 0x80000000, 2, 0xc0000000)
DIV(11, 0x80000000, 0x7fffffff, 0xffffffff)
DIV(12, 0x7fffffff, 0xffffffff, 0x80000001)
DIV(13, 0xffffffff, 0x7fffffff, 0)
#else
DIV(10, 0x80000000, 2, 0x40000000)
DIV(11, 0x80000000, 0x7fffffff, 1)
DIV(12, 0x7fffffff, 0xffffffff, 0)
DIV(13, 0xffffffff, 0x7fffffff, 2)
DIV(14, 0x7fffffffffffffff, 1, 0x7fffffffffffffff)
DIV(15, 1, 0x7fffffffffffffff, 0)
DIV(16, 0x8000000000000000, 1, 0x8000000000000000)
DIV(17, 1, 0x8000000000000000, 0)
DIV(18, 0x7fffffffffffffff, 2, 0x3fffffffffffffff)
DIV(19, 2, 0x7fffffffffffffff, 0)
DIV(20, 0x8000000000000000, 2, 0xc000000000000000)
DIV(21, 2, 0x8000000000000000, 0)
DIV(22, 0x7fffffffffffffff, 0x8000000000000000, 0)
DIV(23, 0x8000000000000000, 0x7fffffffffffffff, 0xffffffffffffffff)
DIV(24, 0x7fffffffffffffff, 0xffffffffffffffff, 0x8000000000000001)
DIV(25, 0xffffffffffffffff, 0x7fffffffffffffff, 0)
DIV(26, 0xffffffffffffffff, 0xffffffffffffffff, 1)
UDIV(14,0x7fffffffffffffff, 1, 0x7fffffffffffffff)
UDIV(15,1, 0x7fffffffffffffff, 0)
UDIV(16,0x8000000000000000, 1, 0x8000000000000000)
UDIV(17,1, 0x8000000000000000, 0)
UDIV(18,0x7fffffffffffffff, 2, 0x3fffffffffffffff)
UDIV(19,2, 0x7fffffffffffffff, 0)
UDIV(20,0x8000000000000000, 2, 0x4000000000000000)
UDIV(21,2, 0x8000000000000000, 0)
UDIV(22,0x7fffffffffffffff, 0x8000000000000000, 0)
UDIV(23,0x8000000000000000, 0x7fffffffffffffff, 1)
UDIV(24,0x7fffffffffffffff, 0xffffffffffffffff, 0)
UDIV(25,0xffffffffffffffff, 0x7fffffffffffffff, 2)
UDIV(26,0xffffffffffffffff, 0xffffffffffffffff, 1)
#endif
#undef DIV
#define DIV(N, T, I0, I1, V) FOP(N, T, div, I0, I1, V)
DIV(0, _f, -0.5, 0.5, -1.0)
DIV(1, _f, 1.25, 0.5, 2.5)
DIV(0, _d, -0.5, 0.5, -1.0)
DIV(1, _d, 1.25, 0.5, 2.5)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_lsh.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_lsh.tst
-57
View File
@@ -1,57 +0,0 @@
#include "alu.inc"
.code
prolog
#define LSH(N, I0, I1, V) ALU(N, , lsh, I0, I1, V)
LSH(0, 0x7f, 1, 0xfe)
LSH(1, 0x7fff, 2, 0x1fffc)
LSH(2, 0x81, 16, 0x810000)
LSH(3, 0xff, 15, 0x7f8000)
LSH(4, 0x7fffffff, 0, 0x7fffffff)
#if __WORDSIZE == 32
LSH(5, 0xffffffff, 8, 0xffffff00)
LSH(6, 0x7fffffff, 3, 0xfffffff8)
LSH(7, -0x7f, 31, 0x80000000)
LSH(8, -0x7fff, 30, 0x40000000)
LSH(9, -0x7fffffff, 29, 0x20000000)
LSH(10, 0x80000001, 28, 0x10000000)
LSH(11, 0x8001, 17, 0x20000)
LSH(12, 0x80000001, 18, 0x40000)
LSH(13, -0xffff, 24, 0x1000000)
#else
LSH(5, 0xffffffff, 8, 0xffffffff00)
LSH(6, 0x7fffffff, 3, 0x3fffffff8)
LSH(7, -0x7f, 31, 0xffffffc080000000)
LSH(8, -0x7fff, 30, 0xffffe00040000000)
LSH(9, -0x7fffffff, 29, 0xf000000020000000)
LSH(10, 0x80000001, 28, 0x800000010000000)
LSH(11, 0x8001, 17, 0x100020000)
LSH(12, 0x80000001, 18, 0x2000000040000)
LSH(13, -0xffff, 24, 0xffffff0001000000)
LSH(14, 0x7f, 33, 0xfe00000000)
LSH(15, 0x7ffff, 34, 0x1ffffc00000000)
LSH(16, 0x7fffffff, 35, 0xfffffff800000000)
LSH(17, -0x7f, 63, 0x8000000000000000)
LSH(18, -0x7fff, 62, 0x4000000000000000)
LSH(19, -0x7fffffff, 61, 0x2000000000000000)
LSH(20, 0x80000001, 60, 0x1000000000000000)
LSH(21, 0x81, 48, 0x81000000000000)
LSH(22, 0x8001, 49, 0x2000000000000)
LSH(23, 0x80000001, 40, 0x10000000000)
LSH(24, 0xff, 47, 0x7f800000000000)
LSH(25, 0xffff0001, 56, 0x100000000000000)
LSH(26, 0xffffffff, 40, 0xffffff0000000000)
LSH(27, 0x7fffffffff, 33, 0xfffffffe00000000)
LSH(28, -0x7fffffffff, 63, 0x8000000000000000)
LSH(29, 0x8000000001, 48, 0x1000000000000)
LSH(30, 0xffffffffff, 47, 0xffff800000000000)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_mul.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_mul.tst
-59
View File
@@ -1,59 +0,0 @@
#include "alu.inc"
.code
prolog
#define MUL(N, I0, I1, V) ALU(N, , mul, I0, I1, V)
MUL(0, 0x7fffffff, 1, 0x7fffffff)
MUL(1, 1, 0x7fffffff, 0x7fffffff)
MUL(2, 0x80000000, 1, 0x80000000)
MUL(3, 1, 0x80000000, 0x80000000)
MUL(4, 0x7fffffff, 2, 0xfffffffe)
MUL(5, 2, 0x7fffffff, 0xfffffffe)
MUL(6, 0x7fffffff, 0, 0)
MUL(7, 0, 0x7fffffff, 0)
#if __WORDSIZE == 32
MUL(8, 0x80000000, 2, 0)
MUL(9, 2, 0x80000000, 0)
MUL(10, 0x7fffffff, 0x80000000, 0x80000000)
MUL(11, 0x80000000, 0x7fffffff, 0x80000000)
MUL(12, 0x7fffffff, 0xffffffff, 0x80000001)
MUL(13, 0xffffffff, 0x7fffffff, 0x80000001)
MUL(14, 0xffffffff, 0xffffffff, 1)
#else
MUL(8, 0x80000000, 2, 0x100000000)
MUL(9, 2, 0x80000000, 0x100000000)
MUL(10, 0x7fffffff, 0x80000000, 0x3fffffff80000000)
MUL(11, 0x80000000, 0x7fffffff, 0x3fffffff80000000)
MUL(12, 0x7fffffff, 0xffffffff, 0x7ffffffe80000001)
MUL(13, 0xffffffff, 0x7fffffff, 0x7ffffffe80000001)
MUL(14, 0xffffffff, 0xffffffff, 0xfffffffe00000001)
MUL(15, 0x7fffffffffffffff, 1, 0x7fffffffffffffff)
MUL(16, 1, 0x7fffffffffffffff, 0x7fffffffffffffff)
MUL(17, 0x8000000000000000, 1, 0x8000000000000000)
MUL(18, 1, 0x8000000000000000, 0x8000000000000000)
MUL(19, 0x7fffffffffffffff, 2, 0xfffffffffffffffe)
MUL(20, 2, 0x7fffffffffffffff, 0xfffffffffffffffe)
MUL(21, 0x8000000000000000, 2, 0)
MUL(22, 2, 0x8000000000000000, 0)
MUL(23, 0x7fffffffffffffff, 0x8000000000000000, 0x8000000000000000)
MUL(24, 0x8000000000000000, 0x7fffffffffffffff, 0x8000000000000000)
MUL(25, 0x7fffffffffffffff, 0xffffffffffffffff, 0x8000000000000001)
MUL(26, 0xffffffffffffffff, 0x7fffffffffffffff, 0x8000000000000001)
MUL(27, 0xffffffffffffffff, 0xffffffffffffffff, 1)
#endif
#undef MUL
#define MUL(N, T, I0, I1, V) FOP(N, T, mul, I0, I1, V)
MUL(0, _f, -0.5, 0.5, -0.25)
MUL(1, _f, 0.25, 0.75, 0.1875)
MUL(0, _d, -0.5, 0.5, -0.25)
MUL(1, _d, 0.25, 0.75, 0.1875)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_neg.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_neg.tst
-42
View File
@@ -1,42 +0,0 @@
#include "alu.inc"
.code
prolog
#define NEG(N, I, V) UN(N, neg, I, V)
NEG(0, 0, 0)
#if __WORDSIZE == 32
NEG(1, 1, 0xffffffff)
NEG(2, 0xffffffff, 1)
NEG(3, 0x80000000, 0x80000000)
NEG(4, 0x7fffffff, 0x80000001)
NEG(5, 0x80000001, 0x7fffffff)
#else
NEG(1, 1, 0xffffffffffffffff)
NEG(2, 0xffffffff, 0xffffffff00000001)
NEG(3, 0x80000000, 0xffffffff80000000)
NEG(4, 0x7fffffff, 0xffffffff80000001)
NEG(5, 0x80000001, 0xffffffff7fffffff)
NEG(6, 0xffffffffffffffff, 1)
NEG(7, 0x8000000000000000, 0x8000000000000000)
NEG(8, 0x7fffffffffffffff, 0x8000000000000001)
#endif
#undef NEG
#define NEG(N, T, I, V) FUN(N, T, neg, I, V)
NEG(0, _f, 0.0, -0.0)
NEG(1, _f, 0.5, -0.5)
NEG(2, _f, $(1 / 0.0), $(-1.0 / 0))
NEG(3, _f, -1.25, 1.25)
NEG(0, _d, 0.0, -0.0)
NEG(1, _d, 0.5, -0.5)
NEG(2, _d, $(1.0 / 0), $(-1 / 0.0))
NEG(3, _d, -1.25, 1.25)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_or.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_or.tst
-36
View File
@@ -1,36 +0,0 @@
#include "alu.inc"
.code
prolog
#define OR(N, I0, I1, V) ALU(N, , or, I0, I1, V)
OR(0, 0x7fffffff, 1, 0x7fffffff)
OR(1, 1, 0x7fffffff, 0x7fffffff)
OR(2, 0x80000000, 1, 0x80000001)
OR(3, 1, 0x80000000, 0x80000001)
OR(4, 0x7fffffff, 0x80000000, 0xffffffff)
OR(5, 0x80000000, 0x7fffffff, 0xffffffff)
OR(6, 0x7fffffff, 0xffffffff, 0xffffffff)
OR(7, 0xffffffff, 0x7fffffff, 0xffffffff)
OR(8, 0xffffffff, 0xffffffff, 0xffffffff)
OR(9, 0x7fffffff, 0, 0x7fffffff)
OR(10, 0, 0x7fffffff, 0x7fffffff)
#if __WORDSIZE == 64
OR(11, 0x7fffffffffffffff, 1, 0x7fffffffffffffff)
OR(12, 1, 0x7fffffffffffffff, 0x7fffffffffffffff)
OR(13, 0x8000000000000000, 1, 0x8000000000000001)
OR(14, 1, 0x8000000000000000, 0x8000000000000001)
OR(15, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff)
OR(16, 0x8000000000000000, 0x7fffffffffffffff, 0xffffffffffffffff)
OR(17, 0x7fffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff)
OR(18, 0xffffffffffffffff, 0x7fffffffffffffff, 0xffffffffffffffff)
OR(19, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_rem.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_rem.tst
-76
View File
@@ -1,76 +0,0 @@
#include "alu.inc"
.code
prolog
#define REM(N, I0, I1, V) ALU(N, , rem, I0, I1, V)
#define UREM(N, I0, I1, V) ALU(N, _u, rem, I0, I1, V)
REM(0, 0x7fffffff, 1, 0)
REM(1, 1, 0x7fffffff, 1)
REM(2, 0x80000000, 1, 0)
REM(3, 1, 0x80000000, 1)
REM(4, 0x7fffffff, 2, 1)
REM(5, 2, 0x7fffffff, 2)
REM(6, 0x80000000, 2, 0)
REM(7, 2, 0x80000000, 2)
REM(8, 0x7fffffff, 0x80000000, 0x7fffffff)
REM(9, 0, 0x7fffffff, 0)
REM(10, 0xffffffff, 0xffffffff, 0)
UREM(0, 0x7fffffff, 1, 0)
UREM(1, 1, 0x7fffffff, 1)
UREM(2, 0x80000000, 1, 0)
UREM(3, 1, 0x80000000, 1)
UREM(4, 0x7fffffff, 2, 1)
UREM(5, 2, 0x7fffffff, 2)
UREM(6, 0x80000000, 2, 0)
UREM(7, 2, 0x80000000, 2)
UREM(8, 0x7fffffff, 0x80000000, 0x7fffffff)
UREM(9, 0x80000000, 0x7fffffff, 1)
UREM(10,0, 0x7fffffff, 0)
UREM(11,0x7fffffff, 0xffffffff, 0x7fffffff)
UREM(12,0xffffffff, 0x7fffffff, 1)
UREM(13,0xffffffff, 0xffffffff, 0)
#if __WORDSIZE == 32
REM(11, 0x80000000, 0x7fffffff, 0xffffffff)
REM(12, 0x7fffffff, 0xffffffff, 0)
REM(13, 0xffffffff, 0x7fffffff, 0xffffffff)
#else
REM(11, 0x80000000, 0x7fffffff, 1)
REM(12, 0x7fffffff, 0xffffffff, 0x7fffffff)
REM(13, 0xffffffff, 0x7fffffff, 1)
REM(14, 0x7fffffffffffffff, 1, 0)
REM(15, 1, 0x7fffffffffffffff, 1)
REM(16, 0x8000000000000000, 1, 0)
REM(17, 1, 0x8000000000000000, 1)
REM(18, 0x7fffffffffffffff, 2, 1)
REM(19, 2, 0x7fffffffffffffff, 2)
REM(20, 0x8000000000000000, 2, 0)
REM(21, 2, 0x8000000000000000, 2)
REM(22, 0x7fffffffffffffff, 0x8000000000000000, 0x7fffffffffffffff)
REM(23, 0x8000000000000000, 0x7fffffffffffffff, 0xffffffffffffffff)
REM(24, 0x7fffffffffffffff, 0xffffffffffffffff, 0)
REM(25, 0xffffffffffffffff, 0x7fffffffffffffff, 0xffffffffffffffff)
REM(26, 0xffffffffffffffff, 0xffffffffffffffff, 0)
UREM(14,0x7fffffffffffffff, 1, 0)
UREM(15,1, 0x7fffffffffffffff, 1)
UREM(16,0x8000000000000000, 1, 0)
UREM(17,1, 0x8000000000000000, 1)
UREM(18,0x7fffffffffffffff, 2, 1)
UREM(19,2, 0x7fffffffffffffff, 2)
UREM(20,0x8000000000000000, 2, 0)
UREM(21,2, 0x8000000000000000, 2)
UREM(22,0x7fffffffffffffff, 0x8000000000000000, 0x7fffffffffffffff)
UREM(23,0x8000000000000000, 0x7fffffffffffffff, 1)
UREM(24,0x7fffffffffffffff, 0xffffffffffffffff, 0x7fffffffffffffff)
UREM(25,0xffffffffffffffff, 0x7fffffffffffffff, 1)
UREM(26,0xffffffffffffffff, 0xffffffffffffffff, 0)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_rsb.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_rsb.tst
-49
View File
@@ -1,49 +0,0 @@
#include "alu.inc"
.code
prolog
#define RSB(N, I0, I1, V) ALU(N, , rsb, I0, I1, V)
RSB(0, 1, 0x7fffffff, 0x7ffffffe)
RSB(2, 1, 0x80000000, 0x7fffffff)
RSB(3, 0x7fffffff, 0x80000000, 1)
RSB(4, 0xffffffff, 0xffffffff, 0)
RSB(5, 0x7fffffff, 0xffffffff, 0x80000000)
RSB(6, 0, 0x7fffffff, 0x7fffffff)
#if __WORDSIZE == 32
RSB(7, 0x7fffffff, 1, 0x80000002)
RSB(8, 0x80000000, 1, 0x80000001)
RSB(9, 0x80000000, 0x7fffffff, 0xffffffff)
RSB(10, 0xffffffff, 0x7fffffff, 0x80000000)
RSB(11, 0x7fffffff, 0, 0x80000001)
#else
RSB(7, 0x7fffffff, 1, 0xffffffff80000002)
RSB(8, 0xffffffff80000000, 1, 0x80000001)
RSB(9, 0xffffffff80000000, 0x7fffffff, 0xffffffff)
RSB(10, 0xffffffffffffffff, 0xffffffff7fffffff, 0xffffffff80000000)
RSB(11, 0x7fffffff, 0, 0xffffffff80000001)
RSB(12, 1, 0x7fffffffffffffff, 0x7ffffffffffffffe)
RSB(13, 0x7fffffffffffffff, 1, 0x8000000000000002)
RSB(14, 1, 0x8000000000000000, 0x7fffffffffffffff)
RSB(15, 0x8000000000000000, 1, 0x8000000000000001)
RSB(16, 0x8000000000000000, 0x7fffffffffffffff, 0xffffffffffffffff)
RSB(17, 0x7fffffffffffffff, 0x8000000000000000, 1)
RSB(18, 0xffffffffffffffff, 0x7fffffffffffffff, 0x8000000000000000)
RSB(19, 0x7fffffffffffffff, 0xffffffffffffffff, 0x8000000000000000)
RSB(20, 0xffffffffffffffff, 0xffffffffffffffff, 0)
#endif
#undef RSB
#define RSB(N, T, I0, I1, V) FOP(N, T, rsb, I0, I1, V)
RSB(0, _f, 0.5, -0.5, -1.0)
RSB(1, _f, 0.75, 0.25, -0.5)
RSB(0, _d, 0.5, -0.5, -1.0)
RSB(1, _d, 0.75, 0.25, -0.5)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_rsh.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_rsh.tst
-85
View File
@@ -1,85 +0,0 @@
#include "alu.inc"
.code
prolog
#define RSH(N, I0, I1, V) ALU(N, , rsh, I0, I1, V)
#define URSH(N, I0, I1, V) ALU(N, _u, rsh, I0, I1, V)
RSH(0, 0xfe, 1, 0x7f)
RSH(1, 0x1fffc, 2, 0x7fff)
RSH(2, 0x40000000, 30, 1)
RSH(3, 0x20000000, 29, 1)
RSH(4, 0x10000000, 28, 1)
RSH(5, 0x810000, 16, 0x81)
RSH(6, 0x20000, 17, 1)
RSH(7, 0x40000, 18, 1)
RSH(8, 0x7f8000, 15, 0xff)
RSH(9, 0x1000000, 24, 1)
RSH(10, 0x7fffffff, 0, 0x7fffffff)
URSH(0, 0xfe, 1, 0x7f)
URSH(1, 0x1fffc, 2, 0x7fff)
URSH(2, 0x80000000, 31, 1)
URSH(3, 0x40000000, 30, 1)
URSH(4, 0x20000000, 29, 1)
URSH(5, 0x10000000, 28, 1)
URSH(6, 0x810000, 16, 0x81)
URSH(7, 0x20000, 17, 1)
URSH(8, 0x40000, 18, 1)
URSH(9,0x7f8000, 15, 0xff)
URSH(10,0x1000000, 24, 1)
URSH(11,0xffffff00, 8, 0xffffff)
URSH(12,0x7fffffff, 0, 0x7fffffff)
#if __WORDSIZE == 32
RSH(11, 0xfffffff8, 3, 0xffffffff)
RSH(12, 0x80000000, 31, 0xffffffff)
RSH(13, 0xffffff00, 8, 0xffffffff)
URSH(13,0xfffffff8, 3, 0x1fffffff)
#else
RSH(11, 0x3fffffff8, 3, 0x7fffffff)
RSH(12, 0xffffffc080000000, 31, 0xffffffffffffff81)
RSH(13, 0xffffff00, 8, 0xffffff)
RSH(14, 0xfe00000000, 33, 0x7f)
RSH(15, 0x1ffffc00000000, 34, 0x7ffff)
RSH(16, 0xfffffff800000000, 29, 0xffffffffffffffc0)
RSH(17, 0x8000000000000000, 63, 0xffffffffffffffff)
RSH(18, 0x4000000000000000, 62, 1)
RSH(19, 0x2000000000000000, 61, 1)
RSH(20, 0x1000000000000000, 60, 1)
RSH(21, 0x81000000000000, 48, 0x81)
RSH(22, 0x2000000000000, 49, 1)
RSH(23, 0x10000000000, 40, 1)
RSH(24, 0x7f800000000000, 47, 0xff)
RSH(25, 0x100000000000000, 56, 1)
RSH(26, 0xffffff0000000000, 40, 0xffffffffffffffff)
RSH(27, 0xfffffffe00000000, 33, 0xffffffffffffffff)
RSH(28, 0x8000000000000001, 63, 0xffffffffffffffff)
RSH(29, 0x1000000000000, 48, 1)
RSH(30, 0xffff800000000000, 47, 0xffffffffffffffff)
URSH(13,0x3fffffff8, 3, 0x7fffffff)
URSH(14,0xffffffc080000000, 31, 0x1ffffff81)
URSH(15,0xfe00000000, 33, 0x7f)
URSH(16,0x1ffffc00000000, 34, 0x7ffff)
URSH(17,0xfffffff800000000, 29, 0x7ffffffc0)
URSH(18,0x8000000000000000, 63, 1)
URSH(19,0x4000000000000000, 62, 1)
URSH(20,0x2000000000000000, 61, 1)
URSH(21,0x1000000000000000, 60, 1)
URSH(22,0x81000000000000, 48, 0x81)
URSH(23,0x2000000000000, 49, 1)
URSH(24,0x10000000000, 40, 1)
URSH(25,0x7f800000000000, 47, 0xff)
URSH(26,0x100000000000000, 56, 1)
URSH(27,0xffffff0000000000, 40, 0xffffff)
URSH(28,0xfffffffe00000000, 33, 0x7fffffff)
URSH(29,0x8000000000000001, 63, 1)
URSH(30,0x1000000000000, 48, 1)
URSH(31,0xffff800000000000, 47, 0x1ffff)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_sub.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_sub.tst
-49
View File
@@ -1,49 +0,0 @@
#include "alu.inc"
.code
prolog
#define SUB(N, I0, I1, V) ALU(N, , sub, I0, I1, V)
SUB(0, 0x7fffffff, 1, 0x7ffffffe)
SUB(2, 0x80000000, 1, 0x7fffffff)
SUB(3, 0x80000000, 0x7fffffff, 1)
SUB(4, 0xffffffff, 0xffffffff, 0)
SUB(5, 0xffffffff, 0x7fffffff, 0x80000000)
SUB(6, 0x7fffffff, 0, 0x7fffffff)
#if __WORDSIZE == 32
SUB(7, 1, 0x7fffffff, 0x80000002)
SUB(8, 1, 0x80000000, 0x80000001)
SUB(9, 0x7fffffff, 0x80000000, 0xffffffff)
SUB(10, 0x7fffffff, 0xffffffff, 0x80000000)
SUB(11, 0, 0x7fffffff, 0x80000001)
#else
SUB(7, 1, 0x7fffffff, 0xffffffff80000002)
SUB(8, 1, 0xffffffff80000000, 0x80000001)
SUB(9, 0x7fffffff, 0xffffffff80000000, 0xffffffff)
SUB(10, 0xffffffff7fffffff, 0xffffffffffffffff, 0xffffffff80000000)
SUB(11, 0, 0x7fffffff, 0xffffffff80000001)
SUB(12, 0x7fffffffffffffff, 1, 0x7ffffffffffffffe)
SUB(13, 1, 0x7fffffffffffffff, 0x8000000000000002)
SUB(14, 0x8000000000000000, 1, 0x7fffffffffffffff)
SUB(15, 1, 0x8000000000000000, 0x8000000000000001)
SUB(16, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff)
SUB(17, 0x8000000000000000, 0x7fffffffffffffff, 1)
SUB(18, 0x7fffffffffffffff, 0xffffffffffffffff, 0x8000000000000000)
SUB(19, 0xffffffffffffffff, 0x7fffffffffffffff, 0x8000000000000000)
SUB(20, 0xffffffffffffffff, 0xffffffffffffffff, 0)
#endif
#undef SUB
#define SUB(N, T, I0, I1, V) FOP(N, T, sub, I0, I1, V)
SUB(0, _f, -0.5, 0.5, -1.0)
SUB(1, _f, 0.25, 0.75, -0.5)
SUB(0, _d, -0.5, 0.5, -1.0)
SUB(1, _d, 0.25, 0.75, -0.5)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alu_xor.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alu_xor.tst
-36
View File
@@ -1,36 +0,0 @@
#include "alu.inc"
.code
prolog
#define XOR(N, I0, I1, V) ALU(N, , xor, I0, I1, V)
XOR(0, 0x7fffffff, 1, 0x7ffffffe)
XOR(1, 1, 0x7fffffff, 0x7ffffffe)
XOR(2, 0x80000000, 1, 0x80000001)
XOR(3, 1, 0x80000000, 0x80000001)
XOR(4, 0x7fffffff, 0x80000000, 0xffffffff)
XOR(5, 0x80000000, 0x7fffffff, 0xffffffff)
XOR(6, 0x7fffffff, 0xffffffff, 0x80000000)
XOR(7, 0xffffffff, 0x7fffffff, 0x80000000)
XOR(9, 0xffffffff, 0xffffffff, 0)
XOR(10, 0x7fffffff, 0, 0x7fffffff)
XOR(11, 0, 0x7fffffff, 0x7fffffff)
#if __WORDSIZE == 64
XOR(12, 0x7fffffffffffffff, 1, 0x7ffffffffffffffe)
XOR(13, 1, 0x7fffffffffffffff, 0x7ffffffffffffffe)
XOR(14, 0x8000000000000000, 1, 0x8000000000000001)
XOR(15, 1, 0x8000000000000000, 0x8000000000000001)
XOR(16, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff)
XOR(17, 0x8000000000000000, 0x7fffffffffffffff, 0xffffffffffffffff)
XOR(18, 0x7fffffffffffffff, 0xffffffffffffffff, 0x8000000000000000)
XOR(19, 0xffffffffffffffff, 0x7fffffffffffffff, 0x8000000000000000)
XOR(20, 0xffffffffffffffff, 0xffffffffffffffff, 0)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alux_add.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alux_add.tst
-49
View File
@@ -1,49 +0,0 @@
#include "alu.inc"
.code
prolog
#define ADDX(N, I0, I1, V) ALUX(N, add, I0, I1, V)
/* nothing */
ADDX(0, 0, 0, 0)
#if __WORDSIZE == 32
/* carry */
ADDX(1, 0xffffffff, 0xffffffff, 1)
/* overflow */
ADDX(2, 0x7fffffff, 1, 0)
/* overflow */
ADDX(3, 0x7fffffff, 0x7fffffff, 0)
/* carry */
ADDX(4, 0x7fffffff, 0x80000000, 0)
/* carry+overflow */
ADDX(5, 0x80000000, 0x80000000, 1)
#else
/* nothing */
ADDX(1, 0xffffffff, 0xffffffff, 0)
/* nothing */
ADDX(2, 0x7fffffff, 1, 0)
/* nothing */
ADDX(3, 0x7fffffff, 0x7fffffff, 0)
/* nothing */
ADDX(4, 0x7fffffff, 0x80000000, 0)
/* nothing */
ADDX(5, 0x80000000, 0x80000000, 0)
/* carry */
ADDX(6, 0xffffffffffffffff, 0xffffffffffffffff, 1)
/* overflow */
ADDX(7, 0x7fffffffffffffff, 1, 0)
/* overflow */
ADDX(8, 0x7fffffffffffffff, 0x7fffffffffffffff, 0)
/* overflow */
ADDX(9, 0x7fffffffffffffff, 0x8000000000000000, 0)
/* carry+overflow */
ADDX(10,0x8000000000000000, 0x8000000000000000, 1)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/alux_sub.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/alux_sub.tst
-49
View File
@@ -1,49 +0,0 @@
#include "alu.inc"
.code
prolog
#define SUBX(N, I0, I1, V) ALUX(N, sub, I0, I1, V)
/* nothing */
SUBX(0, 0, 0, 0)
#if __WORDSIZE == 32
/* carry */
SUBX(1, 0x7fffffff, 0xffffffff, 0xffffffff)
/* overflow */
SUBX(2, 0x80000000, 1, 0)
/* carry */
SUBX(3, 0x7fffffff, 0x80000000, 0xffffffff)
/* overflow */
SUBX(4, 0x80000000, 0x7fffffff, 0)
/* carry+overflow */
SUBX(5, 1, 0x80000000, 0xffffffff)
#else
/* carry */
SUBX(1, 0x7fffffff, 0xffffffff, -1)
/* nothing */
SUBX(2, 0x80000000, 1, 0)
/* carry */
SUBX(3, 0x7fffffff, 0x80000000, -1)
/* nothing */
SUBX(4, 0x80000000, 0x7fffffff, 0)
/* carry */
SUBX(5, 1, 0x80000000, -1)
/* carry */
SUBX(6, 0x7fffffffffffffff, 0xffffffffffffffff, -1)
/* overflow */
SUBX(7, 0x8000000000000000, 1, 0)
/* carry */
SUBX(8, 0x7fffffffffffffff, 0x8000000000000000, -1)
/* overflow */
SUBX(9, 0x8000000000000000, 0x7fffffffffffffff, 0)
/* carry+overflow */
SUBX(10,1, 0x8000000000000000, -1)
#endif
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/bp.ok
-1
View File
@@ -1 +0,0 @@
nfibs(32) = 2178309
parallel-rsp/lightning/check/bp.tst
-46
View File
@@ -1,46 +0,0 @@
.data 32
fmt:
.c "nfibs(%d) = %d\n"
.code
jmpi main
name rfibs
rfibs:
prolog
arg $in
getarg %r0 $in /* R0 = N */
beqi out %r0 0
movr %v0 %r0 /* V0 = R0 */
movi %r0 1
blei_u out %v0 2
subi %v1 %v0 1 /* V1 = N-1 */
subi %v2 %v0 2 /* V1 = N-2 */
prepare
pushargr %v1
finishi rfibs
retval %v1 /* V1 = rfibs(N-1) */
prepare
pushargr %v2
finishi rfibs
retval %r0 /* R0 = rfibs(N-2) */
addr %r0 %r0 %v1
out:
retr %r0
epilog
name main
main:
prolog
prepare
pushargi 32
finishi rfibs
retval %v0
prepare
pushargi fmt
ellipsis
pushargi 32
pushargr %v0
finishi @printf
ret
epilog
parallel-rsp/lightning/check/branch.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/branch.tst
-563
View File
@@ -1,563 +0,0 @@
#if __WORDSIZE == 64
# define I7f 0x7fffffffffffffff
# define I80 0x8000000000000000
# define I81 0x8000000000000001
# define Iff 0xffffffffffffffff
#else
# define I7f 0x7fffffff
# define I80 0x80000000
# define I81 0x80000001
# define Iff 0xffffffff
#endif
.data 12
ok:
.c "ok\n"
. $($NaN = 0.0 / 0.0)
#define BOP(N, Ls, Rs, Lu, Ru, R0, R1) \
movi %R0 Ls \
movi %R1 Rs \
b##N##r N##r_##R0##_##R1 %R0 %R1 \
calli @abort \
N##r_##R0##_##R1: \
b##N##i N##i_##R0##_##R1 %R0 Rs \
calli @abort \
N##i_##R0##_##R1: \
movi %R0 Lu \
movi %R1 Ru \
b##N##r_u N##r_u_##R0##_##R1 %R0 %R1 \
calli @abort \
N##r_u_##R0##_##R1: \
b##N##i_u N##i_u_##R0##_##R1 %R0 Ru \
calli @abort \
N##i_u_##R0##_##R1: \
movi %R0 Ls \
movi %R1 Rs \
N##r %R0 %R0 %R1 \
beqi _##N##r_##R0##_##R1 %R0 1 \
calli @abort \
_##N##r_##R0##_##R1: \
movi %R0 Ls \
N##i %R1 %R0 Rs \
beqi _##N##i_##R0##_##R1 %R1 1 \
calli @abort \
_##N##i_##R0##_##R1: \
movi %R0 Lu \
movi %R1 Ru \
N##r_u %R0 %R0 %R1 \
beqi _##N##r_u_##R0##_##R1 %R0 1 \
calli @abort \
_##N##r_u_##R0##_##R1: \
movi %R0 Lu \
N##i_u %R1 %R0 Ru \
beqi _##N##i_u_##R0##_##R1 %R1 1 \
calli @abort \
_##N##i_u_##R0##_##R1:
#define EB(N, L, R, R0, R1) \
movi %R0 L \
movi %R1 R \
b##N##r N##r_##R0##_##R1 %R0 %R1 \
calli @abort \
N##r_##R0##_##R1: \
b##N##i N##i_##R0##_##R1 %R0 R \
calli @abort \
N##i_##R0##_##R1: \
movi %R0 L \
movi %R1 R \
N##r %R0 %R0 %R1 \
beqi _##N##r_##R0##_##R1 %R0 1 \
calli @abort \
_##N##r_##R0##_##R1: \
movi %R0 L \
N##i %R1 %R0 R \
beqi _##N##i_##R0##_##R1 %R1 1 \
calli @abort \
_##N##i_##R0##_##R1:
#define XEB(N, L, R, R0, R1) \
movi %R0 L \
movi %R1 R \
b##N##r N##r_##R0##_##R1 %R0 %R1 \
calli @abort \
N##r_##R0##_##R1: \
b##N##i N##i_##R0##_##R1 %R0 R \
calli @abort \
N##i_##R0##_##R1:
#define XBOP(N, Ls, Rs, Lu, Ru, R0, R1) \
movi %R0 Ls \
movi %R1 Rs \
b##N##r N##r_##R0##_##R1 %R0 %R1 \
calli @abort \
N##r_##R0##_##R1: \
movi %R0 Ls \
b##N##i N##i_##R0##_##R1 %R0 Rs \
calli @abort \
N##i_##R0##_##R1: \
movi %R0 Lu \
movi %R1 Ru \
b##N##r_u N##r_u_##R0##_##R1 %R0 %R1 \
calli @abort \
N##r_u_##R0##_##R1: \
movi %R0 Lu \
b##N##i_u N##i_u_##R0##_##R1 %R0 Ru \
calli @abort \
N##i_u_##R0##_##R1:
#define BOPI(N, Ls, Rs, Lu, Ru) \
BOP(N, Ls, Rs, Lu, Ru, v0, v1) \
BOP(N, Ls, Rs, Lu, Ru, v0, v2) \
BOP(N, Ls, Rs, Lu, Ru, v0, r0) \
BOP(N, Ls, Rs, Lu, Ru, v0, r1) \
BOP(N, Ls, Rs, Lu, Ru, v0, r2) \
BOP(N, Ls, Rs, Lu, Ru, v1, v0) \
BOP(N, Ls, Rs, Lu, Ru, v1, v2) \
BOP(N, Ls, Rs, Lu, Ru, v1, r0) \
BOP(N, Ls, Rs, Lu, Ru, v1, r1) \
BOP(N, Ls, Rs, Lu, Ru, v1, r2) \
BOP(N, Ls, Rs, Lu, Ru, v2, v0) \
BOP(N, Ls, Rs, Lu, Ru, v2, v1) \
BOP(N, Ls, Rs, Lu, Ru, v2, r0) \
BOP(N, Ls, Rs, Lu, Ru, v2, r1) \
BOP(N, Ls, Rs, Lu, Ru, v2, r2) \
BOP(N, Ls, Rs, Lu, Ru, r0, v0) \
BOP(N, Ls, Rs, Lu, Ru, r0, v1) \
BOP(N, Ls, Rs, Lu, Ru, r0, v2) \
BOP(N, Ls, Rs, Lu, Ru, r0, r1) \
BOP(N, Ls, Rs, Lu, Ru, r0, r2) \
BOP(N, Ls, Rs, Lu, Ru, r1, v0) \
BOP(N, Ls, Rs, Lu, Ru, r1, v1) \
BOP(N, Ls, Rs, Lu, Ru, r1, v2) \
BOP(N, Ls, Rs, Lu, Ru, r1, r0) \
BOP(N, Ls, Rs, Lu, Ru, r1, r2) \
BOP(N, Ls, Rs, Lu, Ru, r2, v0) \
BOP(N, Ls, Rs, Lu, Ru, r2, v1) \
BOP(N, Ls, Rs, Lu, Ru, r2, v2) \
BOP(N, Ls, Rs, Lu, Ru, r2, r0) \
BOP(N, Ls, Rs, Lu, Ru, r2, r1)
#define EBI(N, L, R) \
EB(N, L, R, v0, v1) \
EB(N, L, R, v0, v2) \
EB(N, L, R, v0, r0) \
EB(N, L, R, v0, r1) \
EB(N, L, R, v0, r2) \
EB(N, L, R, v1, v0) \
EB(N, L, R, v1, v2) \
EB(N, L, R, v1, r0) \
EB(N, L, R, v1, r1) \
EB(N, L, R, v1, r2) \
EB(N, L, R, v2, v0) \
EB(N, L, R, v2, v1) \
EB(N, L, R, v2, r0) \
EB(N, L, R, v2, r1) \
EB(N, L, R, v2, r2) \
EB(N, L, R, r0, v0) \
EB(N, L, R, r0, v1) \
EB(N, L, R, r0, v2) \
EB(N, L, R, r0, r1) \
EB(N, L, R, r0, r2) \
EB(N, L, R, r1, v0) \
EB(N, L, R, r1, v1) \
EB(N, L, R, r1, v2) \
EB(N, L, R, r1, r0) \
EB(N, L, R, r1, r2) \
EB(N, L, R, r2, v0) \
EB(N, L, R, r2, v1) \
EB(N, L, R, r2, v2) \
EB(N, L, R, r2, r0) \
EB(N, L, R, r2, r1)
#define XEBI(N, L, R) \
XEB(N, L, R, v0, v1) \
XEB(N, L, R, v0, v2) \
XEB(N, L, R, v0, r0) \
XEB(N, L, R, v0, r1) \
XEB(N, L, R, v0, r2) \
XEB(N, L, R, v1, v0) \
XEB(N, L, R, v1, v2) \
XEB(N, L, R, v1, r0) \
XEB(N, L, R, v1, r1) \
XEB(N, L, R, v1, r2) \
XEB(N, L, R, v2, v0) \
XEB(N, L, R, v2, v1) \
XEB(N, L, R, v2, r0) \
XEB(N, L, R, v2, r1) \
XEB(N, L, R, v2, r2) \
XEB(N, L, R, r0, v0) \
XEB(N, L, R, r0, v1) \
XEB(N, L, R, r0, v2) \
XEB(N, L, R, r0, r1) \
XEB(N, L, R, r0, r2) \
XEB(N, L, R, r1, v0) \
XEB(N, L, R, r1, v1) \
XEB(N, L, R, r1, v2) \
XEB(N, L, R, r1, r0) \
XEB(N, L, R, r1, r2) \
XEB(N, L, R, r2, v0) \
XEB(N, L, R, r2, v1) \
XEB(N, L, R, r2, v2) \
XEB(N, L, R, r2, r0) \
XEB(N, L, R, r2, r1)
#define XBOPI(N, Ls, Rs, Lu, Ru) \
XBOP(N, Ls, Rs, Lu, Ru, v0, v1) \
XBOP(N, Ls, Rs, Lu, Ru, v0, v2) \
XBOP(N, Ls, Rs, Lu, Ru, v0, r0) \
XBOP(N, Ls, Rs, Lu, Ru, v0, r1) \
XBOP(N, Ls, Rs, Lu, Ru, v0, r2) \
XBOP(N, Ls, Rs, Lu, Ru, v1, v0) \
XBOP(N, Ls, Rs, Lu, Ru, v1, v2) \
XBOP(N, Ls, Rs, Lu, Ru, v1, r0) \
XBOP(N, Ls, Rs, Lu, Ru, v1, r1) \
XBOP(N, Ls, Rs, Lu, Ru, v1, r2) \
XBOP(N, Ls, Rs, Lu, Ru, v2, v0) \
XBOP(N, Ls, Rs, Lu, Ru, v2, v1) \
XBOP(N, Ls, Rs, Lu, Ru, v2, r0) \
XBOP(N, Ls, Rs, Lu, Ru, v2, r1) \
XBOP(N, Ls, Rs, Lu, Ru, v2, r2) \
XBOP(N, Ls, Rs, Lu, Ru, r0, v0) \
XBOP(N, Ls, Rs, Lu, Ru, r0, v1) \
XBOP(N, Ls, Rs, Lu, Ru, r0, v2) \
XBOP(N, Ls, Rs, Lu, Ru, r0, r1) \
XBOP(N, Ls, Rs, Lu, Ru, r0, r2) \
XBOP(N, Ls, Rs, Lu, Ru, r1, v0) \
XBOP(N, Ls, Rs, Lu, Ru, r1, v1) \
XBOP(N, Ls, Rs, Lu, Ru, r1, v2) \
XBOP(N, Ls, Rs, Lu, Ru, r1, r0) \
XBOP(N, Ls, Rs, Lu, Ru, r1, r2) \
XBOP(N, Ls, Rs, Lu, Ru, r2, v0) \
XBOP(N, Ls, Rs, Lu, Ru, r2, v1) \
XBOP(N, Ls, Rs, Lu, Ru, r2, v2) \
XBOP(N, Ls, Rs, Lu, Ru, r2, r0) \
XBOP(N, Ls, Rs, Lu, Ru, r2, r1)
#define TBOPF(N, T, L, R) \
movi_##T %f0 L \
movi_##T %f1 R \
b##N##r##_##T N##r_##T %f0 %f1 \
calli @abort \
N##r_##T: \
b##N##i##_##T N##i_##T %f0 R \
calli @abort \
N##i_##T: \
movi_##T %f1 $NaN \
b##N##r##_##T N##r_##T##_##u %f0 %f1 \
jmpi N##r_##T##_##u0 \
N##r_##T##_##u: \
calli @abort \
N##r##_##T##_##u0: \
b##N##i##_##T N##i_##T##_##u %f0 $NaN \
jmpi N##i_##T##_##u0 \
N##i##_##T##_##u: \
calli @abort \
N##i##_##T##_##u0:
#define BOPF(N, L, R) \
TBOPF(N, f, L, R) \
TBOPF(N, d, L, R)
#define TUBOPF(N, T, L, R) \
movi_##T %f0 L \
movi_##T %f1 R \
b##N##r##_##T N##r_##T %f0 %f1 \
calli @abort \
N##r_##T: \
b##N##i##_##T N##i_##T %f0 R \
calli @abort \
N##i_##T: \
movi_##T %f1 $NaN \
b##N##r##_##T N##r_##T##_##u %f0 %f1 \
calli @abort \
N##r_##T##_##u: \
b##N##i##_##T N##i_##T##_##u %f0 $NaN \
calli @abort \
N##i##_##T##_##u:
#define UBOPF(N, L, R) \
TUBOPF(N, f, L, R) \
TUBOPF(N, d, L, R)
.code
prolog
movi %r0 -1
movi %r1 1
bltr xltr_r0_r1 %r0 %r1
calli @abort
xltr_r0_r1:
blti xlti_r0_r1 %r0 1
calli @abort
xlti_r0_r1:
movi %r0 1
movi %r1 -1
bltr_u xltru_r0_r1 %r0 %r1
calli @abort
xltru_r0_r1:
blti_u xltiu_r0_r1 %r0 -1
calli @abort
xltiu_r0_r1:
movi %r0 -1
movi %r1 -1
bler xler_r0_r1 %r0 %r1
calli @abort
xler_r0_r1:
blti xlei_r0_r1 %r0 1
calli @abort
xlei_r0_r1:
movi %r0 1
movi %r1 -1
bltr_u xlteu_r0_r1 %r0 %r1
calli @abort
xlteu_r0_r1:
blei_u xleiu_r0_r1 %r0 -1
calli @abort
xleiu_r0_r1:
movi %r0 32
movi %r1 32
beqr xeqr_r0_r1 %r0 %r1
calli @abort
xeqr_r0_r1:
beqi xeqi_r0_r1 %r0 32
calli @abort
xeqi_r0_r1:
movi %r0 -2
movi %r1 -2
bger xger_r0_r1 %r0 %r1
calli @abort
xger_r0_r1:
bgei xgei_r0_r1 %r0 -2
calli @abort
xgei_r0_r1:
movi %r0 2
movi %r1 2
bger_u xgeru_r0_r1 %r0 %r1
calli @abort
xgeru_r0_r1:
bgei_u xgeiu_r0_r1 %r0 2
calli @abort
xgeiu_r0_r1:
movi %r0 2
movi %r1 -2
bgtr xgtr_r0_r1 %r0 %r1
calli @abort
xgtr_r0_r1:
bgti xgti_r0_r1 %r0 -2
calli @abort
xgti_r0_r1:
movi %r0 -2
movi %r1 2
bgtr_u xgtru_r0_r1 %r0 %r1
calli @abort
xgtru_r0_r1:
bgti_u xgtiu_r0_r1 %r0 2
calli @abort
xgtiu_r0_r1:
movi %r0 -3
movi %r1 3
bner xner_r0_r1 %r0 %r1
calli @abort
xner_r0_r1:
bnei xnei_r0_r1 %r0 3
calli @abort
xnei_r0_r1:
movi %r0 1
movi %r1 3
bmsr xmsr_r0_r1 %r0 %r1
calli @abort
xmsr_r0_r1:
bmsi xmsi_r0_r1 %r0 3
calli @abort
xmsi_r0_r1:
movi %r0 1
movi %r1 2
bmcr xmcr_r0_r1 %r0 %r1
calli @abort
xmcr_r0_r1:
bmci xmci_r0_r1 %r0 2
calli @abort
xmci_r0_r1:
movi %r0 I7f
movi %r1 1
boaddr xoaddr_r0_r1 %r0 %r1
calli @abort
xoaddr_r0_r1:
movi %r0 Iff
movi %r1 1
boaddr_u xoaddr_u_r0_r1 %r0 %r1
calli @abort
xoaddr_u_r0_r1:
movi %r0 I7f
boaddi xoaddi_r0_r1 %r0 1
calli @abort
xoaddi_r0_r1:
movi %r0 Iff
boaddi_u xoaddi_u_r0_r1 %r0 1
calli @abort
xoaddi_u_r0_r1:
movi %r0 I80
movi %r1 1
bxaddr xxaddr_r0_r1 %r0 %r1
calli @abort
xxaddr_r0_r1:
movi %r0 I80
bxaddi xxaddi_r0_r1 %r0 1
calli @abort
xxaddi_r0_r1:
movi %r0 I7f
movi %r1 1
bxaddr_u xxaddr_u_r0_r1 %r0 %r1
calli @abort
xxaddr_u_r0_r1:
movi %r0 I7f
bxaddi_u xxaddi_u_r0_r1 %r0 1
calli @abort
xxaddi_u_r0_r1:
movi %r0 I80
movi %r1 1
bosubr xosubr_r0_r1 %r0 %r1
calli @abort
xosubr_r0_r1:
movi %r0 0
movi %r1 1
bosubr_u xosubr_u_r0_r1 %r0 %r1
calli @abort
xosubr_u_r0_r1:
movi %r0 I80
bosubi xosubi_r0_r1 %r0 1
calli @abort
xosubi_r0_r1:
movi %r0 0
bosubi_u xosubi_u_r0_r1 %r0 1
calli @abort
xosubi_u_r0_r1:
movi %r0 I81
movi %r1 1
bxsubr xxsubr_r0_r1 %r0 %r1
calli @abort
xxsubr_r0_r1:
movi %r0 I81
bxsubi xxsubi_r0_r1 %r0 1
calli @abort
xxsubi_r0_r1:
movi %r0 I80
movi %r1 1
bxsubr_u xxsubr_u_r0_r1 %r0 %r1
calli @abort
xxsubr_u_r0_r1:
movi %r0 I80
bxsubi_u xxsubi_u_r0_r1 %r0 1
calli @abort
xxsubi_u_r0_r1:
movi_f %f0 1
movi_f %f1 2
bltr_f xltr_f_f0_f1 %f0 %f1
calli @abort
xltr_f_f0_f1:
blti_f xlti_f_f0_f1 %f0 2
calli @abort
xlti_f_f0_f1:
movi_f %f0 -1
movi_f %f1 -1
bler_f xler_f_f0_f1 %f0 %f1
calli @abort
xler_f_f0_f1:
blei_f xlei_f_f0_f1 %f0 -1
calli @abort
xlei_f_f0_f1:
movi_f %f0 -2
movi_f %f1 -2
beqr_f xeqr_f_f0_f1 %f0 %f1
calli @abort
xeqr_f_f0_f1:
beqi_f xeqi_f_f0_f1 %f0 -2
calli @abort
xeqi_f_f0_f1:
movi_f %f0 -3
movi_f %f1 -3
bger_f xger_f_f0_f1 %f0 %f1
calli @abort
xger_f_f0_f1:
bgei_f xgei_f_f0_f1 %f0 -3
calli @abort
xgei_f_f0_f1:
movi_f %f0 2
movi_f %f1 1
bgtr_f xgtr_f_f0_f1 %f0 %f1
calli @abort
xgtr_f_f0_f1:
bgti_f xgti_f_f0_f1 %f0 1
calli @abort
xgti_f_f0_f1:
movi_f %f0 0
movi_f %f1 2
bner_f xner_f_f0_f1 %f0 %f1
calli @abort
xner_f_f0_f1:
bnei_f xnei_f_f0_f1 %f0 2
calli @abort
xnei_f_f0_f1:
BOPI(lt, -1, 1, 1, -1)
BOPI(le, -1, -1, 1, 1)
EBI(eq, 32, 32)
BOPI(ge, -2, -2, 2, 2)
BOPI(gt, 2, -2, -2, 2)
EBI(ne, 3, -3)
XEBI(ms, 1, 3)
XEBI(mc, 1, 2)
XBOPI(oadd, I7f, 1, Iff, 1)
XBOPI(xadd, I80, 1, I7f, 1)
XBOPI(osub, I80, 1, 0, 1)
XBOPI(xsub, I81, 1, I80, 1)
BOPF(lt, 1, 2)
BOPF(le, 2, 2)
BOPF(eq, 3, 3)
BOPF(ge, 3, 3)
BOPF(gt, 4, 3)
UBOPF(ne, 4, 3)
UBOPF(unlt, 1, 2)
UBOPF(unle, 2, 2)
UBOPF(uneq, 3, 3)
UBOPF(unge, 3, 3)
UBOPF(ungt, 4, 3)
BOPF(ltgt, 4, 3)
movi_f %f0 5
movi_f %f1 5
bordr_f ordr_f %f0 %f1
calli @abort
ordr_f:
bordi_f ordi_f %f0 1
calli @abort
ordi_f:
bordi_f ordi_f_u %f0 $NaN
jmpi ordi_f_u0
ordi_f_u:
calli @abort
ordi_f_u0:
movi_f %f0 5
movi_f %f1 5
bunordr_f unordr_f %f0 %f1
jmpi unordr_f_0
unordr_f:
calli @abort
unordr_f_0:
bunordi_f unordi_f %f0 1
jmpi unordi_f_0
unordi_f:
calli @abort
unordi_f_0:
bunordi_f unordi_f_1 %f0 $NaN
calli @abort
unordi_f_1:
// just to know did not crash or abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/call.ok
-4
View File
@@ -1,4 +0,0 @@
forward
backward
forward
backward
parallel-rsp/lightning/check/call.tst
-272
View File
@@ -1,272 +0,0 @@
#define def_wi(i) \
name _w##i \
_w##i: \
prolog \
arg $arg##i \
getarg##i %r0 $arg##i \
retr %r0 \
epilog
#define def_wf(f) \
name _w##f \
_w##f: \
prolog \
arg##f $arg##f \
getarg##f %f0 $arg##f \
truncr##f %r0 %f0 \
retr %r0 \
epilog
#define def_fi(f, i) \
name f##i \
f##i: \
prolog \
arg $arg##i \
getarg##i %r0 $arg##i \
extr##f %f0 %r0 \
retr##f %f0 \
epilog
#define def_f(f) \
name f##f \
f##f: \
prolog \
arg##f $arg##f \
getarg##f %f0 $arg##f \
retr##f %f0 \
epilog
#define def_ff(f, g) \
name f##g \
name f##g \
f##g: \
prolog \
arg##g $arg##g \
getarg##g %f0 $arg##g \
extr##g##f %f0 %f0 \
retr##f %f0 \
epilog
.data 32
fstr:
.c "forward"
bstr:
.c "backward"
.code
jmpi main
def_wi(_c)
def_wi(_uc)
def_wi(_s)
def_wi(_us)
#if __WORDSIZE == 64
def_wi(_i)
def_wi(_ui)
#endif
def_wf(_f)
def_wf(_d)
def_fi(_f, _c)
def_fi(_f, _uc)
def_fi(_f, _s)
def_fi(_f, _us)
def_fi(_f, _i)
#if __WORDSIZE == 64
def_fi(_f, _ui)
def_fi(_f, _l)
#endif
def_fi(_d, _c)
def_fi(_d, _uc)
def_fi(_d, _s)
def_fi(_d, _us)
def_fi(_d, _i)
#if __WORDSIZE == 64
def_fi(_d, _ui)
def_fi(_d, _l)
#endif
def_f(_f)
def_f(_d)
def_ff(_f, _d)
def_ff(_d, _f)
name main
main:
prolog
#define _call_w(n, i, a, r) \
prepare \
pushargi a \
finishi _w##i \
retval %r0 \
extr##i %r0 %r0 \
beqi _w##i##_##n %r0 r \
calli @abort \
_w##i##_##n:
#define call_w(n, i, a, r) _call_w(n, i, a, r)
#define _call_wf(n, f, a, r) \
prepare \
pushargi##f a \
finishi _w##f \
retval %r0 \
extr##f %f0 %r0 \
beqi##f _w##f##_##n %f0 r \
calli @abort \
_w##f##_##n:
#define call_wf(n, f, a, r) _call_wf(n, f, a, r)
#define _call_fi(n, f, i, a, r) \
prepare \
pushargi a \
finishi f##i \
retval##f %f0 \
beqi##f f##i##n %f0 r \
calli @abort \
f##i##n:
#define call_fi(n, f, i, a, r) _call_fi(n, f, i, a, r)
#define _call_f(n, f, a, r) \
prepare \
pushargi##f a \
finishi f##f \
retval##f %f0 \
beqi##f f##f##n %f0 r \
calli @abort \
f##f##n:
#define call_f(n, f, a, r) _call_f(n, f, a, r)
#define _call_ff(n, f, g, a, r) \
prepare \
pushargi##g a \
finishi f##g \
retval##f %f0 \
beqi##f f##g##n %f0 r \
calli @abort \
f##g##n:
#define call_ff(n, f, g, a, r) _call_ff(n, f, g, a, r)
#define c7f 0x7f
#define c80 0x80
#define c81 0x81
#define cff 0xff
#define s7f 0x7fff
#define s80 0x8000
#define s81 0x8001
#define i7f 0x7fffffff
#define i80 0x80000000
#define i81 0x80000001
#define iff 0xffffffff
#define l7f 0x7fffffffffffffff
#define l80 0x8000000000000000
#define l81 0x8000000000000001
#define f7f 127.0
#define f80 -128.0
#define f81 -127.0
#define uf80 128.0
#define uf81 127.0
#if __WORDSIZE == 32
# define wc80 0xffffff80
# define wc81 0xffffff81
# define ws80 0xffff8000
# define ws81 0xffff8001
#else
# define wc80 0xffffffffffffff80
# define wc81 0xffffffffffffff81
# define ws80 0xffffffffffff8000
# define ws81 0xffffffffffff8001
# define wi80 0xffffffff80000000
# define wi81 0xffffffff80000001
#endif
call_w(__LINE__, _c, c7f, c7f)
call_w(__LINE__, _c, c80, wc80)
call_w(__LINE__, _c, c81, wc81)
call_w(__LINE__, _uc, c7f, c7f)
call_w(__LINE__, _uc, c80, c80)
call_w(__LINE__, _uc, c81, c81)
call_w(__LINE__, _s, s7f, s7f)
call_w(__LINE__, _s, s80, ws80)
call_w(__LINE__, _s, s81, ws81)
call_w(__LINE__, _us, s7f, s7f)
call_w(__LINE__, _us, s80, s80)
call_w(__LINE__, _us, s81, s81)
#if __WORDSIZE == 64
call_w(__LINE__, _i, i7f, i7f)
call_w(__LINE__, _i, i80, wi80)
call_w(__LINE__, _i, i81, wi81)
call_w(__LINE__, _ui, i7f, i7f)
call_w(__LINE__, _ui, i80, i80)
call_w(__LINE__, _ui, i81, i81)
#endif
call_wf(__LINE__, _f, c7f, f7f)
call_wf(__LINE__, _f, wc80, f80)
call_wf(__LINE__, _f, wc81, f81)
call_wf(__LINE__, _d, c7f, f7f)
call_wf(__LINE__, _d, wc80, f80)
call_wf(__LINE__, _d, wc81, f81)
call_fi(__LINE__, _f, _c, c7f, f7f)
call_fi(__LINE__, _f, _c, c80, f80)
call_fi(__LINE__, _f, _uc, c7f, f7f)
call_fi(__LINE__, _f, _uc, c80, uf80)
call_fi(__LINE__, _f, _s, c7f, f7f)
call_fi(__LINE__, _f, _s, c80, uf80)
call_fi(__LINE__, _f, _us, c7f, f7f)
call_fi(__LINE__, _f, _us, c80, uf80)
call_fi(__LINE__, _f, _i, c7f, f7f)
call_fi(__LINE__, _f, _i, c80, uf80)
#if __WORDSIZE == 64
call_fi(__LINE__, _f, _ui, c7f, f7f)
call_fi(__LINE__, _f, _ui, c80, uf80)
call_fi(__LINE__, _f, _l, c7f, f7f)
call_fi(__LINE__, _f, _l, c80, uf80)
#endif
call_fi(__LINE__, _d, _c, c7f, f7f)
call_fi(__LINE__, _d, _c, c80, f80)
call_fi(__LINE__, _d, _uc, c7f, f7f)
call_fi(__LINE__, _d, _uc, c80, uf80)
call_fi(__LINE__, _d, _s, c7f, f7f)
call_fi(__LINE__, _d, _s, c80, uf80)
call_fi(__LINE__, _d, _us, c7f, f7f)
call_fi(__LINE__, _d, _us, c80, uf80)
call_fi(__LINE__, _d, _i, c7f, f7f)
call_fi(__LINE__, _d, _i, c80, uf80)
#if __WORDSIZE == 64
call_fi(__LINE__, _d, _ui, c7f, f7f)
call_fi(__LINE__, _d, _ui, c80, uf80)
call_fi(__LINE__, _d, _l, c7f, f7f)
call_fi(__LINE__, _d, _l, c80, uf80)
#endif
call_f(__LINE__, _f, f7f, f7f)
call_f(__LINE__, _d, f7f, f7f)
call_ff(__LINE__, _f, _d, f80, f80)
call_ff(__LINE__, _d, _f, f81, f81)
movi %r0 forward
callr %r0
calli iforward
ret
epilog
name backward
backward:
prolog
prepare
pushargi bstr
finishi @puts
ret
epilog
name forward
forward:
prolog
prepare
pushargi fstr
finishi @puts
movi %r0 backward
callr %r0
ret
epilog
name iforward
iforward:
prolog
prepare
pushargi fstr
finishi @puts
calli backward
ret
epilog
parallel-rsp/lightning/check/carg.c
-538
View File
@@ -1,538 +0,0 @@
#include <lightning.h>
#include <stdio.h>
/* Simple test for arguments handling, that also shows how to use
* arguments to store values.
* Register arguments, if available, are very fast, but are also
* very volatile on some ports, because some ports will do C calls
* to implement division, remainder, sometimes multiplication, or
* some float operations.
* Arguments in registers should be fetched in the prolog of the
* function, and if they must be saved, they should be saved in
* the prolog.
* The predicate macro "jit_arg_register_p(arg)" allows knowing if
* an argument lives in a register, where it is known for being a very
* fast to read/write temporary storage.
*/
#define W jit_word_t
#define F jit_float32_t
#define D jit_float64_t
jit_state_t *_jit;
void
cw(W a1, W a2, W a3, W a4, W a5, W a6, W a7, W a8,
W a9, W a10, W a11, W a12, W a13, W a14, W a15, W a16)
{
if ( a1 != 1 || a2 != 2 || a3 != 3 || a4 != 4 ||
a5 != 5 || a6 != 6 || a7 != 7 || a8 != 8 ||
a9 != 9 || a10 != 10 || a11 != 11 || a12 != 12 ||
a13 != 13 || a14 != 14 || a15 != 15 || a16 != 16)
abort();
}
void
cf(F a1, F a2, F a3, F a4, F a5, F a6, F a7, F a8,
F a9, F a10, F a11, F a12, F a13, F a14, F a15, F a16)
{
if ( a1 != 1 || a2 != 2 || a3 != 3 || a4 != 4 ||
a5 != 5 || a6 != 6 || a7 != 7 || a8 != 8 ||
a9 != 9 || a10 != 10 || a11 != 11 || a12 != 12 ||
a13 != 13 || a14 != 14 || a15 != 15 || a16 != 16)
abort();
}
void
cd(D a1, D a2, D a3, D a4, D a5, D a6, D a7, D a8,
D a9, D a10, D a11, D a12, D a13, D a14, D a15, D a16)
{
if ( a1 != 1 || a2 != 2 || a3 != 3 || a4 != 4 ||
a5 != 5 || a6 != 6 || a7 != 7 || a8 != 8 ||
a9 != 9 || a10 != 10 || a11 != 11 || a12 != 12 ||
a13 != 13 || a14 != 14 || a15 != 15 || a16 != 16)
abort();
}
int
main(int argc, char *argv[])
{
void (*code)(void);
jit_node_t *jmp, *pass;
jit_node_t *jw, *jf, *jd;
jit_int32_t s1, s2, s3, s4, s5, s6, s7, s8,
s9, s10, s11, s12, s13, s14, s15, s16;
jit_node_t *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8,
*a9, *a10, *a11, *a12, *a13, *a14, *a15, *a16;
init_jit(argv[0]);
_jit = jit_new_state();
/* jump to "main" label */
jmp = jit_jmpi();
/* Create jit function that
* o Receives 16 word arguments
* o Save in the stack any register argument. Also force register
* arguments to be clobbered to properly make the test
* o Calls a C function that receives 16 word arguments, with
* values different from the ones received by this function
* o Reload from stack any register argument
* o Validated all arguments were not modified in the known
* cases it could have been clobbered
*/
jw = jit_label();
jit_name("jw");
jit_note(__FILE__, __LINE__);
jit_prolog();
a1 = jit_arg();
a2 = jit_arg();
a3 = jit_arg();
a4 = jit_arg();
a5 = jit_arg();
a6 = jit_arg();
a7 = jit_arg();
a8 = jit_arg();
a9 = jit_arg();
a10 = jit_arg();
a11 = jit_arg();
a12 = jit_arg();
a13 = jit_arg();
a14 = jit_arg();
a15 = jit_arg();
a16 = jit_arg();
#define SAVE_ARG(N) \
do { \
if (jit_arg_register_p(a##N)) { \
s##N = jit_allocai(sizeof(W)); \
jit_getarg(JIT_R0, a##N); \
jit_stxi(s##N, JIT_FP, JIT_R0); \
jit_putargi(-1, a##N); \
} \
} while (0)
SAVE_ARG(1);
SAVE_ARG(2);
SAVE_ARG(3);
SAVE_ARG(4);
SAVE_ARG(5);
SAVE_ARG(6);
SAVE_ARG(7);
SAVE_ARG(8);
SAVE_ARG(9);
SAVE_ARG(10);
SAVE_ARG(11);
SAVE_ARG(12);
SAVE_ARG(13);
SAVE_ARG(14);
SAVE_ARG(15);
SAVE_ARG(16);
#undef SAVE_ARG
jit_prepare();
{
jit_pushargi(1);
jit_pushargi(2);
jit_pushargi(3);
jit_pushargi(4);
jit_pushargi(5);
jit_pushargi(6);
jit_pushargi(7);
jit_pushargi(8);
jit_pushargi(9);
jit_pushargi(10);
jit_pushargi(11);
jit_pushargi(12);
jit_pushargi(13);
jit_pushargi(14);
jit_pushargi(15);
jit_pushargi(16);
}
jit_finishi(cw);
#define LOAD_ARG(N) \
do { \
if (jit_arg_register_p(a##N)) { \
jit_ldxi(JIT_R0, JIT_FP, s##N); \
jit_putargr(JIT_R0, a##N); \
} \
} while (0)
LOAD_ARG(1);
LOAD_ARG(2);
LOAD_ARG(3);
LOAD_ARG(4);
LOAD_ARG(5);
LOAD_ARG(6);
LOAD_ARG(7);
LOAD_ARG(8);
LOAD_ARG(9);
LOAD_ARG(10);
LOAD_ARG(11);
LOAD_ARG(12);
LOAD_ARG(13);
LOAD_ARG(14);
LOAD_ARG(15);
LOAD_ARG(16);
#undef LOAD_ARG
pass = jit_forward();
#define CHECK_ARG(N) \
do { \
jit_getarg(JIT_R0, a##N); \
jit_patch_at(jit_beqi(JIT_R0, 17 - N), pass); \
} while (0)
CHECK_ARG(1);
CHECK_ARG(2);
CHECK_ARG(3);
CHECK_ARG(4);
CHECK_ARG(5);
CHECK_ARG(6);
CHECK_ARG(7);
CHECK_ARG(8);
CHECK_ARG(9);
CHECK_ARG(10);
CHECK_ARG(11);
CHECK_ARG(12);
CHECK_ARG(13);
CHECK_ARG(14);
CHECK_ARG(15);
CHECK_ARG(16);
#undef CHECK_ARG
jit_calli(abort);
jit_link(pass);
jit_ret();
jit_epilog();
/* Create jit function that
* o Receives 16 float arguments
* o Save in the stack any register argument. Also force register
* arguments to be clobbered to properly make the test
* o Calls a C function that receives 16 float arguments, with
* values different from the ones received by this function
* o Reload from stack any register argument
* o Validated all arguments were not modified in the known
* cases it could have been clobbered
*/
jf = jit_label();
jit_name("jf");
jit_note(__FILE__, __LINE__);
jit_prolog();
a1 = jit_arg_f();
a2 = jit_arg_f();
a3 = jit_arg_f();
a4 = jit_arg_f();
a5 = jit_arg_f();
a6 = jit_arg_f();
a7 = jit_arg_f();
a8 = jit_arg_f();
a9 = jit_arg_f();
a10 = jit_arg_f();
a11 = jit_arg_f();
a12 = jit_arg_f();
a13 = jit_arg_f();
a14 = jit_arg_f();
a15 = jit_arg_f();
a16 = jit_arg_f();
#define SAVE_ARG(N) \
do { \
if (jit_arg_register_p(a##N)) { \
s##N = jit_allocai(sizeof(F)); \
jit_getarg_f(JIT_F0, a##N); \
jit_stxi_f(s##N, JIT_FP, JIT_F0); \
jit_putargi_f(-1, a##N); \
} \
} while (0)
SAVE_ARG(1);
SAVE_ARG(2);
SAVE_ARG(3);
SAVE_ARG(4);
SAVE_ARG(5);
SAVE_ARG(6);
SAVE_ARG(7);
SAVE_ARG(8);
SAVE_ARG(9);
SAVE_ARG(10);
SAVE_ARG(11);
SAVE_ARG(12);
SAVE_ARG(13);
SAVE_ARG(14);
SAVE_ARG(15);
SAVE_ARG(16);
#undef SAVE_ARG
jit_prepare();
{
jit_pushargi_f(1);
jit_pushargi_f(2);
jit_pushargi_f(3);
jit_pushargi_f(4);
jit_pushargi_f(5);
jit_pushargi_f(6);
jit_pushargi_f(7);
jit_pushargi_f(8);
jit_pushargi_f(9);
jit_pushargi_f(10);
jit_pushargi_f(11);
jit_pushargi_f(12);
jit_pushargi_f(13);
jit_pushargi_f(14);
jit_pushargi_f(15);
jit_pushargi_f(16);
}
jit_finishi(cf);
#define LOAD_ARG(N) \
do { \
if (jit_arg_register_p(a##N)) { \
jit_ldxi_f(JIT_F0, JIT_FP, s##N); \
jit_putargr_f(JIT_F0, a##N); \
} \
} while (0)
LOAD_ARG(1);
LOAD_ARG(2);
LOAD_ARG(3);
LOAD_ARG(4);
LOAD_ARG(5);
LOAD_ARG(6);
LOAD_ARG(7);
LOAD_ARG(8);
LOAD_ARG(9);
LOAD_ARG(10);
LOAD_ARG(11);
LOAD_ARG(12);
LOAD_ARG(13);
LOAD_ARG(14);
LOAD_ARG(15);
LOAD_ARG(16);
#undef LOAD_ARG
pass = jit_forward();
#define CHECK_ARG(N) \
do { \
jit_getarg_f(JIT_F0, a##N); \
jit_patch_at(jit_beqi_f(JIT_F0, 17 - N), pass); \
} while (0)
CHECK_ARG(1);
CHECK_ARG(2);
CHECK_ARG(3);
CHECK_ARG(4);
CHECK_ARG(5);
CHECK_ARG(6);
CHECK_ARG(7);
CHECK_ARG(8);
CHECK_ARG(9);
CHECK_ARG(10);
CHECK_ARG(11);
CHECK_ARG(12);
CHECK_ARG(13);
CHECK_ARG(14);
CHECK_ARG(15);
CHECK_ARG(16);
#undef CHECK_ARG
jit_calli(abort);
jit_link(pass);
jit_ret();
jit_epilog();
/* Create jit function that
* o Receives 16 double arguments
* o Save in the stack any register argument. Also force register
* arguments to be clobbered to properly make the test
* o Calls a C function that receives 16 double arguments, with
* values different from the ones received by this function
* o Reload from stack any register argument
* o Validated all arguments were not modified in the known
* cases it could have been clobbered
*/
jd = jit_label();
jit_name("jd");
jit_note(__FILE__, __LINE__);
jit_prolog();
a1 = jit_arg_d();
a2 = jit_arg_d();
a3 = jit_arg_d();
a4 = jit_arg_d();
a5 = jit_arg_d();
a6 = jit_arg_d();
a7 = jit_arg_d();
a8 = jit_arg_d();
a9 = jit_arg_d();
a10 = jit_arg_d();
a11 = jit_arg_d();
a12 = jit_arg_d();
a13 = jit_arg_d();
a14 = jit_arg_d();
a15 = jit_arg_d();
a16 = jit_arg_d();
#define SAVE_ARG(N) \
do { \
if (jit_arg_register_p(a##N)) { \
s##N = jit_allocai(sizeof(D)); \
jit_getarg_d(JIT_F0, a##N); \
jit_stxi_d(s##N, JIT_FP, JIT_F0); \
jit_putargi_d(-1, a##N); \
} \
} while (0)
SAVE_ARG(1);
SAVE_ARG(2);
SAVE_ARG(3);
SAVE_ARG(4);
SAVE_ARG(5);
SAVE_ARG(6);
SAVE_ARG(7);
SAVE_ARG(8);
SAVE_ARG(9);
SAVE_ARG(10);
SAVE_ARG(11);
SAVE_ARG(12);
SAVE_ARG(13);
SAVE_ARG(14);
SAVE_ARG(15);
SAVE_ARG(16);
#undef SAVE_ARG
jit_prepare();
{
jit_pushargi_d(1);
jit_pushargi_d(2);
jit_pushargi_d(3);
jit_pushargi_d(4);
jit_pushargi_d(5);
jit_pushargi_d(6);
jit_pushargi_d(7);
jit_pushargi_d(8);
jit_pushargi_d(9);
jit_pushargi_d(10);
jit_pushargi_d(11);
jit_pushargi_d(12);
jit_pushargi_d(13);
jit_pushargi_d(14);
jit_pushargi_d(15);
jit_pushargi_d(16);
}
jit_finishi(cd);
#define LOAD_ARG(N) \
do { \
if (jit_arg_register_p(a##N)) { \
jit_ldxi_d(JIT_F0, JIT_FP, s##N); \
jit_putargr_d(JIT_F0, a##N); \
} \
} while (0)
LOAD_ARG(1);
LOAD_ARG(2);
LOAD_ARG(3);
LOAD_ARG(4);
LOAD_ARG(5);
LOAD_ARG(6);
LOAD_ARG(7);
LOAD_ARG(8);
LOAD_ARG(9);
LOAD_ARG(10);
LOAD_ARG(11);
LOAD_ARG(12);
LOAD_ARG(13);
LOAD_ARG(14);
LOAD_ARG(15);
LOAD_ARG(16);
#undef LOAD_ARG
pass = jit_forward();
#define CHECK_ARG(N) \
do { \
jit_getarg_d(JIT_F0, a##N); \
jit_patch_at(jit_beqi_d(JIT_F0, 17 - N), pass); \
} while (0)
CHECK_ARG(1);
CHECK_ARG(2);
CHECK_ARG(3);
CHECK_ARG(4);
CHECK_ARG(5);
CHECK_ARG(6);
CHECK_ARG(7);
CHECK_ARG(8);
CHECK_ARG(9);
CHECK_ARG(10);
CHECK_ARG(11);
CHECK_ARG(12);
CHECK_ARG(13);
CHECK_ARG(14);
CHECK_ARG(15);
CHECK_ARG(16);
#undef CHECK_ARG
jit_calli(abort);
jit_link(pass);
jit_ret();
jit_epilog();
/* Create a jit function that calls the 3 previous ones.
* o First call the function that receives 16 word arguments
* o Then call the function that receives 16 float arguments
* o Finally call the function that receives 16 double arguments
*/
jit_patch(jmp);
jit_name("main");
jit_note(__FILE__, __LINE__);
jit_prolog();
jit_prepare();
{
jit_pushargi(16);
jit_pushargi(15);
jit_pushargi(14);
jit_pushargi(13);
jit_pushargi(12);
jit_pushargi(11);
jit_pushargi(10);
jit_pushargi(9);
jit_pushargi(8);
jit_pushargi(7);
jit_pushargi(6);
jit_pushargi(5);
jit_pushargi(4);
jit_pushargi(3);
jit_pushargi(2);
jit_pushargi(1);
}
jit_patch_at(jit_finishi(NULL), jw);
jit_prepare();
{
jit_pushargi_f(16);
jit_pushargi_f(15);
jit_pushargi_f(14);
jit_pushargi_f(13);
jit_pushargi_f(12);
jit_pushargi_f(11);
jit_pushargi_f(10);
jit_pushargi_f(9);
jit_pushargi_f(8);
jit_pushargi_f(7);
jit_pushargi_f(6);
jit_pushargi_f(5);
jit_pushargi_f(4);
jit_pushargi_f(3);
jit_pushargi_f(2);
jit_pushargi_f(1);
}
jit_patch_at(jit_finishi(NULL), jf);
jit_prepare();
{
jit_pushargi_d(16);
jit_pushargi_d(15);
jit_pushargi_d(14);
jit_pushargi_d(13);
jit_pushargi_d(12);
jit_pushargi_d(11);
jit_pushargi_d(10);
jit_pushargi_d(9);
jit_pushargi_d(8);
jit_pushargi_d(7);
jit_pushargi_d(6);
jit_pushargi_d(5);
jit_pushargi_d(4);
jit_pushargi_d(3);
jit_pushargi_d(2);
jit_pushargi_d(1);
}
jit_patch_at(jit_finishi(NULL), jd);
jit_ret();
jit_epilog();
code = jit_emit();
jit_clear_state();
(*code)();
jit_destroy_state();
finish_jit();
return (0);
}
parallel-rsp/lightning/check/carry.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/carry.tst
-186
View File
@@ -1,186 +0,0 @@
#define ix0 0
#define lx0 0
#define ix1 1
#define lx1 1
#define ix2 2
#define lx2 2
#define ix4 4
#define lx4 4
#if __WORDSIZE == 32
# define ix7fe 0x7ffffffe
# define ix7f 0x7fffffff
# define ix80 0x80000000
# define iff 0xffffffff
# define ife 0xfffffffe
# define ifd 0xfffffffd
# define ifc 0xfffffffc
#else
# define ix7fe 0x7ffffffffffffffe
# define ix7f 0x7fffffffffffffff
# define ix80 0x8000000000000000
# define iff 0xffffffffffffffff
# define ife 0xfffffffffffffffe
# define ifd 0xfffffffffffffffd
# define ifc 0xfffffffffffffffc
#endif
/* check jumps are taken and result value is correct */
#define bopr_t(l, u, op, r0, r1, il, ir, iv) \
movi %r0 il \
movi %r1 ir \
b##op##r##u op##u##r##l##r0##r1 %r0 %r1 \
/* validate did jump */ \
movi %r0 0x5a5a5a5a \
op##u##r##l##r0##r1: \
beqi op##u##r##l##ok##r0##r1 %r0 iv \
calli @abort \
op##u##r##l##ok##r0##r1:
#define bopi_t(l, u, op, r0, il, ir, iv) \
movi %r0 il \
b##op##i##u op##u##i##l##r0##r1 %r0 ir \
/* validate did jump */ \
movi %r0 0x5a5a5a5a \
op##u##i##l##r0##r1: \
beqi op##u##i##l##ok##r0##r1 %r0 iv \
calli @abort \
op##u##i##l##ok##r0##r1:
#define bopr_f(l, u, op, r0, r1, il, ir, iv) \
movi %r0 il \
movi %r1 ir \
b##op##r##u op##u##r##l##r0##r1 %r0 %r1 \
beqi op##u##r##l##ok##r0##r1 %r0 iv \
op##u##r##l##r0##r1: \
calli @abort \
op##u##r##l##ok##r0##r1:
#define bopi_f(l, u, op, r0, il, ir, iv) \
movi %r0 il \
b##op##i##u op##u##i##l##r0##r1 %r0 ir \
beqi op##u##i##l##ok##r0##r1 %r0 iv \
op##u##i##l##r0##r1: \
calli @abort \
op##u##i##l##ok##r0##r1:
#define ccop(cc, l, u, op, r0, r1, il, ir, iv) \
bopr##cc(l, u, op, r0, r1, i##il, i##ir, i##iv) \
bopi##cc(l, u, op, r0, i##il, i##ir, i##iv)
#define tadd(l, u, r0, r1, il, ir, iv) \
ccop(_t, l, u, oadd, r0, r1, il, ir, iv) \
ccop(_f, l, u, xadd, r0, r1, il, ir, iv)
#define fadd(l, u, r0, r1, il, ir, iv) \
ccop(_f, l, u, oadd, r0, r1, il, ir, iv) \
ccop(_t, l, u, xadd, r0, r1, il, ir, iv)
#define tsub(l, u, r0, r1, il, ir, iv) \
ccop(_t, l, u, osub, r0, r1, il, ir, iv) \
ccop(_f, l, u, xsub, r0, r1, il, ir, iv)
#define fsub(l, u, r0, r1, il, ir, iv) \
ccop(_f, l, u, osub, r0, r1, il, ir, iv) \
ccop(_t, l, u, xsub, r0, r1, il, ir, iv)
#define xopr6(l,op,r0,r1,r2,r3,r4,r5,llo,lhi,rlo,rhi,vlo,vhi) \
movi %r1 llo \
movi %r2 lhi \
movi %r4 rlo \
movi %r5 rhi \
op##cr %r0 %r1 %r4 \
op##xr %r3 %r2 %r5 \
beqi op##l##L##r0##r1##r2##r3##r4##r5 %r0 vlo \
calli @abort \
op##l##L##r0##r1##r2##r3##r4##r5: \
beqi op##l##H##r0##r1##r2##r3##r4##r5 %r3 vhi \
calli @abort \
op##l##H##r0##r1##r2##r3##r4##r5:
#define xopr4_(l,op,r0,r1,r2,r3,llo,lhi,rlo,rhi,vlo,vhi) \
movi %r0 llo \
movi %r1 lhi \
movi %r2 rlo \
movi %r3 rhi \
op##cr %r0 %r0 %r2 \
op##xr %r1 %r1 %r3 \
beqi op##l##L_##r0##r1##r2##r3 %r0 vlo \
calli @abort \
op##l##L_##r0##r1##r2##r3: \
beqi op##l##H_##r0##r1##r2##r3 %r1 vhi \
calli @abort \
op##l##H_##r0##r1##r2##r3:
#define xopr_4(l,op,r0,r1,r2,r3,llo,lhi,rlo,rhi,vlo,vhi) \
movi %r0 rlo \
movi %r1 rhi \
movi %r2 llo \
movi %r3 lhi \
op##cr %r0 %r2 %r0 \
op##xr %r1 %r3 %r1 \
beqi op##l##_L##r0##r1##r2##r3 %r0 vlo \
calli @abort \
op##l##_L##r0##r1##r2##r3: \
beqi op##l##_H##r0##r1##r2##r3 %r1 vhi \
calli @abort \
op##l##_H##r0##r1##r2##r3:
#define xaddr(l,llo,lhi,rlo,rhi,vlo,vhi) \
xopr6(l,add,r0,r1,r2,v0,v1,v2,i##llo,i##lhi,i##rlo,i##rhi,i##vlo,i##vhi) \
xopr4_(l,add,r0,r1,r2,v0,i##llo,i##lhi,i##rlo,i##rhi,i##vlo,i##vhi) \
xopr_4(l,add,r0,r1,r2,v0,i##llo,i##lhi,i##rlo,i##rhi,i##vlo,i##vhi)
#define xsubr(l,llo,lhi,rlo,rhi,vlo,vhi) \
xopr6(l,sub,r0,r1,r2,v0,v1,v2,i##llo,i##lhi,i##rlo,i##rhi,i##vlo,i##vhi) \
xopr4_(l,sub,r0,r1,r2,v0,i##llo,i##lhi,i##rlo,i##rhi,i##vlo,i##vhi) \
xopr_4(l,sub,r0,r1,r2,v0,i##llo,i##lhi,i##rlo,i##rhi,i##vlo,i##vhi)
.data 16
ok:
.c "ok\n"
.code
prolog
tadd(__LINE__, , r0, r1, x7f, x1, x80)
fadd(__LINE__, , r0, r1, x7fe, x1, x7f)
tsub(__LINE__, , r0, r1, x80, x1, x7f)
fsub(__LINE__, , r0, r1, x7f, x1, x7fe)
tadd(__LINE__, _u, r0, r1, ff, x1, x0)
fadd(__LINE__, _u, r0, r1, x7f, x1, x80)
tsub(__LINE__, _u, r0, r1, x0, x1, ff)
fsub(__LINE__, _u, r0, r1, x80, x1, x7f)
/* 0xffffffffffffffff + 1 = 0x10000000000000000 */
xaddr(__LINE__, ff, ff, x1, x0, x0, x0)
/* 1 + 0xffffffffffffffff = 0x10000000000000000 */
xaddr(__LINE__, x1, x0, ff, ff, x0, x0)
/* 0xfffffffeffffffff + 1 = 0xffffffff00000000 */
xaddr(__LINE__, ff, fe, x1, x0, x0, ff)
/* 1 + 0xfffffffeffffffff = 0xffffffff00000000 */
xaddr(__LINE__, x1, x0, ff, fe, x0, ff)
/* 0xfffffffefffffffe + 2 = 0xffffffff00000000 */
xaddr(__LINE__, fe, fe, x2, x0, x0, ff)
/* 2 + 0xfffffffefffffffe = 0xffffffff00000000 */
xaddr(__LINE__, x2, x0, fe, fe, x0, ff)
/* 0xffffffffffffffff - 1 = 0xfffffffffffffffe */
xsubr(__LINE__, ff, ff, x1, x0, fe, ff)
/* 1 - 0xffffffffffffffff = -0xfffffffffffffffe */
xsubr(__LINE__, x1, x0, ff, ff, x2, x0)
/* 0xfffffffeffffffff - 1 = 0xfffffffefffffffe */
xsubr(__LINE__, ff, fe, x1, x0, fe, fe)
/* 1 - 0xfffffffeffffffff = -0xfffffffefffffffe */
xsubr(__LINE__, x1, x0, ff, fe, x2, x1)
/* 0xfffffffefffffffe - 2 = 0xfffffffefffffffc */
xsubr(__LINE__, fe, fe, x2, x0, fc, fe)
/* 2 + 0xfffffffefffffffe = -0xfffffffefffffffc */
xsubr(__LINE__, x2, x0, fe, fe, x4, x1)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/ccall.c
-903
View File
@@ -1,903 +0,0 @@
#include <lightning.h>
#include <stdio.h>
#define _w0 0
#define _w1 1
#define _w2 (_w1-2)
#define _w3 (_w2-3)
#define _w4 (_w3-4)
#define _w5 (_w4-5)
#define _w6 (_w5-6)
#define _w7 (_w6-7)
#define _w8 (_w7-8)
#define _w9 (_w8-9)
#define _w10 (_w9-10)
#define _w11 (_w10-11)
#define _w12 (_w11-12)
#define _w13 (_w12-13)
#define _w14 (_w13-14)
#define _w15 (_w14-15)
#define _c0 _w0
#define _c1 _w1
#define _c2 _w2
#define _c3 _w3
#define _c4 _w4
#define _c5 _w5
#define _c6 _w6
#define _c7 _w7
#define _c8 _w8
#define _c9 _w9
#define _c10 _w10
#define _c11 _w11
#define _c12 _w12
#define _c13 _w13
#define _c14 _w14
#define _c15 _w15
#define _uc0 (_w0&0xff)
#define _uc1 (_w1&0xff)
#define _uc2 (_w2&0xff)
#define _uc3 (_w3&0xff)
#define _uc4 (_w4&0xff)
#define _uc5 (_w5&0xff)
#define _uc6 (_w6&0xff)
#define _uc7 (_w7&0xff)
#define _uc8 (_w8&0xff)
#define _uc9 (_w9&0xff)
#define _uc10 (_w10&0xff)
#define _uc11 (_w11&0xff)
#define _uc12 (_w12&0xff)
#define _uc13 (_w13&0xff)
#define _uc14 (_w14&0xff)
#define _uc15 (_w15&0xff)
#define _s0 _w0
#define _s1 _w1
#define _s2 _w2
#define _s3 _w3
#define _s4 _w4
#define _s5 _w5
#define _s6 _w6
#define _s7 _w7
#define _s8 _w8
#define _s9 _w9
#define _s10 _w10
#define _s11 _w11
#define _s12 _w12
#define _s13 _w13
#define _s14 _w14
#define _s15 _w15
#define _us0 (_w0&0xffff)
#define _us1 (_w1&0xffff)
#define _us2 (_w2&0xffff)
#define _us3 (_w3&0xffff)
#define _us4 (_w4&0xffff)
#define _us5 (_w5&0xffff)
#define _us6 (_w6&0xffff)
#define _us7 (_w7&0xffff)
#define _us8 (_w8&0xffff)
#define _us9 (_w9&0xffff)
#define _us10 (_w10&0xffff)
#define _us11 (_w11&0xffff)
#define _us12 (_w12&0xffff)
#define _us13 (_w13&0xffff)
#define _us14 (_w14&0xffff)
#define _us15 (_w15&0xffff)
#define _i0 _w0
#define _i1 _w1
#define _i2 _w2
#define _i3 _w3
#define _i4 _w4
#define _i5 _w5
#define _i6 _w6
#define _i7 _w7
#define _i8 _w8
#define _i9 _w9
#define _i10 _w10
#define _i11 _w11
#define _i12 _w12
#define _i13 _w13
#define _i14 _w14
#define _i15 _w15
#if __WORDSIZE == 64
# define _ui0 (_w0&0xffffffff)
# define _ui1 (_w1&0xffffffff)
# define _ui2 (_w2&0xffffffff)
# define _ui3 (_w3&0xffffffff)
# define _ui4 (_w4&0xffffffff)
# define _ui5 (_w5&0xffffffff)
# define _ui6 (_w6&0xffffffff)
# define _ui7 (_w7&0xffffffff)
# define _ui8 (_w8&0xffffffff)
# define _ui9 (_w9&0xffffffff)
# define _ui10 (_w10&0xffffffff)
# define _ui11 (_w11&0xffffffff)
# define _ui12 (_w12&0xffffffff)
# define _ui13 (_w13&0xffffffff)
# define _ui14 (_w14&0xffffffff)
# define _ui15 (_w15&0xffffffff)
# define _l0 _w0
# define _l1 _w1
# define _l2 _w2
# define _l3 _w3
# define _l4 _w4
# define _l5 _w5
# define _l6 _w6
# define _l7 _w7
# define _l8 _w8
# define _l9 _w9
# define _l10 _w10
# define _l11 _w11
# define _l12 _w12
# define _l13 _w13
# define _l14 _w14
# define _l15 _w15
#endif
/*
* Types
*/
typedef signed char _c;
typedef unsigned char _uc;
typedef signed short _s;
typedef unsigned short _us;
typedef signed int _i;
#if __WORDSIZE == 64
typedef unsigned int _ui;
typedef jit_word_t _l;
#endif
typedef float _f;
typedef double _d;
#define prt0(T) T C##T##0(void);
#define prt1(T) prt0(T) \
T C##T##1(T);
#define prt2(T) prt1(T) \
T C##T##2(T,T);
#define prt3(T) prt2(T) \
T C##T##3(T,T,T);
#define prt4(T) prt3(T) \
T C##T##4(T,T,T,T);
#define prt5(T) prt4(T) \
T C##T##5(T,T,T,T,T);
#define prt6(T) prt5(T) \
T C##T##6(T,T,T,T,T,T);
#define prt7(T) prt6(T) \
T C##T##7(T,T,T,T,T,T,T);
#define prt8(T) prt7(T) \
T C##T##8(T,T,T,T,T,T,T,T);
#define prt9(T) prt8(T) \
T C##T##9(T,T,T,T,T,T,T,T,T);
#define prt10(T) prt9(T) \
T C##T##10(T,T,T,T,T,T,T,T,T,T);
#define prt11(T) prt10(T) \
T C##T##11(T,T,T,T,T,T,T,T,T,T,T);
#define prt12(T) prt11(T) \
T C##T##12(T,T,T,T,T,T,T,T,T,T,T,T);
#define prt13(T) prt12(T) \
T C##T##13(T,T,T,T,T,T,T,T,T,T,T,T,T);
#define prt14(T) prt13(T) \
T C##T##14(T,T,T,T,T,T,T,T,T,T,T,T,T,T);
#define prt15(T) prt14(T) \
T C##T##15(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T);
#define prt(T) prt15(T)
prt(_c)
prt(_uc)
prt(_s)
prt(_us)
prt(_i)
#if __WORDSIZE == 64
prt(_ui)
prt(_l)
#endif
prt(_f)
prt(_d)
#undef prt
#undef prt15
#undef prt14
#undef prt13
#undef prt12
#undef prt11
#undef prt10
#undef prt9
#undef prt8
#undef prt7
#undef prt6
#undef prt5
#undef prt4
#undef prt3
#undef prt2
#undef prt1
#undef prt0
#define prtn(N,T) T J##T##n(void);
#define prt0(T) prtn(0,T)
#define prt1(T) prt0(T) prtn(1,T)
#define prt2(T) prt1(T) prtn(2,T)
#define prt3(T) prt2(T) prtn(3,T)
#define prt4(T) prt3(T) prtn(4,T)
#define prt5(T) prt4(T) prtn(5,T)
#define prt6(T) prt5(T) prtn(6,T)
#define prt7(T) prt6(T) prtn(7,T)
#define prt8(T) prt7(T) prtn(8,T)
#define prt9(T) prt8(T) prtn(9,T)
#define prt10(T) prt9(T) prtn(10,T)
#define prt11(T) prt10(T) prtn(11,T)
#define prt12(T) prt11(T) prtn(12,T)
#define prt13(T) prt12(T) prtn(13,T)
#define prt14(T) prt13(T) prtn(14,T)
#define prt15(T) prt14(T) prtn(15,T)
#define prt(T) prt15(T)
prt(_c)
prt(_uc)
prt(_s)
prt(_us)
prt(_i)
#if __WORDSIZE == 64
prt(_ui)
prt(_l)
#endif
prt(_f)
prt(_d)
#undef prt
#undef prt15
#undef prt14
#undef prt13
#undef prt12
#undef prt11
#undef prt10
#undef prt9
#undef prt8
#undef prt7
#undef prt6
#undef prt5
#undef prt4
#undef prt3
#undef prt2
#undef prt1
#undef prt0
#undef prtn
/*
* Initialization
*/
#define dat0(T) T (*j##T##0)(void); \
jit_node_t *n##T##0;
#define dat1(T) dat0(T) \
T (*j##T##1)(T); \
jit_node_t *n##T##1;
#define dat2(T) dat1(T) \
T (*j##T##2)(T,T); \
jit_node_t *n##T##2;
#define dat3(T) dat2(T) \
T (*j##T##3)(T,T,T); \
jit_node_t *n##T##3;
#define dat4(T) dat3(T) \
T (*j##T##4)(T,T,T,T); \
jit_node_t *n##T##4;
#define dat5(T) dat4(T) \
T (*j##T##5)(T,T,T,T,T); \
jit_node_t *n##T##5;
#define dat6(T) dat5(T) \
T (*j##T##6)(T,T,T,T,T,T); \
jit_node_t *n##T##6;
#define dat7(T) dat6(T) \
T (*j##T##7)(T,T,T,T,T,T,T); \
jit_node_t *n##T##7;
#define dat8(T) dat7(T) \
T (*j##T##8)(T,T,T,T,T,T,T,T); \
jit_node_t *n##T##8;
#define dat9(T) dat8(T) \
T (*j##T##9)(T,T,T,T,T,T,T,T,T); \
jit_node_t *n##T##9;
#define dat10(T) dat9(T) \
T (*j##T##10)(T,T,T,T,T,T,T,T,T,T); \
jit_node_t *n##T##10;
#define dat11(T) dat10(T) \
T (*j##T##11)(T,T,T,T,T,T,T,T,T,T,T); \
jit_node_t *n##T##11;
#define dat12(T) dat11(T) \
T (*j##T##12)(T,T,T,T,T,T,T,T,T,T,T,T); \
jit_node_t *n##T##12;
#define dat13(T) dat12(T) \
T (*j##T##13)(T,T,T,T,T,T,T,T,T,T,T,T,T);\
jit_node_t *n##T##13;
#define dat14(T) dat13(T) \
T (*j##T##14)(T,T,T,T,T,T,T,T,T,T,T,T,T,T);\
jit_node_t *n##T##14;
#define dat15(T) dat14(T) \
T (*j##T##15)(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T);\
jit_node_t *n##T##15;
#define dat(T) dat15(T)
dat(_c)
dat(_uc)
dat(_s)
dat(_us)
dat(_i)
#if __WORDSIZE == 64
dat(_ui)
dat(_l)
#endif
dat(_f)
dat(_d)
#undef dat
#undef dat15
#undef dat14
#undef dat13
#undef dat12
#undef dat11
#undef dat10
#undef dat9
#undef dat8
#undef dat7
#undef dat6
#undef dat5
#undef dat4
#undef dat3
#undef dat2
#undef dat1
#undef dat0
/*
* Implementation
*/
#define dcl0(T) \
T C##T##0(void) \
{ \
return (0); \
}
#define dcl1(T) \
dcl0(T) \
T C##T##1(T A) \
{ \
return (A); \
}
#define dcl2(T) \
dcl1(T) \
T C##T##2(T A,T B) \
{ \
return (A-B); \
}
#define dcl3(T) \
dcl2(T) \
T C##T##3(T A,T B,T C) \
{ \
return (A-B-C); \
}
#define dcl4(T) \
dcl3(T) \
T C##T##4(T A,T B,T C,T D) \
{ \
return (A-B-C-D); \
}
#define dcl5(T) \
dcl4(T) \
T C##T##5(T A,T B,T C,T D,T E) \
{ \
return (A-B-C-D-E); \
}
#define dcl6(T) \
dcl5(T) \
T C##T##6(T A,T B,T C,T D,T E,T F) \
{ \
return (A-B-C-D-E-F); \
}
#define dcl7(T) \
dcl6(T) \
T C##T##7(T A,T B,T C,T D,T E,T F,T G) \
{ \
return (A-B-C-D-E-F-G); \
}
#define dcl8(T) \
dcl7(T) \
T C##T##8(T A,T B,T C,T D,T E,T F,T G,T H) \
{ \
return (A-B-C-D-E-F-G-H); \
}
#define dcl9(T) \
dcl8(T) \
T C##T##9(T A,T B,T C,T D,T E,T F,T G,T H,T I) \
{ \
return (A-B-C-D-E-F-G-H-I); \
}
#define dcl10(T) \
dcl9(T) \
T C##T##10(T A,T B,T C,T D,T E,T F,T G,T H,T I,T J) \
{ \
return (A-B-C-D-E-F-G-H-I-J); \
}
#define dcl11(T) \
dcl10(T) \
T C##T##11(T A,T B,T C,T D,T E,T F,T G,T H,T I,T J,T K) \
{ \
return (A-B-C-D-E-F-G-H-I-J-K); \
}
#define dcl12(T) \
dcl11(T) \
T C##T##12(T A,T B,T C,T D,T E,T F,T G,T H,T I,T J,T K,T L) \
{ \
return (A-B-C-D-E-F-G-H-I-J-K-L); \
}
#define dcl13(T) \
dcl12(T) \
T C##T##13(T A,T B,T C,T D,T E,T F,T G,T H,T I,T J,T K,T L,T M) \
{ \
return (A-B-C-D-E-F-G-H-I-J-K-L-M); \
}
#define dcl14(T) \
dcl13(T) \
T C##T##14(T A,T B,T C,T D,T E,T F,T G,T H,T I,T J,T K,T L,T M,T N) \
{ \
return (A-B-C-D-E-F-G-H-I-J-K-L-M-N); \
}
#define dcl15(T) \
dcl14(T) \
T C##T##15(T A,T B,T C,T D,T E,T F,T G,T H,T I,T J,T K,T L,T M,T N,T O) \
{ \
return (A-B-C-D-E-F-G-H-I-J-K-L-M-N-O); \
}
#define dcl(T) dcl15(T)
dcl(_c)
dcl(_uc)
dcl(_s)
dcl(_us)
dcl(_i)
#if __WORDSIZE == 64
dcl(_ui)
dcl(_l)
#endif
dcl(_f)
dcl(_d)
#undef dcl
#undef dcl15
#undef dcl14
#undef dcl13
#undef dcl12
#undef dcl11
#undef dcl10
#undef dcl9
#undef dcl8
#undef dcl7
#undef dcl6
#undef dcl5
#undef dcl4
#undef dcl3
#undef dcl2
#undef dcl1
#undef dcl0
#define dcl0(T) \
T CJ##T##0(void) \
{ \
return ((*j##T##0)()); \
}
#define dcl1(T) \
dcl0(T) \
T CJ##T##1(void) \
{ \
return ((*j##T##1)(1)); \
}
#define dcl2(T) \
dcl1(T) \
T CJ##T##2(void) \
{ \
return ((*j##T##2)(1,2)); \
}
#define dcl3(T) \
dcl2(T) \
T CJ##T##3(void) \
{ \
return ((*j##T##3)(1,2,3)); \
}
#define dcl4(T) \
dcl3(T) \
T CJ##T##4(void) \
{ \
return ((*j##T##4)(1,2,3,4)); \
}
#define dcl5(T) \
dcl4(T) \
T CJ##T##5(void) \
{ \
return ((*j##T##5)(1,2,3,4,5)); \
}
#define dcl6(T) \
dcl5(T) \
T CJ##T##6(void) \
{ \
return ((*j##T##6)(1,2,3,4,5,6)); \
}
#define dcl7(T) \
dcl6(T) \
T CJ##T##7(void) \
{ \
return ((*j##T##7)(1,2,3,4,5,6,7)); \
}
#define dcl8(T) \
dcl7(T) \
T CJ##T##8(void) \
{ \
return ((*j##T##8)(1,2,3,4,5,6,7,8)); \
}
#define dcl9(T) \
dcl8(T) \
T CJ##T##9(void) \
{ \
return ((*j##T##9)(1,2,3,4,5,6,7,8,9)); \
}
#define dcl10(T) \
dcl9(T) \
T CJ##T##10(void) \
{ \
return ((*j##T##10)(1,2,3,4,5,6,7,8,9,10)); \
}
#define dcl11(T) \
dcl10(T) \
T CJ##T##11(void) \
{ \
return ((*j##T##11)(1,2,3,4,5,6,7,8,9,10,11)); \
}
#define dcl12(T) \
dcl11(T) \
T CJ##T##12(void) \
{ \
return ((*j##T##12)(1,2,3,4,5,6,7,8,9,10,11,12)); \
}
#define dcl13(T) \
dcl12(T) \
T CJ##T##13(void) \
{ \
return ((*j##T##13)(1,2,3,4,5,6,7,8,9,10,11,12,13)); \
}
#define dcl14(T) \
dcl13(T) \
T CJ##T##14(void) \
{ \
return ((*j##T##14)(1,2,3,4,5,6,7,8,9,10,11,12,13,14)); \
}
#define dcl15(T) \
dcl14(T) \
T CJ##T##15(void) \
{ \
return ((*j##T##15)(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)); \
}
#define dcl(t) dcl15(t)
dcl(_c)
dcl(_uc)
dcl(_s)
dcl(_us)
dcl(_i)
#if __WORDSIZE == 64
dcl(_ui)
dcl(_l)
#endif
dcl(_f)
dcl(_d)
#undef dcl
#undef dcl15
#undef dcl14
#undef dcl13
#undef dcl12
#undef dcl11
#undef dcl10
#undef dcl9
#undef dcl8
#undef dcl7
#undef dcl6
#undef dcl5
#undef dcl4
#undef dcl3
#undef dcl2
#undef dcl1
#undef dcl0
int
main(int argc, char *argv[])
{
jit_state_t *_jit;
jit_node_t *jmpi_main;
void (*function)(void);
jit_node_t *a1,*a2,*a3,*a4,*a5,*a6,*a7,*a8,*a9;
jit_node_t *a10,*a11,*a12,*a13,*a14,*a15;
jit_node_t *jmp;
init_jit(argv[0]);
_jit = jit_new_state();
jmpi_main = jit_jmpi();
#define arg0(T) /**/
#define arg1(T) a1 = jit_arg##T();
#define arg2(T) arg1(T) a2 = jit_arg##T();
#define arg3(T) arg2(T) a3 = jit_arg##T();
#define arg4(T) arg3(T) a4 = jit_arg##T();
#define arg5(T) arg4(T) a5 = jit_arg##T();
#define arg6(T) arg5(T) a6 = jit_arg##T();
#define arg7(T) arg6(T) a7 = jit_arg##T();
#define arg8(T) arg7(T) a8 = jit_arg##T();
#define arg9(T) arg8(T) a9 = jit_arg##T();
#define arg10(T) arg9(T) a10 = jit_arg##T();
#define arg11(T) arg10(T) a11 = jit_arg##T();
#define arg12(T) arg11(T) a12 = jit_arg##T();
#define arg13(T) arg12(T) a13 = jit_arg##T();
#define arg14(T) arg13(T) a14 = jit_arg##T();
#define arg15(T) arg14(T) a15 = jit_arg##T();
#define get0(B,T,R) jit_movi##B(R##0,0);
#define get1(B,T,R) jit_getarg##B(R##0,a##1);
#define get2(B,T,R) \
get1(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##2); \
jit_subr##B(R##0, R##1, R##0);
#define get3(B,T,R) \
get2(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##3); \
jit_subr##B(R##0, R##1, R##0);
#define get4(B,T,R) \
get3(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##4); \
jit_subr##B(R##0, R##1, R##0);
#define get5(B,T,R) \
get4(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##5); \
jit_subr##B(R##0, R##1, R##0);
#define get6(B,T,R) \
get5(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##6); \
jit_subr##B(R##0, R##1, R##0);
#define get7(B,T,R) \
get6(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##7); \
jit_subr##B(R##0, R##1, R##0);
#define get8(B,T,R) \
get7(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##8); \
jit_subr##B(R##0, R##1, R##0);
#define get9(B,T,R) \
get8(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##9); \
jit_subr##B(R##0, R##1, R##0);
#define get10(B,T,R) \
get9(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##10); \
jit_subr##B(R##0, R##1, R##0);
#define get11(B,T,R) \
get10(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##11); \
jit_subr##B(R##0, R##1, R##0);
#define get12(B,T,R) \
get11(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##12); \
jit_subr##B(R##0, R##1, R##0);
#define get13(B,T,R) \
get12(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##13); \
jit_subr##B(R##0, R##1, R##0);
#define get14(B,T,R) \
get13(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##14); \
jit_subr##B(R##0, R##1, R##0);
#define get15(B,T,R) \
get14(B,T,R); \
jit_movr##B(R##1, R##0); \
jit_getarg##T(R##0, a##15); \
jit_subr##B(R##0, R##1, R##0);
#if __WORDSIZE == 32
# define jit_extr_i(u, v) /**/
#else
# define jit_extr_l(u, v) /**/
#endif
#define strfy(n) #n
#define defi(T, N) \
n##T##N = jit_name(strfy(n##T##N)); \
jit_note("ccall.c", __LINE__); \
jit_prolog(); \
arg##N(); \
get##N(,T,JIT_R) \
jit_extr##T(JIT_R0, JIT_R0); \
jit_retr(JIT_R0); \
jit_epilog();
#define deff(T, N) \
n##T##N = jit_name(strfy(n##T##N)); \
jit_note("ccall.c", __LINE__); \
jit_prolog(); \
arg##N(T); \
get##N(T,T,JIT_F); \
jit_retr##T(JIT_F0); \
jit_epilog();
#define def0(X, T) def##X(T, 0)
#define def1(X, T) def0(X, T) def##X(T, 1)
#define def2(X, T) def1(X, T) def##X(T, 2)
#define def3(X, T) def2(X, T) def##X(T, 3)
#define def4(X, T) def3(X, T) def##X(T, 4)
#define def5(X, T) def4(X, T) def##X(T, 5)
#define def6(X, T) def5(X, T) def##X(T, 6)
#define def7(X, T) def6(X, T) def##X(T, 7)
#define def8(X, T) def7(X, T) def##X(T, 8)
#define def9(X, T) def8(X, T) def##X(T, 9)
#define def10(X, T) def9(X, T) def##X(T, 10)
#define def11(X, T) def10(X, T) def##X(T, 11)
#define def12(X, T) def11(X, T) def##X(T, 12)
#define def13(X, T) def12(X, T) def##X(T, 13)
#define def14(X, T) def13(X, T) def##X(T, 14)
#define def15(X, T) def14(X, T) def##X(T, 15)
#define def(T) def15(i, T)
def(_c)
def(_uc)
def(_s)
def(_us)
def(_i)
#if __WORDSIZE == 64
def(_ui)
def(_l)
#endif
#undef def
#define def(T) def15(f, T)
def(_f)
def(_d)
#undef def
jit_patch(jmpi_main);
jit_name("main");
jit_note("ccall.c", __LINE__);
jit_prolog();
#define push0(T) /**/
#define push1(T) jit_pushargi##T(1);
#define push2(T) push1(T) jit_pushargi##T(2);
#define push3(T) push2(T) jit_pushargi##T(3);
#define push4(T) push3(T) jit_pushargi##T(4);
#define push5(T) push4(T) jit_pushargi##T(5);
#define push6(T) push5(T) jit_pushargi##T(6);
#define push7(T) push6(T) jit_pushargi##T(7);
#define push8(T) push7(T) jit_pushargi##T(8);
#define push9(T) push8(T) jit_pushargi##T(9);
#define push10(T) push9(T) jit_pushargi##T(10);
#define push11(T) push10(T) jit_pushargi##T(11);
#define push12(T) push11(T) jit_pushargi##T(12);
#define push13(T) push12(T) jit_pushargi##T(13);
#define push14(T) push13(T) jit_pushargi##T(14);
#define push15(T) push14(T) jit_pushargi##T(15);
#define calin(T,N) \
jit_prepare(); \
push##N() \
jit_finishi(C##T##N); \
jit_retval##T(JIT_R0); \
jmp = jit_beqi(JIT_R0, T##N); \
jit_calli(abort); \
jit_patch(jmp);
#define calfn(T,N) \
jit_prepare(); \
push##N(T) \
jit_finishi(C##T##N); \
jit_retval##T(JIT_F0); \
jmp = jit_beqi##T(JIT_F0, _w##N); \
jit_calli(abort); \
jit_patch(jmp);
#define calx0(X,T) cal##X##n(T,0)
#define calx1(X,T) calx0(X,T) cal##X##n(T,1)
#define calx2(X,T) calx1(X,T) cal##X##n(T,2)
#define calx3(X,T) calx2(X,T) cal##X##n(T,3)
#define calx4(X,T) calx3(X,T) cal##X##n(T,4)
#define calx5(X,T) calx4(X,T) cal##X##n(T,5)
#define calx6(X,T) calx5(X,T) cal##X##n(T,6)
#define calx7(X,T) calx6(X,T) cal##X##n(T,7)
#define calx8(X,T) calx7(X,T) cal##X##n(T,8)
#define calx9(X,T) calx8(X,T) cal##X##n(T,9)
#define calx10(X,T) calx9(X,T) cal##X##n(T,10)
#define calx11(X,T) calx10(X,T) cal##X##n(T,11)
#define calx12(X,T) calx11(X,T) cal##X##n(T,12)
#define calx13(X,T) calx12(X,T) cal##X##n(T,13)
#define calx14(X,T) calx13(X,T) cal##X##n(T,14)
#define calx15(X,T) calx14(X,T) cal##X##n(T,15)
#define cali(T) calx15(i,T)
#define calf(T) calx15(f,T)
cali(_c)
cali(_uc)
cali(_s)
cali(_us)
cali(_i)
#if __WORDSIZE == 64
cali(_ui)
cali(_l)
#endif
calf(_f)
calf(_d)
#undef calin
#undef calfn
#define calin(T,N) \
jit_prepare(); \
push##N() \
jit_finishi(CJ##T##N); \
jit_retval##T(JIT_R0); \
jmp = jit_beqi(JIT_R0, T##N); \
jit_calli(abort); \
jit_patch(jmp);
#define calfn(T,N) \
jit_prepare(); \
push##N(T) \
jit_finishi(CJ##T##N); \
jit_retval##T(JIT_F0); \
jmp = jit_beqi##T(JIT_F0, _w##N); \
jit_calli(abort); \
jit_patch(jmp);
cali(_c)
cali(_uc)
cali(_s)
cali(_us)
cali(_i)
#if __WORDSIZE == 64
cali(_ui)
cali(_l)
#endif
calf(_f)
calf(_d)
jit_ret();
function = jit_emit();
#define initn(T,N) j##T##N = jit_address(n##T##N);
#define init0(T) initn(T,0)
#define init1(T) init0(T) initn(T,1)
#define init2(T) init1(T) initn(T,2)
#define init3(T) init2(T) initn(T,3)
#define init4(T) init3(T) initn(T,4)
#define init5(T) init4(T) initn(T,5)
#define init6(T) init5(T) initn(T,6)
#define init7(T) init6(T) initn(T,7)
#define init8(T) init7(T) initn(T,8)
#define init9(T) init8(T) initn(T,9)
#define init10(T) init9(T) initn(T,10)
#define init11(T) init10(T) initn(T,11)
#define init12(T) init11(T) initn(T,12)
#define init13(T) init12(T) initn(T,13)
#define init14(T) init13(T) initn(T,14)
#define init15(T) init14(T) initn(T,15)
#define init(T) init15(T)
init(_c)
init(_uc)
init(_s)
init(_us)
init(_i)
#if __WORDSIZE == 64
init(_ui)
init(_l)
#endif
init(_f)
init(_d)
#if 0
jit_print();
jit_disassemble();
#endif
jit_clear_state();
(*function)();
jit_destroy_state();
finish_jit();
printf("ok\n");
return (0);
}
parallel-rsp/lightning/check/check.arm.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.arm$||'`
./lightning -mthumb=0 $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.arm.swf.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.arm\.swf$||'`
./lightning -mthumb=0 -mvfp=0 $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.arm4.swf.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.arm4\.swf$||'`
./lightning -mcpu=4 -mthumb=0 -mvfp=0 $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.nodata.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.nodata$||'`
./lightning -d $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0`
./lightning $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.swf.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.swf$||'`
./lightning -mvfp=0 $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.x87.nodata.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.x87.nodata$||'`
./lightning -data=0 -mx87=1 $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/check.x87.sh
-15
View File
@@ -1,15 +0,0 @@
#!/bin/sh
test=`basename $0 | sed -e 's|\.x87$||'`
./lightning -mx87=1 $srcdir/$test.tst | tr -d \\r > $test.out
if test $? != 0; then
exit $?
fi
cmp -s $srcdir/$test.ok $test.out
result=$?
if test $result != 0; then
diff $srcdir/$test.ok $test.out
rm $test.out
exit 1
fi
rm $test.out
parallel-rsp/lightning/check/clobber.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/clobber.tst
-1050
View File
File diff suppressed because it is too large. Load diff
parallel-rsp/lightning/check/ctramp.c
-123
View File
@@ -1,123 +0,0 @@
#include <lightning.h>
#include <stdio.h>
jit_state_t *_jit;
long top;
long stk[1024];
int
main(int argc, char *argv[])
{
void *address;
void (*call)(void*);
jit_state_t *frame_jit, *tramp_jit;
jit_node_t *arg, *done, *xfibs, *out, *ret1, *ret2;
init_jit(argv[0]);
_jit = frame_jit = jit_new_state();
jit_name("main");
jit_prolog();
jit_frame(64);
arg = jit_arg();
jit_getarg(JIT_R1, arg);
/* Initialize language stack */
jit_movi(JIT_R0, (jit_word_t)stk);
jit_sti(&top, JIT_R0);
/* return address */
done = jit_movi(JIT_R0, 0);
/* argument */
jit_movi(JIT_V0, 32);
/* jump to code */
jit_jmpr(JIT_R1);
jit_patch(done);
jit_prepare();
jit_pushargi((jit_word_t)"xfibs(%d) = %d\n");
jit_ellipsis();
jit_pushargi(32);
jit_pushargr(JIT_V0);
jit_finishi(printf);
jit_ret();
jit_epilog();
call = jit_emit();
jit_clear_state();
#define SIZE sizeof(jit_word_t)
_jit = tramp_jit = jit_new_state();
jit_name("xfibs");
xfibs = jit_label();
jit_prolog();
jit_tramp(64);
out = jit_blti(JIT_V0, 2);
jit_subi(JIT_V1, JIT_V0, 1); /* V1 = N-1 */
jit_subi(JIT_V2, JIT_V0, 2); /* V1 = N-2 */
/* save return address */
jit_ldi(JIT_R1, &top);
jit_stxi(SIZE * 0, JIT_R1, JIT_R0);
/* save operands */
jit_stxi(SIZE * 1, JIT_R1, JIT_V0);
jit_stxi(SIZE * 2, JIT_R1, JIT_V1);
jit_stxi(SIZE * 3, JIT_R1, JIT_V2);
/* adjust "language" stack */
jit_addi(JIT_R1, JIT_R1, SIZE * 4);
jit_sti(&top, JIT_R1);
/* return address */
ret1 = jit_movi(JIT_R0, 0);
/* argument */
jit_movr(JIT_V0, JIT_V1);
/* indirect goto */
jit_patch_at(jit_jmpi(), xfibs);
jit_patch(ret1);
jit_movr(JIT_V1, JIT_V0); /* V1 = rfibs(N-1) */
/* save V1 */
jit_ldi(JIT_R1, &top);
jit_stxi(-SIZE * 2, JIT_R1, JIT_V1);
/* reload V2 */
jit_ldxi(JIT_V2, JIT_R1, -SIZE * 1);
/* return address */
ret2 = jit_movi(JIT_R0, 0);
/* argument */
jit_movr(JIT_V0, JIT_V2);
/* indirect goto */
jit_patch_at(jit_jmpi(), xfibs);
jit_patch(ret2);
jit_movr(JIT_V2, JIT_V0); /* V2 = rfibs(N-2) */
/* reload return address */
jit_ldi(JIT_R1, &top);
jit_subi(JIT_R1, JIT_R1, SIZE * 4);
jit_ldxi(JIT_R0, JIT_R1, SIZE * 0);
/* reload operands */
jit_ldxi(JIT_V0, JIT_R1, SIZE * 1);
jit_ldxi(JIT_V1, JIT_R1, SIZE * 2);
/* V2 already loaded */
/* update "language" stack */
jit_sti(&top, JIT_R1);
jit_addi(JIT_V1, JIT_V1, 1);
jit_addr(JIT_V0, JIT_V1, JIT_V2);
jit_jmpr(JIT_R0);
jit_patch(out);
jit_movi(JIT_V0, 1);
jit_jmpr(JIT_R0);
jit_epilog();
address = jit_emit();
jit_clear_state();
(*call)(address);
jit_destroy_state();
_jit = frame_jit;
jit_destroy_state();
return 0;
}
parallel-rsp/lightning/check/cva_list.c
-1187
View File
File diff suppressed because it is too large. Load diff
parallel-rsp/lightning/check/cvt.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/cvt.tst
-380
View File
@@ -1,380 +0,0 @@
.data 12
ok:
.c "ok\n"
#if __WORDSIZE == 32
# define w7f 0x7fffffff
# define w80 0x80000000
# define w81 0x80000001
# define wff 0xffffffff
# define LEXTII2(N, R0, R1)
# define LEXTIC2(N, R0)
#else
# define w7f 0x7fffffffffffffff
# define w80 0x8000000000000000
# define w81 0x8000000000000001
# define wff 0xffffffffffffffff
# define i7f wff
# define ui7f 0xffffffff
# define i80 0
# define ui80 0
# define i81 1
# define ui81 1
# define iff wff
# define uiff 0xffffffff
# define LEXTII2(N, R0, R1) \
EXTII2(N, i, R0, R1) \
EXTII2(N, ui, R0, R1)
# define LEXTIC2(N, R0) \
EXTIC2(N, i, R0) \
EXTIC2(N, ui, R0)
#endif
#define c7f wff
#define uc7f 0xff
#define s7f wff
#define us7f 0xffff
#define c80 0
#define uc80 0
#define s80 0
#define us80 0
#define c81 1
#define uc81 1
#define s81 1
#define us81 1
#define cff wff
#define ucff 0xff
#define sff wff
#define usff 0xffff
#define EXTII2(N, T, R0, R1) \
movi %R0 w##N \
extr_##T %R1 %R0 \
beqi T##_##R0##_##R1##_##N %R1 T##N \
calli @abort \
T##_##R0##_##R1##_##N:
#define EXTII1(N, R0, R1) \
EXTII2(N, c, R0, R1) \
EXTII2(N, uc, R0, R1) \
EXTII2(N, s, R0, R1) \
EXTII2(N, us, R0, R1) \
LEXTII2(N, R0, R1)
#define EXTII0(R0, R1) \
EXTII1(7f, R0, R1) \
EXTII1(80, R0, R1) \
EXTII1(81, R0, R1) \
EXTII1(ff, R0, R1)
#define EXTIC2(N, T, R0) \
movi %R0 w##N \
extr_##T %R0 %R0 \
beqi T##_##R0##_##N %R0 T##N \
calli @abort \
T##_##R0##_##N:
#define EXTIC1(N, R0) \
EXTIC2(N, c, R0) \
EXTIC2(N, uc, R0) \
EXTIC2(N, s, R0) \
EXTIC2(N, us, R0) \
LEXTIC2(N, R0)
#define EXTIC0(R0) \
EXTIC1(7f, R0) \
EXTIC1(80, R0) \
EXTIC1(81, R0) \
EXTIC1(ff, R0)
#define EXTII(V0, V1, V2, R0, R1, R2) \
EXTII0(V0, V1) \
EXTII0(V0, V2) \
EXTII0(V0, R0) \
EXTII0(V0, R1) \
EXTII0(V0, R2) \
EXTII0(V1, V0) \
EXTII0(V1, V2) \
EXTII0(V1, R0) \
EXTII0(V1, R1) \
EXTII0(V1, R2) \
EXTII0(V2, V0) \
EXTII0(V2, V1) \
EXTII0(V2, R0) \
EXTII0(V2, R1) \
EXTII0(V2, R2) \
EXTII0(R0, V0) \
EXTII0(R0, V1) \
EXTII0(R0, V2) \
EXTII0(R0, R1) \
EXTII0(R0, R2) \
EXTII0(R1, V0) \
EXTII0(R1, V1) \
EXTII0(R1, V2) \
EXTII0(R1, R0) \
EXTII0(R1, R2) \
EXTII0(R2, V0) \
EXTII0(R2, V1) \
EXTII0(R2, V2) \
EXTII0(R2, R0) \
EXTII0(R2, R1) \
EXTIC0(V0) \
EXTIC0(V1) \
EXTIC0(V2) \
EXTIC0(R0) \
EXTIC0(R1) \
EXTIC0(R2)
#define EXIF1(N, V, R0, R1) \
movi %R0 V \
extr_f %R1 %R0 \
beqi_f wf##_##R0##_##R1##_##N %R1 V \
wf##_##R0##_##R1##_##N:
#define EXIF0(R0, R1) \
EXIF1(0, -1, R0, R1) \
EXIF1(1, 64, R0, R1)
#define EXIF(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
EXIF0(V0, F0) \
EXIF0(V1, F1) \
EXIF0(V2, F2) \
EXIF0(R0, F3) \
EXIF0(R1, F4) \
EXIF0(R2, F5)
#define EXID1(N, V, R0, R1) \
movi %R0 V \
extr_d %R1 %R0 \
beqi_d wd##_##R0##_##R1##_##N %R1 V \
wd##_##R0##_##R1##_##N:
#define EXID0(R0, R1) \
EXID1(0, -1, R0, R1) \
EXID1(1, 64, R0, R1)
#define EXID(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
EXID0(V0, F0) \
EXID0(V1, F1) \
EXID0(V2, F2) \
EXID0(R0, F3) \
EXID0(R1, F4) \
EXID0(R2, F5)
#define EXFI1(N, V, R0, R1) \
movi_f %R1 V \
truncr_f %R0 %R1 \
beqi fi##_##R0##_##R1##_##N %R0 V \
calli @abort \
fi##_##R0##_##R1##_##N:
#define EXFI0(R0, R1) \
EXFI1(0, 42, R0, R1) \
EXFI1(1, -128, R0, R1)
#define EXFI(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
EXFI0(V0, F5) \
EXFI0(V1, F4) \
EXFI0(V2, F3) \
EXFI0(R0, F2) \
EXFI0(R1, F1) \
EXFI0(R2, F0)
#define EXDI1(N, V, R0, R1) \
movi_d %R1 V \
truncr_d %R0 %R1 \
beqi di##_##R0##_##R1##_##N %R0 V \
calli @abort \
di##_##R0##_##R1##_##N:
#define EXDI0(R0, R1) \
EXDI1(0, 42, R0, R1) \
EXDI1(1, -128, R0, R1)
#define EXDI(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
EXDI0(V0, F5) \
EXDI0(V1, F4) \
EXDI0(V2, F3) \
EXDI0(R0, F2) \
EXDI0(R1, F1) \
EXDI0(R2, F0)
#define LEXFI1(N, V, R0, R1) \
movi_f %R1 V \
truncr_f_i %R0 %R1 \
andi %R0 %R0 0xffffffff \
beqi lfi##_##R0##_##R1##_##N %R0 $(V & 0xffffffff) \
calli @abort \
lfi##_##R0##_##R1##_##N:
#define LEXFI0(R0, R1) \
LEXFI1(0, 42, R0, R1) \
LEXFI1(1, -128, R0, R1)
#define LEXFI(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
LEXFI0(V0, F5) \
LEXFI0(V1, F4) \
LEXFI0(V2, F3) \
LEXFI0(R0, F2) \
LEXFI0(R1, F1) \
LEXFI0(R2, F0)
#define LEXDI1(N, V, R0, R1) \
movi_d %R1 V \
truncr_d_i %R0 %R1 \
andi %R0 %R0 0xffffffff \
beqi ldi##_##R0##_##R1##_##N %R0 $(V & 0xffffffff) \
calli @abort \
ldi##_##R0##_##R1##_##N:
#define LEXDI0(R0, R1) \
LEXDI1(0, 42, R0, R1) \
LEXDI1(1, -128, R0, R1)
#define LEXDI(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
LEXDI0(V0, F5) \
LEXDI0(V1, F4) \
LEXDI0(V2, F3) \
LEXDI0(R0, F2) \
LEXDI0(R1, F1) \
LEXDI0(R2, F0)
#define EXTFD2(V, R0, R1) \
movi_f %R0 V \
extr_f_d %R1 %R0 \
beqi_d fd##_##R0##_##R1 %R1 V \
calli @abort \
fd##_##R0##_##R1:
#define EXTFD1(R0, R1) \
EXTFD2(1.25, R0, R1)
#define EXTFDC2(V, R0) \
movi_f %R0 V \
extr_f_d %R0 %R0 \
beqi_d fdc##_##R0 %R0 V \
calli @abort \
fdc##_##R0:
#define EXTFDC1(R0) \
EXTFDC2(-0.75, R0)
#define EXTFD(R0, R1, R2, R3, R4, R5) \
EXTFD1(R0, R1) \
EXTFD1(R0, R2) \
EXTFD1(R0, R3) \
EXTFD1(R0, R4) \
EXTFD1(R0, R5) \
EXTFDC1(R0) \
EXTFDC1(R1) \
EXTFDC1(R2) \
EXTFDC1(R3) \
EXTFDC1(R4) \
EXTFDC1(R5)
#define EXTDF2(V, R0, R1) \
movi_d %R0 V \
extr_d_f %R1 %R0 \
beqi_f df##_##R0##_##R1 %R1 V \
calli @abort \
df##_##R0##_##R1:
#define EXTDF1(R0, R1) \
EXTDF2(1.25, R0, R1)
#define EXTDFC2(V, R0) \
movi_d %R0 V \
extr_d_f %R0 %R0 \
beqi_f dfc##_##R0 %R0 V \
calli @abort \
dfc##_##R0:
#define EXTDFC1(R0) \
EXTDFC2(-0.75, R0)
#define EXTDF(R0, R1, R2, R3, R4, R5) \
EXTDF1(R0, R1) \
EXTDF1(R0, R2) \
EXTDF1(R0, R3) \
EXTDF1(R0, R4) \
EXTDF1(R0, R5) \
EXTDFC1(R0) \
EXTDFC1(R1) \
EXTDFC1(R2) \
EXTDFC1(R3) \
EXTDFC1(R4) \
EXTDFC1(R5)
.code
prolog
/* simple sequence for easier disassembly reading and encoding check */
movi %r0 w7f
extr_c %r1 %r0
beqi xc %r1 c7f
calli @abort
xc:
movi %r0 w7f
extr_uc %r1 %r0
beqi xuc %r1 uc7f
calli @abort
xuc:
movi %r0 w7f
extr_s %r1 %r0
beqi xs %r1 s7f
calli @abort
xs:
movi %r0 w7f
extr_us %r1 %r0
beqi xus %r1 us7f
calli @abort
xus:
#if __WORDSIZE == 64
movi %r0 w7f
extr_i %r1 %r0
beqi xi %r1 i7f
calli @abort
xi:
movi %r0 w7f
extr_ui %r1 %r0
beqi xui %r1 ui7f
calli @abort
xui:
#endif
movi %r0 -2
extr_f %f0 %r0
beqi_f xif %f0 -2
calli @abort
xif:
movi %r0 32
extr_d %f0 %r0
beqi_d xid %f0 32
calli @abort
xid:
movi_f %f0 -128
truncr_f %r0 %f0
beqi xfi %r0 -128
calli @abort
xfi:
movi_d %f0 -128
truncr_d %r0 %f0
beqi xdi %r0 -128
calli @abort
xdi:
#if __WORDSIZE == 64
movi_f %f0 -128
truncr_f_i %r0 %f0
andi %r0 %r0 0xffffffff
beqi yfi %r0 $(-128 & 0xffffffff)
calli @abort
yfi:
movi_d %f0 -128
truncr_d_i %r0 %f0
andi %r0 %r0 0xffffffff
beqi ydi %r0 $(-128 & 0xffffffff)
calli @abort
ydi:
#endif
movi_f %f0 0.5
extr_f_d %f1 %f0
beqi_d xfd %f1 0.5
calli @abort
xfd:
movi_d %f0 0.5
extr_d_f %f1 %f0
beqi_f xdf %f1 0.5
calli @abort
xdf:
EXTII(v0, v1, v2, r0, r1, r2)
EXIF(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
EXID(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
EXFI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
#if __WORDSIZE == 64
LEXFI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
LEXDI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
#endif
EXDI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
EXTFD(f0, f1, f2, f3, f4, f5)
EXTDF(f0, f1, f2, f3, f4, f5)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/divi.ok
-6
View File
@@ -1,6 +0,0 @@
40/8 = 5 (expected 5)
64/8 = 8 (expected 8)
80/8 = 10 (expected 10)
98304/32768 = 3 (expected 3)
65536/32768 = 2 (expected 2)
163840/32768 = 5 (expected 5)
parallel-rsp/lightning/check/divi.tst
-85
View File
@@ -1,85 +0,0 @@
.data 128
small_ops:
.i 40 64 80
large_ops:
.i 98304 65536 163840
fmt:
.c "%i/%i = %i (expected %i)\n"
x:
.c "%d\n"
.code
jmpi main
#define generate_divider(operand) \
name divider_##operand \
divider_##operand: \
prolog \
arg $i \
getarg %r1 $i \
divi %r2 %r1 operand \
retr %r2 \
epilog
generate_divider(8)
generate_divider(32768)
#define generate_test_divider(divisor) \
name test_divider_##divisor \
test_divider_##divisor: \
prolog \
allocai 4 $loc \
arg $p \
arg $c \
getarg %v0 $p \
getarg %v1 $c \
muli %v1 %v1 4 \
addr %v1 %v0 %v1 \
loop_##divisor: \
bger done_##divisor %v0 %v1 \
ldr_i %v2 %v0 \
prepare \
pushargr %v2 \
finishi divider_##divisor \
retval %v2 \
ldr_i %r2 %v0 \
divi %r0 %r2 divisor \
/* save div result */ \
stxi_i $loc %fp %r0 \
prepare \
pushargi fmt \
ellipsis \
pushargr %r2 \
pushargi divisor \
pushargr %v2 \
pushargr %r0 \
finishi @printf \
addi %v0 %v0 4 \
/* reload div result */ \
ldxi_i %r0 %fp $loc \
beqr loop_##divisor %r0 %v2 \
/* return if failed */ \
reti 1 \
done_##divisor: \
reti 0 \
epilog
generate_test_divider(8)
generate_test_divider(32768)
name main
main:
prolog
prepare
pushargi small_ops
pushargi 3
finishi test_divider_8
retval %r0
bnei fail %r0 0
prepare
pushargi large_ops
pushargi 3
finishi test_divider_32768
retval %r0
bnei fail %r0 0
reti 0
fail:
reti 1
epilog
parallel-rsp/lightning/check/fib.ok
-1
View File
@@ -1 +0,0 @@
nfibs(32) = 2178309
parallel-rsp/lightning/check/fib.tst
-62
View File
@@ -1,62 +0,0 @@
.data 32
format:
.c "nfibs(%d) = %d\n"
.code
jmpi main
name nfibs
nfibs:
prolog
arg $in
getarg %r0 $in // R0 = n
beqi ref %r0 0
movr %r1 %r0
movi %r0 1
blei_u ref %r1 2
subi %r2 %r1 2
movr %r1 %r0
loop:
subi %r2 %r2 1 // decr. counter
movr %v0 %r0 // V0 = R0
addr %r0 %r0 %r1 // R0 = R0 + R1
movr %r1 %v0 // R1 = V0
bnei loop %r2 0 // if (R2) goto loop
ref:
retr %r0 // RET = R0
epilog
name main
main:
prolog
arg $argc
arg $argv
getarg_i %r0 $argc
blei default %r0 1
getarg %r0 $argv
addi %r0 %r0 $(__WORDSIZE >> 3)
ldr %r0 %r0
prepare
pushargr %r0
finishi @atoi
retval %r0
jmpi call
default:
movi %r0 32
call:
movr %v0 %r0
prepare
pushargr %r0
finishi nfibs
retval %r0
prepare
pushargi format
ellipsis
pushargr %v0
pushargr %r0
finishi @printf
ret
epilog
parallel-rsp/lightning/check/float.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/float.tst
-367
View File
@@ -1,367 +0,0 @@
.data 4
ok:
.c "ok"
. $($NaN = 0.0 / 0.0)
. $($pInf = 1.0 / 0.0)
. $($nInf = -1.0 / 0.0)
#if __WORDSIZE == 32
# define x7f 0x7fffffff
# define x80 0x80000000
#else
# define x7f 0x7fffffffffffffff
# define x80 0x8000000000000000
#endif
#if __mips__ || __sparc__ || __hppa__ || __riscv
# define wnan x7f
#elif __arm__ || __aarch64__ || __alpha__
# define wnan 0
#else
# define wnan x80
#endif
#if __mips__ || __arm__ || __ppc__ || __sparc__ || __hppa__ || __aarch64__ || __s390__ || __riscv
# define wpinf x7f
#elif __alpha__
/* (at least) bug compatible with gcc 4.2.3 -ieee */
# define wpinf 0
#else
# define wpinf x80
#endif
#if __alpha__
/* (at least) bug compatible with gcc 4.2.3 -ieee */
# define wninf 0
#else
# define wninf x80
#endif
/* ensure result is correct and 0 or 1 in the result register */
#define xtcmp(l, t, op, r0, f0, f1, li, ri) \
movi##t %f0 li \
movi##t %f1 ri \
op##r##t %r0 %f0 %f1 \
bnei T##op##r##t##r0##f0##f1##l %r0 0 \
calli @abort \
T##op##r##t##r0##f0##f1##l: \
movi##t %f0 li \
movi##t %f1 ri \
b##op##r##t bT##op##r##t##r0##f0##f1##l %f0 %f1 \
calli @abort \
bT##op##r##t##r0##f0##f1##l: \
movi##t %f1 li \
op##i##t %r0 %f0 ri \
bnei T##op##i##t##r0##f0##f1##l %r0 0 \
calli @abort \
T##op##i##t##r0##f0##f1##l: \
movi##t %f1 li \
b##op##i##t bT##op##i##t##r0##f0##f1##l %f0 ri \
calli @abort \
bT##op##i##t##r0##f0##f1##l: \
movi##t %f0 li \
movi##t %f1 ri \
op##r##t %r0 %f0 %f1 \
beqi F##op##r##t##r0##f0##f1##l %r0 1 \
calli @abort \
F##op##r##t##r0##f0##f1##l: \
movi##t %f1 li \
op##i##t %r0 %f0 ri \
beqi F##op##i##t##r0##f0##f1##l %r0 1 \
calli @abort \
F##op##i##t##r0##f0##f1##l:
#define tcmp1(l, t, op, r0, li, ri) \
xtcmp(l, t, op, r0, f0, f1, li, ri) \
xtcmp(l, t, op, r0, f1, f2, li, ri) \
xtcmp(l, t, op, r0, f2, f3, li, ri) \
xtcmp(l, t, op, r0, f3, f4, li, ri) \
xtcmp(l, t, op, r0, f4, f5, li, ri)
#define tcmp0(l, t, op, li, ri) \
tcmp1(l, t, op, v0, li, ri) \
tcmp1(l, t, op, v1, li, ri) \
tcmp1(l, t, op, v2, li, ri) \
tcmp1(l, t, op, r0, li, ri) \
tcmp1(l, t, op, r1, li, ri) \
tcmp1(l, t, op, r2, li, ri)
#if __ia64__
# define tcmp(l, op, li, ri) \
xtcmp(l, _f, op, r0, f0, f1, li, ri) \
xtcmp(l, _d, op, r0, f0, f1, li, ri)
#else
# define tcmp(l, op, li, ri) \
tcmp0(l, _f, op, li, ri) \
tcmp0(l, _d, op, li, ri)
#endif
#define xfcmp(l, t, op, r0, f0, f1, li, ri) \
movi##t %f0 li \
movi##t %f1 ri \
op##r##t %r0 %f0 %f1 \
beqi T##op##r##t##r0##f0##f1##l %r0 0 \
calli @abort \
T##op##r##t##r0##f0##f1##l: \
movi##t %f1 li \
op##i##t %r0 %f0 ri \
beqi T##op##i##t##r0##f0##f1##l %r0 0 \
calli @abort \
T##op##i##t##r0##f0##f1##l: \
movi##t %f0 li \
movi##t %f1 ri \
op##r##t %r0 %f0 %f1 \
bnei F##op##r##t##r0##f0##f1##l %r0 1 \
calli @abort \
F##op##r##t##r0##f0##f1##l: \
movi##t %f1 li \
op##i##t %r0 %f0 ri \
bnei F##op##i##t##r0##f0##f1##l %r0 1 \
calli @abort \
F##op##i##t##r0##f0##f1##l:
#define fcmp1(l, t, op, r0, li, ri) \
xfcmp(l, t, op, r0, f0, f1, li, ri) \
xfcmp(l, t, op, r0, f1, f2, li, ri) \
xfcmp(l, t, op, r0, f2, f3, li, ri) \
xfcmp(l, t, op, r0, f3, f4, li, ri) \
xfcmp(l, t, op, r0, f4, f5, li, ri)
#define fcmp0(l, t, op, li, ri) \
fcmp1(l, t, op, v0, li, ri) \
fcmp1(l, t, op, v1, li, ri) \
fcmp1(l, t, op, v2, li, ri) \
fcmp1(l, t, op, r0, li, ri) \
fcmp1(l, t, op, r1, li, ri) \
fcmp1(l, t, op, r2, li, ri)
#if __ia64__
# define fcmp(l, op, li, ri) \
xfcmp(l, _f, op, r0, f0, f1, li, ri) \
xfcmp(l, _d, op, r0, f0, f1, li, ri)
#else
# define fcmp(l, op, li, ri) \
fcmp0(l, _f, op, li, ri) \
fcmp0(l, _d, op, li, ri)
#endif
#define xf2w(l, f, r0, f0, iv, fv) \
movi##f %f0 fv \
truncr##f %r0 %f0 \
beqi W##f##r0##f0##l %r0 iv \
calli @abort \
W##f##r0##f0##l:
#define f2w1(l, t, r0, iv, fv) \
xf2w(l, t, r0, f0, iv, fv) \
xf2w(l, t, r0, f1, iv, fv) \
xf2w(l, t, r0, f2, iv, fv) \
xf2w(l, t, r0, f3, iv, fv) \
xf2w(l, t, r0, f4, iv, fv) \
xf2w(l, t, r0, f5, iv, fv)
#define f2w0(l, t, iv, fv) \
f2w1(l, t, v0, iv, fv) \
f2w1(l, t, v1, iv, fv) \
f2w1(l, t, v2, iv, fv) \
f2w1(l, t, r0, iv, fv) \
f2w1(l, t, r1, iv, fv) \
f2w1(l, t, r2, iv, fv)
#if __ia64__
# define f2w(l, iv, fv) \
xf2w(l, _f, r0, f0, iv, fv) \
xf2w(l, _d, r0, f0, iv, fv)
#else
# define f2w(l, iv, fv) \
f2w0(l, _f, iv, fv) \
f2w0(l, _d, iv, fv)
#endif
.code
prolog
tcmp(__LINE__, lt, 0, 1)
tcmp(__LINE__, lt, $nInf, $pInf)
tcmp(__LINE__, lt, $nInf, 0)
tcmp(__LINE__, lt, 0, $pInf)
fcmp(__LINE__, lt, $NaN, 0)
fcmp(__LINE__, lt, $NaN, $NaN)
fcmp(__LINE__, lt, $nInf, $NaN)
fcmp(__LINE__, lt, 1, 0)
fcmp(__LINE__, lt, 0, 0)
fcmp(__LINE__, lt, $pInf, $nInf)
fcmp(__LINE__, lt, 0, $nInf)
fcmp(__LINE__, lt, 0, $NaN)
tcmp(__LINE__, le, 0, 1)
tcmp(__LINE__, le, 0, 0)
tcmp(__LINE__, le, 1, 1)
tcmp(__LINE__, le, $nInf, $pInf)
tcmp(__LINE__, le, $nInf, 0)
tcmp(__LINE__, le, 0, $pInf)
fcmp(__LINE__, le, $NaN, 0)
fcmp(__LINE__, le, $NaN, $NaN)
fcmp(__LINE__, le, $nInf, $NaN)
fcmp(__LINE__, le, 1, 0)
fcmp(__LINE__, le, $pInf, $nInf)
fcmp(__LINE__, le, 0, $nInf)
fcmp(__LINE__, le, 0, $NaN)
tcmp(__LINE__, eq, 0, 0)
tcmp(__LINE__, eq, 1, 1)
fcmp(__LINE__, eq, $NaN, 0)
fcmp(__LINE__, eq, $NaN, $NaN)
fcmp(__LINE__, eq, $nInf, $NaN)
fcmp(__LINE__, eq, 0, 1)
fcmp(__LINE__, eq, 1, 0)
fcmp(__LINE__, eq, $pInf, $nInf)
fcmp(__LINE__, eq, 0, $nInf)
fcmp(__LINE__, eq, 0, $NaN)
tcmp(__LINE__, ge, 1, 0)
tcmp(__LINE__, ge, 0, 0)
tcmp(__LINE__, ge, 1, 1)
tcmp(__LINE__, ge, $pInf, $nInf)
tcmp(__LINE__, ge, 0, $nInf)
tcmp(__LINE__, ge, $pInf, 0)
fcmp(__LINE__, ge, $NaN, 0)
fcmp(__LINE__, ge, $NaN, $NaN)
fcmp(__LINE__, ge, $nInf, $NaN)
fcmp(__LINE__, ge, 0, 1)
fcmp(__LINE__, ge, $nInf, $pInf)
fcmp(__LINE__, ge, $nInf, 0)
fcmp(__LINE__, ge, 0, $NaN)
tcmp(__LINE__, gt, 1, 0)
tcmp(__LINE__, gt, $pInf, $nInf)
tcmp(__LINE__, gt, 0, $nInf)
tcmp(__LINE__, gt, $pInf, 0)
fcmp(__LINE__, gt, $NaN, 0)
fcmp(__LINE__, gt, $NaN, $NaN)
fcmp(__LINE__, gt, $nInf, $NaN)
fcmp(__LINE__, gt, 0, 1)
fcmp(__LINE__, gt, 0, 0)
fcmp(__LINE__, gt, $nInf, $pInf)
fcmp(__LINE__, gt, $nInf, 0)
fcmp(__LINE__, gt, 0, $NaN)
tcmp(__LINE__, ne, 0, 1)
tcmp(__LINE__, ne, 1, 0)
tcmp(__LINE__, ne, $NaN, $NaN)
tcmp(__LINE__, ne, $nInf, $pInf)
tcmp(__LINE__, ne, $NaN, 0)
tcmp(__LINE__, ne, $nInf, $NaN)
tcmp(__LINE__, ne, $pInf, $nInf)
tcmp(__LINE__, ne, 0, $nInf)
tcmp(__LINE__, ne, 0, $NaN)
fcmp(__LINE__, ne, 0, 0)
fcmp(__LINE__, ne, 1, 1)
tcmp(__LINE__, unlt, 0, 1)
tcmp(__LINE__, unlt, $nInf, $pInf)
tcmp(__LINE__, unlt, $nInf, 0)
tcmp(__LINE__, unlt, 0, $pInf)
tcmp(__LINE__, unlt, $NaN, 0)
tcmp(__LINE__, unlt, $NaN, $NaN)
tcmp(__LINE__, unlt, $nInf, $NaN)
tcmp(__LINE__, unlt, 0, $NaN)
fcmp(__LINE__, unlt, 1, 0)
fcmp(__LINE__, unlt, 0, 0)
fcmp(__LINE__, unlt, $pInf, $nInf)
fcmp(__LINE__, unlt, 0, $nInf)
tcmp(__LINE__, unle, 0, 1)
tcmp(__LINE__, unle, 0, 0)
tcmp(__LINE__, unle, 1, 1)
tcmp(__LINE__, unle, $nInf, $pInf)
tcmp(__LINE__, unle, $nInf, 0)
tcmp(__LINE__, unle, 0, $pInf)
tcmp(__LINE__, unle, $NaN, 0)
tcmp(__LINE__, unle, $NaN, $NaN)
tcmp(__LINE__, unle, $nInf, $NaN)
tcmp(__LINE__, unle, 0, $NaN)
fcmp(__LINE__, unle, 1, 0)
fcmp(__LINE__, unle, $pInf, $nInf)
fcmp(__LINE__, unle, 0, $nInf)
tcmp(__LINE__, uneq, 0, 0)
tcmp(__LINE__, uneq, 1, 1)
tcmp(__LINE__, uneq, $NaN, 0)
tcmp(__LINE__, uneq, $NaN, $NaN)
tcmp(__LINE__, uneq, $nInf, $NaN)
tcmp(__LINE__, uneq, 0, $NaN)
fcmp(__LINE__, uneq, 0, 1)
fcmp(__LINE__, uneq, 1, 0)
fcmp(__LINE__, uneq, $pInf, $nInf)
fcmp(__LINE__, uneq, 0, $nInf)
tcmp(__LINE__, unge, 1, 0)
tcmp(__LINE__, unge, 0, 0)
tcmp(__LINE__, unge, 1, 1)
tcmp(__LINE__, unge, $pInf, $nInf)
tcmp(__LINE__, unge, 0, $nInf)
tcmp(__LINE__, unge, $pInf, 0)
tcmp(__LINE__, unge, $NaN, 0)
tcmp(__LINE__, unge, $NaN, $NaN)
tcmp(__LINE__, unge, $nInf, $NaN)
tcmp(__LINE__, unge, 0, $NaN)
fcmp(__LINE__, unge, 0, 1)
fcmp(__LINE__, unge, $nInf, $pInf)
fcmp(__LINE__, unge, $nInf, 0)
tcmp(__LINE__, ungt, 1, 0)
tcmp(__LINE__, ungt, $pInf, $nInf)
tcmp(__LINE__, ungt, 0, $nInf)
tcmp(__LINE__, ungt, $pInf, 0)
tcmp(__LINE__, ungt, $NaN, 0)
tcmp(__LINE__, ungt, $NaN, $NaN)
tcmp(__LINE__, ungt, $nInf, $NaN)
tcmp(__LINE__, ungt, 0, $NaN)
fcmp(__LINE__, ungt, 0, 1)
fcmp(__LINE__, ungt, 0, 0)
fcmp(__LINE__, ungt, $nInf, $pInf)
fcmp(__LINE__, ungt, $nInf, 0)
tcmp(__LINE__, ltgt, 0, 1)
tcmp(__LINE__, ltgt, 1, 0)
tcmp(__LINE__, ltgt, $nInf, $pInf)
tcmp(__LINE__, ltgt, $pInf, $nInf)
tcmp(__LINE__, ltgt, 0, $nInf)
fcmp(__LINE__, ltgt, $NaN, $NaN)
fcmp(__LINE__, ltgt, $NaN, 0)
fcmp(__LINE__, ltgt, $nInf, $NaN)
fcmp(__LINE__, ltgt, 0, $NaN)
fcmp(__LINE__, ltgt, 0, 0)
fcmp(__LINE__, ltgt, 1, 1)
tcmp(__LINE__, ord, 0, 1)
tcmp(__LINE__, ord, 1, 0)
tcmp(__LINE__, ord, $nInf, $pInf)
tcmp(__LINE__, ord, $pInf, $nInf)
tcmp(__LINE__, ord, 0, $nInf)
tcmp(__LINE__, ord, 0, 0)
tcmp(__LINE__, ord, 1, 1)
fcmp(__LINE__, ord, $NaN, $NaN)
fcmp(__LINE__, ord, $NaN, 0)
fcmp(__LINE__, ord, $nInf, $NaN)
fcmp(__LINE__, ord, 0, $NaN)
tcmp(__LINE__, unord, $NaN, $NaN)
tcmp(__LINE__, unord, $NaN, 0)
tcmp(__LINE__, unord, $nInf, $NaN)
tcmp(__LINE__, unord, 0, $NaN)
fcmp(__LINE__, unord, 0, 1)
fcmp(__LINE__, unord, 1, 0)
fcmp(__LINE__, unord, $nInf, $pInf)
fcmp(__LINE__, unord, $pInf, $nInf)
fcmp(__LINE__, unord, 0, $nInf)
fcmp(__LINE__, unord, 0, 0)
fcmp(__LINE__, unord, 1, 1)
f2w(__LINE__, 0, 0)
f2w(__LINE__, 1, 1)
/* not all loongson agree on it */
#if !__mips__
f2w(__LINE__, wninf, $nInf)
#endif
f2w(__LINE__, wpinf, $pInf)
f2w(__LINE__, wnan, $NaN)
prepare
pushargi ok
ellipsis
finishi @puts
ret
epilog
parallel-rsp/lightning/check/fop_abs.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/fop_abs.tst
-31
View File
@@ -1,31 +0,0 @@
#include "alu.inc"
.code
prolog
#define ABS(N, T, I, V) FUN(N, T, abs, I, V)
#define UABS(N, T, I, V) UFUN(N, T, abs, I, V)
ABS(0, _f, -0.0, 0.0)
ABS(1, _f, 0.5, 0.5)
ABS(2, _f, -0.5, 0.5)
ABS(3, _f, $Inf, $Inf)
ABS(4, _f, $nInf, $Inf)
ABS(5, _f, 1.25, 1.25)
ABS(6, _f, -1.25, 1.25)
ABS(7, _f, $nInf, $Inf)
UABS(0, _f, $NaN, $NaN)
ABS(0, _d, -0.0, 0.0)
ABS(1, _d, 0.5, 0.5)
ABS(2, _d, -0.5, 0.5)
ABS(3, _d, $Inf, $Inf)
ABS(4, _d, $nInf, $Inf)
ABS(5, _d, 1.25, 1.25)
ABS(6, _d, -1.25, 1.25)
ABS(7, _d, $nInf, $Inf)
UABS(0, _d, $NaN, $NaN)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/fop_sqrt.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/fop_sqrt.tst
-23
View File
@@ -1,23 +0,0 @@
#include "alu.inc"
.code
prolog
#define SQRT(N, T, I, V) FUN(N, T, sqrt, I, V)
#define USQRT(N, T, I, V) UFUN(N, T, sqrt, I, V)
SQRT(0, _f, -0.0, 0.0)
SQRT(1, _f, 4.0, 2.0)
SQRT(2, _f, 2.25, 1.5)
SQRT(3, _f, $Inf, $Inf)
USQRT(0, _f, $NaN, $NaN)
SQRT(0, _d, -0.0, 0.0)
SQRT(1, _d, 4.0, 2.0)
SQRT(2, _d, 2.25, 1.5)
SQRT(3, _d, $Inf, $Inf)
USQRT(0, _d, $NaN, $NaN)
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/hton.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/hton.tst
-169
View File
@@ -1,169 +0,0 @@
.data 16
ok:
.c "ok\n"
#define us12_i 0x1234
#define us7f_i 0x7ff7
#define us80_i 0x8008
#define usff_i 0xffff
#define ui12_i 0x01234567
#define ui7f_i 0x7f7ff7f7
#define ui80_i 0x80800808
#define uiff_i 0xffffffff
#define ul12_i 0x0123456789abcdef
#define ul7f_i 0x7f7f7f7ff7f7f7f7
#define ul80_i 0x8080808008080808
#define ulff_i 0xffffffffffffffff
#if __WORDSIZE == 32
# define xus12_i 0xffff1234
# define xus7f_i 0x10107ff7
# define xus80_i 0x81188008
# define xusff_i 0xeaaeffff
#else
# define xus12_i 0xffffffffffff1234
# define xus7f_i 0x1010100101017ff7
# define xus80_i 0x8181811818818008
# define xusff_i 0xeaeaeaaeaeaeffff
# define xui12_i 0xffffffff01234567
# define xui7f_i 0x101001017f7ff7f7
# define xui80_i 0x8181181880800808
# define xuiff_i 0xeaeaaeaeffffffff
#endif
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define us12_o 0x3412
# define us7f_o 0xf77f
# define us80_o 0x0880
# define usff_o 0xffff
# define ui12_o 0x67452301
# define ui7f_o 0xf7f77f7f
# define ui80_o 0x08088080
# define uiff_o 0xffffffff
# define ul12_o 0xefcdab8967452301
# define ul7f_o 0xf7f7f7f77f7f7f7f
# define ul80_o 0x0808080880808080
# define ulff_o 0xffffffffffffffff
#else
# define us12_o us12_i
# define us7f_o us7f_i
# define us80_o us80_i
# define usff_o usff_i
# define ui12_o ui12_i
# define ui7f_o ui7f_i
# define ui80_o ui80_i
# define uiff_o uiff_i
# define ul12_o ul12_i
# define ul7f_o ul7f_i
# define ul80_o ul80_i
# define ulff_o ulff_i
#endif
#define HTON4(I, O, T, R0, R1) \
movi %R0 I \
htonr_##T %R1 %R0 \
beqi T##R0##R1##I %R1 O \
calli @abort \
T##R0##R1##I:
#define HTON3(T, R0, R1) \
HTON4(T##12_i, T##12_o, T, R0, R1) \
HTON4(x##T##12_i, T##12_o, T, R0, R1) \
HTON4(T##7f_i, T##7f_o, T, R0, R1) \
HTON4(x##T##7f_i, T##7f_o, T, R0, R1) \
HTON4(T##80_i, T##80_o, T, R0, R1) \
HTON4(x##T##80_i, T##80_o, T, R0, R1) \
HTON4(T##ff_i, T##ff_o, T, R0, R1) \
HTON4(x##T##ff_i, T##ff_o, T, R0, R1)
#define HTON3x(T, R0, R1) \
HTON4(T##12_i, T##12_o, T, R0, R1) \
HTON4(T##7f_i, T##7f_o, T, R0, R1) \
HTON4(T##80_i, T##80_o, T, R0, R1) \
HTON4(T##ff_i, T##ff_o, T, R0, R1)
#define HTON2(T, V0, V1, V2, R0, R1, R2) \
HTON3(T, V0, V0) \
HTON3(T, V0, V1) \
HTON3(T, V0, V2) \
HTON3(T, V0, R0) \
HTON3(T, V0, R1) \
HTON3(T, V0, R2) \
#define HTON2x(T, V0, V1, V2, R0, R1, R2) \
HTON3x(T, V0, V0) \
HTON3x(T, V0, V1) \
HTON3x(T, V0, V2) \
HTON3x(T, V0, R0) \
HTON3x(T, V0, R1) \
HTON3x(T, V0, R2) \
#define HTON1(T, V0, V1, V2, R0, R1, R2) \
HTON2(T, V0, V1, V2, R0, R1, R2) \
HTON2(T, V1, V2, R0, R1, R2, V0) \
HTON2(T, V2, R0, R1, R2, V0, V1) \
HTON2(T, R0, R1, R2, V0, V1, V2) \
HTON2(T, R1, R2, V0, V1, V2, R0) \
HTON2(T, R2, V0, V1, V2, R0, R1)
#define HTON1x(T, V0, V1, V2, R0, R1, R2) \
HTON2x(T, V0, V1, V2, R0, R1, R2) \
HTON2x(T, V1, V2, R0, R1, R2, V0) \
HTON2x(T, V2, R0, R1, R2, V0, V1) \
HTON2x(T, R0, R1, R2, V0, V1, V2) \
HTON2x(T, R1, R2, V0, V1, V2, R0) \
HTON2x(T, R2, V0, V1, V2, R0, R1)
#if __WORDSIZE == 32
# define HTON(V0, V1, V2, R0, R1, R2) \
HTON1(us, V0, V1, V2, R0, R1, R2) \
HTON1x(ui, V0, V1, V2, R0, R1, R2)
#else
# define HTON(V0, V1, V2, R0, R1, R2) \
HTON1(us, V0, V1, V2, R0, R1, R2) \
HTON1(ui, V0, V1, V2, R0, R1, R2) \
HTON1x(ul, V0, V1, V2, R0, R1, R2)
#endif
.code
prolog
/* simple sequence for easier disassembly reading and encoding check */
movi %r0 us12_i
htonr_us %r1 %r0
beqi us %r1 us12_o
calli @abort
us:
movi %r0 xus12_i
htonr_us %r1 %r0
beqi xus %r1 us12_o
calli @abort
xus:
movi %r0 ui12_i
htonr_ui %r1 %r0
beqi ui %r1 ui12_o
calli @abort
ui:
#if __WORDSIZE == 64
movi %r0 xui12_i
htonr_ui %r1 %r0
beqi xui %r1 ui12_o
calli @abort
xui:
movi %r0 ul12_i
htonr_ul %r1 %r0
beqi ul %r1 ul12_o
calli @abort
ul:
#endif
HTON(v0, v1, v2, r0, r1, r2)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/jmpr.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/jmpr.tst
-66
View File
@@ -1,66 +0,0 @@
/*
This is a very simple check to a condition that on lightning 2.0.5
could cause an assertion on some backends, due to correcting a problem
with temporaries that could not be saved/reloaded due to being used only
in the hardware instruction, or being considered live for too long on the
lightning instruction, and that could not be reloaded after the jump target
(or after false/true target on conditional branches).
If this code in lib/lightning.c:_jit_update():
for (regno = 0; regno < _jitc->reglen; regno++) {
spec = jit_class(_rvs[regno].spec);
if (jit_regset_tstbit(mask, regno) &&
(spec & (jit_class_gpr|jit_class_fpr)) &&
!(spec & jit_class_sav))
jit_regset_clrbit(mask, regno);
}
were removed, this test case, on x86_64 would fail like this:
lt-lightning: lightning.c:305: _jit_get_reg: Assertion `regspec & 0x02000000' failed.
Aborted (core dumped)
*/
.data 32
ret:
#if __WORDSIZE == 32
.i 0
#else
.l 0
#endif
ok:
.c "ok"
.code
prolog
jmpi start
add_v1_v2:
addr %v1 %v1 %v2
ldi %r0 ret
jmpr %r0
start:
movi %v1 1
movi %v2 2
movi %r0 ret_add_v1_v2
sti ret %r0
movi %v0 add_v1_v2
jmpr %v0
movi_d %f0 3
beqi_d pass_movi_f0 %f0 3
calli @abort
pass_movi_f0:
beqi pass_check_v2 %v2 2
calli @abort
pass_check_v2:
ret_add_v1_v2:
beqi pass_add_v1_v2 %v1 3
calli @abort
pass_add_v1_v2:
prepare
pushargi ok
finishi @puts
ret
epilog
parallel-rsp/lightning/check/ldst.inc
-102
View File
@@ -1,102 +0,0 @@
#if __WORDSIZE == 64
# define L0 0x8000000000000001
# define LL0 L0
# define LC0 0xffffffffffffff81
# define LS0 0xffffffffffff8001
# define LI0 0xffffffff80000001
# define L1 0x8000000000000000
# define LL1 L1
# define LC1 0xffffffffffffff80
# define LS1 0xffffffffffff8000
# define LI1 0xffffffff80000000
# define L2 0x7fffffffffffffff
# define LL2 L2
# define LC2 0x000000000000007f
# define LS2 0x0000000000007fff
# define LI2 0x000000007fffffff
# define L3 0xffffffffffffffff
# define LL3 L3
# define LC3 0xffffffffffffffff
# define LS3 0xffffffffffffffff
# define LI3 0xffffffffffffffff
# define XC LC0
# define XS LS0
# define XI LI0
#else
# define XC IC0
# define XS IS0
# define XI II0
#endif
#define I0 0x80000001
#define II0 I0
#define IC0 0xffffff81
#define IS0 0xffff8001
#define I1 0x80000000
#define II1 I1
#define IC1 0xffffff80
#define IS1 0xffff8000
#define I2 0x7fffffff
#define II2 I2
#define IC2 0x0000007f
#define IS2 0x00007fff
#define I3 0xffffffff
#define II3 I3
#define IC3 0xffffffff
#define IS3 0xffffffff
#define S0 0x8001
#define S1 0x8000
#define S2 0x7fff
#define S3 0xffff
#define C0 0x81
#define C1 0x80
#define C2 0x7f
#define C3 0xff
#define F0 0.25
#define F1 0.75
#define F2 -0.25
#define F3 -0.75
#define D0 0.25
#define D1 0.75
#define D2 -0.25
#define D3 -0.75
.data 512
ok:
.c "ok\n"
.align 8
t0:
c0:
.c 0
uc0:
.c 0
s0:
.s 0
us0:
.s 0
.align 4
i0:
.i 0
#if __WORDSIZE == 64
ui0:
.i 0
.align 8
l0:
.l 0
#endif
f0:
.f 0
.align 8
d0:
.d 0
. $($offc = c0 - t0)
. $($offuc = uc0 - t0)
. $($offs = s0 - t0)
. $($offus = us0 - t0)
. $($offi = i0 - t0)
#if __WORDSIZE == 64
. $($offui = ui0 - t0)
. $($offl = l0 - t0)
#endif
. $($offf = f0 - t0)
. $($offd = d0 - t0)
parallel-rsp/lightning/check/ldsti.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/ldsti.tst
-146
View File
@@ -1,146 +0,0 @@
#include "ldst.inc"
#if __WORDSIZE == 64
# define LDSTL(N, R0) \
sti_i ui0 %R0 \
movi %R0 L##N \
sti_l l0 %R0
# define SI(C, N, x, X, R0) \
ldi_##x %R0 x##0 \
beqi L##x##C %R0 L##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0) \
UI(C, N, i, I, R0) \
SI(C, N, l, L, R0)
#else
# define LDSTL(C, R0)
# define SI(C, N, x, X, R0) \
ldi_##x %R0 x##0 \
beqi L##x##C %R0 I##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0)
#endif
#define UI(C, N, x, X, R0) \
ldi_u##x %R0 u##x##0 \
beqi Lu##x##C %R0 X##N \
calli @abort \
Lu##x##C:
#define FF(C, N, x, X, F0) \
ldi_##x %F0 x##0 \
beqi_##x L##x##C %F0 X##N \
L##x##C:
#define LDST1(X, N, R0, F0) \
movi %R0 C##N \
sti_c c0 %R0 \
sti_c uc0 %R0 \
movi %R0 S##N \
sti_s s0 %R0 \
sti_s us0 %R0 \
movi %R0 I##N \
sti_i i0 %R0 \
LDSTL(N, R0) \
movi_f %F0 F##N \
sti_f f0 %F0 \
movi_d %F0 D##N \
sti_d d0 %F0 \
SI(X, N, c, C, R0) \
UI(X, N, c, C, R0) \
SI(X, N, s, S, R0) \
UI(X, N, s, S, R0) \
SI(X, N, i, I, R0) \
LDRL(X, N, R0) \
FF(X, N, f, F, F0) \
FF(X, N, d, D, F0)
#define LDST0(R0, F0) \
LDST1(0_##R0##_##F0, 0, R0, F0) \
LDST1(1_##R0##_##F0, 1, R0, F0) \
LDST1(2_##R0##_##F0, 2, R0, F0) \
LDST1(3_##R0##_##F0, 3, R0, F0)
#define LDST(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
LDST0(V0, F0) \
LDST0(V1, F1) \
LDST0(V2, F3) \
LDST0(R0, F4) \
LDST0(R1, F5) \
LDST0(R2, F0)
.code
prolog
/* Simple test to simplify validating encodings before
* brute force tests */
movi %r1 0x81
sti_c c0 %r1
sti_c uc0 %r1
movi %r1 0x8001
sti_s s0 %r1
sti_s us0 %r1
movi %r1 0x80000001
sti_i i0 %r1
#if __WORDSIZE == 64
sti_i ui0 %r1
movi %r1 0x8000000000000001
sti_l l0 %r1
#endif
movi_f %f0 0.5
sti_f f0 %f0
movi_d %f0 0.25
sti_d d0 %f0
ldi_c %r1 c0
beqi Lc %r1 XC
calli @abort
Lc:
ldi_uc %r1 uc0
beqi Luc %r1 0x81
calli @abort
Luc:
ldi_s %r1 s0
beqi Ls %r1 XS
calli @abort
Ls:
ldi_us %r1 us0
beqi Lus %r1 0x8001
calli @abort
Lus:
ldi_i %r1 i0
beqi Li %r1 XI
calli @abort
Li:
#if __WORDSIZE == 64
ldi_ui %r1 ui0
beqi Lui %r1 0x80000001
calli @abort
Lui:
ldi_l %r1 l0
beqi Ll %r1 0x8000000000000001
calli @abort
Ll:
#endif
ldi_f %f0 f0
beqi_f Lf %f0 0.5
calli @abort
Lf:
ldi_d %f0 d0
beqi_d Ld %f0 0.25
calli @abort
Ld:
LDST(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/ldstr-c.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/ldstr-c.tst
-155
View File
@@ -1,155 +0,0 @@
#include "ldst.inc"
#if __WORDSIZE == 64
# define LDSTL(N, R0, R1) \
movi %R0 $(t0 + $offui) \
str_i %R0 %R1 \
movi %R0 $(t0 + $offl) \
movi %R1 L##N \
str_l %R0 %R1
# define SI(C, N, x, X, R0) \
movi %R0 $(t0 + $off##x) \
ldr_##x %R0 %R0 \
beqi L##x##C %R0 L##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1) \
UI(C, N, i, I, R0) \
SI(C, N, l, L, R0)
#else
# define LDSTL(C, R0, R1)
# define SI(C, N, x, X, R0) \
movi %R0 $(t0 + $off##x) \
ldr_##x %R0 %R0 \
beqi L##x##C %R0 I##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1)
#endif
#define UI(C, N, x, X, R0) \
movi %R0 $(t0 + $offu##x) \
ldr_u##x %R0 %R0 \
beqi Lu##x##C %R0 X##N \
calli @abort \
Lu##x##C:
#define LDST1(X, N, R0, R1) \
movi %R0 $(t0 + $offc) \
movi %R1 C##N \
str_c %R0 %R1 \
movi %R0 $(t0 + $offuc) \
str_c %R0 %R1 \
movi %R0 $(t0 + $offs) \
movi %R1 S##N \
str_s %R0 %R1 \
movi %R0 $(t0 + $offus) \
str_s %R0 %R1 \
movi %R0 $(t0 + $offi) \
movi %R1 I##N \
str_i %R0 %R1 \
LDSTL(N, R0, R1) \
movi %R0 $(t0 + $offf) \
SI(X, N, c, C, R0) \
UI(X, N, c, C, R0) \
SI(X, N, s, S, R0) \
UI(X, N, s, S, R0) \
SI(X, N, i, I, R0) \
LDRL(X, N, R0, R1) \
#define LDST0(R0, R1) \
LDST1(0_##R0##_##R1, 0, R0, R1) \
LDST1(1_##R0##_##R1, 1, R0, R1) \
LDST1(2_##R0##_##R1, 2, R0, R1) \
LDST1(3_##R0##_##R1, 3, R0, R1)
#define LDST(V0, V1, V2, R0, R1, R2) \
LDST0(V0, V1) \
LDST0(V0, V2) \
LDST0(V0, R0) \
LDST0(V0, R1) \
LDST0(V0, R2) \
LDST0(V1, V0) \
LDST0(V1, V2) \
LDST0(V1, R0) \
LDST0(V1, R1) \
LDST0(V1, R2) \
LDST0(V2, R0) \
LDST0(V2, R1) \
LDST0(V2, R2)
.code
prolog
/* Simple test to simplify validating encodings before
* brute force tests */
movi %r0 $(t0 + $offc)
movi %r1 0x81
str_c %r0 %r1
movi %r0 $(t0 + $offuc)
str_c %r0 %r1
movi %r0 $(t0 + $offs)
movi %r1 0x8001
str_s %r0 %r1
movi %r0 $(t0 + $offus)
str_s %r0 %r1
movi %r0 $(t0 + $offi)
movi %r1 0x80000001
str_i %r0 %r1
#if __WORDSIZE == 64
movi %r0 $(t0 + $offui)
str_i %r0 %r1
movi %r0 $(t0 + $offl)
movi %r1 0x8000000000000001
str_l %r0 %r1
#endif
movi %r0 $(t0 + $offc)
ldr_c %r0 %r0
beqi Lc %r0 XC
calli @abort
Lc:
movi %r0 $(t0 + $offuc)
ldr_uc %r0 %r0
beqi Luc %r0 0x81
calli @abort
Luc:
movi %r0 $(t0 + $offs)
ldr_s %r0 %r0
beqi Ls %r0 XS
calli @abort
Ls:
movi %r0 $(t0 + $offus)
ldr_us %r0 %r0
beqi Lus %r0 0x8001
calli @abort
Lus:
movi %r0 $(t0 + $offi)
ldr_i %r0 %r0
beqi Li %r0 XI
calli @abort
Li:
#if __WORDSIZE == 64
movi %r0 $(t0 + $offui)
ldr_ui %r0 %r0
beqi Lui %r0 0x80000001
calli @abort
Lui:
movi %r0 $(t0 + $offl)
ldr_l %r0 %r0
beqi Ll %r0 0x8000000000000001
calli @abort
Ll:
#endif
LDST(v0, v1, v2, r0, r1, r2)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/ldstr.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/ldstr.tst
-183
View File
@@ -1,183 +0,0 @@
#include "ldst.inc"
#if __WORDSIZE == 64
# define LDSTL(N, R0, R1) \
movi %R0 $(t0 + $offui) \
str_i %R0 %R1 \
movi %R0 $(t0 + $offl) \
movi %R1 L##N \
str_l %R0 %R1
# define SI(C, N, x, X, R0, R1) \
movi %R0 $(t0 + $off##x) \
ldr_##x %R1 %R0 \
beqi L##x##C %R1 L##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1) \
UI(C, N, i, I, R0, R1) \
SI(C, N, l, L, R0, R1)
#else
# define LDSTL(C, R0, R1)
# define SI(C, N, x, X, R0, R1) \
movi %R0 $(t0 + $off##x) \
ldr_##x %R1 %R0 \
beqi L##x##C %R1 I##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1)
#endif
#define UI(C, N, x, X, R0, R1) \
movi %R0 $(t0 + $offu##x) \
ldr_u##x %R1 %R0 \
beqi Lu##x##C %R1 X##N \
calli @abort \
Lu##x##C:
#define FF(C, N, x, X, R0, F0) \
movi %R0 $(t0 + $off##x) \
ldr_##x %F0 %R0 \
beqi_##x L##x##C %F0 X##N \
L##x##C:
#define LDST1(X, N, R0, R1, F0) \
movi %R0 $(t0 + $offc) \
movi %R1 C##N \
str_c %R0 %R1 \
movi %R0 $(t0 + $offuc) \
str_c %R0 %R1 \
movi %R0 $(t0 + $offs) \
movi %R1 S##N \
str_s %R0 %R1 \
movi %R0 $(t0 + $offus) \
str_s %R0 %R1 \
movi %R0 $(t0 + $offi) \
movi %R1 I##N \
str_i %R0 %R1 \
LDSTL(N, R0, R1) \
movi %R0 $(t0 + $offf) \
movi_f %F0 F##N \
str_f %R0 %F0 \
movi %R0 $(t0 + $offd) \
movi_d %F0 D##N \
str_d %R0 %F0 \
SI(X, N, c, C, R0, R1) \
UI(X, N, c, C, R0, R1) \
SI(X, N, s, S, R0, R1) \
UI(X, N, s, S, R0, R1) \
SI(X, N, i, I, R0, R1) \
LDRL(X, N, R0, R1) \
FF(X, N, f, F, R0, F0) \
FF(X, N, d, D, R0, F0)
#define LDST0(R0, R1, F0) \
LDST1(0_##R0##_##R1##_##F0, 0, R0, R1, F0) \
LDST1(1_##R0##_##R1##_##F0, 1, R0, R1, F0) \
LDST1(2_##R0##_##R1##_##F0, 2, R0, R1, F0) \
LDST1(3_##R0##_##R1##_##F0, 3, R0, R1, F0)
#define LDST(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
LDST0(V0, V1, F0) \
LDST0(V0, V2, F1) \
LDST0(V0, R0, F3) \
LDST0(V0, R1, F4) \
LDST0(V0, R2, F5) \
LDST0(V1, V2, F0) \
LDST0(V1, R0, F1) \
LDST0(V1, R1, F2) \
LDST0(V1, R2, F3) \
LDST0(V2, R0, F4) \
LDST0(V2, R1, F5) \
LDST0(V2, R2, F0)
.code
prolog
/* Simple test to simplify validating encodings before
* brute force tests */
movi %r0 $(t0 + $offc)
movi %r1 0x81
str_c %r0 %r1
movi %r0 $(t0 + $offuc)
str_c %r0 %r1
movi %r0 $(t0 + $offs)
movi %r1 0x8001
str_s %r0 %r1
movi %r0 $(t0 + $offus)
str_s %r0 %r1
movi %r0 $(t0 + $offi)
movi %r1 0x80000001
str_i %r0 %r1
#if __WORDSIZE == 64
movi %r0 $(t0 + $offui)
str_i %r0 %r1
movi %r0 $(t0 + $offl)
movi %r1 0x8000000000000001
str_l %r0 %r1
#endif
movi %r0 $(t0 + $offf)
movi_f %f0 0.5
str_f %r0 %f0
movi %r0 $(t0 + $offd)
movi_d %f0 0.25
str_d %r0 %f0
movi %r0 $(t0 + $offc)
ldr_c %r1 %r0
beqi Lc %r1 XC
calli @abort
Lc:
movi %r0 $(t0 + $offuc)
ldr_uc %r1 %r0
beqi Luc %r1 0x81
calli @abort
Luc:
movi %r0 $(t0 + $offs)
ldr_s %r1 %r0
beqi Ls %r1 XS
calli @abort
Ls:
movi %r0 $(t0 + $offus)
ldr_us %r1 %r0
beqi Lus %r1 0x8001
calli @abort
Lus:
movi %r0 $(t0 + $offi)
ldr_i %r1 %r0
beqi Li %r1 XI
calli @abort
Li:
#if __WORDSIZE == 64
movi %r0 $(t0 + $offui)
ldr_ui %r1 %r0
beqi Lui %r1 0x80000001
calli @abort
Lui:
movi %r0 $(t0 + $offl)
ldr_l %r1 %r0
beqi Ll %r1 0x8000000000000001
calli @abort
Ll:
#endif
movi %r0 $(t0 + $offf)
ldr_f %f0 %r0
beqi_f Lf %f0 0.5
calli @abort
Lf:
movi %r0 $(t0 + $offd)
ldr_d %f0 %r0
beqi_d Ld %f0 0.25
calli @abort
Ld:
LDST(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/ldstxi-c.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/ldstxi-c.tst
-158
View File
@@ -1,158 +0,0 @@
#include "ldst.inc"
#if __WORDSIZE == 64
# define LDSTL(N, R0, R1) \
stxi_i $offui %R0 %R1 \
movi %R1 L##N \
stxi_l $offl %R0 %R1
# define SI(C, N, x, X, R0) \
ldxi_##x %R0 %R0 $off##x \
beqi L##x##C %R0 L##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1) \
UI(C, N, i, I, R0) \
movi %R0 t0 \
SI(C, N, l, L, R0)
#else
# define LDSTL(C, R0, R1)
# define SI(C, N, x, X, R0) \
ldxi_##x %R0 %R0 $off##x \
beqi L##x##C %R0 I##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1)
#endif
#define UI(C, N, x, X, R0) \
ldxi_u##x %R0 %R0 $offu##x \
beqi Lu##x##C %R0 X##N \
calli @abort \
Lu##x##C:
#define LDST1(X, N, R0, R1) \
movi %R0 t0 \
movi %R1 C##N \
stxi_c $offc %R0 %R1 \
stxi_c $offuc %R0 %R1 \
movi %R1 S##N \
stxi_s $offs %R0 %R1 \
stxi_s $offus %R0 %R1 \
movi %R1 I##N \
stxi_i $offi %R0 %R1 \
LDSTL(N, R0, R1) \
SI(X, N, c, C, R0) \
movi %R0 t0 \
UI(X, N, c, C, R0) \
movi %R0 t0 \
SI(X, N, s, S, R0) \
movi %R0 t0 \
UI(X, N, s, S, R0) \
movi %R0 t0 \
SI(X, N, i, I, R0) \
movi %R0 t0 \
LDRL(X, N, R0, R1) \
#define LDST0(R0, R1) \
LDST1(0_##R0##_##R1, 0, R0, R1) \
LDST1(1_##R0##_##R1, 1, R0, R1) \
LDST1(2_##R0##_##R1, 2, R0, R1) \
LDST1(3_##R0##_##R1, 3, R0, R1)
#define LDST(V0, V1, V2, R0, R1, R2) \
LDST0(V0, V1) \
LDST0(V0, V2) \
LDST0(V0, R0) \
LDST0(V0, R1) \
LDST0(V0, R2) \
LDST0(V1, V2) \
LDST0(V1, R0) \
LDST0(V1, R1) \
LDST0(V1, R2) \
LDST0(V2, R0) \
LDST0(V2, R1) \
LDST0(V2, R2) \
LDST0(R0, V0) \
LDST0(R0, V1) \
LDST0(R0, V2) \
LDST0(R0, R1) \
LDST0(R0, R2) \
LDST0(R1, V0) \
LDST0(R1, V1) \
LDST0(R1, V2) \
LDST0(R1, R0) \
LDST0(R1, R2) \
LDST0(R2, V0) \
LDST0(R2, V1) \
LDST0(R2, V2) \
LDST0(R2, R0) \
LDST0(R2, R1)
.code
prolog
/* Simple test to simplify validating encodings before
* brute force tests */
movi %r0 t0
movi %r1 0x81
stxi_c $offc %r0 %r1
stxi_c $offuc %r0 %r1
movi %r1 0x8001
stxi_s $offs %r0 %r1
stxi_s $offus %r0 %r1
movi %r1 0x80000001
stxi_i $offi %r0 %r1
#if __WORDSIZE == 64
stxi_i $offui %r0 %r1
movi %r1 0x8000000000000001
stxi_l $offl %r0 %r1
#endif
ldxi_c %r0 %r0 $offc
beqi Lc %r0 XC
calli @abort
Lc:
movi %r0 t0
ldxi_uc %r0 %r0 $offuc
beqi Luc %r0 0x81
calli @abort
Luc:
movi %r0 t0
ldxi_s %r0 %r0 $offs
beqi Ls %r0 XS
calli @abort
Ls:
movi %r0 t0
ldxi_us %r0 %r0 $offus
beqi Lus %r0 0x8001
calli @abort
Lus:
movi %r0 t0
ldxi_i %r0 %r0 $offi
beqi Li %r0 XI
calli @abort
Li:
#if __WORDSIZE == 64
movi %r0 t0
ldxi_ui %r0 %r0 $offui
beqi Lui %r0 0x80000001
calli @abort
Lui:
movi %r0 t0
ldxi_l %r0 %r0 $offl
beqi Ll %r0 0x8000000000000001
calli @abort
Ll:
#endif
LDST(v0, v1, v2, r0, r1, r2)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/ldstxi.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/ldstxi.tst
-154
View File
@@ -1,154 +0,0 @@
#include "ldst.inc"
#if __WORDSIZE == 64
# define LDSTL(N, R0, R1) \
stxi_i $offui %R0 %R1 \
movi %R1 L##N \
stxi_l $offl %R0 %R1
# define SI(C, N, x, X, R0, R1) \
ldxi_##x %R1 %R0 $off##x \
beqi L##x##C %R1 L##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1) \
UI(C, N, i, I, R0, R1) \
SI(C, N, l, L, R0, R1)
#else
# define LDSTL(C, R0, R1)
# define SI(C, N, x, X, R0, R1) \
ldxi_##x %R1 %R0 $off##x \
beqi L##x##C %R1 I##X##N \
calli @abort \
L##x##C:
# define LDRL(C, N, R0, R1)
#endif
#define UI(C, N, x, X, R0, R1) \
ldxi_u##x %R1 %R0 $offu##x \
beqi Lu##x##C %R1 X##N \
calli @abort \
Lu##x##C:
#define FF(C, N, x, X, R0, F0) \
ldxi_##x %F0 %R0 $off##x \
beqi_##x L##x##C %F0 X##N \
L##x##C:
#define LDST1(X, N, R0, R1, F0) \
movi %R0 t0 \
movi %R1 C##N \
stxi_c $offc %R0 %R1 \
stxi_c $offuc %R0 %R1 \
movi %R1 S##N \
stxi_s $offs %R0 %R1 \
stxi_s $offus %R0 %R1 \
movi %R1 I##N \
stxi_i $offi %R0 %R1 \
LDSTL(N, R0, R1) \
movi_f %F0 F##N \
stxi_f $offf %R0 %F0 \
movi_d %F0 D##N \
stxi_d $offd %R0 %F0 \
SI(X, N, c, C, R0, R1) \
UI(X, N, c, C, R0, R1) \
SI(X, N, s, S, R0, R1) \
UI(X, N, s, S, R0, R1) \
SI(X, N, i, I, R0, R1) \
LDRL(X, N, R0, R1) \
FF(X, N, f, F, R0, F0) \
FF(X, N, d, D, R0, F0)
#define LDST0(R0, R1, F0) \
LDST1(0_##R0##_##R1##_##F0, 0, R0, R1, F0) \
LDST1(1_##R0##_##R1##_##F0, 1, R0, R1, F0) \
LDST1(2_##R0##_##R1##_##F0, 2, R0, R1, F0) \
LDST1(3_##R0##_##R1##_##F0, 3, R0, R1, F0)
#define LDST(V0, V1, V2, R0, R1, R2, F0, F1, F2, F3, F4, F5) \
LDST0(V0, V1, F0) \
LDST0(V0, V2, F1) \
LDST0(V0, R0, F3) \
LDST0(V0, R1, F4) \
LDST0(V0, R2, F5) \
LDST0(V1, V2, F0) \
LDST0(V1, R0, F1) \
LDST0(V1, R1, F2) \
LDST0(V1, R2, F3) \
LDST0(V2, R0, F4) \
LDST0(V2, R1, F5) \
LDST0(V2, R2, F0)
.code
prolog
/* Simple test to simplify validating encodings before
* brute force tests */
movi %r0 t0
movi %r1 0x81
stxi_c $offc %r0 %r1
stxi_c $offuc %r0 %r1
movi %r1 0x8001
stxi_s $offs %r0 %r1
stxi_s $offus %r0 %r1
movi %r1 0x80000001
stxi_i $offi %r0 %r1
#if __WORDSIZE == 64
stxi_i $offui %r0 %r1
movi %r1 0x8000000000000001
stxi_l $offl %r0 %r1
#endif
movi_f %f0 0.5
stxi_f $offf %r0 %f0
movi_d %f0 0.25
stxi_d $offd %r0 %f0
ldxi_c %r1 %r0 $offc
beqi Lc %r1 XC
calli @abort
Lc:
ldxi_uc %r1 %r0 $offuc
beqi Luc %r1 0x81
calli @abort
Luc:
ldxi_s %r1 %r0 $offs
beqi Ls %r1 XS
calli @abort
Ls:
ldxi_us %r1 %r0 $offus
beqi Lus %r1 0x8001
calli @abort
Lus:
ldxi_i %r1 %r0 $offi
beqi Li %r1 XI
calli @abort
Li:
#if __WORDSIZE == 64
ldxi_ui %r1 %r0 $offui
beqi Lui %r1 0x80000001
calli @abort
Lui:
ldxi_l %r1 %r0 $offl
beqi Ll %r1 0x8000000000000001
calli @abort
Ll:
#endif
ldxi_f %f0 %r0 $offf
beqi_f Lf %f0 0.5
calli @abort
Lf:
ldxi_d %f0 %r0 $offd
beqi_d Ld %f0 0.25
calli @abort
Ld:
LDST(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
parallel-rsp/lightning/check/ldstxr-c.ok
-1
View File
@@ -1 +0,0 @@
ok
parallel-rsp/lightning/check/ldstxr-c.tst
-219
View File
@@ -1,219 +0,0 @@
#include "ldst.inc"
#if __WORDSIZE == 64
# define LDSTL(N, R0, R1, R2) \
movi %R2 $offui \
stxr_i %R2 %R0 %R1 \
movi %R1 L##N \
movi %R2 $offl \
stxr_l %R2 %R0 %R1
# define SI(C, N, x, X, R0, R1) \
movi %R1 $off##x \
ldxr_##x %R1 %R0 %R1 \
beqi L##x##C##0 %R1 L##X##N \
calli @abort \
L##x##C##0: \
movi %R1 $off##x \
ldxr_##x %R0 %R0 %R1 \
beqi L##x##C##1 %R0 L##X##N \
calli @abort \
L##x##C##1:
# define LDRL(C, N, R0, R1, R2) \
UI(C, N, i, I, R0, R1) \
movi %R0 t0 \
SI(C, N, l, L, R0, R1)
#else
# define LDSTL(C, R0, R1, R2)
# define SI(C, N, x, X, R0, R1) \
movi %R1 $off##x \
ldxr_##x %R1 %R0 %R1 \
beqi L##x##C##0 %R1 I##X##N \
calli @abort \
L##x##C##0: \
movi %R1 $off##x \
ldxr_##x %R0 %R0 %R1 \
beqi L##x##C##1 %R0 I##X##N \
calli @abort \
L##x##C##1:
# define LDRL(C, N, R0, R1, R2)
#endif
#define UI(C, N, x, X, R0, R1) \
movi %R1 $offu##x \
ldxr_u##x %R1 %R0 %R1 \
beqi Lu##x##C##0 %R1 X##N \
calli @abort \
Lu##x##C##0: \
movi %R1 $offu##x \
ldxr_u##x %R0 %R0 %R1 \
beqi Lu##x##C##1 %R0 X##N \
calli @abort \
Lu##x##C##1:
#define LDST1(X, N, R0, R1, R2) \
movi %R0 t0 \
movi %R1 C##N \
movi %R2 $offc \
stxr_c %R2 %R0 %R1 \
movi %R2 $offuc \
stxr_c %R2 %R0 %R1 \
movi %R1 S##N \
movi %R2 $offs \
stxr_s %R2 %R0 %R1 \
movi %R2 $offus \
stxr_s %R2 %R0 %R1 \
movi %R1 I##N \
movi %R2 $offi \
stxr_i %R2 %R0 %R1 \
LDSTL(N, R0, R1, R2) \
SI(X, N, c, C, R0, R1) \
movi %R0 t0 \
UI(X, N, c, C, R0, R1) \
movi %R0 t0 \
SI(X, N, s, S, R0, R1) \
movi %R0 t0 \
UI(X, N, s, S, R0, R1) \
movi %R0 t0 \
SI(X, N, i, I, R0, R1) \
movi %R0 t0 \
LDRL(X, N, R0, R1, R2) \
#define LDST0(R0, R1, R2) \
LDST1(0_##R0##_##R1##_##R2, 0, R0, R1, R2) \
LDST1(1_##R0##_##R1##_##R2, 1, R0, R1, R2) \
LDST1(2_##R0##_##R1##_##R2, 2, R0, R1, R2) \
LDST1(3_##R0##_##R1##_##R2, 3, R0, R1, R2)
#define LDST(V0, V1, V2, R0, R1, R2) \
LDST0(V1, V2, V0) \
LDST0(V1, R0, V0) \
LDST0(V1, R1, V0) \
LDST0(V1, R2, V0) \
LDST0(V0, R0, V1) \
LDST0(V0, R1, V1) \
LDST0(V0, R2, V1) \
LDST0(V0, V2, V1) \
LDST0(V2, V0, V1) \
LDST0(V2, R0, V1) \
LDST0(V2, R1, V1) \
LDST0(V2, R2, V1) \
LDST0(R0, R1, V2) \
LDST0(R0, R2, V2)
.code
prolog
/* Simple test to simplify validating encodings before
* brute force tests */
movi %r0 t0
movi %r1 0x81
movi %r2 $offc
stxr_c %r2 %r0 %r1
movi %r2 $offuc
stxr_c %r2 %r0 %r1
movi %r1 0x8001
movi %r2 $offs
stxr_s %r2 %r0 %r1
movi %r2 $offus
stxr_s %r2 %r0 %r1
movi %r1 0x80000001
movi %r2 $offi
stxr_i %r2 %r0 %r1
#if __WORDSIZE == 64
movi %r2 $offui
stxr_i %r2 %r0 %r1
movi %r1 0x8000000000000001
movi %r2 $offl
stxr_l %r2 %r0 %r1
#endif
movi %r1 $offc
ldxr_c %r1 %r0 %r1
beqi Lc0 %r1 XC
calli @abort
Lc0:
movi %r1 $offc
ldxr_c %r0 %r0 %r1
beqi Lc1 %r0 XC
calli @abort
Lc1:
movi %r0 t0
movi %r1 $offuc
ldxr_uc %r1 %r0 %r1
beqi Luc0 %r1 0x81
calli @abort
Luc0:
movi %r1 $offuc
ldxr_uc %r0 %r0 %r1
beqi Luc1 %r0 0x81
calli @abort
Luc1:
movi %r0 t0
movi %r1 $offs
ldxr_s %r1 %r0 %r1
beqi Ls0 %r1 XS
calli @abort
Ls0:
movi %r1 $offs
ldxr_s %r0 %r0 %r1
beqi Ls1 %r0 XS
calli @abort
Ls1:
movi %r0 t0
movi %r1 $offus
ldxr_us %r1 %r0 %r1
beqi Lus0 %r1 0x8001
calli @abort
Lus0:
movi %r1 $offus
ldxr_us %r0 %r0 %r1
beqi Lus1 %r0 0x8001
calli @abort
Lus1:
movi %r0 t0
movi %r1 $offi
ldxr_i %r1 %r0 %r1
beqi Li0 %r1 XI
calli @abort
Li0:
movi %r1 $offi
ldxr_i %r0 %r0 %r1
beqi Li1 %r0 XI
calli @abort
Li1:
#if __WORDSIZE == 64
movi %r0 t0
movi %r1 $offui
ldxr_ui %r1 %r0 %r1
beqi Lui0 %r1 0x80000001
calli @abort
Lui0:
movi %r1 $offui
ldxr_ui %r0 %r0 %r1
beqi Lui1 %r0 0x80000001
calli @abort
Lui1:
movi %r0 t0
movi %r1 $offl
ldxr_l %r1 %r0 %r1
beqi Ll0 %r1 0x8000000000000001
calli @abort
Ll0:
movi %r1 $offl
ldxr_l %r0 %r0 %r1
beqi Ll1 %r0 0x8000000000000001
calli @abort
Ll1:
#endif
LDST(v0, v1, v2, r0, r1, r2)
// just to know did not abort
prepare
pushargi ok
ellipsis
finishi @printf
ret
epilog
Loaded 100 of 181 files, more files were not shown because too many files have changed in this diff. Show more