[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 215/437: Add functional hppa port. All tests pass.
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 215/437: Add functional hppa port. All tests pass. |
|
Date: |
Mon, 2 Jul 2018 05:14:23 -0400 (EDT) |
wingo pushed a commit to branch lightning
in repository guile.
commit 3356b9d93a59c0aaa7c1303bea70cc10b87d7827
Author: pcpa <address@hidden>
Date: Sat Jun 1 01:53:33 2013 -0300
Add functional hppa port. All tests pass.
* include/lightning/jit_hppa.h, lib/jit_hppa-cpu.c,
lib/jit_hppa-fpu.c, lib/jit_hppa.c: New files implementing
the hppa port. Built on Debian Linux PA-RISC 2.0, 32 bit.
* check/float.tst: Add preprocessor for hppa expected
values when converting NaN and +-Inf to an integer.
* check/ldst.inc: Ensure double load/store tests use an
8 byte aligned address by default.
* lib/lightning.c: Correct a bug found during tests in
the new port, where qmul* and qdiv* were not properly
setting one of the result registers as modified in the
function, what would be a problem if the only "write"
usage were the qmul* or qdiv*.
* check/varargs.tst, check/varargs.ok: Add one extra
interleaved integer/double test to validate proper code
generation in the extra case.
* check/lightning.c, configure.ac, include/lightning.h,
include/lightning/Makefile.am,
include/lightning/jit_private.h, lib/Makefile.am,
lib/jit_disasm.c: Update for the hppa port.
---
ChangeLog | 27 +
check/float.tst | 4 +-
check/ldst.inc | 1 +
check/lightning.c | 5 +
check/varargs.ok | 1 +
check/varargs.tst | 118 ++
configure.ac | 2 +
include/lightning.h | 2 +
include/lightning/Makefile.am | 4 +
include/lightning/jit_hppa.h | 123 ++
include/lightning/jit_private.h | 4 +
lib/Makefile.am | 3 +
lib/jit_disasm.c | 2 +-
lib/jit_hppa-cpu.c | 2695 +++++++++++++++++++++++++++++++++++++++
lib/jit_hppa-fpu.c | 924 ++++++++++++++
lib/jit_hppa.c | 1186 +++++++++++++++++
lib/lightning.c | 16 +-
17 files changed, 5111 insertions(+), 6 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index f56d322..1c0afba 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,30 @@
+2013-06-01 Paulo Andrade <address@hidden>
+
+ * include/lightning/jit_hppa.h, lib/jit_hppa-cpu.c,
+ lib/jit_hppa-fpu.c, lib/jit_hppa.c: New files implementing
+ the hppa port. Built on Debian Linux PA-RISC 2.0, 32 bit.
+
+ * check/float.tst: Add preprocessor for hppa expected
+ values when converting NaN and +-Inf to an integer.
+
+ * check/ldst.inc: Ensure double load/store tests use an
+ 8 byte aligned address by default.
+
+ * lib/lightning.c: Correct a bug found during tests in
+ the new port, where qmul* and qdiv* were not properly
+ setting one of the result registers as modified in the
+ function, what would be a problem if the only "write"
+ usage were the qmul* or qdiv*.
+
+ * check/varargs.tst, check/varargs.ok: Add one extra
+ interleaved integer/double test to validate proper code
+ generation in the extra case.
+
+ * check/lightning.c, configure.ac, include/lightning.h,
+ include/lightning/Makefile.am,
+ include/lightning/jit_private.h, lib/Makefile.am,
+ lib/jit_disasm.c: Update for the hppa port.
+
2013-04-27 Paulo Andrade <address@hidden>
* check/varargs.tst: Correct misplaced .align directive
diff --git a/check/float.tst b/check/float.tst
index 65ab3c6..f905dbe 100644
--- a/check/float.tst
+++ b/check/float.tst
@@ -14,14 +14,14 @@ ok:
# define x80 0x8000000000000000
#endif
-#if __mips__ || __sparc__
+#if __mips__ || __sparc__ || __hppa__
# define wnan x7f
#elif __arm__
# define wnan 0
#else
# define wnan x80
#endif
-#if __mips__ || __arm__ || __ppc__ || __sparc__
+#if __mips__ || __arm__ || __ppc__ || __sparc__ || __hppa__
# define wpinf x7f
#else
# define wpinf x80
diff --git a/check/ldst.inc b/check/ldst.inc
index 51eb2a4..c2bc59a 100644
--- a/check/ldst.inc
+++ b/check/ldst.inc
@@ -63,6 +63,7 @@
.data 512
ok:
.c "ok\n"
+.align 8
t0:
c0:
.c 0
diff --git a/check/lightning.c b/check/lightning.c
index 40adeb3..bf1e126 100644
--- a/check/lightning.c
+++ b/check/lightning.c
@@ -3975,6 +3975,11 @@ main(int argc, char *argv[])
sizeof(cmdline) - opt_short,
" -D__ia64__=1");
#endif
+#if defined(__hppa__)
+ opt_short += snprintf(cmdline + opt_short,
+ sizeof(cmdline) - opt_short,
+ " -D__hppa__=1");
+#endif
if ((parser.fp = popen(cmdline, "r")) == NULL)
error("cannot execute %s", cmdline);
diff --git a/check/varargs.ok b/check/varargs.ok
index 5dcccb0..e103283 100644
--- a/check/varargs.ok
+++ b/check/varargs.ok
@@ -1,3 +1,4 @@
0 1 2 3 4 5 6 7 8 9
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
0 0.0 1 1.0 2 2.0 3 3.0 4 4.0 5 5.0 6 6.0 7 7.0 8 8.0 9 9.0
+0.0 0 1.0 1 2.0 2 3.0 3 4.0 4 5.0 5 6.0 6 7.0 7 8.0 8 9.0 9
diff --git a/check/varargs.tst b/check/varargs.tst
index e838c7a..11131d9 100644
--- a/check/varargs.tst
+++ b/check/varargs.tst
@@ -15,6 +15,10 @@ idfmt:
.c "%d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d
%.1f %d %.1f\n"
ldfmt:
.c "%d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d
%lf\n"
+difmt:
+.c "%.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f %d %.1f
%d %.1f %d\n"
+dlfmt:
+.c "%lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf %d %lf
%d\n"
.align 8
buff:
.size 256
@@ -276,5 +280,119 @@ outid:
ellipsis
finishi @printf
+ /*
+ sprintf(buff,
+ "%.1f %d %.1f %d %.1f %d %.1f %d %.1f %d "
+ "%.1f %d %.1f %d %.1f %d %.1f %d %.1f %d\n",
+ 0.0, 0, 1.0, 1, 2.0, 2, 3.0, 3, 4.0, 4,
+ 5, 5.0, 6.0, 6, 7.0, 7, 8.0, 8, 9.0, 9);
+ */
+ prepare
+ pushargi buff
+ pushargi difmt
+ ellipsis
+ pushargi_d 0.0
+ pushargi 0
+ pushargi_d 1.0
+ pushargi 1
+ pushargi_d 2.0
+ pushargi 2
+ pushargi_d 3.0
+ pushargi 3
+ pushargi_d 4.0
+ pushargi 4
+ pushargi_d 5.0
+ pushargi 5
+ pushargi_d 6.0
+ pushargi 6
+ pushargi_d 7.0
+ pushargi 7
+ pushargi_d 8.0
+ pushargi 8
+ pushargi_d 9.0
+ pushargi 9
+ finishi @sprintf
+
+ /*
+ sscanf(buff,
+ "%lf %d %lf %d %lf %d %lf %d %lf %d "
+ "%lf %d %lf %d %lf %d %lf %d %lf %d \n",
+ dchk+0, ichk+0, dchk+1, ichk+1, dchk+2,
+ ichk+2, dchk+3, ichk+3, dchk+4, ichk+4,
+ dchk+5, ichk+5, dchk+6, ichk+6, dchk+7,
+ ichk+7, dchk+8, ichk+8, dchk+9, ichk+9);
+ */
+ movi %v0 dchk
+ movi %v1 ichk
+ prepare
+ pushargi buff
+ pushargi dlfmt
+ ellipsis
+ pushargr %v0 /* 0 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 1 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 2 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 3 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 4 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 5 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 6 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 7 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 8 */
+ addi %v0 %v0 8
+ pushargr %v1
+ addi %v1 %v1 4
+ pushargr %v0 /* 9 */
+ pushargr %v1
+ finishi @sscanf
+
+ movi %v0 ichk
+ movi %v1 dchk
+ movi %r0 0
+ movi_d %f0 0.0
+loopdi:
+ ldr_i %r1 %v0
+ beqr check_d %r0 %r1
+ calli @abort
+check_d:
+ ldr_d %f1 %v1
+ beqr_d nextdi %f0 %f1
+ calli @abort
+nextdi:
+ addi %r0 %r0 1
+ addi_d %f0 %f0 1.0
+ bgei outdi %r0 10
+ addi %v0 %v0 4
+ addi %v1 %v1 8
+ jmpi loopdi
+outdi:
+
+ prepare
+ pushargi buff
+ ellipsis
+ finishi @printf
+
ret
epilog
diff --git a/configure.ac b/configure.ac
index f32e532..8d60615 100644
--- a/configure.ac
+++ b/configure.ac
@@ -74,6 +74,7 @@ case "$target_cpu" in
*powerpc*) cpu=ppc ;;
*sparc*) cpu=sparc ;;
ia64) cpu=ia64 ;;
+ hppa*) cpu=hppa ;;
*) ;;
esac
AM_CONDITIONAL(cpu_arm, [test cpu-$cpu = cpu-arm])
@@ -82,6 +83,7 @@ AM_CONDITIONAL(cpu_ppc, [test cpu-$cpu = cpu-ppc])
AM_CONDITIONAL(cpu_sparc, [test cpu-$cpu = cpu-sparc])
AM_CONDITIONAL(cpu_x86, [test cpu-$cpu = cpu-x86])
AM_CONDITIONAL(cpu_ia64, [test cpu-$cpu = cpu-ia64])
+AM_CONDITIONAL(cpu_hppa, [test cpu-$cpu = cpu-hppa])
# Test x87 if both, x87 and sse2 available
ac_cv_test_x86_x87=
diff --git a/include/lightning.h b/include/lightning.h
index 7cbaf30..e836aaf 100644
--- a/include/lightning.h
+++ b/include/lightning.h
@@ -76,6 +76,8 @@ typedef jit_int32_t jit_fpr_t;
# include <lightning/jit_sparc.h>
#elif defined(__ia64__)
# include <lightning/jit_ia64.h>
+#elif defined(__hppa__)
+# include <lightning/jit_hppa.h>
#endif
#define jit_flag_node 0x00000001 /* patch node not absolute */
diff --git a/include/lightning/Makefile.am b/include/lightning/Makefile.am
index 23e232b..7c77c49 100644
--- a/include/lightning/Makefile.am
+++ b/include/lightning/Makefile.am
@@ -41,3 +41,7 @@ if cpu_ia64
lightning_include_HEADERS = \
jit_ia64.h
endif
+if cpu_hppa
+lightning_include_HEADERS = \
+ jit_hppa.h
+endif
diff --git a/include/lightning/jit_hppa.h b/include/lightning/jit_hppa.h
new file mode 100644
index 0000000..a4d6c8c
--- /dev/null
+++ b/include/lightning/jit_hppa.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2013 Free Software Foundation, Inc.
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Authors:
+ * Paulo Cesar Pereira de Andrade
+ */
+
+#ifndef _jit_hppa_h
+#define _jit_hppa_h
+
+#define JIT_HASH_CONSTS 1
+#define JIT_NUM_OPERANDS 3
+
+/*
+ * Types
+ */
+typedef enum {
+#define jit_arg_reg_p(i) (i >= 0 && i <= 4)
+#define jit_arg_f_reg_p(i) (i >= 0 && i <= 4)
+ _R0, /* Always zero */
+ _R1, /* ADDIL implicit target */
+ _R2, /* B,L implicit target */
+#define jit_r_num() 4
+#define jit_r(n) ((n) < 4 ? _R4 + (n) : _R10 + (n))
+#define jit_v_num() 4
+#define jit_v(n) ((n) < 4 ? _R7 + (n) : _R11 + (n))
+#define jit_f_num() 8
+#define jit_f(n) (_F12 - (n))
+#define JIT_FP _R3
+#define JIT_R0 _R4
+#define JIT_R1 _R5
+#define JIT_R2 _R6
+#define JIT_V0 _R7
+#define JIT_V1 _R8
+#define JIT_V2 _R9
+ _R3,
+ _R19,
+ _R20,
+ _R21,
+ _R22,
+ _R29, /* ret1 */
+ _R28, /* ret0 */
+ _R4,
+ _R5,
+ _R6,
+ _R7,
+ _R8,
+ _R9,
+ _R10,
+ _R11,
+ _R12,
+ _R13,
+ _R14,
+ _R15,
+ _R16,
+ _R17,
+ _R18,
+ _R23, /* arg3 */
+ _R24, /* arg2 */
+ _R25, /* arg1 */
+ _R26, /* arg0 */
+ _R27, /* Data Pointer */
+ _R30, /* Stack Pointer */
+ _R31, /* Link register */
+#define JIT_F0 _F12
+#define JIT_F1 _F13
+#define JIT_F2 _F14
+#define JIT_F3 _F15
+#define JIT_F4 _F16
+#define JIT_F5 _F17
+ /* Caller Saves */
+ _F31,
+ _F30,
+ _F29,
+ _F28,
+ _F27,
+ _F26,
+ _F25,
+ _F24,
+ _F23,
+ _F22,
+ _F11,
+ _F10,
+ _F9,
+ _F8,
+ /* Arguments */
+ _F7, /* farg3 */
+ _F6, /* farg2 */
+ _F5, /* farg1 */
+ _F4, /* farg0 */
+ /* Callee Saves */
+ _F21,
+ _F20,
+ _F19,
+ _F18,
+ _F17,
+ _F16,
+ _F15,
+ _F14,
+ _F13,
+ _F12,
+ /* Floating-Pointer Status and Exception */
+ _F0,
+ _F1,
+ _F2,
+ _F3,
+#define JIT_NOREG _NOREG
+ _NOREG,
+} jit_reg_t;
+
+typedef jit_int64_t jit_regset_t;
+
+#endif /* _jit_hppa */
diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h
index b6740e4..9c7eecf 100644
--- a/include/lightning/jit_private.h
+++ b/include/lightning/jit_private.h
@@ -77,6 +77,10 @@
# define JIT_SP _R12
# define JIT_RET _R8
# define JIT_FRET _F8
+#elif defined(__hppa__)
+# define JIT_SP _R30
+# define JIT_RET _R28
+# define JIT_FRET _F4
#endif
#define jit_size(vector) (sizeof(vector) / sizeof((vector)[0]))
diff --git a/lib/Makefile.am b/lib/Makefile.am
index 6b5dbc2..2cbe047 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -28,6 +28,9 @@ EXTRA_DIST = \
jit_arm-cpu.c \
jit_arm-swf.c \
jit_arm-vfp.c \
+ jit_hppa.c \
+ jit_hppa-cpu.c \
+ jit_hppa-fpu.c \
jit_ia64.c \
jit_ia64-cpu.c \
jit_ia64-fpu.c \
diff --git a/lib/jit_disasm.c b/lib/jit_disasm.c
index 6366ac7..829220c 100644
--- a/lib/jit_disasm.c
+++ b/lib/jit_disasm.c
@@ -89,7 +89,7 @@ jit_init_debug(void)
# endif
# if defined(__sparc__)
disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG;
-#endif
+# endif
disasm_info.print_address_func = disasm_print_address;
if (bfd_get_file_flags(disasm_bfd) & HAS_SYMS) {
diff --git a/lib/jit_hppa-cpu.c b/lib/jit_hppa-cpu.c
new file mode 100644
index 0000000..71a684c
--- /dev/null
+++ b/lib/jit_hppa-cpu.c
@@ -0,0 +1,2695 @@
+/*
+ * Copyright (C) 2013 Free Software Foundation, Inc.
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Authors:
+ * Paulo Cesar Pereira de Andrade
+ */
+
+#if PROTO
+typedef struct idiv {
+ int quo;
+ int rem;
+} idiv_t;
+
+typedef struct udiv {
+ unsigned int quo;
+ unsigned int rem;
+} udiv_t;
+
+/* 16 spill bytes; -52 for first actual stack argument */
+#define params_offset -32
+/* Assume all callee save registers may need to be spilled */
+#define alloca_offset 192
+#define _R0_REGNO 0
+#define _R1_REGNO 1
+#define _RP_REGNO 2
+#define _FP_REGNO 3
+#define _R19_REGNO 19
+#define _R23_REGNO 23
+#define _R24_REGNO 24
+#define _R25_REGNO 25
+#define _R26_REGNO 26
+#define _R28_REGNO 28
+#define _R29_REGNO 29
+#define _SP_REGNO 30
+#define _R31_REGNO 31
+#define _CR11_REGNO 11
+#define ii(v) *_jit->pc.ui++ = v
+#define f1(o,b,t,i) _f1(_jit,o,b,t,i)
+static void _f1(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f2(o,b,r,i,j) _f2(_jit,o,b,r,i,j)
+static void _f2(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f3(o,b,t,i,j) _f3(_jit,o,b,t,i,j)
+static void _f3(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f4(o,b,x,s,u,y,c,z,m,t) _f4(_jit,o,b,x,s,u,y,c,z,m,t)
+static void _f4(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f5(o,b,i,s,a,y,c,z,m,t) _f5(_jit,o,b,i,s,a,y,c,z,m,t)
+static void _f5(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f6(o,b,r,s,a,x,c,y,m,i) _f6(_jit,o,b,r,s,a,x,c,y,m,i)
+static void _f6(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f7(o,r,i) _f7(_jit,o,r,i)
+static void _f7(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f8(o,r2,r1,cf,e1,x,e2,y,d,t) _f8(_jit,o,r2,r1,cf,e1,x,e2,y,d,t)
+static void _f8(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f9(o,r,t,cf,e1,im) _f9(_jit,o,r,t,cf,e1,im)
+static void _f9(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f10(o,r2,r1,u,v,w,x,sa,y,t) _f10(_jit,o,r2,r1,u,v,w,x,sa,y,t)
+static void _f10(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f11(o,r2,r1,c,x,y,z,u,t) _f11(_jit,o,r2,r1,c,x,y,z,u,t)
+static void _f11(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f12(o,r,t,c,x,se,y,c1,z,clen) _f12(_jit,o,r,t,c,x,se,y,c1,z,clen)
+static void _f12(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f13(o,t,r,c,x,nz,c1,clen) _f13(_jit,o,t,r,c,x,nz,c1,clen)
+static void _f13(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f13x(o,t,i,c,x,nz,c1,clen) _f13x(_jit,o,t,i,c,x,nz,c1,clen)
+static void _f13x(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f14(o,r2,r1,c,x,cp,y,cpos,t) _f14(_jit,o,r2,r1,c,x,cp,y,cpos,t)
+static void _f14(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f15(o,r,t,c,c1,p,se,pos,clen) _f15(_jit,o,r,t,c,c1,p,se,pos,clen)
+static void _f15(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f16(o,t,r,c,c1,cp,nz,cpos,clen)
_f16(_jit,o,t,r,c,c1,cp,nz,cpos,clen)
+static void _f16(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f16x(o,t,i,c,c1,cp,nz,cpos,clen) _f16x(_jit,o,t,i,c,c1,cp,nz,cpos,clen)
+static void _f16x(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f17(o,r2,r1,c,i,n) _f17(_jit,o,r2,r1,c,i,n)
+static void _f17(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f17x(o,r2,r1,c,i,n) _f17x(_jit,o,r2,r1,c,i,n)
+static void _f17x(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f18(o,p,r,c,i,n) _f18(_jit,o,p,r,c,i,n)
+static void _f18(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f19(o,b,s,i,n) _f19(_jit,o,b,s,i,n)
+static void _f19(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f20(o,t,i,g,n) _f20(_jit,o,t,i,g,n)
+static void _f20(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f21(o,t,x,y,n) _f21(_jit,o,t,x,y,n)
+static void _f21(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define f22(o,b,x,r,n,p) _f22(_jit,o,b,x,r,n,p)
+static void _f22(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f23(o,a,b,c,d,e,f,g,h) _f23(_jit,o,a,b,c,d,e,f,g,h)
+static void _f23(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f24(o,b,x,s,y,m,r) _f24(_jit,o,b,x,s,y,m,r)
+static void _f24(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f25(o,b,i,s,y,m,r) _f25(_jit,o,b,i,s,y,m,r)
+static void _f25(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f26(o,b,x,s,y,m,r) _f26(_jit,o,b,x,s,y,m,r)
+static void _f26(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f27(o,i,j) _f27(_jit,o,i,j)
+static void _f27(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t)
maybe_unused;
+#define f28(o,i) _f28(_jit,o,i)
+static void _f28(jit_state_t*,jit_int32_t,jit_int32_t) maybe_unused;
+#define f29(o,r,x,s,y,t) _f29(_jit,o,r,x,s,y,t)
+static void _f29(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f30(o,b,r,s,x,y,t) _f30(_jit,o,b,r,s,x,y,t)
+static void _f30(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f31(o,t,r,v,x,y) _f31(_jit,o,t,r,v,x,y)
+static void _f31(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f33(o,x,r,y,z,u) _f33(_jit,o,x,r,y,z,u)
+static void _f33(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f34(o,o1,x,sf,n,o2) _f34(_jit,o,o1,x,sf,n,o2)
+static void _f34(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f35(o,op,x,sf,n,t) _f35(_jit,o,op,x,sf,n,t)
+static void _f35(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f36(o,r,o1,x,sf,n,o2) _f36(_jit,o,r,o1,x,sf,n,o2)
+static void _f36(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f37(o,r2,r1,o1,x,sf,n,o2) _f37(_jit,o,r2,r1,o1,x,sf,n,o2)
+static void _f37(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f38(o,s,u,n) _f38(_jit,o,s,u,n)
+static void _f38(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+/* nulify next instruction if condition is met with addition */
+#define ADD_CF_NV 0 /* never */
+#define ADD_CF_EQ 2 /* O1 == -O2 (word) */
+#define ADD_CF_LT 4 /* O1 < -O2 (signed)*/
+#define ADD_CF_LE 6 /* O1 <= -O2 (signed) */
+#define ADD_CF_NUV 8 /* O1 + O2 does not overflow
(unsigned) */
+#define ADD_CF_ZNV 10 /* O1 + O2 is zero or no overflow
(unsigned) */
+#define ADD_CF_SV 12 /* O1 + O2 overflows (signed) */
+#define ADD_CF_OD 14 /* O1 + O2 is odd */
+#define ADD_CF_TR 1 /* always */
+#define ADD_CF_NE 3 /* O1 != -O2 */
+#define ADD_CF_GE 5 /* O1 >= -O2 (signed) */
+#define ADD_CF_GT 7 /* O1 > -O2 (signed) */
+#define ADD_CF_UV 9 /* O1 + O2 overflows (unsigned) */
+#define ADD_CF_VNZ 11 /* O1 + O2 is nonzero and overflows
(unsigned) */
+#define ADD_CF_NSV 13 /* O1 + O2 does not overflow (signed)
*/
+#define ADD_CF_EV 15 /* O1 + O2 is even */
+#define ADD_EN_NONE 6 /* none */
+#define ADD_EN_C 7 /* with carry */
+#define ADD_EN_L 10 /* logical */
+#define ADD_EN_TSV 12 /* trap on signed overflow */
+#define ADD_EN_C_TSV 13 /* with carry and trap on signed
overflow */
+#define ADDI_OE_TC 0 /* trap on condition */
+#define ADDI_OE_TSV_TC 1 /* trap on signed overflow or condition
*/
+#define ADDI_OE_NONE 2 /* none */
+#define ADDI_OE_TSV 3 /* trap on signed overflow */
+#define ADD_(en,cf,r1,r2,t) f8(0x2,r2,r1,cf,en>>2,1,en&1,0,0,t)
+#define ADD(r1,r2,t) ADD_(ADD_EN_NONE,ADD_CF_NV,r1,r2,t)
+#define ADD_C(r1,r2,t) ADD_(ADD_EN_C,ADD_CF_NV,r1,r2,t)
+#define ADD_L(r1,r2,t) ADD_(ADD_EN_L,ADD_CF_NV,r1,r2,t)
+#define ADDB_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,0)
+#define ADDB(r1,r2,t) ADDB_(ADD_CF_NV,r1,r2,t)
+#define ADDB_EQ(r1,r2,t) ADDB_(ADD_CF_EQ,r1,r2,t)
+#define ADDB_LT(r1,r2,t) ADDB_(ADD_CF_LT,r1,r2,t)
+#define ADDB_LE(r1,r2,t) ADDB_(ADD_CF_LE,r1,r2,t)
+#define ADDB_NUV(r1,r2,t) ADDB_(ADD_CF_NUV,r1,r2,t)
+#define ADDB_ZNV(r1,r2,t) ADDB_(ADD_CF_ZNV,r1,r2,t)
+#define ADDB_SV(r1,r2,t) ADDB_(ADD_CF_SV,r1,r2,t)
+#define ADDB_OD(r1,r2,t) ADDB_(ADD_CF_OD,r1,r2,t)
+#define ADDB_TR(r1,r2,t) ADDB_(ADD_CF_TR,r1,r2,t)
+#define ADDB_NE(r1,r2,t) ADDB_(ADD_CF_NE,r1,r2,t)
+#define ADDB_GE(r1,r2,t) ADDB_(ADD_CF_GE,r1,r2,t)
+#define ADDB_GT(r1,r2,t) ADDB_(ADD_CF_GT,r1,r2,t)
+#define ADDB_UV(r1,r2,t) ADDB_(ADD_CF_UV,r1,r2,t)
+#define ADDB_VNZ(r1,r2,t) ADDB_(ADD_CF_VNZ,r1,r2,t)
+#define ADDB_NSV(r1,r2,t) ADDB_(ADD_CF_NSV,r1,r2,t)
+#define ADDB_EV(r1,r2,t) ADDB_(ADD_CF_EV,r2,r1,t)
+#define ADDB_N_(cc,r1,r2,t) f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,1)
+#define ADDB_N(r1,r2,t) ADDB_N_(ADD_CF_NV,r1,r2,t)
+#define ADDB_N_EQ(r1,r2,t) ADDB_N_(ADD_CF_EQ,r1,r2,t)
+#define ADDB_N_LT(r1,r2,t) ADDB_N_(ADD_CF_LT,r1,r2,t)
+#define ADDB_N_LE(r1,r2,t) ADDB_N_(ADD_CF_LE,r1,r2,t)
+#define ADDB_N_NUV(r1,r2,t) ADDB_N_(ADD_CF_NUV,r1,r2,t)
+#define ADDB_N_ZNV(r1,r2,t) ADDB_N_(ADD_CF_ZNV,r1,r2,t)
+#define ADDB_N_SV(r1,r2,t) ADDB_N_(ADD_CF_SV,r1,r2,t)
+#define ADDB_N_OD(r1,r2,t) ADDB_N_(ADD_CF_OD,r1,r2,t)
+#define ADDB_N_TR(r1,r2,t) ADDB_N_(ADD_CF_TR,r1,r2,t)
+#define ADDB_N_NE(r1,r2,t) ADDB_N_(ADD_CF_NE,r1,r2,t)
+#define ADDB_N_GE(r1,r2,t) ADDB_N_(ADD_CF_GE,r1,r2,t)
+#define ADDB_N_GT(r1,r2,t) ADDB_N_(ADD_CF_GT,r1,r2,t)
+#define ADDB_N_UV(r1,r2,t) ADDB_N_(ADD_CF_UV,r1,r2,t)
+#define ADDB_N_VNZ(r1,r2,t) ADDB_N_(ADD_CF_VNZ,r1,r2,t)
+#define ADDB_N_NSV(r1,r2,t) ADDB_N_(ADD_CF_NSV,r1,r2,t)
+#define ADDB_N_EV(r1,r2,t) ADDB_N_(ADD_CF_EV,r1,r2,t)
+#define ADDI_(ec,cf,i,r,t) f9(0x2c|(ec>>1),r,t,cf,ec&1,i)
+#define ADDI(i,r,t) ADDI_(ADDI_OE_NONE,ADD_CF_NV,i,r,t)
+#define ADDIB_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,0)
+#define ADDIB(i,r,t) ADDIB_(ADD_CF_NV,i,r,t)
+#define ADDIB_EQ(i,r,t) ADDIB_(ADD_CF_EQ,i,r,t)
+#define ADDIB_LT(i,r,t) ADDIB_(ADD_CF_LT,i,r,t)
+#define ADDIB_LE(i,r,t) ADDIB_(ADD_CF_LE,i,r,t)
+#define ADDIB_NUV(i,r,t) ADDIB_(ADD_CF_NUV,i,r,t)
+#define ADDIB_ZNV(i,r,t) ADDIB_(ADD_CF_ZNV,i,r,t)
+#define ADDIB_SV(i,r,t) ADDIB_(ADD_CF_SV,i,r,t)
+#define ADDIB_OD(i,r,t) ADDIB_(ADD_CF_OD,i,r,t)
+#define ADDIB_TR(i,r,t) ADDIB_(ADD_CF_TR,i,r,t)
+#define ADDIB_NE(i,r,t) ADDIB_(ADD_CF_NE,i,r,t)
+#define ADDIB_GE(i,r,t) ADDIB_(ADD_CF_GE,i,r,t)
+#define ADDIB_GT(i,r,t) ADDIB_(ADD_CF_GT,i,r,t)
+#define ADDIB_UV(i,r,t) ADDIB_(ADD_CF_UV,i,r,t)
+#define ADDIB_VNZ(i,r,t) ADDIB_(ADD_CF_VNZ,i,r,t)
+#define ADDIB_NSV(i,r,t) ADDIB_(ADD_CF_NSV,i,r,t)
+#define ADDIB_EV(i,r,t) ADDIB_(ADD_CF_EV,i,r,t)
+#define ADDIB_N_(cc,i,r,t) f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,1)
+#define ADDIB_N(i,r,t) ADDIB_N_(ADD_CF_NV,i,r,t)
+#define ADDIB_N_EQ(i,r,t) ADDIB_N_(ADD_CF_EQ,i,r,t)
+#define ADDIB_N_LT(i,r,t) ADDIB_N_(ADD_CF_LT,i,r,t)
+#define ADDIB_N_LE(i,r,t) ADDIB_N_(ADD_CF_LE,i,r,t)
+#define ADDIB_N_NUV(i,r,t) ADDIB_N_(ADD_CF_NUV,i,r,t)
+#define ADDIB_N_ZNV(i,r,t) ADDIB_N_(ADD_CF_ZNV,i,r,t)
+#define ADDIB_N_SV(i,r,t) ADDIB_N_(ADD_CF_SV,i,r,t)
+#define ADDIB_N_OD(i,r,t) ADDIB_N_(ADD_CF_OD,i,r,t)
+#define ADDIB_N_TR(i,r,t) ADDIB_N_(ADD_CF_TR,i,r,t)
+#define ADDIB_N_NE(i,r,t) ADDIB_N_(ADD_CF_NE,i,r,t)
+#define ADDIB_N_GE(i,r,t) ADDIB_N_(ADD_CF_GE,i,r,t)
+#define ADDIB_N_GT(i,r,t) ADDIB_N_(ADD_CF_GT,i,r,t)
+#define ADDIB_N_UV(i,r,t) ADDIB_N_(ADD_CF_UV,i,r,t)
+#define ADDIB_N_VNZ(i,r,t) ADDIB_N_(ADD_CF_VNZ,i,r,t)
+#define ADDIB_N_NSV(i,r,t) ADDIB_N_(ADD_CF_NSV,i,r,t)
+#define ADDIB_N_EV(i,r,t) ADDIB_N_(ADD_CF_EV,0,i,r,t)
+#define ADDIL(i,r) f7(0xa,r,i)
+#define LOG_CC_NV 0 /* never */
+#define LOG_CC_EQ 1 /* all bits are 0 */
+#define LOG_CC_LT 2 /* leftmost bit is 1 */
+#define LOG_CC_LE 3 /* leftmost bit is 1 or all bits are 0
*/
+#define LOG_CC_OD 7 /* rightmost bit is 1 */
+#define LOG_CC_TR 8 /* always */
+#define LOG_CC_NE 9 /* some bits are 1 */
+#define LOG_CC_GE 10 /* leftmost bit is 0 */
+#define LOG_CC_GT 11 /* leftmost bit is 0 or some bits are 1
*/
+#define LOG_CC_EV 15 /* rightmost bit is 0 */
+#define AND_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,1,0,0,0,t)
+#define AND(r1,r2,t) AND_(LOG_CC_NV,r1,r2,t)
+#define ANDCM_(cc,r1,r2,t) f8(0x2,r2,r1,cc,0,0,0,0,0,t)
+#define ANDCM(r1,r2,t) ANDCM_(LOG_CC_NV,r1,r2,t)
+#define B_(n,i,t) f20(0x3a,t,i,0,n)
+#define B(i,t) B_(0,i,t)
+#define B_N(i,t) B_(1,i,t)
+#define B_L(i) B_(0,i,_RP_REGNO)
+#define B_L_N(i) B_(1,i,_RP_REGNO)
+#define BB_CC_LT 0 /* leftmost bit in word is 1 */
+#define BB_CC_GE 1 /* leftmost bit in word is 0 */
+#define BB_(c,r,i) f18(0x30,0,r,c,i,0)
+#define BB_N_(c,r,i) f18(0x30,0,r,c,i,1)
+#define BBI_(c,r,p,i) f18(0x31,p,r,c,i,0)
+#define BBI_N_(c,r,p,i) f18(0x31,p,r,c,i,1)
+#define BB(c,r,i) BB_(c,r,i)
+#define BBI_LT(r,p,i) BBI_(BB_CC_LT,r,p,i)
+#define BBI_GE(r,p,i) BBI_(BB_CC_GE,r,p,i)
+#define BB_N(c,r,i) BB_(c,r,i)
+#define BBI_N_LT(r,p,i) BBI_N_(BB_CC_LT,r,p,i)
+#define BBI_N_GE(r,p,i) BBI_N_(BB_CC_GE,r,p,i)
+#define BE(i,s,b) f19(0x38,b,s,i,0)
+#define BE_L(i,s,b) f19(0x39,b,s,i,0)
+#define BLR(x,t) f21(0x3a,t,x,2,0)
+#define BLR_N(x,t) f21(0x3a,t,x,2,1)
+#define BREAK(i,j) f27(0,j,i)
+#define BV(x,b) f21(0x3a,b,x,6,0)
+#define BV_N(x,b) f21(0x3a,b,x,6,1)
+#define BVE(b) f22(0x3a,b,6,0,0,0)
+#define BVE_L(b) f22(0x3a,b,7,0,0,0)
+#define II_C_NONE 0
+#define II_C_M (1<<5)
+#define II_C_S (1<<13)
+#define II_C_SM (II_C_S|II_C_M)
+#define II_AU_NONE 0
+#define II_AU_PRE ((1<<13)|II_C_M)
+#define II_AU_POS II_C_M
+#define LD_CC_H_NONE 0 /* No hint */
+#define LD_CC_H_SPL 2 /* Spatial Locality */
+#define CLRBTS() f23(0x3a,0,0,2,0,0,1,0,1)
+#define CS_CC_NV 0 /* never */
+#define CS_CC_EQ 2 /* O1 = O2 */
+#define CS_CC_LT 4 /* O1 < O2 (signed) */
+#define CS_CC_LE 6 /* O1 <= O2 (signed) */
+#define CS_CC_ULT 8 /* O1 < O2 (unsigned) */
+#define CS_CC_ULE 10 /* O1 <= O2 (unsigned) */
+#define CS_CC_SV 12 /* O1 - O2 overflows (signed) */
+#define CS_CC_OD 14 /* O1 - O2 is odd */
+#define CS_CC_TR 1 /* always */
+#define CS_CC_NE 3 /* O1 != O2 */
+#define CS_CC_GE 5 /* O1 >= O2 (signed) */
+#define CS_CC_GT 7 /* O1 > O2 (signed) */
+#define CS_CC_UGE 9 /* O1 >= O2 (unsigned) */
+#define CS_CC_UGT 11 /* O1 > O2 (unsigned) */
+#define CS_CC_NSV 13 /* O1 - O2 does not overflows (signed)
*/
+#define CS_CC_EV 15 /* O1 - O2 is even */
+#define CMPB_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,0)
+#define CMPB(r1,r2,i) CMPB_(CS_CC_NV,r1,r2,i)
+#define CMPB_EQ(r1,r2,i) CMPB_(CS_CC_EQ,r1,r2,i)
+#define CMPB_LT(r1,r2,i) CMPB_(CS_CC_LT,r1,r2,i)
+#define CMPB_LE(r1,r2,i) CMPB_(CS_CC_LE,r1,r2,i)
+#define CMPB_ULT(r1,r2,i) CMPB_(CS_CC_ULT,r1,r2,i)
+#define CMPB_ULE(r1,r2,i) CMPB_(CS_CC_ULE,r1,r2,i)
+#define CMPB_SV(r1,r2,i) CMPB_(CS_CC_SV,r1,r2,i)
+#define CMPB_OD(r1,r2,i) CMPB_(CS_CC_OD,r1,r2,i)
+#define CMPB_TR(r1,r2,i) CMPB_(CS_CC_TR,r1,r2,i)
+#define CMPB_NE(r1,r2,i) CMPB_(CS_CC_NE,r1,r2,i)
+#define CMPB_GE(r1,r2,i) CMPB_(CS_CC_GE,r1,r2,i)
+#define CMPB_GT(r1,r2,i) CMPB_(CS_CC_GT,r1,r2,i)
+#define CMPB_UGE(r1,r2,i) CMPB_(CS_CC_UGE,r1,r2,i)
+#define CMPB_UGT(r1,r2,i) CMPB_(CS_CC_UGT,r1,r2,i)
+#define CMPB_NSV(r1,r2,i) CMPB_(CS_CC_NSV,r1,r2,i)
+#define CMPB_EV(r1,r2,i) CMPB_(CS_CC_EV,r1,r2,i)
+#define CMPB_N_(c,r1,r2,i) f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,1)
+#define CMPB_N(r1,r2,i) CMPB_N_(CS_CC_NV,r1,r2,i)
+#define CMPB_EQ_N(r1,r2,i) CMPB_N_(CS_CC_EQ,r1,r2,i)
+#define CMPB_LT_N(r1,r2,i) CMPB_N_(CS_CC_LT,r1,r2,i)
+#define CMPB_LE_N(r1,r2,i) CMPB_N_(CS_CC_LE,r1,r2,i)
+#define CMPB_ULT_N(r1,r2,i) CMPB_N_(CS_CC_ULT,r1,r2,i)
+#define CMPB_ULE_N(r1,r2,i) CMPB_N_(CS_CC_ULE,r1,r2,i)
+#define CMPB_SV_N(r1,r2,i) CMPB_N_(CS_CC_SV,r1,r2,i)
+#define CMPB_OD_N(r1,r2,i) CMPB_N_(CS_CC_OD,r1,r2,i)
+#define CMPB_TR_N(r1,r2,i) CMPB_N_(CS_CC_TR,r1,r2,i)
+#define CMPB_NE_N(r1,r2,i) CMPB_N_(CS_CC_NE,r1,r2,i)
+#define CMPB_GE_N(r1,r2,i) CMPB_N_(CS_CC_GE,r1,r2,i)
+#define CMPB_GT_N(r1,r2,i) CMPB_N_(CS_CC_GT,r1,r2,i)
+#define CMPB_UGE_N(r1,r2,i) CMPB_N_(CS_CC_UGE,r1,r2,i)
+#define CMPB_UGT_N(r1,r2,i) CMPB_N_(CS_CC_UGT,r1,r2,i)
+#define CMPB_NSV_N(r1,r2,i) CMPB_N_(CS_CC_NSV,r1,r2,i)
+#define CMPB_EV_N(r1,r2,i) CMPB_N_(CS_CC_EV,r1,r2,i)
+#define CMPCLR_(c,r1,r2,i) f8(0x2,r2,r1,c,2,0,0,2,0,i)
+#define CMPCLR(r1,r2,i) CMPCLR_(CS_CC_NV,r1,r2,i)
+#define CMPCLR_EQ(r1,r2,i) CMPCLR_(CS_CC_EQ,r1,r2,i)
+#define CMPCLR_LT(r1,r2,i) CMPCLR_(CS_CC_LT,r1,r2,i)
+#define CMPCLR_LE(r1,r2,i) CMPCLR_(CS_CC_LE,r1,r2,i)
+#define CMPCLR_ULT(r1,r2,i) CMPCLR_(CS_CC_ULT,r1,r2,i)
+#define CMPCLR_ULE(r1,r2,i) CMPCLR_(CS_CC_ULE,r1,r2,i)
+#define CMPCLR_SV(r1,r2,i) CMPCLR_(CS_CC_SV,r1,r2,i)
+#define CMPCLR_OD(r1,r2,i) CMPCLR_(CS_CC_OD,r1,r2,i)
+#define CMPCLR_TR(r1,r2,i) CMPCLR_(CS_CC_TR,r1,r2,i)
+#define CMPCLR_NE(r1,r2,i) CMPCLR_(CS_CC_NE,r1,r2,i)
+#define CMPCLR_GE(r1,r2,i) CMPCLR_(CS_CC_GE,r1,r2,i)
+#define CMPCLR_GT(r1,r2,i) CMPCLR_(CS_CC_GT,r1,r2,i)
+#define CMPCLR_UGE(r1,r2,i) CMPCLR_(CS_CC_UGE,r1,r2,i)
+#define CMPCLR_UGT(r1,r2,i) CMPCLR_(CS_CC_UGT,r1,r2,i)
+#define CMPCLR_NSV(r1,r2,i) CMPCLR_(CS_CC_NSV,r1,r2,i)
+#define CMPCLR_EV(r1,r2,i) CMPCLR_(CS_CC_EV,r1,r2,i)
+#define CMPIB_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,0)
+#define CMPIB_NONE(i,r,t) CMPIB_(CS_CC_NV,i,r,t)
+#define CMPIB_EQ(i,r,t) CMPIB_(CS_CC_EQ,i,r,t)
+#define CMPIB_LT(i,r,t) CMPIB_(CS_CC_LT,i,r,t)
+#define CMPIB_LE(i,r,t) CMPIB_(CS_CC_LE,i,r,t)
+#define CMPIB_ULT(i,r,t) CMPIB_(CS_CC_ULT,i,r,t)
+#define CMPIB_ULE(i,r,t) CMPIB_(CS_CC_ULE,i,r,t)
+#define CMPIB_SV(i,r,t) CMPIB_(CS_CC_SV,i,r,t)
+#define CMPIB_OD(i,r,t) CMPIB_(CS_CC_OD,i,r,t)
+#define CMPIB(i,r,t) CMPIB_(CS_CC_TR,i,r,t)
+#define CMPIB_NE(i,r,t) CMPIB_(CS_CC_NE,i,r,t)
+#define CMPIB_GE(i,r,t) CMPIB_(CS_CC_GE,i,r,t)
+#define CMPIB_GT(i,r,t) CMPIB_(CS_CC_GT,i,r,t)
+#define CMPIB_UGE(i,r,t) CMPIB_(CS_CC_UGE,i,r,t)
+#define CMPIB_UGT(i,r,t) CMPIB_(CS_CC_UGT,i,r,t)
+#define CMPIB_NSV(i,r,t) CMPIB_(CS_CC_NSV,i,r,t)
+#define CMPIB_EV(i,r,t) CMPIB_(CS_CC_EV,i,r,t)
+#define CMPIB_N_(c,i,r,t) f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,1)
+#define CMPIB_NONE_N(i,r,t) CMPIB_N_(CS_CC_NV,i,r,t)
+#define CMPIB_EQ_N(i,r,t) CMPIB_N_(CS_CC_EQ,i,r,t)
+#define CMPIB_LT_N(i,r,t) CMPIB_N_(CS_CC_LT,i,r,t)
+#define CMPIB_LE_N(i,r,t) CMPIB_N_(CS_CC_LE,i,r,t)
+#define CMPIB_ULT_N(i,r,t) CMPIB_N_(CS_CC_ULT,i,r,t)
+#define CMPIB_ULE_N(i,r,t) CMPIB_N_(CS_CC_ULE,i,r,t)
+#define CMPIB_SV_N(i,r,t) CMPIB_N_(CS_CC_SV,i,r,t)
+#define CMPIB_OD_N(i,r,t) CMPIB_N_(CS_CC_OD,i,r,t)
+#define CMPIB_N(i,r,t) CMPIB_N_(CS_CC_TR,i,r,t)
+#define CMPIB_NE_N(i,r,t) CMPIB_N_(CS_CC_NE,i,r,t)
+#define CMPIB_GE_N(i,r,t) CMPIB_N_(CS_CC_GE,i,r,t)
+#define CMPIB_GT_N(i,r,t) CMPIB_N_(CS_CC_GT,i,r,t)
+#define CMPIB_UGE_N(i,r,t) CMPIB_N_(CS_CC_UGE,i,r,t)
+#define CMPIB_UGT_N(i,r,t) CMPIB_N_(CS_CC_UGT,i,r,t)
+#define CMPIB_NSV_N(i,r,t) CMPIB_N_(CS_CC_NSV,i,r,t)
+#define CMPIB_EV_N(i,r,t) CMPIB_N_(CS_CC_EV,i,r,t)
+#define CMPICLR_(c,i,r,t) f9(0x24,r,t,c,0,i)
+#define CMPICLR(i,r,t) CMPICLR_(CS_CC_NV,i,r,t)
+#define CMPICLR_EQ(i,r,t) CMPICLR_(CS_CC_EQ,i,r,t)
+#define CMPICLR_LT(i,r,t) CMPICLR_(CS_CC_LT,i,r,t)
+#define CMPICLR_LE(i,r,t) CMPICLR_(CS_CC_LE,i,r,t)
+#define CMPICLR_ULT(i,r,t) CMPICLR_(CS_CC_ULT,i,r,t)
+#define CMPICLR_ULE(i,r,t) CMPICLR_(CS_CC_ULE,i,r,t)
+#define CMPICLR_SV(i,r,t) CMPICLR_(CS_CC_SV,i,r,t)
+#define CMPICLR_OD(i,r,t) CMPICLR_(CS_CC_OD,i,r,t)
+#define CMPICLR_TR(i,r,t) CMPICLR_(CS_CC_TR,i,r,t)
+#define CMPICLR_NE(i,r,t) CMPICLR_(CS_CC_NE,i,r,t)
+#define CMPICLR_GE(i,r,t) CMPICLR_(CS_CC_GE,i,r,t)
+#define CMPICLR_GT(i,r,t) CMPICLR_(CS_CC_GT,i,r,t)
+#define CMPICLR_UGE(i,r,t) CMPICLR_(CS_CC_UGE,i,r,t)
+#define CMPICLR_UGT(i,r,t) CMPICLR_(CS_CC_UGT,i,r,t)
+#define CMPICLR_NSV(i,r,t) CMPICLR_(CS_CC_NSV,i,r,t)
+#define CMPICLR_EV(i,r,t) CMPICLR_(CS_CC_EV,i,r,t)
+#define COPR(u,s) f38(0x0c,s,u,0)
+#define UI_CF_NONE 0 /* never */
+#define UI_CF_SBZ 2 /* some byte zero */
+#define UI_CF_SHZ 3 /* some halfword zero */
+#define UI_CF_SDC 4 /* some digit carry */
+#define UI_CF_SBC 6 /* some byte carry */
+#define UI_CF_SHC 7 /* some halfword carry */
+#define UI_TR_SHC 8 /* always */
+#define UI_CF_NBZ 10 /* no byte zero */
+#define UI_CF_NHZ 11 /* no halfword zero */
+#define UI_CF_NDC 12 /* no digit carry */
+#define UI_CF_NBC 14 /* no byte carry */
+#define UI_CF_NHC 15 /* no halfword carry */
+#define DCOR_(e1,cf,r,t) f8(0x2,r,0,cf,2,1,1,e1,0,t)
+#define DCOR(r,t) DCOR_(2,UI_CF_NONE,r,t)
+#define DCOR_I(r,t) DCOR_(3,UI_CF_NONE,r,t)
+#define SED_C_NEVER 0 /* never */
+#define SED_C_EQ 1 /* all bits 0 */
+#define SED_C_LT 2 /* lefmost bits 1 */
+#define SED_C_OD 3 /* rightmost bit 1 */
+#define SED_C_TR 4 /* always */
+#define SED_C_NE 5 /* some bit 1 */
+#define SED_C_GE 6 /* lefmost bits 1 */
+#define SED_C_EV 7 /* rightmost bit 0 */
+#define DEPW(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,1,0,len)
+#define DEPW_Z(r,len,t) f13(0x35,t,r,SED_C_NEVER,0,0,0,len)
+#define DEPWR(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,1,31-(pos),len)
+#define DEPWR_Z(r,pos,len,t) f16(0x35,t,r,SED_C_NEVER,0,1,0,31-(pos),len)
+#define SHLWI(r,sa,t) DEPWR_Z(r,31-(sa),32-(sa),t)
+#define DEPWI(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,1,0,len)
+#define DEPWI_Z(i,len,t) f13x(0x35,t,i,SED_C_NEVER,2,0,0,len)
+#define DEPWRI(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,1,31-(pos),len)
+#define DEPWRI_Z(i,pos,len,t) f16x(0x35,t,i,SED_C_NEVER,1,1,0,31-(pos),len)
+#define DIAG(i) f28(0x5,i)
+#define DS(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,1,0,0,1,0,t)
+#define EXTRW(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,1,0,0,0,len)
+#define EXTRW_U(r,len,t) f12(0x34,r,t,SED_C_NEVER,2,0,0,0,0,len)
+#define EXTRWR(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,1,pos,len)
+#define SHRWI(r,sa,t) EXTRWR(r,31-(sa),32-(sa),t)
+#define EXTRWR_U(r,pos,len,t) f15(0x34,r,t,SED_C_NEVER,1,1,0,pos,len)
+#define SHRWI_U(r,sa,t) EXTRWR_U(r,31-(sa),32-(sa),t)
+#define FDC(x,s,b) f24(0x1,b,x,s,0x4a,0,0)
+#define FDC_M(x,s,b) f24(0x1,b,x,s,0x4a,1,0)
+#define FDCI(i,s,b) f25(0x1,b,i,s,0xca,0,0)
+#define FDCE(x,s,b) f24(0x1,b,x,s,0x4b,0,0)
+#define FDCE_M(x,s,b) f24(0x1,b,x,s,0x4b,1,0)
+#define FIC(x,s,b) f26(0x1,b,x,s,0xa,0,0)
+#define FIC_M(x,s,b) f26(0x1,b,x,s,0xa,1,0)
+#define FICI(x,s,b) f25(0x1,b,x,s,0x4f,0,0)
+#define FICI_M(x,s,b) f25(0x1,b,x,s,0x4f,1,0)
+#define FICE(x,s,b) f26(0x1,b,x,s,0xb,0,0)
+#define FICE_M(x,s,b) f26(0x1,b,x,s,0xb,1,0)
+#define HADD_(c,r1,r2,t) f8(0x2,r2,r1,0,0,1,1,c,0,t)
+#define HADD(r1,r2,t) HADD_(3,r1,r2,t)
+#define HADD_SS(r1,r2,t) HADD_(1,r1,r2,t)
+#define HADD_US(r1,r2,t) HADD_(0,r1,r2,t)
+#define HAVG(r1,r2,t) f8(0x2,r2,r1,0,0,1,0,3,0,t)
+#define HSHL(r,sa,t) f10(0x3e,0,r,1,0,0,2,sa,0,t)
+#define HSHLADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,1,1,sa,0,t)
+#define HSHR(r,sa,t) f10(0x3e,r,0,1,2,0,3,sa,0,t)
+#define HSHR_U(r,sa,t) f10(0x3e,r,0,1,2,0,2,sa,0,t)
+#define HSHRADD(r1,sa,r2,t) f8(0x2,r2,r1,0,1,0,1,sa,0,t)
+#define HSUB_(c,r1,r2,t) f8(0x2,r2,r1,0,0,0,1,c,0,t)
+#define HSUB(r1,r2,t) HSUB_(3,r1,r2,t)
+#define HSUB_SS(r1,r2,t) HSUB_(1,r1,r2,t)
+#define HSUB_US(r1,r2,t) HSUB_(0,r1,r2,t)
+#define IDTLBT(r1,r2) f26(0x1,r2,r1,0,0x60,0,0)
+#define IITLBT(r1,r2) f26(0x1,r2,r1,0,0x20,0,0)
+#define LCI(x,s,b,t) f24(0x1,b,x,s,0x4c,0,t)
+#define LDBL(i,b,t) f1(0x10,b,t,i)
+#define LDB(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,0,0,t)
+#define LDBI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,0,0,t)
+#define LDCD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,5,0,t)
+#define LDCDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,5,0,t)
+#define LDCW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,7,0,t)
+#define LDCWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,7,0,t)
+#define LDDL(i,b,t) f3(0x14,b,t,i,0)
+#define LDD(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,3,0,t)
+#define LDDI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,3,0,t)
+#define LDDA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,4,0,t)
+#define LDDAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,4,0,t)
+#define LDHL(i,b,t) f1(0x11,b,t,i)
+#define LDH(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,1,0,t)
+#define LDHI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,1,0,t)
+#define LDIL(i,t) f7(0x8,t,i)
+#define LDO(i,b,t) f1(0xd,b,t,i)
+#define LDI(i,t) LDO(i,0,t)
+#define LDSID(s,b,t) f30(0x0,b,0,s,0,0x85,t)
+#define LDWL(i,b,t) f1(0x12,b,t,i)
+#define LDWL_MB(i,b,t) f1(0x13,b,t,i) /* pre-dec or post-inc */
+#define LDWL_MA(i,b,t) f2(0x17,b,t,i,2)/* post-dec or pre-inc */
+#define LDW(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,2,0,t)
+#define LDWI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,2,0,t)
+#define LDWA(x,b,t) f4(0x3,b,x,0,0,0,LD_CC_H_NONE,6,0,t)
+#define LDWAI(i,b,t) f5(0x3,b,i,0,0,1,LD_CC_H_NONE,6,0,t)
+#define LPA(x,s,b,t) f24(0x1,b,x,s,0x4d,0,t)
+#define MFSP(s,t) f29(0x0,0,0,s,0x25,t)
+#define MIXH_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,1,0,0,t)
+#define MIXH_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,1,0,0,t)
+#define MIXW_L(r1,r2,t) f10(0x3e,r2,r1,1,0,0,0,0,0,t)
+#define MIXW_R(r1,r2,t) f10(0x3e,r2,r1,1,2,0,0,0,0,t)
+#define MOVB_(c,r1,r2,i) f17(0x32,r2,r1,c,i,0)
+#define MOVB(r1,r2,i) MOVB_(SED_C_NEVER,r1,r2,i)
+#define MOVB_EQ(r1,r2,i) MOVB_(SED_C_EQ,r1,r2,i)
+#define MOVB_LT(r1,r2,i) MOVB_(SED_C_LT,r1,r2,i)
+#define MOVB_OD(r1,r2,i) MOVB_(SED_C_OD,r1,r2,i)
+#define MOVB_TR(r1,r2,i) MOVB_(SED_C_TR,r1,r2,i)
+#define MOVB_NE(r1,r2,i) MOVB_(SED_C_NE,r1,r2,i)
+#define MOVB_GE(r1,r2,i) MOVB_(SED_C_GE,r1,r2,i)
+#define MOVB_EV(r1,r2,i) MOVB_(SED_C_EV,r1,r2,i)
+#define MOVIB_(c,r,i,t) f17x(0x33,r,i,c,t,0)
+#define MOVIB(i,r,t) MOVIB_(SED_C_NEVER,i,r,t)
+#define MOVIB_EQ(i,r,t) MOVIB_(SED_C_EQ,i,r,t)
+#define MOVIB_LT(i,r,t) MOVIB_(SED_C_LT,i,r,t)
+#define MOVIB_OD(i,r,t) MOVIB_(SED_C_OD,i,r,t)
+#define MOVIB_TR(i,r,t) MOVIB_(SED_C_TR,i,r,t)
+#define MOVIB_NE(i,r,t) MOVIB_(SED_C_NE,i,r,t)
+#define MOVIB_GE(i,r,t) MOVIB_(SED_C_GE,i,r,t)
+#define MOVIB_EV(i,r,t) MOVIB_(SED_C_EV,i,r,t)
+#define MTCTL(r,t) f31(0x0,t,r,0,0xc2,0)
+#define MTSAR(r) MTCTL(r,_CR11_REGNO)
+#define MTSARCM(r) f31(0x0,0xb,r,0,0xc6,0)
+#define MTSM(r) f33(0x0,0,r,0,0xc3,0)
+#define MTSP(r,s) f29(0x0,0,r,s,0xc1,0)
+#define OR_(c,r1,r2,t) f8(0x2,r2,r1,c,0,1,0,1,0,t)
+#define OR(r1,r2,t) OR_(LOG_CC_NV,r1,r2,t)
+#define NOP() OR(_R0_REGNO,_R0_REGNO,_R0_REGNO)
+#define COPY(r,t) OR(r,0,t)
+#define PDC(x,s,b) f24(0x1,b,x,s,0x4e,0,0)
+#define PDTLB(x,s,b) f24(0x1,b,x,s,0x48,0,0)
+#define PDTLB_L(x,s,b) f24(0x1,b,x,s,0x58,0,0)
+#define PDTLBE(x,s,b) f24(0x1,b,x,s,0x49,0,0)
+#define PERMH(c,r,t)
f10(0x3e,r,r,0,(c)&3,0,((c)>>2)&3,(((c)>>2)&6)|(((c)>>6)&3),0,t)
+#define PITBL(x,s,b) f26(0x1,b,x,s,0x08,0,0)
+#define PITBL_L(x,s,b) f26(0x1,b,x,s,0x18,0,0)
+#define PITBLE(x,s,b) f26(0x1,b,x,s,0x09,0,0)
+#define POPBTS(i) f23(0x3a,0,0,2,0,i,1,0,1)
+#define PROBE_R(s,b,r,t) f24(0x1,b,r,s,0x46,0,t)
+#define PROBE_W(s,b,r,t) f24(0x1,b,r,s,0x47,0,t)
+#define PROBEI_R(s,b,i,t) f24(0x1,b,i,s,0x46,0,t)
+#define PROBEI_W(s,b,i,t) f24(0x1,b,i,s,0x47,0,t)
+#define PUSHBTS(r) f23(0x3a,0,r,2,0,0,0,0,1)
+#define PUSHNOM() f23(0x3a,0,0,2,0,0,0,0,1)
+#define RFI() f33(0x0,0,0,0,0x60,0)
+#define RFI_R() f33(0x0,0,0,0,0x65,0)
+#define RSM(i,t) f33(0x0,((i)&0x3e0)>>5,(i)&0x1f,0,0x73,t)
+#define SHLADD_(e,cf,r1,sa,r2,t) f8(0x2,r2,r1,cf,e,1,0,sa,0,t)
+#define SHLADD(r1,sa,r2,t) SHLADD_(1,ADD_CF_NV,r1,sa,r2,t)
+#define SHLADD_L(r1,sa,r2,t) SHLADD_(2,ADD_CF_NV,r1,sa,r2,t)
+#define SHLADD_TSV(r1,sa,r2,t) SHLADD_(3,ADD_CF_NV,r1,sa,r2,t)
+#define SHRPD(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,1,0,t)
+#define SHRPDI(r1,r2,sa,t)
f14(0x34,r2,r1,SED_C_NEVER,0,(63-(sa))>>5,1,(63-(sa))&0x1f,t)
+#define SHRPW(r1,r2,t) f11(0x34,r2,r1,SED_C_NEVER,0,0,0,0,t)
+#define SHRPWI(r1,r2,sa,t) f14(0x34,r2,r1,SED_C_NEVER,0,1,0,31-(sa),t)
+#define SPOP0(sf,so) f34(0x4,(so)>>5,0,sf,0,(so)&0x1f)
+#define SPOP1(sf,so,t) f35(0x4,so,1,sf,0,t)
+#define SPOP2(sf,so,r) f36(0x4,r,(so)>>5,2,sf,0,(so)&0x1f)
+#define SPOP3(sf,so,r1,r2) f37(0x4,r2,r1,(so)>>5,3,sf,0,(so)&0x1f)
+#define SSM(i,t) f33(0x00,(i)>>5,(i)&0x1f,0,0x6b,t)
+#define STBL(r,i,b) f1(0x18,b,r,i)
+#define STBI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x8,0,i)
+#define STDL(r,i,b) f3(0x1c,b,r,i,0)
+#define STDI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xc,0,i)
+#define STDA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xf,0,i)
+#define STHL(r,i,b) f1(0x19,b,r,i)
+#define STHI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x9,0,i)
+#define STWL(r,i,b) f1(0x1a,b,r,i)
+#define STWL_MA(r,i,b) f1(0x1b,b,r,i) /* pre-dec or post-inc */
+#define STWL_MB(r,i,b) f2(0x1f,b,r,i,2)/* post-dec or pre-inc */
+#define STWI(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xa,0,i)
+#define STWA(r,i,b) f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xe,0,i)
+#define SUB_(e1,e2,cf,r1,r2,t) f8(0x2,r2,r1,cf,e1,0,e2,0,0,t)
+#define SUB(r1,r2,t) SUB_(1,0,CS_CC_NV,r1,r2,t)
+#define SUB_B(r1,r2,t) SUB_(1,1,CS_CC_NV,r1,r2,t)
+#define SUB_SV(r1,r2,t) SUB_(1,0,CS_CC_SV,r1,r2,t)
+#define SUB_NSV(r1,r2,t) SUB_(1,0,CS_CC_NSV,r1,r2,t)
+/* actually, rsbi */
+#define SUBI_(e1,cf,i,r,t) f9(0x25,r,t,cf,e1,i)
+#define SUBI(i,r,t) SUBI_(0,ADD_CF_NV,i,r,t)
+#define SYNC() f33(0x0,0,0,0,0x20,0)
+#define SYNCDMA() f33(0x0,0,1<<4,0,0x20,0)
+#define UADDCM(r1,r2,t) f8(0x2,r2,r1,ADD_CF_NV,2,0,1,2,0,t)
+#define UXOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,1,2,0,t)
+#define XOR(r1,r2,t) f8(0x2,r2,r1,LOG_CC_NV,0,1,0,2,0,t)
+#define movr(r0,r1) _movr(_jit,r0,r1)
+static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+#define movi(r0,i0) _movi(_jit,r0,i0)
+static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+#define movi_p(r0,i0) _movi_p(_jit,r0,i0)
+static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+#define comr(r0,r1) UADDCM(_R0_REGNO,r1,r0)
+#define negr(r0,r1) SUB(_R0_REGNO,r1,r0)
+#define extr_c(r0,r1) EXTRWR(r1,31,8,r0)
+#define extr_uc(r0,r1) EXTRWR_U(r1,31,8,r0)
+#define extr_s(r0,r1) EXTRWR(r1,31,16,r0)
+#define extr_us(r0,r1) EXTRWR_U(r1,31,16,r0)
+#if __BYTE_ORDER == __BIG_ENDIAN
+# define htonr(r0,r1) movr(r0,r1)
+#else
+# error need htonr implementation
+#endif
+#define addr(r0,r1,r2) ADD(r1,r2,r0)
+#define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
+static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define addcr(r0,r1,r2) addr(r0,r1,r2)
+#define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
+static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define addxr(r0,r1,r2) ADD_C(r1,r2,r0)
+#define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
+static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define subr(r0,r1,r2) SUB(r1,r2,r0)
+#define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
+static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define subcr(r0,r1,r2) subr(r0,r1,r2)
+#define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
+static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define subxr(r0,r1,r2) SUB_B(r1,r2,r0)
+#define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
+static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
+static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
+static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static long long __llmul(int, int);
+#define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
+static void _qmulr(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
+static void _qmuli(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+#define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
+static void _qmulr_u(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
+static void _qmuli_u(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+static int __idiv(int, int);
+#define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
+static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
+static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static unsigned int __udiv(unsigned int, unsigned int);
+#define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
+static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
+static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static int __irem(int, int);
+#define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
+static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
+static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static unsigned int __urem(unsigned int, unsigned int);
+#define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
+static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
+static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static idiv_t __idivrem(int, int);
+#define qdivr(r0,r1,r2,r3) _qdivr(_jit,r0,r1,r2,r3)
+static void _qdivr(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
+static void _qdivi(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+static udiv_t __udivrem(unsigned int, unsigned int);
+#define qdivr_u(r0,r1,r2,r3) _qdivr_u(_jit,r0,r1,r2,r3)
+static void _qdivr_u(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
+static void _qdivi_u(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+#define andr(r0,r1,r2) AND(r1,r2,r0)
+#define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
+static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define orr(r0,r1,r2) OR(r1,r2,r0)
+#define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
+static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define xorr(r0,r1,r2) XOR(r1,r2,r0)
+#define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
+static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define lshr(r0,r1,r2) _lshr(_jit,r0,r1,r2)
+static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define lshi(r0,r1,i0) SHLWI(r1,i0,r0)
+#define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2)
+static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define rshi(r0,r1,i0) SHRWI(r1,i0,r0)
+#define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2)
+static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define rshi_u(r0,r1,i0) SHRWI_U(r1,i0,r0)
+#define cmpr(c,r0,r1,r2) _cmpr(_jit,c,r0,r1,r2)
+static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define cmpi(c,ci,r0,r1,i0) _cmpi(_jit,c,ci,r0,r1,i0)
+static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
+ jit_int32_t,jit_int32_t,jit_word_t);
+#define ltr(r0,r1,r2) cmpr(CS_CC_GE,r0,r1,r2)
+#define lti(r0,r1,i0) cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0)
+#define ltr_u(r0,r1,r2) cmpr(CS_CC_UGE,r0,r1,r2)
+#define lti_u(r0,r1,i0) cmpi(CS_CC_UGE,CS_CC_ULE,r0,r1,i0)
+#define ler(r0,r1,r2) cmpr(CS_CC_GT,r0,r1,r2)
+#define lei(r0,r1,i0) cmpi(CS_CC_GT,CS_CC_LT,r0,r1,i0)
+#define ler_u(r0,r1,r2) cmpr(CS_CC_UGT,r0,r1,r2)
+#define lei_u(r0,r1,i0) cmpi(CS_CC_UGT,CS_CC_ULT,r0,r1,i0)
+#define eqr(r0,r1,r2) cmpr(CS_CC_NE,r0,r1,r2)
+#define eqi(r0,r1,i0) cmpi(CS_CC_NE,CS_CC_NE,r0,r1,i0)
+#define ger(r0,r1,r2) cmpr(CS_CC_LT,r0,r1,r2)
+#define gei(r0,r1,i0) cmpi(CS_CC_LT,CS_CC_GT,r0,r1,i0)
+#define ger_u(r0,r1,r2) cmpr(CS_CC_ULT,r0,r1,r2)
+#define gei_u(r0,r1,i0) cmpi(CS_CC_ULT,CS_CC_UGT,r0,r1,i0)
+#define gtr(r0,r1,r2) cmpr(CS_CC_LE,r0,r1,r2)
+#define gti(r0,r1,i0) cmpi(CS_CC_LE,CS_CC_GE,r0,r1,i0)
+#define gtr_u(r0,r1,r2) cmpr(CS_CC_ULE,r0,r1,r2)
+#define gti_u(r0,r1,i0) cmpi(CS_CC_ULE,CS_CC_UGE,r0,r1,i0)
+#define ner(r0,r1,r2) cmpr(CS_CC_EQ,r0,r1,r2)
+#define nei(r0,r1,i0) cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0)
+#define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
+static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+#define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
+static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
+static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
+static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define ldr_uc(r0,r1) LDBI(_R0_REGNO,r1,r0)
+#define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
+static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_uc(r0,r1,r2) LDB(r2,r1,r0)
+#define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
+static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define ldr_s(r0,r1) _ldr_s(_jit,r0,r1)
+static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+#define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
+static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
+static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
+static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define ldr_us(r0,r1) LDHI(_R0_REGNO,r1,r0)
+#define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
+static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_us(r0,r1,r2) LDH(r2,r1,r0)
+#define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
+static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define ldr_i(r0,r1) ldr_ui(r0,r1)
+#define ldr_ui(r0,r1) LDWI(_R0_REGNO,r1,r0)
+#define ldi_i(r0,i0) ldi_ui(r0,i0)
+#define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
+static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_i(r0,r1,r2) ldxr_ui(r0,r1,r2)
+#define ldxr_ui(r0,r1,r2) LDW(r2,r1,r0)
+#define ldxi(r0,r1,i0) ldxi_ui(r0,r1,i0)
+#define ldxi_i(r0,r1,i0) ldxi_ui(r0,r1,i0)
+#define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
+static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define str_c(r0,r1) STBI(r1,_R0_REGNO,r0)
+#define sti_c(i0,r0) _sti_c(_jit,i0,r0)
+static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+#define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
+static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
+static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define str_s(r0,r1) STHI(r1,_R0_REGNO,r0)
+#define sti_s(i0,r0) _sti_s(_jit,i0,r0)
+static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+#define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
+static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
+static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define str_i(r0,r1) STWI(r1,_R0_REGNO,r0)
+#define sti_i(i0,r0) _sti_i(_jit,i0,r0)
+static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+#define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
+static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+#define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
+#define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
+static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bcmpr(c,i0,r0,r1) _bcmpr(_jit,c,i0,r0,r1)
+static jit_word_t _bcmpr(jit_state_t*,jit_word_t,
+ jit_word_t,jit_int32_t,jit_int32_t);
+#define bcmpi(c,ci,i0,r0,i1) _bcmpi(_jit,c,ci,i0,r0,i1)
+static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t,
+ jit_word_t,jit_int32_t,jit_word_t);
+#define bltr(i0,r0,r1) bcmpr(CS_CC_LT,i0,r0,r1)
+#define blti(i0,r0,r1) bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1)
+#define bltr_u(i0,r0,r1) bcmpr(CS_CC_ULT,i0,r0,r1)
+#define blti_u(i0,r0,r1) bcmpi(CS_CC_ULT,CS_CC_UGT,i0,r0,r1)
+#define bler(i0,r0,r1) bcmpr(CS_CC_LE,i0,r0,r1)
+#define blei(i0,r0,r1) bcmpi(CS_CC_LE,CS_CC_GE,i0,r0,r1)
+#define bler_u(i0,r0,r1) bcmpr(CS_CC_ULE,i0,r0,r1)
+#define blei_u(i0,r0,r1) bcmpi(CS_CC_ULE,CS_CC_UGE,i0,r0,r1)
+#define beqr(i0,r0,r1) bcmpr(CS_CC_EQ,i0,r0,r1)
+#define beqi(i0,r0,r1) bcmpi(CS_CC_EQ,CS_CC_EQ,i0,r0,r1)
+#define bger(i0,r0,r1) bcmpr(CS_CC_GE,i0,r0,r1)
+#define bgei(i0,r0,r1) bcmpi(CS_CC_GE,CS_CC_LE,i0,r0,r1)
+#define bger_u(i0,r0,r1) bcmpr(CS_CC_UGE,i0,r0,r1)
+#define bgei_u(i0,r0,r1) bcmpi(CS_CC_UGE,CS_CC_ULE,i0,r0,r1)
+#define bgtr(i0,r0,r1) bcmpr(CS_CC_GT,i0,r0,r1)
+#define bgti(i0,r0,r1) bcmpi(CS_CC_GT,CS_CC_LT,i0,r0,r1)
+#define bgtr_u(i0,r0,r1) bcmpr(CS_CC_UGT,i0,r0,r1)
+#define bgti_u(i0,r0,r1) bcmpi(CS_CC_UGT,CS_CC_ULT,i0,r0,r1)
+#define bner(i0,r0,r1) bcmpr(CS_CC_NE,i0,r0,r1)
+#define bnei(i0,r0,r1) bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1)
+#define bmxr(c,i0,r0,r1) _bmxr(_jit,c,i0,r0,r1)
+static jit_word_t _bmxr(jit_state_t*,jit_bool_t,
+ jit_word_t,jit_int32_t,jit_int32_t);
+#define bmxi(c,i0,r0,i1) _bmxi(_jit,c,i0,r0,i1)
+static jit_word_t _bmxi(jit_state_t*,jit_bool_t,
+ jit_word_t,jit_int32_t,jit_word_t);
+#define bmcr(r0,r1,r2) bmxr(0,r0,r1,r2)
+#define bmci(r0,r1,r2) bmxi(0,r0,r1,r2)
+#define bmsr(r0,r1,r2) bmxr(1,r0,r1,r2)
+#define bmsi(r0,r1,r2) bmxi(1,r0,r1,r2)
+#define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
+static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
+static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
+static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
+static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
+static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
+static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
+static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
+static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
+static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
+static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
+static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
+static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
+static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
+static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
+static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
+static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+#define jmpr(r0) _jmpr(_jit,r0)
+static void _jmpr(jit_state_t*,jit_int32_t);
+#define jmpi(i0) _jmpi(_jit,i0)
+static void _jmpi(jit_state_t*,jit_word_t);
+#define jmpi_p(i0) _jmpi_p(_jit,i0)
+static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
+#define callr(r0) _callr(_jit,r0)
+static void _callr(jit_state_t*,jit_int32_t);
+#define calli(i0) _calli(_jit,i0)
+static void _calli(jit_state_t*,jit_word_t);
+#define calli_p(i0) _calli_p(_jit,i0)
+static jit_word_t _calli_p(jit_state_t*,jit_word_t);
+#define prolog(node) _prolog(_jit, node)
+static void _prolog(jit_state_t*, jit_node_t*);
+#define epilog(node) _epilog(_jit, node)
+static void _epilog(jit_state_t*, jit_node_t*);
+#define patch_at(i,l) _patch_at(_jit,i,l)
+static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
+#endif
+
+#if CODE
+/* from binutils bfd/libhppa.h */
+static inline int
+sign_extend (int x, int len)
+{
+ int signbit = (1 << (len - 1));
+ int mask = (signbit << 1) - 1;
+ return ((x & mask) ^ signbit) - signbit;
+}
+
+static inline int
+sign_unext (int x, int len)
+{
+ int len_ones;
+
+ len_ones = (1 << len) - 1;
+
+ return x & len_ones;
+}
+
+static inline int
+low_sign_unext (int x, int len)
+{
+ int temp;
+ int sign;
+
+ sign = (x >> (len-1)) & 1;
+
+ temp = sign_unext (x, len-1);
+
+ return (temp << 1) | sign;
+}
+
+static inline int
+re_assemble_3 (int as3)
+{
+ return (( (as3 & 4) << (13-2))
+ | ((as3 & 3) << (13+1)));
+}
+
+static inline int
+re_assemble_12 (int as12)
+{
+ return (( (as12 & 0x800) >> 11)
+ | ((as12 & 0x400) >> (10 - 2))
+ | ((as12 & 0x3ff) << (1 + 2)));
+}
+
+static inline int
+re_assemble_16 (int as16)
+{
+ int s, t;
+
+ /* Unusual 16-bit encoding, for wide mode only. */
+ t = (as16 << 1) & 0xffff;
+ s = (as16 & 0x8000);
+ return (t ^ s ^ (s >> 1)) | (s >> 15);
+}
+
+static inline int
+re_assemble_17 (int as17)
+{
+ return (( (as17 & 0x10000) >> 16)
+ | ((as17 & 0x0f800) << (16 - 11))
+ | ((as17 & 0x00400) >> (10 - 2))
+ | ((as17 & 0x003ff) << (1 + 2)));
+}
+
+static inline int
+re_assemble_21 (int as21)
+{
+ return (( (as21 & 0x100000) >> 20)
+ | ((as21 & 0x0ffe00) >> 8)
+ | ((as21 & 0x000180) << 7)
+ | ((as21 & 0x00007c) << 14)
+ | ((as21 & 0x000003) << 12));
+}
+
+static inline int
+re_assemble_22 (int as22)
+{
+ return (( (as22 & 0x200000) >> 21)
+ | ((as22 & 0x1f0000) << (21 - 16))
+ | ((as22 & 0x00f800) << (16 - 11))
+ | ((as22 & 0x000400) >> (10 - 2))
+ | ((as22 & 0x0003ff) << (1 + 2)));
+}
+
+static void
+_f1(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t t, jit_int32_t i)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(t & ~0x1f));
+ assert(i >= -8192 && i <= 8191);
+ ii((o<<26)|(b<<21)|(t<<16)|(re_assemble_16(i)));
+}
+
+static void
+_f2(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(t & ~0x1f));
+ assert(i >= -32768 && i <= 32767);
+ assert(!(j & ~0x3));
+ ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
+}
+
+static void
+_f3(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(t & ~0x1f));
+ assert(i >= -32768 && i <= 32767);
+ assert(!(j & ~0x1));
+ ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
+}
+
+static void
+_f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
+ jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
+ jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(s & ~0x3));
+ assert(!(u & ~0x1));
+ assert(!(y & ~0x1));
+ assert(!(c & ~0x3));
+ assert(!(z & ~0xf));
+ assert(!(m & ~0x1));
+ assert(!(t & ~0x1f));
+
ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(u<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
+}
+
+static void
+_f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
+ jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
+ jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(s & ~0x3));
+ assert(!(a & ~0x1));
+ assert(!(y & ~0x1));
+ assert(!(c & ~0x3));
+ assert(!(z & ~0xf));
+ assert(!(m & ~0x1));
+ assert(i >= -16 && i <= 15);
+ ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|
+ (s<<14)|(a<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
+}
+
+static void
+_f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
+ jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
+ jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(s & ~0x3));
+ assert(!(a & ~0x1));
+ assert(!(x & ~0x1));
+ assert(!(c & ~0x3));
+ assert(!(y & ~0xf));
+ assert(!(m & ~0x1));
+ assert(i >= -16 && i <= 15);
+ ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(a<<13)|
+ (x<<12)|(c<<10)|(y<<6)|(m<<5)|low_sign_unext(i,5));
+}
+
+static void
+_f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(i & 0x7ff));
+ ii((o<<26)|(r<<21)|re_assemble_21(i>>11));
+}
+
+static void
+_f8(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r2, jit_int32_t r1, jit_int32_t cf,
+ jit_int32_t e1, jit_int32_t x, jit_int32_t e2,
+ jit_int32_t e3, jit_int32_t d, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r2 & ~0x1f));
+ assert(!(r1 & ~0x1f));
+ assert(!(cf & ~0xf));
+ assert(!(e1 & ~0x3));
+ assert(!(x & ~0x1));
+ assert(!(e2 & ~0x3));
+ assert(!(e3 & ~0x3));
+ assert(!(d & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(cf<<12)|
+ (e1<<10)|(x<<9)|(e2<<8)|(e3<<6)|(d<<5)|t);
+}
+
+static void
+_f9(jit_state_t *_jit,
+ jit_int32_t o, jit_int32_t r, jit_int32_t t,
+ jit_int32_t cf, jit_int32_t e1, jit_int32_t i)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(t & ~0x1f));
+ assert(!(cf & ~0xf));
+ assert(!(e1 & ~0x1));
+ assert(i >= -2048 && i <= 2047);
+ ii((o<<26)|(r<<21)|(t<<16)|(cf<<12)|(e1<<11)|low_sign_unext(i,11));
+}
+
+static void
+_f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
+ jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
+ jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r2 & ~0x1f));
+ assert(!(r1 & ~0x1f));
+ assert(!(u & ~0x1));
+ assert(!(v & ~0x3));
+ assert(!(w & ~0x1));
+ assert(!(x & ~0x3));
+ assert(!(sa & ~0xf));
+ assert(!(y & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(u<<15)|
+ (v<<13)|(w<<12)|(x<<10)|(sa<<6)|(y<<5)|t);
+}
+
+static void
+_f11(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
+ jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r1 & ~0x1f));
+ assert(!(r2 & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(x & ~0x3));
+ assert(!(y & ~0x1));
+ assert(!(z & ~0x1));
+ assert(!(u & ~0xf));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<11)|(y<<10)|(z<<9)|(u<<5)|t);
+}
+
+static void
+_f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
+ jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
+ jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(t & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(x & ~0x3));
+ assert(!(se & ~0x1));
+ assert(!(y & ~0x1));
+ assert(!(c1 & ~0x1));
+ assert(!(z & ~0x7));
+ assert(!((32-clen) & ~0x1f));
+ ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(x<<11)|
+ (se<<10)|(y<<9)|(c1<<8)|(z<<5)|(32-clen));
+}
+
+static void
+_f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
+ jit_int32_t r, jit_int32_t c, jit_int32_t x,
+ jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(!(r & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(x & ~0x3));
+ assert(!(nz & ~0x1));
+ assert(!(c1 & ~0x1));
+ assert(!((32-clen) & ~0x1f));
+ ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
+ (x<<11)|(nz<<10)|(c1<<8)|(32-clen));
+}
+
+static void
+_f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
+ jit_int32_t i, jit_int32_t c, jit_int32_t x,
+ jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(i >= -16 && i <= 15);
+ assert(!(c & ~0x7));
+ assert(!(x & ~0x3));
+ assert(!(nz & ~0x1));
+ assert(!((32-clen) & ~0x1f));
+ ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|
+ (c<<13)|(x<<11)|(nz<<10)|(c1<<8)|(32-clen));
+}
+
+static void
+_f14(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
+ jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r1 & ~0x1f));
+ assert(!(r2 & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(x & ~0x3));
+ assert(!(cp & ~0x1));
+ assert(!(y & ~0x1));
+ assert(!(cpos & ~0x1f));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<12)|(cp<<11)|(y<<10)|(cpos<<5)|t);
+}
+
+static void
+_f15(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
+ jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(t & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(c1 & ~0x1));
+ assert(!(p & ~0x1));
+ assert(!(se & ~0x1));
+ assert(!(pos & ~0x1f));
+ assert(!((32-clen) & ~0x1f));
+ ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(c1<<12)|
+ (p<<11)|(se<<10)|(pos<<5)|(32-clen));
+}
+
+static void
+_f16(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
+ jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(!(r & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(c1 & ~0x1));
+ assert(!(cp & ~0x1));
+ assert(!(nz & ~0x1));
+ assert(!(cpos & ~0x1f));
+ assert(!((32-clen) & ~0x3f));
+ ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
+ (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
+}
+
+static void
+_f16x(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
+ jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(i >= -16 && i <= 15);
+ assert(!(c & ~0x7));
+ assert(!(c1 & ~0x1));
+ assert(!(cp & ~0x1));
+ assert(!(nz & ~0x1));
+ assert(!(cpos & ~0x1f));
+ assert(!((32-clen) & ~0x3f));
+ ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|(c<<13)|
+ (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
+}
+
+static void
+_f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
+ jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r2 & ~0x1f));
+ assert(!(r1 & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(i >= -2048 && i <= 2047);
+ assert(!(n & ~0x1));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|re_assemble_12(i)|(n<<1));
+}
+
+static void
+_f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
+ jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(i >= -16 && i <= 15);
+ assert(!(c & ~0x7));
+ assert(t >= -2048 && t <= 2047);
+ assert(!(n & ~0x1));
+ ii((o<<26)|(r<<21)|
+ (low_sign_unext(i,5)<<16)|(c<<13)|re_assemble_12(t)|(n<<1));
+}
+
+static void
+_f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
+ jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(p & ~0x1f));
+ assert(!(r & ~0x1f));
+ assert(!(c & ~0x1));
+ assert(i >= -2048 && i <= 2047);
+ assert(!(n & ~0x1));
+ ii((o<<26)|(p<<21)|(r<<16)|(c<<15)|(1<<14)|re_assemble_12(i)|(n<<1));
+}
+
+static void
+_f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
+ jit_int32_t s, jit_int32_t i, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(s & ~0x7));
+ assert(i >= -65536 && i <= 65535);
+ assert(!(n & ~0x1));
+ ii((o<<26)|(b<<21)|re_assemble_3(s)|re_assemble_17(i)|(n<<1));
+}
+
+static void
+_f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
+ jit_int32_t i, jit_int32_t g, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(i >= -32768 && i <= 32767);
+ assert(!(g & ~0x7));
+ assert(!(n & ~0x1));
+ ii((o<<26)|(t<<21)|(g<<13)|re_assemble_17(i)|(n<<1));
+}
+
+static void
+_f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
+ jit_int32_t x, jit_int32_t y, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(y & ~0x7));
+ assert(!(n & ~0x1));
+ ii((o<<26)|(t<<21)|(x<<16)|(y<<13)|(n<<1));
+}
+
+static void
+_f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
+ jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(x & ~0x7));
+ assert(!(r & ~0x3f));
+ assert(!(n & ~0x1));
+ assert(!(p & ~0x1));
+ ii((o<<26)|(b<<21)|(x<<13)|(1<<12)|(r<<2)|(n<<1)|p);
+}
+
+static void
+_f23(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
+ jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
+{
+ assert(!(o & ~0x3f));
+ assert(!(a & ~0x1f));
+ assert(!(b & ~0x1f));
+ assert(!(c & ~0x7));
+ assert(!(d & ~0x1));
+ assert(!(e & ~0x1ff));
+ assert(!(f & ~0x1));
+ assert(!(g & ~0x1));
+ assert(!(h & ~0x1));
+ ii((o<<26)|(a<<21)|(b<<16)|(c<<13)|(d<<12)|(e<<3)|(f<<2)|(g<<1)|h);
+}
+
+static void
+_f24(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t x, jit_int32_t s,
+ jit_int32_t y, jit_int32_t m,jit_int32_t r)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(s & ~0x3));
+ assert(!(y & ~0xff));
+ assert(!(m & ~0x1));
+ assert(!(r & ~0x1f));
+ ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(y<<6)|(m<<5)|r);
+}
+
+static void
+_f25(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t i, jit_int32_t s,
+ jit_int32_t y, jit_int32_t m, jit_int32_t r)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(i >= -16 && i <= 15);
+ assert(!(s & ~0x3));
+ assert(!(y & ~0xff));
+ assert(!(m & ~0x1));
+ assert(!(r & ~0x1f));
+ ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(s<<14)|(y<<6)|(m<<5)|r);
+}
+
+static void
+_f26(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t x, jit_int32_t s,
+ jit_int32_t y, jit_int32_t m,jit_int32_t r)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(s & ~0x7));
+ assert(!(y & ~0x7f));
+ assert(!(m & ~0x1));
+ assert(!(r & ~0x1f));
+ ii((o<<26)|(b<<21)|(x<<16)|(s<<13)|(y<<6)|(m<<5)|r);
+}
+
+static void
+_f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j)
+{
+ assert(!(o & ~0x3f));
+ assert(i >= -4096 && i < 4095);
+ assert(j >= -16 && j < 15);
+ ii((o<<26)|(i<<13)|j);
+}
+
+static void
+_f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
+{
+ assert(!(o & ~0x3f));
+ assert(!(i & ~0x1ffffff));
+ ii((o<<26)|i);
+}
+
+static void
+_f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
+ jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(s & ~0x7));
+ assert(!(y & ~0xff));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r<<21)|(x<<16)|re_assemble_3(s)|(y<<5)|t);
+}
+
+static void
+_f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r,
+ jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(r & ~0x1f));
+ assert(!(s & ~0x3));
+ assert(!(x & ~0x1));
+ assert(!(y & ~0xff));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(x<<13)|(y<<5)|t);
+}
+
+static void
+_f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
+ jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
+{
+ assert(!(o & ~0x3f));
+ assert(!(t & ~0x1f));
+ assert(!(r & ~0x1f));
+ assert(!(v & ~0x1f));
+ assert(!(x & ~0xff));
+ assert(!(y & ~0x1f));
+ ii((o<<26)|(t<<21)|(r<<16)|(v<<14)|(x<<5)|y);
+}
+
+static void
+_f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
+ jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
+{
+ assert(!(o & ~0x3f));
+ assert(!(x & ~0x1f));
+ assert(!(r & ~0x1f));
+ assert(!(y & ~0x7));
+ assert(!(z & ~0xff));
+ assert(!(u & ~0x1f));
+ ii((o<<26)|(x<<21)|(r<<16)|(y<<13)|(z<<5)|u);
+}
+
+static void
+_f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
+ jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
+{
+ assert(!(o & ~0x3f));
+ assert(!(o1 & ~0x7fff));
+ assert(!(x & ~0x3));
+ assert(!(sf & ~0x7));
+ assert(!(n & ~0x1));
+ assert(!(o2 & ~0x1f));
+ ii((o<<26)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
+}
+
+static void
+_f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
+ jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(op & ~0x7fff));
+ assert(!(x & ~0x3));
+ assert(!(sf & ~0x7));
+ assert(!(n & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(op<<11)|(x<<9)|(sf<<6)|(n<<5)|t);
+}
+
+static void
+_f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1,
+ jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(o1 & ~0x3ff));
+ assert(!(x & ~0x3));
+ assert(!(sf & ~0x7));
+ assert(!(n & ~0x1));
+ assert(!(o2 & ~0x1f));
+ ii((o<<26)|(r<<21)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
+}
+
+static void
+_f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
+ jit_int32_t r1, jit_int32_t o1, jit_int32_t x,
+ jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r2 & ~0x1f));
+ assert(!(r1 & ~0x1f));
+ assert(!(o1 & ~0x1f));
+ assert(!(x & ~0x3));
+ assert(!(sf & ~0x7));
+ assert(!(n & ~0x1));
+ assert(!(o2 & ~0x1f));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
+}
+
+static void
+_f38(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t s, jit_int32_t u, jit_int32_t n)
+{
+ assert(!(o & ~0x3f));
+ assert(!(s & ~0x3fffff));
+ assert(!(u & ~0x7));
+ assert(!(n & ~0x1));
+ ii((o<<26)|((s>>5)<<9)|(u<<6)|(n<<1)|(s&0x1f));
+}
+
+static void
+_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ if (r0 != r1)
+ COPY(r1, r0);
+}
+
+static void
+_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ if (i0 >= -8192 && i0 <= 8191)
+ LDI(i0, r0);
+ else if (!(i0 & 0x7ff))
+ LDIL(i0, r0);
+ else {
+ LDIL(i0 & ~0x7ff, r0);
+ LDO(i0 & 0x7ff, r0, r0);
+ }
+}
+
+static jit_word_t
+_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_word_t w;
+ w = _jit->pc.w;
+ LDIL(i0 & ~0x7ff, r0);
+ LDO(i0 & 0x7ff, r0, r0);
+ return (w);
+}
+
+static void
+_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -2048 && i0 <= 2047)
+ ADDI(i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ addr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ addcr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ addxr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ subr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ subcr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ subxr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ jit_int32_t t0, t1;
+ t0 = jit_get_reg(jit_class_fpr);
+ t1 = jit_get_reg(jit_class_fpr);
+ stxi(alloca_offset - 8, _FP_REGNO, r1);
+ ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
+ stxi(alloca_offset - 8, _FP_REGNO, r2);
+ ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
+ XMPYU(rn(t0), rn(t1), rn(t0));
+ stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
+ ldxi(r0, _FP_REGNO, alloca_offset - 4);
+ jit_unget_reg(t1);
+ jit_unget_reg(t0);
+}
+
+static void
+_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (r0 != r1) {
+ movi(r0, i0);
+ mulr(r0, r1, r0);
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ mulr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static long long
+__llmul(int u, int v)
+{
+ return ((long long)u * (long long)v);
+}
+
+static void
+_qmulr(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+{
+ movr(_R26_REGNO, r2);
+ movr(_R25_REGNO, r3);
+ calli((jit_word_t)__llmul);
+ movr(r0, _R29_REGNO);
+ movr(r1, _R28_REGNO);
+}
+
+static void
+_qmuli(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+{
+ movr(_R26_REGNO, r2);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__llmul);
+ movr(r0, _R29_REGNO);
+ movr(r1, _R28_REGNO);
+}
+
+static void
+_qmulr_u(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+{
+ jit_int32_t t0, t1;
+ t0 = jit_get_reg(jit_class_fpr);
+ t1 = jit_get_reg(jit_class_fpr);
+ stxi(alloca_offset - 8, _FP_REGNO, r2);
+ ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
+ stxi(alloca_offset - 8, _FP_REGNO, r3);
+ ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
+ XMPYU(rn(t0), rn(t1), rn(t0));
+ stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
+ ldxi(r0, _FP_REGNO, alloca_offset - 4);
+ ldxi(r1, _FP_REGNO, alloca_offset - 8);
+ jit_unget_reg(t1);
+ jit_unget_reg(t0);
+}
+
+static void
+_qmuli_u(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ qmulr_u(r0, r1, r2, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static int
+__idiv(int u, int v)
+{
+ return (u / v);
+}
+
+static void
+_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ movr(_R26_REGNO, r1);
+ movr(_R25_REGNO, r2);
+ calli((jit_word_t)__idiv);
+ movr(r0, _R28_REGNO);
+}
+
+static void
+_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ movr(_R26_REGNO, r1);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__idiv);
+ movr(r0, _R28_REGNO);
+}
+
+static unsigned int
+__udiv(unsigned int u, unsigned int v)
+{
+ return (u / v);
+}
+
+static void
+_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ movr(_R26_REGNO, r1);
+ movr(_R25_REGNO, r2);
+ calli((jit_word_t)__udiv);
+ movr(r0, _R28_REGNO);
+}
+
+static void
+_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ movr(_R26_REGNO, r1);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__udiv);
+ movr(r0, _R28_REGNO);
+}
+
+static int
+__irem(int u, int v)
+{
+ return (u % v);
+}
+
+static void
+_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ movr(_R26_REGNO, r1);
+ movr(_R25_REGNO, r2);
+ calli((jit_word_t)__irem);
+ movr(r0, _R28_REGNO);
+}
+
+static void
+_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ movr(_R26_REGNO, r1);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__irem);
+ movr(r0, _R28_REGNO);
+}
+
+static unsigned int
+__urem(unsigned int u, unsigned int v)
+{
+ return (u % v);
+}
+
+static void
+_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ movr(_R26_REGNO, r1);
+ movr(_R25_REGNO, r2);
+ calli((jit_word_t)__urem);
+ movr(r0, _R28_REGNO);
+}
+
+static void
+_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ movr(_R26_REGNO, r1);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__urem);
+ movr(r0, _R28_REGNO);
+}
+
+static idiv_t
+__idivrem(int u, int v)
+{
+ idiv_t div;
+ div.quo = u / v;
+ div.rem = u % v;
+ return (div);
+}
+
+static void
+_qdivr(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+{
+ movr(_R26_REGNO, r2);
+ movr(_R25_REGNO, r3);
+ calli((jit_word_t)__idivrem);
+ movr(r0, _R28_REGNO);
+ movr(r1, _R29_REGNO);
+}
+
+static void
+_qdivi(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+{
+ movr(_R26_REGNO, r2);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__idivrem);
+ movr(r0, _R28_REGNO);
+ movr(r1, _R29_REGNO);
+}
+
+static udiv_t
+__udivrem(unsigned int u, unsigned int v)
+{
+ udiv_t div;
+ div.quo = u / v;
+ div.rem = u % v;
+ return (div);
+}
+
+static void
+_qdivr_u(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+{
+ movr(_R26_REGNO, r2);
+ movr(_R25_REGNO, r3);
+ calli((jit_word_t)__udivrem);
+ movr(r0, _R28_REGNO);
+ movr(r1, _R29_REGNO);
+}
+
+static void
+_qdivi_u(jit_state_t *_jit,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+{
+ movr(_R26_REGNO, r2);
+ movi(_R25_REGNO, i0);
+ calli((jit_word_t)__udivrem);
+ movr(r0, _R28_REGNO);
+ movr(r1, _R29_REGNO);
+}
+
+static void
+_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ andr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ orr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ xorr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+{
+ SUBI(0x1f, r2, _R1_REGNO);
+ MTSAR(_R1_REGNO);
+ DEPW_Z(r1, 32, r0);
+}
+
+static void
+_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+{
+ SUBI(0x1f, r2, _R1_REGNO);
+ MTSAR(_R1_REGNO);
+ EXTRW(r1, 32, r0);
+}
+
+static void
+_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+{
+ SUBI(0x1f, r2, _R1_REGNO);
+ MTSAR(_R1_REGNO);
+ EXTRW_U(r1, 32, r0);
+}
+
+static void
+_cmpr(jit_state_t *_jit, jit_word_t c,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ CMPCLR_(c, r1, r2, r0);
+ LDI(1, r0);
+}
+
+static void
+_cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ CMPICLR_(ci, i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ CMPCLR_(c, r1, rn(reg), r0);
+ jit_unget_reg(reg);
+ }
+ LDI(1, r0);
+}
+
+static void
+_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ ldr_uc(r0, r1);
+ extr_c(r0, r0);
+}
+
+static void
+_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ ldi_uc(r0, i0);
+ extr_c(r0, r0);
+}
+
+static void
+_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ ldxr_uc(r0, r1, r2);
+ extr_c(r0, r0);
+}
+
+static void
+_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ ldxi_uc(r0, r1, i0);
+ extr_c(r0, r0);
+}
+
+static void
+_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -8182 && i0 <= 8191)
+ LDBL(i0, _R0_REGNO, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ LDIL(i0 & ~0x7ff, rn(reg));
+ LDBL(sign_extend(i0, 11), rn(reg), r0);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ LDBI(i0, r1, r0);
+ else if (i0 >= -8182 && i0 <= 8191)
+ LDBL(i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_uc(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ ldr_us(r0, r1);
+ extr_s(r0, r0);
+}
+
+static void
+_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ ldi_us(r0, i0);
+ extr_s(r0, r0);
+}
+
+static void
+_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ ldxr_us(r0, r1, r2);
+ extr_s(r0, r0);
+}
+
+static void
+_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ ldxi_us(r0, r1, i0);
+ extr_s(r0, r0);
+}
+
+static void
+_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -8182 && i0 <= 8191)
+ LDHL(i0, _R0_REGNO, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ LDIL(i0 & ~0x7ff, rn(reg));
+ LDHL(sign_extend(i0, 11), rn(reg), r0);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ LDHI(i0, r1, r0);
+ else if (i0 >= -8182 && i0 <= 8191)
+ LDHL(i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_us(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -8182 && i0 <= 8191)
+ LDWL(i0, _R0_REGNO, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ LDIL(i0 & ~0x7ff, rn(reg));
+ LDWL(sign_extend(i0, 11), rn(reg), r0);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ LDWI(i0, r1, r0);
+ else if (i0 >= -8182 && i0 <= 8191)
+ LDWL(i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_ui(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ if (i0 >= -8182 && i0 <= 8191)
+ STBL(r0, i0, _R0_REGNO);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ LDIL(i0 & ~0x7ff, rn(reg));
+ STBL(r0, sign_extend(i0, 11), rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ addr(rn(reg), r0, r1);
+ str_c(rn(reg), r2);
+ jit_unget_reg(reg);
+}
+
+static void
+_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ STBI(r1, i0, r0);
+ else if (i0 >= -8182 && i0 <= 8191)
+ STBL(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ addi(rn(reg), r0, i0);
+ str_c(rn(reg), r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ if (i0 >= -8182 && i0 <= 8191)
+ STHL(r0, i0, _R0_REGNO);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ LDIL(i0 & ~0x7ff, rn(reg));
+ STHL(r0, sign_extend(i0, 11), rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ addr(rn(reg), r0, r1);
+ str_s(rn(reg), r2);
+ jit_unget_reg(reg);
+}
+
+static void
+_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ STHI(r1, i0, r0);
+ else if (i0 >= -8182 && i0 <= 8191)
+ STHL(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ addi(rn(reg), r0, i0);
+ str_s(rn(reg), r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ if (i0 >= -8182 && i0 <= 8191)
+ STWL(r0, i0, _R0_REGNO);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ LDIL(i0 & ~0x7ff, rn(reg));
+ STWL(r0, sign_extend(i0, 11), rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ addr(rn(reg), r0, r1);
+ str_i(rn(reg), r2);
+ jit_unget_reg(reg);
+}
+
+static void
+_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ STWI(r1, i0, r0);
+ else if (i0 >= -8182 && i0 <= 8191)
+ STWL(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ addi(rn(reg), r0, i0);
+ str_i(rn(reg), r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static jit_word_t
+_bcmpr(jit_state_t *_jit, jit_word_t c,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ w = _jit->pc.w;
+ CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (i1 >= -16 && i1 <= 15) {
+ w = _jit->pc.w;
+ CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = _jit->pc.w;
+ CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2);
+ jit_unget_reg(reg);
+ }
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bmxr(jit_state_t *_jit, jit_bool_t c,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ andr(rn(reg), r0, r1);
+ w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
+ jit_unget_reg(reg);
+ return (w);
+}
+
+static jit_word_t
+_bmxi(jit_state_t *_jit, jit_bool_t c,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ andr(rn(reg), r0, rn(reg));
+ w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
+ jit_unget_reg(reg);
+ return (w);
+}
+
+static jit_word_t
+_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ w = _jit->pc.w;
+ ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (i1 >= -16 && i1 <= 15) {
+ w = _jit->pc.w;
+ ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = boaddr(i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static jit_word_t
+_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ w = _jit->pc.w;
+ ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (i1 >= -16 && i1 <= 15) {
+ w = _jit->pc.w;
+ ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = boaddr_u(i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static jit_word_t
+_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ w = _jit->pc.w;
+ ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (i1 >= -16 && i1 <= 15) {
+ w = _jit->pc.w;
+ ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = bxaddr(i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static jit_word_t
+_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ w = _jit->pc.w;
+ ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (i1 >= -16 && i1 <= 15) {
+ w = _jit->pc.w;
+ ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = bxaddr_u(i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static jit_word_t
+_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ SUB_NSV(r0, r1, r0);
+ w = _jit->pc.w;
+ /* null'ed if no signed overflow */
+ B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ movi(_R1_REGNO, i1);
+ return (bosubr(i0, r0, _R1_REGNO));
+}
+
+static jit_word_t
+_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ SUB(r0, r1, r0);
+ SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
+ return (bnei(i0, _R1_REGNO, 0));
+}
+
+static jit_word_t
+_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ movi(_R1_REGNO, i1);
+ SUB(r0, _R1_REGNO, r0);
+ SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
+ return (bnei(i0, _R1_REGNO, 0));
+}
+
+static jit_word_t
+_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ SUB_SV(r0, r1, r0);
+ w = _jit->pc.w;
+ /* null'ed if signed overflow */
+ B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ movi(_R1_REGNO, i1);
+ return (bxsubr(i0, r0, _R1_REGNO));
+}
+
+static jit_word_t
+_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ SUB(r0, r1, r0);
+ SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
+ return (beqi(i0, _R1_REGNO, 0));
+}
+
+static jit_word_t
+_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ movi(_R1_REGNO, i1);
+ SUB(r0, _R1_REGNO, r0);
+ SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
+ return (beqi(i0, _R1_REGNO, 0));
+}
+
+static void
+_jmpr(jit_state_t *_jit, jit_int32_t r0)
+{
+ BV_N(_R0_REGNO, r0);
+}
+
+static void
+_jmpi(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ w = ((i0 - _jit->pc.w) >> 2) - 2;
+ if (w >= -32768 && w <= 32767)
+ B_N(w, _R0_REGNO);
+ else {
+ movi(_R1_REGNO, w);
+ BV_N(_R0_REGNO, _R1_REGNO);
+ }
+}
+
+static jit_word_t
+_jmpi_p(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ w = movi_p(_R1_REGNO, i0);
+ jmpr(_R1_REGNO);
+ return (w);
+}
+
+static void
+_callr(jit_state_t *_jit, jit_int32_t r0)
+{
+ if (r0 != _R1_REGNO)
+ COPY(r0, _R1_REGNO);
+ /* inline $$dyncall */
+ BBI_N_GE(_R1_REGNO, 30, 4); /* if (r1 & 2) {
*/
+ DEPWRI(0, 31, 2, _R1_REGNO); /* r1 &= ~2; */
+ LDWI(4, _R1_REGNO, _R19_REGNO); /* r19 = r1[1]; */
+ LDWI(0, _R1_REGNO, _R1_REGNO); /* r1 = r1[0]; */
+ /* } */
+ BVE_L(_R1_REGNO);
+ STWL(_RP_REGNO, -24, _SP_REGNO);
+}
+
+static void
+_calli(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ if (i0 & 2) {
+ i0 &= -4;
+ movi(_R1_REGNO, i0);
+ LDWI(4, _R1_REGNO, _R19_REGNO);
+ LDWI(0, _R1_REGNO, _R1_REGNO);
+ BVE_L(_R1_REGNO);
+ STWL(_RP_REGNO, -24, _SP_REGNO);
+ }
+ else {
+ w = ((i0 - _jit->pc.w) >> 2) - 2;
+ if (w >= -32768 && w <= 32767)
+ B_L_N(w);
+ else {
+ movi(_R1_REGNO, w);
+ BLR_N(_R1_REGNO, _RP_REGNO);
+ }
+ NOP();
+ }
+}
+
+static jit_word_t
+_calli_p(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ w = movi_p(_R1_REGNO, i0);
+ callr(_R1_REGNO);
+ return (w);
+}
+
+static jit_int32_t gr[] = {
+ _R4, _R5, _R6, _R7, _R8,
+ _R9, _R10, _R11, _R12, _R13,
+ _R14, _R15, _R16, _R17, _R18
+};
+
+static jit_int32_t fr[] = {
+ _F12, _F13, _F14, _F15, _F16,
+ _F17, _F18, _F19, _F20, _F21
+};
+
+static void
+_prolog(jit_state_t *_jit, jit_node_t *node)
+{
+ jit_int32_t regno;
+ jit_word_t offset;
+
+ _jitc->function->stack = ((_jitc->function->self.aoff -
+ _jitc->function->self.alen -
+ _jitc->function->self.size) + 63) & -64;
+
+ /* Save stack frame (FIXME Only required if non leaf) */
+ STWL(_RP_REGNO, -20, _SP_REGNO);
+
+ /* Create stack frame */
+ COPY(_FP_REGNO, _R1_REGNO);
+ COPY(_SP_REGNO, _FP_REGNO);
+ STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO);
+
+ /* Save any modified callee save registers */
+ offset = alloca_offset - 140;
+ for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
+ if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
+ stxi(offset, _FP_REGNO, rn(gr[regno]));
+ }
+ for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
+ if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
+ stxi_d(offset, _FP_REGNO, rn(fr[regno]));
+ }
+}
+
+static void
+_epilog(jit_state_t *_jit, jit_node_t *node)
+{
+ jit_int32_t regno;
+ jit_word_t offset;
+
+ /* Restore any modified callee save registers */
+ offset = alloca_offset - 140;
+ for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
+ if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
+ ldxi(rn(gr[regno]), _FP_REGNO, offset);
+ }
+ for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
+ if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
+ ldxi_d(rn(fr[regno]), _FP_REGNO, offset);
+ }
+
+ /* Restore stack frame (FIXME Only required if non leaf) */
+ LDWL(-20, _FP_REGNO, _RP_REGNO);
+ LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO);
+ LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO);
+ BV_N(_R0_REGNO, _RP_REGNO);
+}
+
+static void
+_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
+{
+ jit_word_t w;
+ union {
+ jit_uint32_t *i;
+ jit_word_t w;
+ } u;
+ u.w = instr;
+ switch (u.i[0] >> 26) {
+ case 0x8: /* LDIL */
+ u.i[0] &= ~0x1fffff;
+ u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11);
+ assert((u.i[1] >> 26) == 0xd); /* LDO */
+ u.i[1] &= ~0xffff;
+ u.i[1] |= re_assemble_16(label & 0x7ff);
+ break;
+ case 0x20: case 0x22: /* CMPB */
+ case 0x21: case 0x23: /* CMPIB */
+ case 0x28: case 0x2a: /* ADDB */
+ case 0x29: case 0x2b: /* ADDIB */
+ case 0x31: /* BBI */
+ w = ((label - instr) >> 2) - 2;
+ assert(w >= -2048 && w <= 2047);
+ u.i[0] &= ~0x1ffd;
+ u.i[0] |= re_assemble_12(w);
+ break;
+ case 0x3a: /* B */
+ w = ((label - instr) >> 2) - 2;
+ assert(w >= -32768 && w <= 32767);
+ u.i[0] &= ~0x1f1ffd;
+ u.i[0] |= re_assemble_17(w);
+ break;
+ default:
+ abort();
+ }
+}
+#endif
diff --git a/lib/jit_hppa-fpu.c b/lib/jit_hppa-fpu.c
new file mode 100644
index 0000000..ab81891
--- /dev/null
+++ b/lib/jit_hppa-fpu.c
@@ -0,0 +1,924 @@
+/*
+ * Copyright (C) 2013 Free Software Foundation, Inc.
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Authors:
+ * Paulo Cesar Pereira de Andrade
+ */
+
+#if PROTO
+#define f39(o,b,x,t) _f39(_jit,o,b,x,t)
+static void _f39(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f40(o,b,x,r) _f40(_jit,o,b,x,r)
+static void _f40(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f41(o,b,x,t) _f41(_jit,o,b,x,t)
+static void _f41(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f42(o,b,i,r) _f42(_jit,o,b,i,r)
+static void _f42(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f43(o,b,t,i) f1(o,b,t,i)
+#define f45(o,r,a,b,fmt,c,d,e,t) _f45(_jit,o,r,a,b,fmt,c,d,e,t)
+static void _f45(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f46(o,r,a,s,df,sf,b,c,d,t) _f46(_jit,o,r,a,s,df,sf,b,c,d,t)
+static void _f46(jit_state_t*,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f47(o,r1,r2,a,fmt,b,c,d,t) f47_48(o,r1,r2,a,fmt,b,c,d,t)
+#define f48(o,r1,r2,a,fmt,b,c,d,t) f47_48(o,r1,r2,a,fmt,b,c,d,t)
+#define f47_48(o,r1,r2,y,fmt,b,c,d,t) _f47_48(_jit,o,r1,r2,y,fmt,b,c,d,t)
+static void _f47_48(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f49(o,r,a,b,c,f,d,e,g,h,i,t) f49_52(o,r,a,b,c,f,d,e,g,h,i,t)
+#define f51(o,r1,r2,y,a,f,b,d,e,g,h,c) f49_52(o,r1,r2,y,a,f,b,d,e,g,h,c)
+#define f52(o,r1,r2,a,b,f,c,d,e,g,h,t) f49_52(o,r1,r2,a,b,f,c,d,e,g,h,t)
+#define f49_52(o,r1,r2,y,v,f,a,b,u,c,d,t)
_f49_52(_jit,o,r1,r2,y,v,f,a,b,u,c,d,t)
+static void _f49_52(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define f53(o,r1,r2,ta,ra,f,tm) _f53(_jit,o,r1,r2,ta,ra,f,tm)
+static void _f53(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define f54(o,r1,r2,a,b,f,c,d,e,g,t) _f54(_jit,o,r1,r2,a,b,f,c,d,e,g,t)
+static void _f54(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+#define FABS_(f,r,t) f49(0xe,r,0,3,0,f,0,0,0,0,0,t)
+#define FABS_S(r,t) FABS_(0,r,t)
+#define FABS_D(r,t) FABS_(1,r,t)
+#define FABS_Q(r,t) f45(0xc,r,0,3,3,0,0,0,t)
+#define FADD_(f,r1,r2,t) f52(0xe,r1,r2,0,0,f,3,0,0,0,0,t)
+#define FADD_S(r1,r2,t) FADD_(0,r1,r2,t)
+#define FADD_D(r1,r2,t) FADD_(1,r1,r2,t)
+#define FADD_Q(r1,r2,t) f48(0xc,r1,r2,0,3,3,0,0,t)
+#define FPSR_GT 1
+#define FPSR_LT 2
+#define FPSR_EQ 4
+#define FPSR_UN 8
+/*
+ Actually these are reversed, but easier for the FTEST after the FCMP
+ fcmp,dbl,false? fr4,fr12 0
+ fcmp,dbl,false fr4,fr12 1
+ fcmp,dbl,? fr4,fr12 2
+ fcmp,dbl,!<=> fr4,fr12 3 ORD
+ fcmp,dbl,= fr4,fr12 4 NE
+ fcmp,dbl,=t fr4,fr12 5
+ fcmp,dbl,?= fr4,fr12 6
+ fcmp,dbl,!<> fr4,fr12 7 LTGT
+ fcmp,dbl,!?>= fr4,fr12 8
+ fcmp,dbl,< fr4,fr12 9 UNGE
+ fcmp,dbl,?< fr4,fr12 10
+ fcmp,dbl,!>= fr4,fr12 11 GE
+ fcmp,dbl,!?> fr4,fr12 12
+ fcmp,dbl,<= fr4,fr12 13 UNGT
+ fcmp,dbl,?<= fr4,fr12 14
+ fcmp,dbl,!> fr4,fr12 15 GT
+ fcmp,dbl,!?<= fr4,fr12 16
+ fcmp,dbl,> fr4,fr12 17 UNLE
+ fcmp,dbl,?> fr4,fr12 18
+ fcmp,dbl,!<= fr4,fr12 19 LE
+ fcmp,dbl,!?< fr4,fr12 20
+ fcmp,dbl,>= fr4,fr12 21 UNLT
+ fcmp,dbl,?>= fr4,fr12 22
+ fcmp,dbl,!< fr4,fr12 23 LT
+ fcmp,dbl,!?= fr4,fr12 24
+ fcmp,dbl,<> fr4,fr12 25 UNEQ
+ fcmp,dbl,!= fr4,fr12 26 EQ
+ fcmp,dbl,!=t fr4,fr12 27
+ fcmp,dbl,!? fr4,fr12 28
+ fcmp,dbl,<=> fr4,fr12 29 UNORD
+ fcmp,dbl,true? fr4,fr12 30
+ fcmp,dbl,true fr4,fr12 31
+ */
+#define FCMP_LT 23
+#define FCMP_LE 19
+#define FCMP_EQ 26
+#define FCMP_GE 11
+#define FCMP_GT 15
+#define FCMP_NE 4
+#define FCMP_UNLT 21
+#define FCMP_UNLE 17
+#define FCMP_UNEQ 25
+#define FCMP_UNGE 9
+#define FCMP_UNGT 13
+#define FCMP_LTGT 7
+#define FCMP_ORD 3
+#define FCMP_UNORD 29
+#define FCMP_(f,r1,r2,c) f51(0xe,r1,r2,0,0,f,2,0,0,0,0,c)
+#define FCMP_S_(r1,r2,c) FCMP_(0,r1,r2,c)
+#define FCMP_D_(r1,r2,c) FCMP_(1,r1,r2,c)
+#define FCMP_Q_(r1,r2,c) f47(0xc,r1,r2,0,3,2,0,0,c)
+#define FCMP_S_LT(r1,r2) FCMP_S_(r1,r2,FCMP_LT)
+#define FCMP_D_LT(r1,r2) FCMP_D_(r1,r2,FCMP_LT)
+#define FCMP_Q_LT(r1,r2) FCMP_Q_(r1,r2,FCMP_LT)
+#define FCMP_S_LE(r1,r2) FCMP_S_(r1,r2,FCMP_LE)
+#define FCMP_D_LE(r1,r2) FCMP_D_(r1,r2,FCMP_LE)
+#define FCMP_Q_LE(r1,r2) FCMP_Q_(r1,r2,FCMP_LE)
+#define FCMP_S_EQ(r1,r2) FCMP_S_(r1,r2,FCMP_EQ)
+#define FCMP_D_EQ(r1,r2) FCMP_D_(r1,r2,FCMP_EQ)
+#define FCMP_Q_EQ(r1,r2) FCMP_Q_(r1,r2,FCMP_EQ)
+#define FCMP_S_GE(r1,r2) FCMP_S_(r1,r2,FCMP_GE)
+#define FCMP_D_GE(r1,r2) FCMP_D_(r1,r2,FCMP_GE)
+#define FCMP_Q_GE(r1,r2) FCMP_Q_(r1,r2,FCMP_GE)
+#define FCMP_S_GT(r1,r2) FCMP_S_(r1,r2,FCMP_GT)
+#define FCMP_D_GT(r1,r2) FCMP_D_(r1,r2,FCMP_GT)
+#define FCMP_Q_GT(r1,r2) FCMP_Q_(r1,r2,FCMP_GT)
+#define FCMP_S_NE(r1,r2) FCMP_S_(r1,r2,FCMP_NE)
+#define FCMP_D_NE(r1,r2) FCMP_D_(r1,r2,FCMP_NE)
+#define FCMP_Q_NE(r1,r2) FCMP_Q_(r1,r2,FCMP_NE)
+#define FCMP_S_UNLT(r1,r2) FCMP_S_(r1,r2,FCMP_UNLT)
+#define FCMP_D_UNLT(r1,r2) FCMP_D_(r1,r2,FCMP_UNLT)
+#define FCMP_Q_UNLT(r1,r2) FCMP_Q_(r1,r2,FCMP_UNLT)
+#define FCMP_S_UNLE(r1,r2) FCMP_S_(r1,r2,FCMP_UNLE)
+#define FCMP_D_UNLE(r1,r2) FCMP_D_(r1,r2,FCMP_UNLE)
+#define FCMP_Q_UNLE(r1,r2) FCMP_Q_(r1,r2,FCMP_UNLE)
+#define FCMP_S_UNEQ(r1,r2) FCMP_S_(r1,r2,FCMP_UNEQ)
+#define FCMP_D_UNEQ(r1,r2) FCMP_D_(r1,r2,FCMP_UNEQ)
+#define FCMP_Q_UNEQ(r1,r2) FCMP_Q_(r1,r2,FCMP_UNEQ)
+#define FCMP_S_UNGE(r1,r2) FCMP_S_(r1,r2,FCMP_UNGE)
+#define FCMP_D_UNGE(r1,r2) FCMP_D_(r1,r2,FCMP_UNGE)
+#define FCMP_Q_UNGE(r1,r2) FCMP_Q_(r1,r2,FCMP_UNGE)
+#define FCMP_S_UNGT(r1,r2) FCMP_S_(r1,r2,FCMP_UNGT)
+#define FCMP_D_UNGT(r1,r2) FCMP_D_(r1,r2,FCMP_UNGT)
+#define FCMP_Q_UNGT(r1,r2) FCMP_Q_(r1,r2,FCMP_UNGT)
+#define FCMP_S_LTGT(r1,r2) FCMP_S_(r1,r2,FCMP_LTGT)
+#define FCMP_D_LTGT(r1,r2) FCMP_D_(r1,r2,FCMP_LTGT)
+#define FCMP_Q_LTGT(r1,r2) FCMP_Q_(r1,r2,FCMP_LTGT)
+#define FCMP_S_ORD(r1,r2) FCMP_S_(r1,r2,FCMP_ORD)
+#define FCMP_D_ORD(r1,r2) FCMP_D_(r1,r2,FCMP_ORD)
+#define FCMP_Q_ORD(r1,r2) FCMP_Q_(r1,r2,FCMP_ORD)
+#define FCMP_S_UNORD(r1,r2) FCMP_S_(r1,r2,FCMP_UNORD)
+#define FCMP_D_UNORD(r1,r2) FCMP_D_(r1,r2,FCMP_UNORD)
+#define FCMP_Q_UNORD(r1,r2) FCMP_Q_(r1,r2,FCMP_UNORD)
+#define XFNVFF(s,d,r,t) f46(0xc,r,0,0,d,s,1,0,0,t)
+#define FCNVFF_Q_S(r,t) XFNVFF(3,0,r,t)
+#define FCNVFF_Q_D(r,t) XFNVFF(3,1,r,t)
+#define FCNVFF_S_Q(r,t) XFNVFF(0,3,r,t)
+#define FCNVFF_D_Q(r,t) XFNVFF(1,3,r,t)
+#define FCNVFF_(s,d,r,t) f46(0xc,r,0,0,d,s,1,0,0,t)
+#define FCNVFF_S_D(r,t) FCNVFF_(0,1,r,t)
+#define FCNVFF_D_S(r,t) FCNVFF_(1,0,r,t)
+#define FCNVXF_(s,d,r,t) f46(0xc,r,0,1,d,s,1,0,0,t)
+#define FCNVXF_S_S(r,t) FCNVXF_(0,0,r,t)
+#define FCNVXF_S_D(r,t) FCNVXF_(0,1,r,t)
+#define FCNVXT_(s,d,r,t) f46(0xc,r,0,3,d,s,1,0,0,t)
+#define FCNVXT_S_S(r,t) FCNVXT_(0,0,r,t)
+#define FCNVXT_D_S(r,t) FCNVXT_(1,0,r,t)
+#define FCPY_(f,r,t) f49(0xe,r,0,2,0,f,0,0,0,0,0,t)
+#define FCPY_S(r,t) FCPY_(0,r,t)
+#define FCPY_D(r,t) FCPY_(1,r,t)
+#define FCPY_Q(r,t) f45(0xc,r,0,2,2,0,0,0,t)
+#define FDIV_(f,r1,r2,t) f52(0xe,r1,r2,3,0,f,3,0,0,0,0,t)
+#define FDIV_S(r1,r2,t) FDIV_(0,r1,r2,t)
+#define FDIV_D(r1,r2,t) FDIV_(1,r1,r2,t)
+#define FDIV_Q(r1,r2,t) f48(0xc,r1,r2,3,3,3,0,0,t)
+#define FID() f45(0xc,0,0,0,2,0,0,0,0)
+#define FLDDL(i,b,t) f3(0x14,b,t,i,1)
+#define FLDD(x,b,t) f39(0xb,b,x,t)
+#define FLDDI(i,b,t) f41(0xb,b,i,t)
+#define FLDWL(i,b,t) f43(0x17,b,t,i)
+#define FLDW(x,b,t) f39(0x9,b,x,t)
+#define FLDWI(i,b,t) f41(0x9,b,i,t)
+#define FMPY_(f,r1,r2,t) f52(0xe,r1,r2,2,0,f,3,0,0,0,0,t)
+#define FMPY_S(r1,r2,t) FMPY_(0,r1,r2,t)
+#define FMPY_D(r1,r2,t) FMPY_(1,r1,r2,t)
+#define FMPY_Q(r1,r2,t) f48(0xc,r1,r2,2,3,3,0,0,t)
+/* FIXME not disassembled */
+#define FMPYADD_(f,r1,r2,ta,ra,tm) f53(0x6,r1,r2,ta,ra,f,tm)
+#define FMPYADD_S(r1,r2,ta,ra,tm) FMPYADD_(0,r1,r2,ta,ra,tm)
+#define FMPYADD_D(r1,r2,ta,ra,tm) FMPYADD_(1,r1,r2,ta,ra,tm)
+#define FMPYFADD_(f,r1,r2,ra,t)
f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,0,t)
+#define FMPYFADD_S(r1,r2,ra,t) FMPYFADD_(0,r1,r2,ra,t)
+#define FMPYFADD_D(r1,r2,ra,t) FMPYFADD_(1,r1,r2,ra,t)
+#define FMPYNFADD_(f,r1,r2,ra,t) f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,1,t)
+#define FMPYNFADD_S(r1,r2,ra,t) FMPYNFADD_(0,r1,r2,ra,t)
+#define FMPYNFADD_D(r1,r2,ra,t) FMPYNFADD_(1,r1,r2,ra,t)
+#define FMPYSUB_(f,r1,r2,ta,ra,tm) f53(0x26,r1,r2,ta,ra,f,tm)
+#define FMPYSUB_S(r1,r2,ta,ra,tm) FMPYSUB_(0,r1,r2,ta,ra,tm)
+#define FMPYSUB_D(r1,r2,ta,ra,tm) FMPYSUB_(1,r1,r2,ta,ra,tm)
+#define FNEG_(f,r,t) f49(0xe,r,0,6,0,f,0,0,0,0,0,t)
+#define FNEG_S(r,t) FNEG_(0,r,t)
+#define FNEG_D(r,t) FNEG_(1,r,t)
+/* FIXME not disassembled */
+#define FNEG_Q(r,t) f45(0xc,r,0,6,3,0,0,0,t)
+#define FNEGABS_(f,r,t) f49(0xe,r,0,7,0,f,0,0,0,0,0,t)
+#define FNEGABS_S(r,t) FNEGABS_(0,r,t)
+#define FNEGABS_D(r,t) FNEGABS_(1,r,t)
+#define FNEGABS_Q(r,t) f45(0xc,r,0,7,3,0,0,0,t)
+#define FRND_(f,r,t) f49(0xe,r,0,5,0,f,0,0,0,0,0,t)
+#define FRND_S(r,t) FRND_(0,r,t)
+#define FRND_D(r,t) FRND_(1,r,t)
+#define FRND_Q(r,t) f45(0xc,r,0,5,3,0,0,0,t)
+#define FSQRT_(f,r,t) f49(0xe,r,0,4,0,f,0,0,0,0,0,t)
+#define FSQRT_S(r,t) FSQRT_(0,r,t)
+#define FSQRT_D(r,t) FSQRT_(1,r,t)
+#define FSQRT_Q(r,t) f45(0xc,r,0,4,3,0,0,0,t)
+#define FSTDL(r,i,b) f3(0x1c,b,r,i,1)
+#define FSTD(r,x,b) f40(0xb,b,x,r)
+#define FSTDI(r,i,b) f42(0xb,b,i,r)
+#define FSTWL(r,i,b) f43(0x1f,b,r,i)
+#define FSTW(r,x,b) f40(0x9,b,x,r)
+#define FSTWI(r,i,b) f42(0x9,b,i,r)
+#define FSUB_(f,r1,r2,t) f52(0xe,r1,r2,1,0,f,3,0,0,0,0,t)
+#define FSUB_S(r1,r2,t) FSUB_(0,r1,r2,t)
+#define FSUB_D(r1,r2,t) FSUB_(1,r1,r2,t)
+#define FSUB_Q(r1,r2,t) f48(0xc,r1,r2,1,3,3,0,0,t)
+#define FTEST_(c) f47(0xc,0,0,0,0,2,0,1,c)
+#define FTEST() f47(0xc,0,0,1,0,2,0,1,0)
+#define FTEST_LT() FTEST_(FCMP_LT)
+#define FTEST_LE() FTEST_(FCMP_LE)
+#define FTEST_EQ() FTEST_(FCMP_EQ)
+#define FTEST_GE() FTEST_(FCMP_GE)
+#define FTEST_GT() FTEST_(FCMP_GT)
+#define FTEST_NE() FTEST_(FCMP_NE)
+#define FTEST_UNLT() FTEST_(FCMP_UNLT)
+#define FTEST_UNLE() FTEST_(FCMP_UNLE)
+#define FTEST_UNEQ() FTEST_(FCMP_UNEQ)
+#define FTEST_UNGE() FTEST_(FCMP_UNGE)
+#define FTEST_UNGT() FTEST_(FCMP_UNGT)
+#define FTEST_LTGT() FTEST_(FCMP_LTGT)
+#define FTEST_ORD() FTEST_(FCMP_ORD)
+#define FTEST_UNORD() FTEST_(FCMP_UNORD)
+#define XMPYU(r1,r2,t) f52(0xe,r1,r2,2,0,0,3,1,0,0,0,t)
+#define XMPYU_L_R(r1,r2,t) f52(0xe,r1,r2,2,1,0,3,1,0,0,0,t)
+#define XMPYU_R_L(r1,r2,t) f52(0xe,r1,r2,2,0,0,3,1,1,0,0,t)
+#define XMPYU_R_R(r1,r2,t) f52(0xe,r1,r2,2,1,0,3,1,1,0,0,t)
+#define negr_f(r0,r1) FNEG_S(r1,r0)
+#define negr_d(r0,r1) FNEG_D(r1,r0)
+#define sqrtr_f(r0,r1) FSQRT_S(r1,r0)
+#define sqrtr_d(r0,r1) FSQRT_D(r1,r0)
+#define extr_f(r0,r1) _extr_f(_jit,r0,r1)
+static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+#define extr_d(r0,r1) _extr_d(_jit,r0,r1)
+static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+#define extr_f_d(r0,r1) FCNVFF_S_D(r1,r0)
+#define extr_d_f(r0,r1) FCNVFF_D_S(r1,r0)
+#define truncr_f(r0,r1) truncr_f_i(r0,r1)
+#define truncr_f_i(r0,r1) _truncr_f_i(_jit,r0,r1)
+static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
+#define truncr_d(r0,r1) truncr_d_i(r0,r1)
+#define truncr_d_i(r0,r1) _truncr_d_i(_jit,r0,r1)
+static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+#define movr_f(r0,r1) FCPY_S(r1,r0)
+#define movi_f(r0,i0) _movi_f(_jit,r0,i0)
+static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
+#define movr_d(r0,r1) FCPY_D(r1,r0)
+#define movi_d(r0,i0) _movi_d(_jit,r0,i0)
+static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
+#define absr_f(r0,r1) FABS_S(r1,r0)
+#define absr_d(r0,r1) FABS_D(r1,r0)
+#define addr_f(r0,r1,r2) FADD_S(r1,r2,r0)
+#define addi_f(r0,r1,i0) _addi_f(_jit,r0,r1,i0)
+static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+#define addr_d(r0,r1,r2) FADD_D(r1,r2,r0)
+#define addi_d(r0,r1,i0) _addi_d(_jit,r0,r1,i0)
+static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+#define subr_f(r0,r1,r2) FSUB_S(r1,r2,r0)
+#define subi_f(r0,r1,i0) _subi_f(_jit,r0,r1,i0)
+static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+#define subr_d(r0,r1,r2) FSUB_D(r1,r2,r0)
+#define subi_d(r0,r1,i0) _subi_d(_jit,r0,r1,i0)
+static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+#define mulr_f(r0,r1,r2) FMPY_S(r1,r2,r0)
+#define muli_f(r0,r1,i0) _muli_f(_jit,r0,r1,i0)
+static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+#define mulr_d(r0,r1,r2) FMPY_D(r1,r2,r0)
+#define muli_d(r0,r1,i0) _muli_d(_jit,r0,r1,i0)
+static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+#define divr_f(r0,r1,r2) FDIV_S(r1,r2,r0)
+#define divi_f(r0,r1,i0) _divi_f(_jit,r0,r1,i0)
+static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+#define divr_d(r0,r1,r2) FDIV_D(r1,r2,r0)
+#define divi_d(r0,r1,i0) _divi_d(_jit,r0,r1,i0)
+static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+#define cmpr_f(c,r0,r1,r2) _cmpr_f(_jit,c,r0,r1,r2)
+static void _cmpr_f(jit_state_t*,jit_word_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define cmpi_f(c,r0,r1,i0) _cmpi_f(_jit,c,r0,r1,i0)
+static void _cmpi_f(jit_state_t*,jit_word_t,
+ jit_int32_t,jit_int32_t,jit_float32_t*);
+#define cmpr_d(c,r0,r1,r2) _cmpr_d(_jit,c,r0,r1,r2)
+static void _cmpr_d(jit_state_t*,jit_word_t,
+ jit_int32_t,jit_int32_t,jit_int32_t);
+#define cmpi_d(c,r0,r1,i0) _cmpi_d(_jit,c,r0,r1,i0)
+static void _cmpi_d(jit_state_t*,jit_word_t,
+ jit_int32_t,jit_int32_t,jit_float64_t*);
+#define ltr_f(r0,r1,r2) cmpr_f(FCMP_LT,r0,r1,r2)
+#define lti_f(r0,r1,i0) cmpi_f(FCMP_LT,r0,r1,i0)
+#define ltr_d(r0,r1,r2) cmpr_d(FCMP_LT,r0,r1,r2)
+#define lti_d(r0,r1,i0) cmpi_d(FCMP_LT,r0,r1,i0)
+#define ler_f(r0,r1,r2) cmpr_f(FCMP_LE,r0,r1,r2)
+#define lei_f(r0,r1,i0) cmpi_f(FCMP_LE,r0,r1,i0)
+#define ler_d(r0,r1,r2) cmpr_d(FCMP_LE,r0,r1,r2)
+#define lei_d(r0,r1,i0) cmpi_d(FCMP_LE,r0,r1,i0)
+#define eqr_f(r0,r1,r2) cmpr_f(FCMP_EQ,r0,r1,r2)
+#define eqi_f(r0,r1,i0) cmpi_f(FCMP_EQ,r0,r1,i0)
+#define eqr_d(r0,r1,r2) cmpr_d(FCMP_EQ,r0,r1,r2)
+#define eqi_d(r0,r1,i0) cmpi_d(FCMP_EQ,r0,r1,i0)
+#define ger_f(r0,r1,r2) cmpr_f(FCMP_GE,r0,r1,r2)
+#define gei_f(r0,r1,i0) cmpi_f(FCMP_GE,r0,r1,i0)
+#define ger_d(r0,r1,r2) cmpr_d(FCMP_GE,r0,r1,r2)
+#define gei_d(r0,r1,i0) cmpi_d(FCMP_GE,r0,r1,i0)
+#define gtr_f(r0,r1,r2) cmpr_f(FCMP_GT,r0,r1,r2)
+#define gti_f(r0,r1,i0) cmpi_f(FCMP_GT,r0,r1,i0)
+#define gtr_d(r0,r1,r2) cmpr_d(FCMP_GT,r0,r1,r2)
+#define gti_d(r0,r1,i0) cmpi_d(FCMP_GT,r0,r1,i0)
+#define ner_f(r0,r1,r2) cmpr_f(FCMP_NE,r0,r1,r2)
+#define nei_f(r0,r1,i0) cmpi_f(FCMP_NE,r0,r1,i0)
+#define ner_d(r0,r1,r2) cmpr_d(FCMP_NE,r0,r1,r2)
+#define nei_d(r0,r1,i0) cmpi_d(FCMP_NE,r0,r1,i0)
+#define unltr_f(r0,r1,r2) cmpr_f(FCMP_UNLT,r0,r1,r2)
+#define unlti_f(r0,r1,i0) cmpi_f(FCMP_UNLT,r0,r1,i0)
+#define unltr_d(r0,r1,r2) cmpr_d(FCMP_UNLT,r0,r1,r2)
+#define unlti_d(r0,r1,i0) cmpi_d(FCMP_UNLT,r0,r1,i0)
+#define unler_f(r0,r1,r2) cmpr_f(FCMP_UNLE,r0,r1,r2)
+#define unlei_f(r0,r1,i0) cmpi_f(FCMP_UNLE,r0,r1,i0)
+#define unler_d(r0,r1,r2) cmpr_d(FCMP_UNLE,r0,r1,r2)
+#define unlei_d(r0,r1,i0) cmpi_d(FCMP_UNLE,r0,r1,i0)
+#define uneqr_f(r0,r1,r2) cmpr_f(FCMP_UNEQ,r0,r1,r2)
+#define uneqi_f(r0,r1,i0) cmpi_f(FCMP_UNEQ,r0,r1,i0)
+#define uneqr_d(r0,r1,r2) cmpr_d(FCMP_UNEQ,r0,r1,r2)
+#define uneqi_d(r0,r1,i0) cmpi_d(FCMP_UNEQ,r0,r1,i0)
+#define unger_f(r0,r1,r2) cmpr_f(FCMP_UNGE,r0,r1,r2)
+#define ungei_f(r0,r1,i0) cmpi_f(FCMP_UNGE,r0,r1,i0)
+#define unger_d(r0,r1,r2) cmpr_d(FCMP_UNGE,r0,r1,r2)
+#define ungei_d(r0,r1,i0) cmpi_d(FCMP_UNGE,r0,r1,i0)
+#define ungtr_f(r0,r1,r2) cmpr_f(FCMP_UNGT,r0,r1,r2)
+#define ungti_f(r0,r1,i0) cmpi_f(FCMP_UNGT,r0,r1,i0)
+#define ungtr_d(r0,r1,r2) cmpr_d(FCMP_UNGT,r0,r1,r2)
+#define ungti_d(r0,r1,i0) cmpi_d(FCMP_UNGT,r0,r1,i0)
+#define ltgtr_f(r0,r1,r2) cmpr_f(FCMP_LTGT,r0,r1,r2)
+#define ltgti_f(r0,r1,i0) cmpi_f(FCMP_LTGT,r0,r1,i0)
+#define ltgtr_d(r0,r1,r2) cmpr_d(FCMP_LTGT,r0,r1,r2)
+#define ltgti_d(r0,r1,i0) cmpi_d(FCMP_LTGT,r0,r1,i0)
+#define ordr_f(r0,r1,r2) cmpr_f(FCMP_ORD,r0,r1,r2)
+#define ordi_f(r0,r1,i0) cmpi_f(FCMP_ORD,r0,r1,i0)
+#define ordr_d(r0,r1,r2) cmpr_d(FCMP_ORD,r0,r1,r2)
+#define ordi_d(r0,r1,i0) cmpi_d(FCMP_ORD,r0,r1,i0)
+#define unordr_f(r0,r1,r2) cmpr_f(FCMP_UNORD,r0,r1,r2)
+#define unordi_f(r0,r1,i0) cmpi_f(FCMP_UNORD,r0,r1,i0)
+#define unordr_d(r0,r1,r2) cmpr_d(FCMP_UNORD,r0,r1,r2)
+#define unordi_d(r0,r1,i0) cmpi_d(FCMP_UNORD,r0,r1,i0)
+#define ldr_f(r0,r1) FLDWI(0,r1,r0)
+#define ldi_f(r0,i0) _ldi_f(_jit,r0,i0)
+static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_f(r0,r1,r2) FLDW(r2,r1,r0)
+#define ldxi_f(r0,r1,i0) _ldxi_f(_jit,r0,r1,i0)
+static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define ldr_d(r0,r1) FLDDI(0,r1,r0)
+#define ldi_d(r0,i0) _ldi_d(_jit,r0,i0)
+static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+#define ldxr_d(r0,r1,r2) FLDD(r2,r1,r0)
+#define ldxi_d(r0,r1,i0) _ldxi_d(_jit,r0,r1,i0)
+static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+#define str_f(r0,r1) FSTWI(r1,0,r0)
+#define sti_f(i0,r0) _sti_f(_jit,i0,r0)
+static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+#define stxr_f(r0,r1,r2) FSTW(r2,r1,r0)
+#define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1)
+static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define str_d(r0,r1) FSTDI(r1,0,r0)
+#define sti_d(i0,r0) _sti_d(_jit,i0,r0)
+static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+#define stxr_d(r0,r1,r2) FSTD(r2,r1,r0)
+#define stxi_d(i0,r0,r1) _stxi_d(_jit,i0,r0,r1)
+static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+#define bcmpr_f(c,i0,r0,r1) _bcmpr_f(_jit,c,i0,r0,r1)
+static jit_word_t _bcmpr_f(jit_state_t*,jit_word_t,
+ jit_word_t,jit_int32_t,jit_int32_t);
+#define bcmpi_f(c,i0,r0,i1) _bcmpi_f(_jit,c,i0,r0,i1)
+static jit_word_t _bcmpi_f(jit_state_t*,jit_word_t,
+ jit_word_t,jit_int32_t,jit_float32_t*);
+#define bcmpr_d(c,i0,r0,r1) _bcmpr_d(_jit,c,i0,r0,r1)
+static jit_word_t _bcmpr_d(jit_state_t*,jit_word_t,
+ jit_word_t,jit_int32_t,jit_int32_t);
+#define bcmpi_d(c,i0,r0,i1) _bcmpi_d(_jit,c,i0,r0,i1)
+static jit_word_t _bcmpi_d(jit_state_t*,jit_word_t,
+ jit_word_t,jit_int32_t,jit_float64_t*);
+#define bltr_f(i0,r0,r1) bcmpr_f(FCMP_LT,i0,r0,r1)
+#define blti_f(i0,r0,i1) bcmpi_f(FCMP_LT,i0,r0,i1)
+#define bltr_d(i0,r0,r1) bcmpr_d(FCMP_LT,i0,r0,r1)
+#define blti_d(i0,r0,i1) bcmpi_d(FCMP_LT,i0,r0,i1)
+#define bler_f(i0,r0,r1) bcmpr_f(FCMP_LE,i0,r0,r1)
+#define blei_f(i0,r0,i1) bcmpi_f(FCMP_LE,i0,r0,i1)
+#define bler_d(i0,r0,r1) bcmpr_d(FCMP_LE,i0,r0,r1)
+#define blei_d(i0,r0,i1) bcmpi_d(FCMP_LE,i0,r0,i1)
+#define beqr_f(i0,r0,r1) bcmpr_f(FCMP_EQ,i0,r0,r1)
+#define beqi_f(i0,r0,i1) bcmpi_f(FCMP_EQ,i0,r0,i1)
+#define beqr_d(i0,r0,r1) bcmpr_d(FCMP_EQ,i0,r0,r1)
+#define beqi_d(i0,r0,i1) bcmpi_d(FCMP_EQ,i0,r0,i1)
+#define bger_f(i0,r0,r1) bcmpr_f(FCMP_GE,i0,r0,r1)
+#define bgei_f(i0,r0,i1) bcmpi_f(FCMP_GE,i0,r0,i1)
+#define bger_d(i0,r0,r1) bcmpr_d(FCMP_GE,i0,r0,r1)
+#define bgei_d(i0,r0,i1) bcmpi_d(FCMP_GE,i0,r0,i1)
+#define bgtr_f(i0,r0,r1) bcmpr_f(FCMP_GT,i0,r0,r1)
+#define bgti_f(i0,r0,i1) bcmpi_f(FCMP_GT,i0,r0,i1)
+#define bgtr_d(i0,r0,r1) bcmpr_d(FCMP_GT,i0,r0,r1)
+#define bgti_d(i0,r0,i1) bcmpi_d(FCMP_GT,i0,r0,i1)
+#define bner_f(i0,r0,r1) bcmpr_f(FCMP_NE,i0,r0,r1)
+#define bnei_f(i0,r0,i1) bcmpi_f(FCMP_NE,i0,r0,i1)
+#define bner_d(i0,r0,r1) bcmpr_d(FCMP_NE,i0,r0,r1)
+#define bnei_d(i0,r0,i1) bcmpi_d(FCMP_NE,i0,r0,i1)
+#define bunltr_f(i0,r0,r1) bcmpr_f(FCMP_UNLT,i0,r0,r1)
+#define bunlti_f(i0,r0,i1) bcmpi_f(FCMP_UNLT,i0,r0,i1)
+#define bunltr_d(i0,r0,r1) bcmpr_d(FCMP_UNLT,i0,r0,r1)
+#define bunlti_d(i0,r0,i1) bcmpi_d(FCMP_UNLT,i0,r0,i1)
+#define bunler_f(i0,r0,r1) bcmpr_f(FCMP_UNLE,i0,r0,r1)
+#define bunlei_f(i0,r0,i1) bcmpi_f(FCMP_UNLE,i0,r0,i1)
+#define bunler_d(i0,r0,r1) bcmpr_d(FCMP_UNLE,i0,r0,r1)
+#define bunlei_d(i0,r0,i1) bcmpi_d(FCMP_UNLE,i0,r0,i1)
+#define buneqr_f(i0,r0,r1) bcmpr_f(FCMP_UNEQ,i0,r0,r1)
+#define buneqi_f(i0,r0,i1) bcmpi_f(FCMP_UNEQ,i0,r0,i1)
+#define buneqr_d(i0,r0,r1) bcmpr_d(FCMP_UNEQ,i0,r0,r1)
+#define buneqi_d(i0,r0,i1) bcmpi_d(FCMP_UNEQ,i0,r0,i1)
+#define bunger_f(i0,r0,r1) bcmpr_f(FCMP_UNGE,i0,r0,r1)
+#define bungei_f(i0,r0,i1) bcmpi_f(FCMP_UNGE,i0,r0,i1)
+#define bunger_d(i0,r0,r1) bcmpr_d(FCMP_UNGE,i0,r0,r1)
+#define bungei_d(i0,r0,i1) bcmpi_d(FCMP_UNGE,i0,r0,i1)
+#define bungtr_f(i0,r0,r1) bcmpr_f(FCMP_UNGT,i0,r0,r1)
+#define bungti_f(i0,r0,i1) bcmpi_f(FCMP_UNGT,i0,r0,i1)
+#define bungtr_d(i0,r0,r1) bcmpr_d(FCMP_UNGT,i0,r0,r1)
+#define bungti_d(i0,r0,i1) bcmpi_d(FCMP_UNGT,i0,r0,i1)
+#define bltgtr_f(i0,r0,r1) bcmpr_f(FCMP_LTGT,i0,r0,r1)
+#define bltgti_f(i0,r0,i1) bcmpi_f(FCMP_LTGT,i0,r0,i1)
+#define bltgtr_d(i0,r0,r1) bcmpr_d(FCMP_LTGT,i0,r0,r1)
+#define bltgti_d(i0,r0,i1) bcmpi_d(FCMP_LTGT,i0,r0,i1)
+#define bordr_f(i0,r0,r1) bcmpr_f(FCMP_ORD,i0,r0,r1)
+#define bordi_f(i0,r0,i1) bcmpi_f(FCMP_ORD,i0,r0,i1)
+#define bordr_d(i0,r0,r1) bcmpr_d(FCMP_ORD,i0,r0,r1)
+#define bordi_d(i0,r0,i1) bcmpi_d(FCMP_ORD,i0,r0,i1)
+#define bunordr_f(i0,r0,r1) bcmpr_f(FCMP_UNORD,i0,r0,r1)
+#define bunordi_f(i0,r0,i1) bcmpi_f(FCMP_UNORD,i0,r0,i1)
+#define bunordr_d(i0,r0,r1) bcmpr_d(FCMP_UNORD,i0,r0,r1)
+#define bunordi_d(i0,r0,i1) bcmpi_d(FCMP_UNORD,i0,r0,i1)
+#endif
+
+#if CODE
+static void
+_f39(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t x, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(b<<21)|(x<<16)|t);
+}
+
+static void
+_f40(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t x, jit_int32_t r)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(!(x & ~0x1f));
+ assert(!(r & ~0x1f));
+ ii((o<<26)|(b<<21)|(x<<16)|(1<<9)|r);
+}
+
+static void
+_f41(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t x, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(x >= -16 && x < 15);
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(b<<21)|(low_sign_unext(x,5)<<16)|(1<<12)|t);
+}
+
+static void
+_f42(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t b, jit_int32_t i, jit_int32_t r)
+{
+ assert(!(o & ~0x3f));
+ assert(!(b & ~0x1f));
+ assert(i >= -16 && i < 15);
+ assert(!(r & ~0x1f));
+ ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(1<<12)|(1<<9)|r);
+}
+
+static void
+_f45(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r, jit_int32_t a, jit_int32_t b, jit_int32_t fmt,
+ jit_int32_t c, jit_int32_t d, jit_int32_t e, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(a & ~0x1f));
+ assert(!(b & ~0x7));
+ assert(!(fmt & ~0x3));
+ assert(!(c & ~0x3));
+ assert(!(d & ~0x7));
+ assert(!(e & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r<<21)|(a<<16)|(fmt<<13)|(b<<11)|(c<<9)|(d<<6)|(e<<5)|t);
+}
+
+static void
+_f46(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
+ jit_int32_t a, jit_int32_t s, jit_int32_t df, jit_int32_t sf,
+ jit_int32_t b, jit_int32_t c, jit_int32_t d, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r & ~0x1f));
+ assert(!(a & ~0x7));
+ assert(!(s & ~0x7));
+ assert(!(df & ~0x3));
+ assert(!(sf & ~0x3));
+ assert(!(b & ~0x3));
+ assert(!(c & ~0x7));
+ assert(!(d & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r<<21)|(a<<18)|(s<<15)|
+ (df<<13)|(sf<<11)|(b<<9)|(c<<6)|(d<<5)|t);
+}
+
+static void
+_f47_48(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r2, jit_int32_t r1, jit_int32_t y, jit_int32_t fmt,
+ jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r2 & ~0x1f));
+ assert(!(r1 & ~0x1f));
+ assert(!(y & ~0x7));
+ assert(!(fmt & ~0x3));
+ assert(!(a & ~0x3));
+ assert(!(b & ~0x7));
+ assert(!(c & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r2<<21)|(r1<<16)|(y<<13)|(fmt<<11)|(a<<9)|(b<<6)|(c<<5)|t);
+}
+
+static void
+_f49_52(jit_state_t *_jit, jit_int32_t o,
+ jit_int32_t r1, jit_int32_t r2, jit_int32_t y,
+ jit_int32_t v, jit_int32_t f, jit_int32_t a, jit_int32_t b,
+ jit_int32_t u, jit_int32_t c, jit_int32_t d, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r1 & ~0x1f));
+ assert(!(r2 & ~0x3f));
+ assert(!(y & ~0x7));
+ assert(!(v & ~0x1));
+ assert(!(f & ~0x1));
+ assert(!(a & ~0x3));
+ assert(!(b & ~0x1));
+ assert(!(u & ~0x1));
+ assert(!(c & ~0x1));
+ assert(!(d & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r1<<21)|(r2<<16)|(y<<13)|(v<<12)|
+ (f<<11)|(a<<9)|(b<<8)|(u<<7)|(c<<6)|(d<<5)|t);
+}
+
+static void
+_f53(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2,
+ jit_int32_t ta, jit_int32_t ra, jit_int32_t f, jit_int32_t tm)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r1 & ~0x1f));
+ assert(!(r2 & ~0x1f));
+ assert(!(ta & ~0x1f));
+ assert(!(ra & ~0x1f));
+ assert(!(f & ~0x1));
+ assert(!(tm & ~0x1f));
+ assert(ra != tm ||
+ (ta == r1 || ta == r2 || ta == tm) ||
+ (f && ra == 1) || (!f && !ra));
+ ii((o<<26)|(r1<<21)|(r2<<16)|(ta<<11)|(ra<<6)|(f<<5)|tm);
+}
+
+static void
+_f54(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2,
+ jit_int32_t a, jit_int32_t b, jit_int32_t f, jit_int32_t c,
+ jit_int32_t d, jit_int32_t e, jit_int32_t g, jit_int32_t t)
+{
+ assert(!(o & ~0x3f));
+ assert(!(r1 & ~0x1f));
+ assert(!(r2 & ~0x1f));
+ assert(!(a & ~0x7));
+ assert(!(b & ~0x1));
+ assert(!(f & ~0x1));
+ assert(!(c & ~0x7));
+ assert(!(e & ~0x1));
+ assert(!(e & ~0x1));
+ assert(!(g & ~0x1));
+ assert(!(t & ~0x1f));
+ ii((o<<26)|(r1<<21)|(r2<<16)|(a<<13)|
+ (b<<12)|(f<11)|(c<<8)|(d<<7)|(e<<6)|(g<<5)|t);
+}
+
+static void
+_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ stxi(alloca_offset - 8, _FP_REGNO, r1);
+ ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
+ FCNVXF_S_S(r0, r0);
+}
+
+static void
+_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ stxi(alloca_offset - 8, _FP_REGNO, r1);
+ ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
+ FCNVXF_S_D(r0, r0);
+}
+
+static void
+_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_fpr);
+ FCNVXT_S_S(r1, rn(reg));
+ stxi_f(alloca_offset - 8, _FP_REGNO, rn(reg));
+ ldxi(r0, _FP_REGNO, alloca_offset - 8);
+ jit_unget_reg(reg);
+}
+
+static void
+_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_fpr);
+ FCNVXT_D_S(r1, rn(reg));
+ stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg));
+ ldxi(r0, _FP_REGNO, alloca_offset - 8);
+ jit_unget_reg(reg);
+}
+
+static void
+_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+{
+ ldi_f(r0, (jit_word_t)i0);
+}
+
+static void
+_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+{
+ ldi_d(r0, (jit_word_t)i0);
+}
+
+#define fpr_opi(name, type, size) \
+static void \
+_##name##i_##type(jit_state_t *_jit, \
+ jit_int32_t r0, jit_int32_t r1, \
+ jit_float##size##_t *i0) \
+{ \
+ jit_int32_t reg = jit_get_reg(jit_class_fpr);
\
+ movi_##type(rn(reg), i0); \
+ name##r_##type(r0, r1, rn(reg)); \
+ jit_unget_reg(reg);
\
+}
+#define fopi(name) fpr_opi(name, f, 32)
+#define dopi(name) fpr_opi(name, d, 64)
+
+fopi(add)
+dopi(add)
+fopi(sub)
+dopi(sub)
+fopi(mul)
+dopi(mul)
+fopi(div)
+dopi(div)
+
+static void
+_cmpr_f(jit_state_t *_jit, jit_word_t c,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ LDI(0, r0);
+ FCMP_S_(r1, r2, c);
+ FTEST();
+ LDI(1, r0);
+}
+
+static void
+_cmpi_f(jit_state_t *_jit, jit_word_t c,
+ jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
+{
+ jit_int32_t reg = jit_get_reg(jit_class_fpr);
+ movi_f(rn(reg), i0);
+ cmpr_f(c, r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_cmpr_d(jit_state_t *_jit, jit_word_t c,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ LDI(0, r0);
+ FCMP_D_(r1, r2, c);
+ FTEST();
+ LDI(1, r0);
+}
+
+static void
+_cmpi_d(jit_state_t *_jit, jit_word_t c,
+ jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
+{
+ jit_int32_t reg = jit_get_reg(jit_class_fpr);
+ movi_d(rn(reg), i0);
+ cmpr_d(c, r0, r1, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ assert(!(i0 & 3));
+ if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
+ FLDWL(i0, _R0_REGNO, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_f(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ FLDWI(i0, r1, r0);
+ /* |im11a|0|t|i| */
+ else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
+ FLDWL(i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_f(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ assert(!(i0 & 7));
+ if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
+ FLDDL(i0, _R0_REGNO, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_d(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ FLDDI(i0, r1, r0);
+ /* |im10a|m|a|1|i| */
+ else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
+ FLDDL(i0, r1, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_d(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ assert(!(i0 & 3));
+ if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
+ FSTWL(r0, i0, _R0_REGNO);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ str_f(rn(reg), r0);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ FSTWI(r1, i0, r0);
+ /* |im11a|0|t|i| */
+ else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
+ FSTWL(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ addi(rn(reg), r0, i0);
+ str_f(rn(reg), r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ assert(!(i0 & 7));
+ if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
+ FSTDL(r0, i0, _R0_REGNO);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ str_d(rn(reg), r0);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_int32_t reg;
+ if (i0 >= -16 && i0 <= 15)
+ FSTDI(r1, i0, r0);
+ /* |im10a|m|a|1|i| */
+ else if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
+ FSTDL(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ stxr_d(rn(reg), r0, r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static jit_word_t
+_bcmpr_f(jit_state_t *_jit, jit_word_t c,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ FCMP_S_(r0, r1, c);
+ FTEST();
+ w = _jit->pc.w;
+ B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bcmpi_f(jit_state_t *_jit, jit_word_t c,
+ jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_fpr);
+ movi_f(rn(reg), i1);
+ FCMP_S_(r0, rn(reg), c);
+ FTEST();
+ w = _jit->pc.w;
+ B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
+ NOP();
+ jit_unget_reg(reg);
+ return (w);
+}
+
+static jit_word_t
+_bcmpr_d(jit_state_t *_jit, jit_word_t c,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ FCMP_D_(r0, r1, c);
+ FTEST();
+ w = _jit->pc.w;
+ B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bcmpi_d(jit_state_t *_jit, jit_word_t c,
+ jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_fpr);
+ movi_d(rn(reg), i1);
+ FCMP_D_(r0, rn(reg), c);
+ FTEST();
+ w = _jit->pc.w;
+ B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
+ NOP();
+ jit_unget_reg(reg);
+ return (w);
+}
+#endif
diff --git a/lib/jit_hppa.c b/lib/jit_hppa.c
new file mode 100644
index 0000000..d733231
--- /dev/null
+++ b/lib/jit_hppa.c
@@ -0,0 +1,1186 @@
+/*
+ * Copyright (C) 2013 Free Software Foundation, Inc.
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Authors:
+ * Paulo Cesar Pereira de Andrade
+ */
+
+#include <lightning.h>
+#include <lightning/jit_private.h>
+
+#define rc(value) jit_class_##value
+#define rn(reg)
(jit_regno(_rvs[jit_regno(reg)].spec))
+
+#define PROTO 1
+# include "jit_hppa-cpu.c"
+# include "jit_hppa-fpu.c"
+#undef PROTO
+
+/*
+ * Prototypes
+ */
+#define patch(instr, node) _patch(_jit, instr, node)
+static void _patch(jit_state_t*,jit_word_t,jit_node_t*);
+
+/*
+ * Initialization
+ */
+jit_register_t _rvs[] = {
+ { 0, "r0" }, /* Zero */
+ /* Not register starved, so, avoid allocating r1 and rp
+ * due to being implicit target of ADDIL and B,L */
+ { 1, "r1" }, /* Scratch */
+ { 2, "rp" }, /* Return Pointer and scratch */
+ { rc(sav) | 3, "r3" },
+ { 19, "r19" }, /* Linkage Table */
+ { rc(gpr) | 20, "r20" },
+ { rc(gpr) | 21, "r21" },
+ { rc(gpr) | 22, "r22" },
+ { rc(gpr) | 29, "ret1" },
+ { rc(gpr) | 28, "ret0" },
+ /* JIT_Rx in callee save registers due to need to call
+ * functions to implement some instructions */
+ /* JIT_R0- JIT_R2 */
+ { rc(gpr) | rc(sav) | 4, "r4" },
+ { rc(gpr) | rc(sav) | 5, "r5" },
+ { rc(gpr) | rc(sav) | 6, "r6" },
+ /* JIT_V0- JIT_V2 */
+ { rc(gpr) | rc(sav) | 7, "r7" },
+ { rc(sav) | rc(sav) | 8, "r8" },
+ { rc(gpr) | rc(sav) | 9, "r9" },
+ /* JIT_R3 */
+ { rc(gpr) | rc(sav) | 10, "r10" },
+ /* JIT_V3+ */
+ { rc(gpr) | rc(sav) | 11, "r11" },
+ { rc(gpr) | rc(sav) | 12, "r12" },
+ { rc(gpr) | rc(sav) | 13, "r13" },
+ { rc(gpr) | rc(sav) | 14, "r14" },
+ { rc(gpr) | rc(sav) | 15, "r15" },
+ { rc(gpr) | rc(sav) | 16, "r16" },
+ { rc(gpr) | rc(sav) | 17, "r17" },
+ { rc(gpr) | rc(sav) | 18, "r18" },
+ /* Arguments */
+ { rc(gpr) | rc(arg) | 23, "r23" },
+ { rc(gpr) | rc(arg) | 24, "r24" },
+ { rc(gpr) | rc(arg) | 25, "r25" },
+ { rc(gpr) | rc(arg) | 26, "r26" },
+ { 27, "dp" }, /* Data Pointer */
+ { 30, "sp" },
+ { 31, "r31" }, /* Link Register */
+ { rc(fpr) | 31, "fr31" },
+ { rc(fpr) | 30, "fr30" },
+ { rc(fpr) | 29, "fr29" },
+ { rc(fpr) | 28, "fr28" },
+ { rc(fpr) | 27, "fr27" },
+ { rc(fpr) | 26, "fr26" },
+ { rc(fpr) | 25, "fr25" },
+ { rc(fpr) | 24, "fr24" },
+ { rc(fpr) | 23, "fr23" },
+ { rc(fpr) | 22, "fr22" },
+ { rc(fpr) | 11, "fr11" },
+ { rc(fpr) | 10, "fr10" },
+ { rc(fpr) | 9, "fr9" },
+ { rc(fpr) | 8, "fr8" },
+ /* Arguments */
+ { rc(fpr) | rc(arg) | 7, "fr7" },
+ { rc(fpr) | rc(arg) | 6, "fr6" },
+ { rc(fpr) | rc(arg) | 5, "fr5" },
+ { rc(fpr) | rc(arg) | 4, "fr4" },
+ /* Callee Saves */
+ { rc(fpr) | rc(sav) | 21, "fr21" },
+ { rc(fpr) | rc(sav) | 20, "fr20" },
+ { rc(fpr) | rc(sav) | 19, "fr19" },
+ { rc(fpr) | rc(sav) | 18, "fr18" },
+ { rc(fpr) | rc(sav) | 17, "fr17" },
+ { rc(fpr) | rc(sav) | 16, "fr16" },
+ { rc(fpr) | rc(sav) | 15, "fr15" },
+ { rc(fpr) | rc(sav) | 14, "fr14" },
+ { rc(fpr) | rc(sav) | 13, "fr13" },
+ { rc(fpr) | rc(sav) | 12, "fr12" },
+ { 0, "fpsr" },
+ { 1, "fpe2" },
+ { 2, "fpe4" },
+ { 3, "fpe6" },
+ { _NOREG, "<none>" },
+};
+
+/*
+ * Implementation
+ */
+void
+jit_get_cpu(void)
+{
+ /* FIXME Expecting PARISC 2.0, for PARISC 1.0 should not use fr16-fr31 */
+}
+
+void
+_jit_init(jit_state_t *_jit)
+{
+ _jitc->reglen = jit_size(_rvs) - 1;
+}
+
+void
+_jit_prolog(jit_state_t *_jit)
+{
+ jit_int32_t offset;
+
+ if (_jitc->function)
+ jit_epilog();
+ assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0);
+ jit_regset_set_ui(&_jitc->regsav, 0);
+ offset = _jitc->functions.offset;
+ if (offset >= _jitc->functions.length) {
+ jit_realloc((jit_pointer_t *)&_jitc->functions.ptr,
+ _jitc->functions.length * sizeof(jit_function_t),
+ (_jitc->functions.length + 16) * sizeof(jit_function_t));
+ _jitc->functions.length += 16;
+ }
+ _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++;
+ _jitc->function->self.size = params_offset;
+ _jitc->function->self.argi = _jitc->function->self.alen = 0;
+ /* float conversion */
+ _jitc->function->self.aoff = alloca_offset - 8;
+ _jitc->function->self.call = jit_call_default;
+ jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
+ _jitc->reglen * sizeof(jit_int32_t));
+
+ _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog);
+ jit_link(_jitc->function->prolog);
+ _jitc->function->prolog->w.w = offset;
+ _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog);
+ /* u: label value
+ * v: offset in blocks vector
+ * w: offset in functions vector
+ */
+ _jitc->function->epilog->w.w = offset;
+
+ jit_regset_new(&_jitc->function->regset);
+}
+
+jit_int32_t
+_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+{
+ jit_int32_t offset;
+ assert(_jitc->function);
+ switch (length) {
+ case 0: case 1:
+ break;
+ case 2:
+ _jitc->function->self.aoff = (_jitc->function->self.aoff + 1) & -2;
+ break;
+ case 3: case 4:
+ _jitc->function->self.aoff = (_jitc->function->self.aoff + 3) & -4;
+ break;
+ default:
+ _jitc->function->self.aoff = (_jitc->function->self.aoff + 7) & -8;
+ break;
+ }
+ offset = _jitc->function->self.aoff;
+ _jitc->function->self.aoff += length;
+ return (offset);
+}
+
+void
+_jit_ret(jit_state_t *_jit)
+{
+ jit_node_t *instr;
+
+ assert(_jitc->function);
+
+ /* jump to epilog */
+ instr = jit_jmpi();
+ jit_patch_at(instr, _jitc->function->epilog);
+}
+
+void
+_jit_retr(jit_state_t *_jit, jit_int32_t u)
+{
+ jit_movr(JIT_RET, u);
+ jit_ret();
+}
+
+void
+_jit_reti(jit_state_t *_jit, jit_word_t u)
+{
+ jit_movi(JIT_RET, u);
+ jit_ret();
+}
+
+void
+_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+{
+ jit_movr_f(JIT_FRET, u);
+ jit_ret();
+}
+
+void
+_jit_reti_f(jit_state_t *_jit, jit_float32_t u)
+{
+ jit_movi_f(JIT_FRET, u);
+ jit_ret();
+}
+
+void
+_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+{
+ jit_movr_d(JIT_FRET, u);
+ jit_ret();
+}
+
+void
+_jit_reti_d(jit_state_t *_jit, jit_float64_t u)
+{
+ jit_movi_d(JIT_FRET, u);
+ jit_ret();
+}
+
+void
+_jit_epilog(jit_state_t *_jit)
+{
+ assert(_jitc->function);
+ assert(_jitc->function->epilog->next == NULL);
+ jit_link(_jitc->function->epilog);
+ _jitc->function = NULL;
+}
+
+jit_node_t *
+_jit_arg(jit_state_t *_jit)
+{
+ jit_int32_t offset;
+ assert(_jitc->function);
+ _jitc->function->self.size -= sizeof(jit_word_t);
+ if (_jitc->function->self.argi < 4)
+ offset = _jitc->function->self.argi++;
+ else
+ offset = _jitc->function->self.size;
+ return (jit_new_node_w(jit_code_arg, offset));
+}
+
+jit_node_t *
+_jit_arg_f(jit_state_t *_jit)
+{
+ jit_int32_t offset;
+ assert(_jitc->function);
+ _jitc->function->self.size -= sizeof(jit_word_t);
+ if (_jitc->function->self.argi < 4)
+ offset = _jitc->function->self.argi++;
+ else
+ offset = _jitc->function->self.size;
+ return (jit_new_node_w(jit_code_arg_f, offset));
+}
+
+jit_node_t *
+_jit_arg_d(jit_state_t *_jit)
+{
+ jit_int32_t offset;
+ assert(_jitc->function);
+ if (_jitc->function->self.argi & 1) {
+ ++_jitc->function->self.argi;
+ _jitc->function->self.size -= sizeof(jit_word_t);
+ }
+ _jitc->function->self.size -= sizeof(jit_float64_t);
+ if (_jitc->function->self.argi < 4) {
+ offset = _jitc->function->self.argi + 1;
+ _jitc->function->self.argi += 2;
+ }
+ else {
+ /* "Standard" initial value (-52) is unaligned */
+ if (_jitc->function->self.size & 7)
+ _jitc->function->self.size -= sizeof(jit_word_t);
+ offset = _jitc->function->self.size;
+ }
+ return (jit_new_node_w(jit_code_arg_d, offset));
+}
+
+jit_bool_t
+_jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
+{
+ return (jit_arg_f_reg_p(offset));
+}
+
+void
+_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_extr_c(u, _R26 - v->u.w);
+ else
+ jit_ldxi_c(u, JIT_FP, v->u.w + 3);
+}
+
+void
+_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_extr_uc(u, _R26 - v->u.w);
+ else
+ jit_ldxi_uc(u, JIT_FP, v->u.w + 3);
+}
+
+void
+_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_extr_s(u, _R26 - v->u.w);
+ else
+ jit_ldxi_s(u, JIT_FP, v->u.w + 2);
+}
+
+void
+_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_extr_us(u, _R26 - v->u.w);
+ else
+ jit_ldxi_us(u, JIT_FP, v->u.w + 2);
+}
+
+void
+_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_movr(u, _R26 - v->u.w);
+ else
+ jit_ldxi_i(u, JIT_FP, v->u.w);
+}
+
+void
+_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_movr_f(u, _F4 - v->u.w);
+ else
+ jit_ldxi_f(u, JIT_FP, v->u.w);
+}
+
+void
+_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+{
+ if (v->u.w >= 0)
+ jit_movr_d(u, _F4 - v->u.w);
+ else
+ jit_ldxi_d(u, JIT_FP, v->u.w);
+}
+
+void
+_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+{
+ assert(_jitc->function);
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ if (_jitc->function->call.argi < 4) {
+ jit_movr(_R26 - _jitc->function->call.argi, u);
+ ++_jitc->function->call.argi;
+ }
+ else
+ jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, u);
+}
+
+void
+_jit_pushargi(jit_state_t *_jit, jit_word_t u)
+{
+ jit_int32_t regno;
+ assert(_jitc->function);
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ if (_jitc->function->call.argi < 4) {
+ jit_movi(_R26 - _jitc->function->call.argi, u);
+ ++_jitc->function->call.argi;
+ }
+ else {
+ regno = jit_get_reg(jit_class_gpr);
+ jit_movi(regno, u);
+ jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, regno);
+ jit_unget_reg(regno);
+ }
+}
+
+void
+_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+{
+ assert(_jitc->function);
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ if (_jitc->function->call.argi < 4) {
+ jit_movr_f(_F4 - _jitc->function->call.argi, u);
+ if (_jitc->function->call.call & jit_call_varargs) {
+ jit_stxi_f(alloca_offset - 8, JIT_FP, u);
+ jit_ldxi(_R26 - _jitc->function->call.argi, JIT_FP,
+ alloca_offset - 8);
+ }
+ ++_jitc->function->call.argi;
+ }
+ else
+ jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, u);
+}
+
+void
+_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
+{
+ jit_int32_t regno;
+ assert(_jitc->function);
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ if (_jitc->function->call.argi < 4) {
+ jit_movi_f(_F4 - _jitc->function->call.argi, u);
+ if (_jitc->function->call.call & jit_call_varargs) {
+ jit_stxi_f(alloca_offset - 8, JIT_FP,
+ _F4 - _jitc->function->call.argi);
+ jit_ldxi(_R26 - _jitc->function->call.argi,
+ JIT_FP, alloca_offset - 8);
+ }
+ ++_jitc->function->call.argi;
+ }
+ else {
+ regno = jit_get_reg(jit_class_fpr);
+ jit_movi_f(regno, u);
+ jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, regno);
+ jit_unget_reg(regno);
+ }
+}
+
+void
+_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+{
+ assert(_jitc->function);
+ _jitc->function->call.size -= sizeof(jit_float64_t);
+ if (_jitc->function->call.argi & 1) {
+ ++_jitc->function->call.argi;
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ }
+ if (_jitc->function->call.argi < 4) {
+ jit_movr_d(_F4 - (_jitc->function->call.argi + 1), u);
+ if (_jitc->function->call.call & jit_call_varargs) {
+ jit_stxi_d(alloca_offset - 8, JIT_FP, u);
+ jit_ldxi(_R26 - _jitc->function->call.argi,
+ JIT_FP, alloca_offset - 4);
+ jit_ldxi(_R25 - _jitc->function->call.argi,
+ JIT_FP, alloca_offset - 8);
+ }
+ _jitc->function->call.argi += 2;
+ }
+ else {
+ /* "Standard" initial value (-52) is unaligned */
+ if ((_jitc->function->call.size + params_offset) & 7)
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, u);
+ }
+}
+
+void
+_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
+{
+ jit_int32_t regno;
+ assert(_jitc->function);
+ _jitc->function->call.size -= sizeof(jit_float64_t);
+ if (_jitc->function->call.argi & 1) {
+ ++_jitc->function->call.argi;
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ }
+ if (_jitc->function->call.argi < 4) {
+ jit_movi_d(_F4 - (_jitc->function->call.argi + 1), u);
+ if (_jitc->function->call.call & jit_call_varargs) {
+ jit_stxi_d(alloca_offset - 8, JIT_FP,
+ _F4 - (_jitc->function->call.argi + 1));
+ jit_ldxi(_R26 - _jitc->function->call.argi,
+ JIT_FP, alloca_offset - 4);
+ jit_ldxi(_R25 - _jitc->function->call.argi,
+ JIT_FP, alloca_offset - 8);
+ }
+ _jitc->function->call.argi += 2;
+ }
+ else {
+ regno = jit_get_reg(jit_class_fpr);
+ jit_movi_d(regno, u);
+ if ((_jitc->function->call.size + params_offset) & 7)
+ _jitc->function->call.size -= sizeof(jit_word_t);
+ jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, regno);
+ jit_unget_reg(regno);
+ }
+}
+
+jit_bool_t
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+{
+ jit_int32_t spec;
+ spec = jit_class(_rvs[regno].spec);
+ if (spec & jit_class_arg) {
+ if (spec & jit_class_gpr) {
+ regno = _R26 - regno;
+ if (regno >= 0 && regno < node->v.w)
+ return (1);
+ }
+ else if (spec & jit_class_fpr) {
+ regno = _F4 - regno;
+ if (regno >= 0 && regno < node->w.w)
+ return (1);
+ }
+ }
+ return (0);
+}
+
+void
+_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_node_t *call;
+ assert(_jitc->function);
+ if (_jitc->function->self.alen > _jitc->function->call.size)
+ _jitc->function->self.alen = _jitc->function->call.size;
+ call = jit_callr(r0);
+ call->v.w = call->w.w = _jitc->function->call.argi;
+ _jitc->function->call.argi = _jitc->function->call.size = 0;
+ _jitc->prepare = 0;
+}
+
+jit_node_t *
+_jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
+{
+ jit_node_t *node;
+ assert(_jitc->function);
+ if (_jitc->function->self.alen > _jitc->function->call.size)
+ _jitc->function->self.alen = _jitc->function->call.size;
+ node = jit_calli(i0);
+ node->v.w = node->w.w = _jitc->function->call.argi;
+ _jitc->function->call.argi = _jitc->function->call.size = 0;
+ _jitc->prepare = 0;
+ return (node);
+}
+
+void
+_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_extr_c(r0, JIT_RET);
+}
+
+void
+_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_extr_uc(r0, JIT_RET);
+}
+
+void
+_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_extr_s(r0, JIT_RET);
+}
+
+void
+_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_extr_us(r0, JIT_RET);
+}
+
+void
+_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_movr(r0, JIT_RET);
+}
+
+void
+_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_movr_f(r0, JIT_FRET);
+}
+
+void
+_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+{
+ jit_movr_d(r0, JIT_FRET);
+}
+
+jit_pointer_t
+_emit_code(jit_state_t *_jit)
+{
+ jit_node_t *node;
+ jit_node_t *temp;
+ jit_word_t word;
+ jit_int32_t value;
+ jit_int32_t offset;
+ struct {
+ jit_node_t *node;
+ jit_word_t word;
+ jit_int32_t patch_offset;
+ } undo;
+
+ _jitc->function = NULL;
+
+ jit_reglive_setup();
+
+ undo.word = 0;
+ undo.node = NULL;
+ undo.patch_offset = 0;
+
+#define case_rr(name, type) \
+ case jit_code_##name##r##type: \
+ name##r##type(rn(node->u.w), rn(node->v.w)); \
+ break
+#define case_rw(name, type) \
+ case jit_code_##name##i##type: \
+ name##i##type(rn(node->u.w), node->v.w); \
+ break
+#define case_wr(name, type) \
+ case jit_code_##name##i##type: \
+ name##i##type(node->u.w, rn(node->v.w)); \
+ break
+#define case_rrr(name, type) \
+ case jit_code_##name##r##type: \
+ name##r##type(rn(node->u.w), \
+ rn(node->v.w), rn(node->w.w)); \
+ break
+#define case_rrrr(name, type) \
+ case jit_code_##name##r##type: \
+ name##r##type(rn(node->u.q.l), rn(node->u.q.h), \
+ rn(node->v.w), rn(node->w.w)); \
+ break
+#define case_rrw(name, type) \
+ case jit_code_##name##i##type: \
+ name##i##type(rn(node->u.w),rn(node->v.w), node->w.w); \
+ break
+#define case_rrrw(name, type) \
+ case jit_code_##name##i##type: \
+ name##i##type(rn(node->u.q.l), rn(node->u.q.h), \
+ rn(node->v.w), node->w.w); \
+ break
+#define case_rrf(name, type, size) \
+ case jit_code_##name##i##type: \
+ assert(node->flag & jit_flag_data); \
+ name##i##type(rn(node->u.w), rn(node->v.w), \
+ (jit_float##size##_t *)node->w.n->u.w); \
+ break
+#define case_wrr(name, type) \
+ case jit_code_##name##i##type: \
+ name##i##type(node->u.w,rn(node->v.w), rn(node->w.w)); \
+ break
+#define case_brr(name, type) \
+ case jit_code_##name##r##type: \
+ temp = node->u.n; \
+ assert(temp->code == jit_code_label || \
+ temp->code == jit_code_epilog); \
+ if (temp->flag & jit_flag_patch) \
+ name##r##type(temp->u.w, rn(node->v.w), \
+ rn(node->w.w)); \
+ else { \
+ word = name##r##type(_jit->pc.w, \
+ rn(node->v.w), rn(node->w.w)); \
+ patch(word, node); \
+ } \
+ break
+#define case_brw(name, type) \
+ case jit_code_##name##i##type: \
+ temp = node->u.n; \
+ assert(temp->code == jit_code_label || \
+ temp->code == jit_code_epilog); \
+ if (temp->flag & jit_flag_patch) \
+ name##i##type(temp->u.w, \
+ rn(node->v.w), node->w.w); \
+ else { \
+ word = name##i##type(_jit->pc.w, \
+ rn(node->v.w), node->w.w); \
+ patch(word, node); \
+ } \
+ break
+#define case_brf(name, type, size) \
+ case jit_code_##name##i##type: \
+ temp = node->u.n; \
+ assert(temp->code == jit_code_label || \
+ temp->code == jit_code_epilog); \
+ if (temp->flag & jit_flag_patch) \
+ name##i##type(temp->u.w, rn(node->v.w), \
+ (jit_float##size##_t *)node->w.n->u.w); \
+ else { \
+ word = name##i##type(_jit->pc.w, rn(node->v.w), \
+ (jit_float##size##_t *)node->w.n->u.w); \
+ patch(word, node); \
+ } \
+ break
+ for (node = _jitc->head; node; node = node->next) {
+ if (_jit->pc.uc >= _jitc->code.end && !jit_remap())
+ return (NULL);
+
+ value = jit_classify(node->code);
+ jit_regarg_set(node, value);
+ switch (node->code) {
+ case jit_code_note: case jit_code_name:
+ node->u.w = _jit->pc.w;
+ break;
+ case jit_code_label:
+ /* remember label is defined */
+ node->flag |= jit_flag_patch;
+ node->u.w = _jit->pc.w;
+ break;
+ case_rrr(add,);
+ case_rrw(add,);
+ case_rrr(addc,);
+ case_rrw(addc,);
+ case_rrr(addx,);
+ case_rrw(addx,);
+ case_rrr(sub,);
+ case_rrw(sub,);
+ case_rrr(subc,);
+ case_rrw(subc,);
+ case_rrr(subx,);
+ case_rrw(subx,);
+ case_rrr(mul,);
+ case_rrw(mul,);
+ case_rrrr(qmul,);
+ case_rrrw(qmul,);
+ case_rrrr(qmul, _u);
+ case_rrrw(qmul, _u);
+ case_rrr(div,);
+ case_rrw(div,);
+ case_rrr(div, _u);
+ case_rrw(div, _u);
+ case_rrr(rem,);
+ case_rrw(rem,);
+ case_rrr(rem, _u);
+ case_rrw(rem, _u);
+ case_rrrr(qdiv,);
+ case_rrrw(qdiv,);
+ case_rrrr(qdiv, _u);
+ case_rrrw(qdiv, _u);
+ case_rrr(and,);
+ case_rrw(and,);
+ case_rrr(or,);
+ case_rrw(or,);
+ case_rrr(xor,);
+ case_rrw(xor,);
+ case_rrr(lsh,);
+ case_rrw(lsh,);
+ case_rrr(rsh,);
+ case_rrw(rsh,);
+ case_rrr(rsh, _u);
+ case_rrw(rsh, _u);
+ case_rr(mov,);
+ case jit_code_movi:
+ if (node->flag & jit_flag_node) {
+ temp = node->v.n;
+ if (temp->code == jit_code_data ||
+ (temp->code == jit_code_label &&
+ (temp->flag & jit_flag_patch)))
+ movi(rn(node->u.w), temp->u.w);
+ else {
+ assert(temp->code == jit_code_label ||
+ temp->code == jit_code_epilog);
+ word = movi_p(rn(node->u.w), node->v.w);
+ patch(word, node);
+ }
+ }
+ else
+ movi(rn(node->u.w), node->v.w);
+ break;
+ case_rr(neg,);
+ case_rr(com,);
+ case_rr(ext, _c);
+ case_rr(ext, _uc);
+ case_rr(ext, _s);
+ case_rr(ext, _us);
+ case_rr(hton,);
+ case_rrr(lt,);
+ case_rrw(lt,);
+ case_rrr(lt, _u);
+ case_rrw(lt, _u);
+ case_rrr(le,);
+ case_rrw(le,);
+ case_rrr(le, _u);
+ case_rrw(le, _u);
+ case_rrr(eq,);
+ case_rrw(eq,);
+ case_rrr(ge,);
+ case_rrw(ge,);
+ case_rrr(ge, _u);
+ case_rrw(ge, _u);
+ case_rrr(gt,);
+ case_rrw(gt,);
+ case_rrr(gt, _u);
+ case_rrw(gt, _u);
+ case_rrr(ne,);
+ case_rrw(ne,);
+ case_rr(ld, _c);
+ case_rw(ld, _c);
+ case_rr(ld, _uc);
+ case_rw(ld, _uc);
+ case_rr(ld, _s);
+ case_rw(ld, _s);
+ case_rr(ld, _us);
+ case_rw(ld, _us);
+ case_rr(ld, _i);
+ case_rw(ld, _i);
+ case_rrr(ldx, _c);
+ case_rrw(ldx, _c);
+ case_rrr(ldx, _uc);
+ case_rrw(ldx, _uc);
+ case_rrr(ldx, _s);
+ case_rrw(ldx, _s);
+ case_rrr(ldx, _us);
+ case_rrw(ldx, _us);
+ case_rrr(ldx, _i);
+ case_rrw(ldx, _i);
+ case_rr(st, _c);
+ case_wr(st, _c);
+ case_rr(st, _s);
+ case_wr(st, _s);
+ case_rr(st, _i);
+ case_wr(st, _i);
+ case_rrr(stx, _c);
+ case_wrr(stx, _c);
+ case_rrr(stx, _s);
+ case_wrr(stx, _s);
+ case_rrr(stx, _i);
+ case_wrr(stx, _i);
+ case_brr(blt,);
+ case_brw(blt,);
+ case_brr(blt, _u);
+ case_brw(blt, _u);
+ case_brr(ble,);
+ case_brw(ble,);
+ case_brr(ble, _u);
+ case_brw(ble, _u);
+ case_brr(beq,);
+ case_brw(beq,);
+ case_brr(bge,);
+ case_brw(bge,);
+ case_brr(bge, _u);
+ case_brw(bge, _u);
+ case_brr(bgt,);
+ case_brw(bgt,);
+ case_brr(bgt, _u);
+ case_brw(bgt, _u);
+ case_brr(bne,);
+ case_brw(bne,);
+ case_brr(bms,);
+ case_brw(bms,);
+ case_brr(bmc,);
+ case_brw(bmc,);
+ case_brr(boadd,);
+ case_brw(boadd,);
+ case_brr(boadd, _u);
+ case_brw(boadd, _u);
+ case_brr(bxadd,);
+ case_brw(bxadd,);
+ case_brr(bxadd, _u);
+ case_brw(bxadd, _u);
+ case_brr(bosub,);
+ case_brw(bosub,);
+ case_brr(bosub, _u);
+ case_brw(bosub, _u);
+ case_brr(bxsub,);
+ case_brw(bxsub,);
+ case_brr(bxsub, _u);
+ case_brw(bxsub, _u);
+ case_rr(mov, _f);
+ case jit_code_movi_f:
+ assert(node->flag & jit_flag_data);
+ movi_f(rn(node->u.w), (jit_float32_t *)node->v.n->u.w);
+ break;
+ case_rr(mov, _d);
+ case jit_code_movi_d:
+ assert(node->flag & jit_flag_data);
+ movi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
+ break;
+ case_rr(trunc, _f_i);
+ case_rr(trunc, _d_i);
+ case_rr(ext, _f);
+ case_rr(ext, _d);
+ case_rr(ext, _d_f);
+ case_rr(ext, _f_d);
+ case_rr(abs, _f);
+ case_rr(abs, _d);
+ case_rr(neg, _f);
+ case_rr(neg, _d);
+ case_rr(sqrt, _f);
+ case_rr(sqrt, _d);
+ case_rrr(add, _f);
+ case_rrf(add, _f, 32);
+ case_rrr(add, _d);
+ case_rrf(add, _d, 64);
+ case_rrr(sub, _f);
+ case_rrf(sub, _f, 32);
+ case_rrr(sub, _d);
+ case_rrf(sub, _d, 64);
+ case_rrr(mul, _f);
+ case_rrf(mul, _f, 32);
+ case_rrr(mul, _d);
+ case_rrf(mul, _d, 64);
+ case_rrr(div, _f);
+ case_rrf(div, _f, 32);
+ case_rrr(div, _d);
+ case_rrf(div, _d, 64);
+ case_rrr(lt, _f);
+ case_rrf(lt, _f, 32);
+ case_rrr(lt, _d);
+ case_rrf(lt, _d, 64);
+ case_rrr(le, _f);
+ case_rrf(le, _f, 32);
+ case_rrr(le, _d);
+ case_rrf(le, _d, 64);
+ case_rrr(eq, _f);
+ case_rrf(eq, _f, 32);
+ case_rrr(eq, _d);
+ case_rrf(eq, _d, 64);
+ case_rrr(ge, _f);
+ case_rrf(ge, _f, 32);
+ case_rrr(ge, _d);
+ case_rrf(ge, _d, 64);
+ case_rrr(gt, _f);
+ case_rrf(gt, _f, 32);
+ case_rrr(gt, _d);
+ case_rrf(gt, _d, 64);
+ case_rrr(ne, _f);
+ case_rrf(ne, _f, 32);
+ case_rrr(ne, _d);
+ case_rrf(ne, _d, 64);
+ case_rrr(unlt, _f);
+ case_rrf(unlt, _f, 32);
+ case_rrr(unlt, _d);
+ case_rrf(unlt, _d, 64);
+ case_rrr(unle, _f);
+ case_rrf(unle, _f, 32);
+ case_rrr(unle, _d);
+ case_rrf(unle, _d, 64);
+ case_rrr(uneq, _f);
+ case_rrf(uneq, _f, 32);
+ case_rrr(uneq, _d);
+ case_rrf(uneq, _d, 64);
+ case_rrr(unge, _f);
+ case_rrf(unge, _f, 32);
+ case_rrr(unge, _d);
+ case_rrf(unge, _d, 64);
+ case_rrr(ungt, _f);
+ case_rrf(ungt, _f, 32);
+ case_rrr(ungt, _d);
+ case_rrf(ungt, _d, 64);
+ case_rrr(ltgt, _f);
+ case_rrf(ltgt, _f, 32);
+ case_rrr(ltgt, _d);
+ case_rrf(ltgt, _d, 64);
+ case_rrr(ord, _f);
+ case_rrf(ord, _f, 32);
+ case_rrr(ord, _d);
+ case_rrf(ord, _d, 64);
+ case_rrr(unord, _f);
+ case_rrf(unord, _f, 32);
+ case_rrr(unord, _d);
+ case_rrf(unord, _d, 64);
+ case_rr(ld, _f);
+ case_rw(ld, _f);
+ case_rr(ld, _d);
+ case_rw(ld, _d);
+ case_rrr(ldx, _f);
+ case_rrw(ldx, _f);
+ case_rrr(ldx, _d);
+ case_rrw(ldx, _d);
+ case_rr(st, _f);
+ case_wr(st, _f);
+ case_rr(st, _d);
+ case_wr(st, _d);
+ case_rrr(stx, _f);
+ case_wrr(stx, _f);
+ case_rrr(stx, _d);
+ case_wrr(stx, _d);
+ case_brr(blt, _f);
+ case_brf(blt, _f, 32);
+ case_brr(blt, _d);
+ case_brf(blt, _d, 64);
+ case_brr(ble, _f);
+ case_brf(ble, _f, 32);
+ case_brr(ble, _d);
+ case_brf(ble, _d, 64);
+ case_brr(beq, _f);
+ case_brf(beq, _f, 32);
+ case_brr(beq, _d);
+ case_brf(beq, _d, 64);
+ case_brr(bge, _f);
+ case_brf(bge, _f, 32);
+ case_brr(bge, _d);
+ case_brf(bge, _d, 64);
+ case_brr(bgt, _f);
+ case_brf(bgt, _f, 32);
+ case_brr(bgt, _d);
+ case_brf(bgt, _d, 64);
+ case_brr(bne, _f);
+ case_brf(bne, _f, 32);
+ case_brr(bne, _d);
+ case_brf(bne, _d, 64);
+ case_brr(bunlt, _f);
+ case_brf(bunlt, _f, 32);
+ case_brr(bunlt, _d);
+ case_brf(bunlt, _d, 64);
+ case_brr(bunle, _f);
+ case_brf(bunle, _f, 32);
+ case_brr(bunle, _d);
+ case_brf(bunle, _d, 64);
+ case_brr(buneq, _f);
+ case_brf(buneq, _f, 32);
+ case_brr(buneq, _d);
+ case_brf(buneq, _d, 64);
+ case_brr(bunge, _f);
+ case_brf(bunge, _f, 32);
+ case_brr(bunge, _d);
+ case_brf(bunge, _d, 64);
+ case_brr(bungt, _f);
+ case_brf(bungt, _f, 32);
+ case_brr(bungt, _d);
+ case_brf(bungt, _d, 64);
+ case_brr(bltgt, _f);
+ case_brf(bltgt, _f, 32);
+ case_brr(bltgt, _d);
+ case_brf(bltgt, _d, 64);
+ case_brr(bord, _f);
+ case_brf(bord, _f, 32);
+ case_brr(bord, _d);
+ case_brf(bord, _d, 64);
+ case_brr(bunord, _f);
+ case_brf(bunord, _f, 32);
+ case_brr(bunord, _d);
+ case_brf(bunord, _d, 64);
+ case jit_code_jmpr:
+ jmpr(rn(node->u.w));
+ break;
+ case jit_code_jmpi:
+ temp = node->u.n;
+ assert(temp->code == jit_code_label ||
+ temp->code == jit_code_epilog);
+ /* no support for jump outside jit */
+ if (temp->flag & jit_flag_patch)
+ jmpi(temp->u.w);
+ else {
+ word = jmpi_p(_jit->pc.w);
+ patch(word, node);
+ }
+ break;
+ case jit_code_callr:
+ callr(rn(node->u.w));
+ break;
+ case jit_code_calli:
+ if (node->flag & jit_flag_node) {
+ temp = node->u.n;
+ assert(temp->code == jit_code_label ||
+ temp->code == jit_code_epilog);
+ if (!(temp->flag & jit_flag_patch)) {
+ word = calli_p(temp->u.w);
+ patch(word, node);
+ }
+ else
+ calli(temp->u.w);
+ }
+ else
+ calli(node->u.w);
+ break;
+ case jit_code_prolog:
+ _jitc->function = _jitc->functions.ptr + node->w.w;
+ undo.node = node;
+ undo.word = _jit->pc.w;
+ undo.patch_offset = _jitc->patches.offset;
+ restart_function:
+ _jitc->again = 0;
+ prolog(node);
+ break;
+ case jit_code_epilog:
+ assert(_jitc->function == _jitc->functions.ptr + node->w.w);
+ if (_jitc->again) {
+ for (temp = undo.node->next;
+ temp != node; temp = temp->next) {
+ if (temp->code == jit_code_label ||
+ temp->code == jit_code_epilog)
+ temp->flag &= ~jit_flag_patch;
+ }
+ temp->flag &= ~jit_flag_patch;
+ node = undo.node;
+ _jit->pc.w = undo.word;
+ _jitc->patches.offset = undo.patch_offset;
+ goto restart_function;
+ }
+ /* remember label is defined */
+ node->flag |= jit_flag_patch;
+ node->u.w = _jit->pc.w;
+ epilog(node);
+ _jitc->function = NULL;
+ break;
+ case jit_code_live:
+ case jit_code_arg:
+ case jit_code_arg_f: case jit_code_arg_d:
+ break;
+ default:
+ abort();
+ }
+ jit_regarg_clr(node, value);
+ /* update register live state */
+ jit_reglive(node);
+ }
+#undef case_brf
+#undef case_brw
+#undef case_brr
+#undef case_wrr
+#undef case_rrf
+#undef case_rrrw
+#undef case_rrw
+#undef case_rrrr
+#undef case_rrr
+#undef case_wr
+#undef case_rw
+#undef case_rr
+
+ for (offset = 0; offset < _jitc->patches.offset; offset++) {
+ node = _jitc->patches.ptr[offset].node;
+ word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w;
+ patch_at(_jitc->patches.ptr[offset].inst, word);
+ }
+
+ return (_jit->code.ptr);
+}
+
+#define CODE 1
+# include "jit_hppa-cpu.c"
+# include "jit_hppa-fpu.c"
+#undef CODE
+
+void
+_emit_ldxi(jit_state_t *_jit, jit_gpr_t r0, jit_gpr_t r1, jit_word_t i0)
+{
+ ldxi(rn(r0), rn(r1), i0);
+}
+
+void
+_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_gpr_t r1)
+{
+ stxi(i0, rn(r0), rn(r1));
+}
+
+void
+_emit_ldxi_d(jit_state_t *_jit, jit_fpr_t r0, jit_gpr_t r1, jit_word_t i0)
+{
+ ldxi_d(rn(r0), rn(r1), i0);
+}
+
+void
+_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_fpr_t r1)
+{
+ stxi_d(i0, rn(r0), rn(r1));
+}
+
+static void
+_patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
+{
+ jit_int32_t flag;
+
+ assert(node->flag & jit_flag_node);
+ if (node->code == jit_code_movi)
+ flag = node->v.n->flag;
+ else
+ flag = node->u.n->flag;
+ assert(!(flag & jit_flag_patch));
+ if (_jitc->patches.offset >= _jitc->patches.length) {
+ jit_realloc((jit_pointer_t *)&_jitc->patches.ptr,
+ _jitc->patches.length * sizeof(jit_patch_t),
+ (_jitc->patches.length + 1024) * sizeof(jit_patch_t));
+ _jitc->patches.length += 1024;
+ }
+ _jitc->patches.ptr[_jitc->patches.offset].inst = instr;
+ _jitc->patches.ptr[_jitc->patches.offset].node = node;
+ ++_jitc->patches.offset;
+}
diff --git a/lib/lightning.c b/lib/lightning.c
index 30f268d..7242e9d 100644
--- a/lib/lightning.c
+++ b/lib/lightning.c
@@ -1460,9 +1460,17 @@ _jit_optimize(jit_state_t *_jit)
#endif
if (_jitc->function) {
if ((mask & (jit_cc_a0_reg|jit_cc_a0_chg)) ==
- (jit_cc_a0_reg|jit_cc_a0_chg))
- jit_regset_setbit(&_jitc->function->regset,
- jit_regno(node->u.w));
+ (jit_cc_a0_reg|jit_cc_a0_chg)) {
+ if (mask & jit_cc_a0_rlh) {
+ jit_regset_setbit(&_jitc->function->regset,
+ jit_regno(node->u.q.l));
+ jit_regset_setbit(&_jitc->function->regset,
+ jit_regno(node->u.q.h));
+ }
+ else
+ jit_regset_setbit(&_jitc->function->regset,
+ jit_regno(node->u.w));
+ }
if ((mask & (jit_cc_a1_reg|jit_cc_a1_chg)) ==
(jit_cc_a1_reg|jit_cc_a1_chg))
jit_regset_setbit(&_jitc->function->regset,
@@ -2869,4 +2877,6 @@ _patch_register(jit_state_t *_jit, jit_node_t *node,
jit_node_t *link,
# include "jit_sparc.c"
#elif defined(__ia64__)
# include "jit_ia64.c"
+#elif defined(__hppa__)
+# include "jit_hppa.c"
#endif
- [Guile-commits] 429/437: Remove disassembler support from lightning, (continued)
- [Guile-commits] 429/437: Remove disassembler support from lightning, Andy Wingo, 2018/07/02
- [Guile-commits] 346/437: PPC: Build and pass all tests in powerpcle, Andy Wingo, 2018/07/02
- [Guile-commits] 180/437: Correct C sequence point problem., Andy Wingo, 2018/07/02
- [Guile-commits] 370/437: Add missing ellipsis in allocar.tst, Andy Wingo, 2018/07/02
- [Guile-commits] 337/437: Remove a wrong optimization of callee save registers, Andy Wingo, 2018/07/02
- [Guile-commits] 437/437: Wire up lightning into libguile build, Andy Wingo, 2018/07/02
- [Guile-commits] 362/437: Avoid problems if JIT_INSTR_MAX is miscalculated, Andy Wingo, 2018/07/02
- [Guile-commits] 183/437: Correct qmul and qdiv in ppc., Andy Wingo, 2018/07/02
- [Guile-commits] 235/437: Correct build on FreeBSD/amd64, Andy Wingo, 2018/07/02
- [Guile-commits] 240/437: Correct wrong test and update of arm thumb offset information., Andy Wingo, 2018/07/02
- [Guile-commits] 215/437: Add functional hppa port. All tests pass.,
Andy Wingo <=
- [Guile-commits] 369/437: Correct typo in x87.nodata test list, Andy Wingo, 2018/07/02
- [Guile-commits] 307/437: x86: Build and pass all tests on 32 bit cygwin, Andy Wingo, 2018/07/02
- [Guile-commits] 401/437: Implement a correct generation of Fibonacci numbers., Andy Wingo, 2018/07/02
- [Guile-commits] 318/437: Add label predicates, Andy Wingo, 2018/07/02
- [Guile-commits] 373/437: Update copyright date, Andy Wingo, 2018/07/02
- [Guile-commits] 403/437: Correct wrong movr simplification, Andy Wingo, 2018/07/02
- [Guile-commits] 324/437: misc: Enable silent rules to make warnings stick out, Andy Wingo, 2018/07/02
- [Guile-commits] 175/437: Make JIT_RET, JIT_FRET and JIT_SP private., Andy Wingo, 2018/07/02
- [Guile-commits] 430/437: Remove special cflags for obsolete Lightning targets, Andy Wingo, 2018/07/02
- [Guile-commits] 375/437: Update the correct fp offset and add assertions, Andy Wingo, 2018/07/02