[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 188/437: Add framework for sparc port.
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 188/437: Add framework for sparc port. |
|
Date: |
Mon, 2 Jul 2018 05:14:15 -0400 (EDT) |
wingo pushed a commit to branch lightning
in repository guile.
commit 610a56930024c9479388c9b0afa3fc94ef9fa7c5
Author: pcpa <address@hidden>
Date: Mon Feb 18 01:18:54 2013 -0300
Add framework for sparc port.
* include/lightning/jit_sparc.h, lib/jit_sparc-cpu.c,
lib/jit_sparc-fpu.c, lib/jit_sparc.c: New files implementing
the basic framework of the sparc port.
* configure.ac, include/lightning.h, include/lightning/Makefile.am,
include/lightning/jit_private.h, lib/jit_disasm.c: Update
for the sparc port framework.
* lib/jit_mips.c: Correct reversed retr/reti logic.
* lib/jit_ppc.c: Correct misspelled __LITTLE_ENDIAN.
* lib/lightning.c: Always do byte hashing in hash_data, because
the logic to "compress" strings causes large pointers to not
be guaranteed aligned at 4 byte boundaries.
Update for the sparc port framework.
---
ChangeLog | 19 +
check/lightning.c | 8 +
configure.ac | 10 +-
include/lightning.h | 2 +
include/lightning/Makefile.am | 4 +
include/lightning/jit_private.h | 4 +
include/lightning/jit_sparc.h | 60 ++
lib/Makefile.am | 3 +
lib/jit_disasm.c | 3 +
lib/jit_mips.c | 10 +-
lib/jit_ppc.c | 10 +-
lib/jit_sparc-cpu.c | 1535 +++++++++++++++++++++++++++++++++++++++
lib/jit_sparc-fpu.c | 689 ++++++++++++++++++
lib/{jit_ppc.c => jit_sparc.c} | 756 ++++++++-----------
lib/lightning.c | 16 +-
15 files changed, 2661 insertions(+), 468 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index e0d1532..1e20323 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,22 @@
+2013-02-17 Paulo Andrade <address@hidden>
+
+ * include/lightning/jit_sparc.h, lib/jit_sparc-cpu.c,
+ lib/jit_sparc-fpu.c, lib/jit_sparc.c: New files implementing
+ the basic framework of the sparc port.
+
+ * configure.ac, include/lightning.h, include/lightning/Makefile.am,
+ include/lightning/jit_private.h, lib/jit_disasm.c: Update
+ for the sparc port framework.
+
+ * lib/jit_mips.c: Correct reversed retr/reti logic.
+
+ * lib/jit_ppc.c: Correct misspelled __LITTLE_ENDIAN.
+
+ * lib/lightning.c: Always do byte hashing in hash_data, because
+ the logic to "compress" strings causes large pointers to not
+ be guaranteed aligned at 4 byte boundaries.
+ Update for the sparc port framework.
+
2013-02-11 Paulo Andrade <address@hidden>
* lib/jit_arm.c: Correct jit_pushargi_f in the arm hardfp abi.
diff --git a/check/lightning.c b/check/lightning.c
index 58bca38..ca18385 100644
--- a/check/lightning.c
+++ b/check/lightning.c
@@ -522,6 +522,9 @@ static void rehash(hash_t *hash);
/*
* Initialization
*/
+#if __sparc__
+extern int missing_count;
+#endif
static jit_state_t *_jit;
static int flag_verbose;
static int flag_disasm;
@@ -3994,6 +3997,11 @@ main(int argc, char *argv[])
pclose(parser.fp);
parser.fp = NULL;
+#if defined(__sparc__)
+ if (missing_count)
+ flag_disasm = 1;
+#endif
+
for (opt_short = 0; opt_index < argc; opt_short++, opt_index++)
argv[opt_short] = argv[opt_index];
argv[opt_short] = NULL;
diff --git a/configure.ac b/configure.ac
index 9e9f939..13a8c85 100644
--- a/configure.ac
+++ b/configure.ac
@@ -75,12 +75,14 @@ case "$target_cpu" in
*arm*) cpu=arm ;;
*mips*) cpu=mips ;;
*powerpc*) cpu=ppc ;;
+ *sparc*) cpu=sparc ;;
*) ;;
esac
-AM_CONDITIONAL(cpu_arm, [test cpu-$cpu = cpu-arm])
-AM_CONDITIONAL(cpu_mips, [test cpu-$cpu = cpu-mips])
-AM_CONDITIONAL(cpu_ppc, [test cpu-$cpu = cpu-ppc])
-AM_CONDITIONAL(cpu_x86, [test cpu-$cpu = cpu-x86])
+AM_CONDITIONAL(cpu_arm, [test cpu-$cpu = cpu-arm])
+AM_CONDITIONAL(cpu_mips, [test cpu-$cpu = cpu-mips])
+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])
# Test x87 if both, x87 and sse2 available
ac_cv_test_x86_x87=
diff --git a/include/lightning.h b/include/lightning.h
index bd9e37d..fff4851 100644
--- a/include/lightning.h
+++ b/include/lightning.h
@@ -72,6 +72,8 @@ typedef jit_int32_t jit_fpr_t;
# include <lightning/jit_arm.h>
#elif defined(__ppc__)
# include <lightning/jit_ppc.h>
+#elif defined(__sparc__)
+# include <lightning/jit_sparc.h>
#endif
#define jit_flag_node 0x00000001 /* patch node not absolute */
diff --git a/include/lightning/Makefile.am b/include/lightning/Makefile.am
index 94aadcd..9e1425a 100644
--- a/include/lightning/Makefile.am
+++ b/include/lightning/Makefile.am
@@ -29,6 +29,10 @@ if cpu_ppc
lightning_include_HEADERS = \
jit_ppc.h
endif
+if cpu_sparc
+lightning_include_HEADERS = \
+ jit_sparc.h
+endif
if cpu_x86
lightning_include_HEADERS = \
jit_x86.h
diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h
index a708a3d..384d287 100644
--- a/include/lightning/jit_private.h
+++ b/include/lightning/jit_private.h
@@ -70,6 +70,10 @@
# define JIT_SP _R1
# define JIT_RET _R3
# define JIT_FRET _F1
+#elif defined(__sparc__)
+# define JIT_SP _SP
+# define JIT_RET _I0
+# define JIT_FRET _F0
#endif
#define jit_size(vector) (sizeof(vector) / sizeof((vector)[0]))
diff --git a/include/lightning/jit_sparc.h b/include/lightning/jit_sparc.h
new file mode 100644
index 0000000..54cb221
--- /dev/null
+++ b/include/lightning/jit_sparc.h
@@ -0,0 +1,60 @@
+/*
+ * 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_sparc_h
+#define _jit_sparc_h
+
+#define JIT_HASH_CONSTS 1
+#define JIT_NUM_OPERANDS 3
+
+/*
+ * Types
+ */
+#define JIT_FP _FP
+typedef enum {
+#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 6)
+#define jit_r(i) (_G2 + (i))
+#define jit_r_num() 6
+#define jit_v(i) (_L0 + (i))
+#define jit_v_num() 8
+#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 6)
+#define jit_f(i) (_F0 + (i))
+#define jit_f_num() 8
+#define JIT_R0 _G2
+#define JIT_R1 _G3
+#define JIT_R2 _G4
+#define JIT_V0 _L0
+#define JIT_V1 _L1
+#define JIT_V2 _L2
+ _G0, _G1, _G2, _G3, _G4, _G5, _G6, _G7,
+ _O0, _O1, _O2, _O3, _O4, _O5, _SP, _O7,
+ _L0, _L1, _L2, _L3, _L4, _L5, _L6, _L7,
+ _I0, _I1, _I2, _I3, _I4, _I5, _FP, _I7,
+#define JIT_F0 _F0
+#define JIT_F1 _F1
+#define JIT_F2 _F2
+#define JIT_F3 _F3
+#define JIT_F4 _F4
+#define JIT_F5 _F5
+ _F0, _F1, _F2, _F3, _F4, _F5, _F6, _F7,
+#define JIT_NOREG _NOREG
+ _NOREG,
+} jit_reg_t;
+
+typedef jit_int64_t jit_regset_t;
+
+#endif /* _jit_sparc_h */
diff --git a/lib/Makefile.am b/lib/Makefile.am
index 02d5897..3b33ce3 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -33,6 +33,9 @@ EXTRA_DIST = \
jit_ppc.c \
jit_ppc-cpu.c \
jit_ppc-fpu.c \
+ jit_sparc.c \
+ jit_sparc-cpu.c \
+ jit_sparc-fpu.c \
jit_x86.c \
jit_x86-cpu.c \
jit_x86-sse.c \
diff --git a/lib/jit_disasm.c b/lib/jit_disasm.c
index 07252fc..6230c6e 100644
--- a/lib/jit_disasm.c
+++ b/lib/jit_disasm.c
@@ -81,6 +81,9 @@ jit_init_debug(void)
if (jit_cpu.thumb)
disasm_info.disassembler_options = "force-thumb";
# endif
+# if defined(__sparc__)
+ disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG;
+#endif
disasm_info.print_address_func = disasm_print_address;
if (bfd_get_file_flags(disasm_bfd) & HAS_SYMS) {
diff --git a/lib/jit_mips.c b/lib/jit_mips.c
index 745623f..b646b3f 100644
--- a/lib/jit_mips.c
+++ b/lib/jit_mips.c
@@ -180,17 +180,17 @@ _jit_ret(jit_state_t *_jit)
void
_jit_retr(jit_state_t *_jit, jit_int32_t u)
{
- jit_movr(JIT_RET, u);
+ if (JIT_RET != u)
+ jit_movr(JIT_RET, u);
+ else
+ jit_live(JIT_RET);
jit_ret();
}
void
_jit_reti(jit_state_t *_jit, jit_word_t u)
{
- if (JIT_RET != u)
- jit_movi(JIT_RET, u);
- else
- jit_live(JIT_RET);
+ jit_movi(JIT_RET, u);
jit_ret();
}
diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c
index d63fe79..5dc8f6a 100644
--- a/lib/jit_ppc.c
+++ b/lib/jit_ppc.c
@@ -322,7 +322,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
if (v->u.w < 8)
jit_extr_uc(u, JIT_RA0 - v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
+#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_uc(u, JIT_FP, v->u.w);
#else
jit_ldxi_uc(u, JIT_FP,
@@ -337,7 +337,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
if (v->u.w < 8)
jit_extr_s(u, JIT_RA0 - v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
+#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_s(u, JIT_FP, v->u.w);
#else
jit_ldxi_s(u, JIT_FP,
@@ -352,7 +352,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
if (v->u.w < 8)
jit_extr_us(u, JIT_RA0 - v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
+#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_us(u, JIT_FP, v->u.w);
#else
jit_ldxi_us(u, JIT_FP,
@@ -367,7 +367,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
if (v->u.w < 8)
jit_movr(u, JIT_RA0 - v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
+#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_i(u, JIT_FP, v->u.w);
#else
jit_ldxi_i(u, JIT_FP,
@@ -383,7 +383,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
if (v->u.w < 8)
jit_extr_ui(u, JIT_RA0 - v->u.w);
else {
-# if __BYTE_ORDER == __LITTLE__ENDIAN
+# if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_ui(u, JIT_FP, v->u.w);
# else
jit_ldxi_ui(u, JIT_FP,
diff --git a/lib/jit_sparc-cpu.c b/lib/jit_sparc-cpu.c
new file mode 100644
index 0000000..77ea71f
--- /dev/null
+++ b/lib/jit_sparc-cpu.c
@@ -0,0 +1,1535 @@
+/*
+ * 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 _SP_REGNO 0x0e
+# define _FP_REGNO 0x1e
+# define _O7_REGNO 0x0f
+# define _L0_REGNO 0x10
+# define _L1_REGNO 0x11
+# define _L2_REGNO 0x12
+# define _L3_REGNO 0x13
+# define _L4_REGNO 0x14
+# define _L5_REGNO 0x15
+# define _L6_REGNO 0x16
+# define _L7_REGNO 0x17
+# define _I7_REGNO 0x1f
+/*
+ * - previous stack frame
+ * fp ----
+ * fp- local variables (in lightning, 8 bytes space for float conversion)
+ * fp- alloca
+ * sp+ stack arguments
+ * sp+ 6 words to save register arguments
+ * sp+ 1 word for hidden address of aggregate return value
+ * sp+ 16 words for in and local registers
+ * sp ----
+ * decreasing memory address - next stack frame (not yet allocated)
+ */
+ /* FIXME need to allocate space for saving float registers f0-f7? */
+# define stack_framesize ((16 + 1 + 6) * 4)
+
+typedef union {
+ struct { jit_uint32_t b: 2; } op;
+ struct { jit_uint32_t _: 2; jit_uint32_t b: 1; } a;
+ struct { jit_uint32_t _: 2; jit_uint32_t b: 5; } rd;
+ struct { jit_uint32_t _: 2; jit_uint32_t b: 30; } disp30;
+ struct { jit_uint32_t _: 3; jit_uint32_t b: 4; } cond;
+ struct { jit_uint32_t _: 7; jit_uint32_t b: 3; } op2;
+ struct { jit_uint32_t _: 7; jit_uint32_t b: 6; } op3;
+ struct { jit_uint32_t _: 10; jit_uint32_t b: 22; } imm22;
+ struct { jit_uint32_t _: 10; jit_uint32_t b: 22; } disp22;
+ struct { jit_uint32_t _: 13; jit_uint32_t b: 5; } rs1;
+ struct { jit_uint32_t _: 18; jit_uint32_t b: 1; } i;
+ struct { jit_uint32_t _: 18; jit_uint32_t b: 9; } opf;
+ struct { jit_uint32_t _: 19; jit_uint32_t b: 8; } asi;
+ struct { jit_uint32_t _: 19; jit_uint32_t b: 6; } res;
+ struct { jit_uint32_t _: 19; jit_uint32_t b: 13; } simm13;
+ struct { jit_uint32_t _: 27; jit_uint32_t b: 5; } rs2;
+ struct { jit_uint32_t _: 25; jit_uint32_t b: 7; } imm7;
+ jit_int32_t v;
+} jit_instr_t;
+# define ii(i) *_jit->pc.ui++ = i
+
+# define s7_p(imm) ((imm) <= 127 && (imm) >= -128)
+# define s13_p(imm) ((imm) <= 8191 && (imm) >= -8192)
+# define s22_p(imm) ((imm) <= 4194303 && (imm) >= -4194304)
+# define s30_p(imm) ((imm) <= 1073741823 && (imm) >=
-1073741824)
+# define f1(op, disp30) _f1(_jit, op, disp30)
+static void _f1(jit_state_t*,jit_int32_t,jit_int32_t);
+# define f2r(op, rd, op2, imm22) _f2r(_jit, op, rd, op2, imm22)
+static void _f2r(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+# define f2b(op, a, cond, op2, disp22) _f2b(_jit, op, a, cond, op2,
disp22)
+static void
+_f2b(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+# define f3r(op, rd, op3, rs1, rs2) _f3r(_jit, op, rd, op3, rs1, rs2)
+static void _f3r(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+# define f3i(op, rd, op3, rs1, simm13) _f3i(_jit, op, rd, op3, rs1,
simm13)
+static void _f3i(jit_state_t*,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+# define f3t(cond, rs1, i, ri) _f3t(_jit, cond, rs1, i, ri)
+static void _f3t(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
+ maybe_unused;
+# define f3a(op, rd, op3, rs1, rs2) _f3a(_jit, op, rd, op3, rs1, asi, rs2)
+static void _f3a(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
+ maybe_unused;
+
+# define LDSB(rs1, rs2, rd) f3r(3, rd, 9, rs1, rs2)
+# define LDSBI(rs1, imm, rd) f3i(3, rd, 9, rs1, imm)
+# define LDSH(rs1, rs2, rd) f3r(3, rd, 10, rs1, rs2)
+# define LDSHI(rs1, imm, rd) f3r(3, rd, 10, rs1, imm)
+# define LDUB(rs1, rs2, rd) f3r(3, rd, 1, rs1, rs2)
+# define LDUBI(rs1, imm, rd) f3i(3, rd, 1, rs1, imm)
+# define LDUH(rs1, rs2, rd) f3r(3, rd, 2, rs1, rs2)
+# define LDUHI(rs1, imm, rd) f3i(3, rd, 2, rs1, imm)
+# define LD(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2)
+# define LDI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm)
+# define LDD(rs1, rs2, rd) f3r(3, rd, 3, rs1, rs2)
+# define LDDI(rs1, imm, rd) f3i(3, rd, 3, rs1, imm)
+# define LDSBA(rs1, rs2, asi, rd) f3a(3, rd, 25, rs1, asi, rs2)
+# define LDSHA(rs1, rs2, asi, rd) f3a(3, rd, 26, rs1, asi, rs2)
+# define LDUBA(rs1, rs2, asi, rd) f3a(3, rd, 17, rs1, asi, rs2)
+# define LDUHA(rs1, rs2, asi, rd) f3a(3, rd, 18, rs1, asi, rs2)
+# define LDA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2)
+# define LDDA(rs1, rs2, asi, rd) f3a(3, rd, 19, rs1, asi, rs2)
+# define LDC(rs1, rs2, rd) f3r(3, rd, 48, rs1, rs2)
+# define LDCI(rs1, imm, rd) f3i(3, rd, 48, rs1, imm)
+# define LDDC(rs1, rs2, rd) f3r(3, rd, 51, rs1, rs2)
+# define LDDCI(rs1, imm, rd) f3i(3, rd, 51, rs1, imm)
+# define LDCSR(rs1, rs2, rd) f3r(3, rd, 49, rs1, rs2)
+# define LDCSRI(rs1, imm, rd) f3i(3, rd, 49, rs1, imm)
+# define STB(rd, rs1, rs2) f3r(3, rd, 5, rs1, rs2)
+# define STBI(rd, rs1, imm) f3i(3, rd, 5, rs1, imm)
+# define STH(rd, rs1, rs2) f3r(3, rd, 6, rs1, rs2)
+# define STHI(rd, rs1, imm) f3i(3, rd, 6, rs1, imm)
+# define ST(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2)
+# define STI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm)
+# define STD(rrd, s1, rs2) f3r(3, rd, 7, rs1, rs2)
+# define STDI(rd, rs1, imm) f3i(3, rd, 7, rs1, imm)
+# define STBA(rd, rs1, rs2) f3a(3, rd, 21, rs1, asi, rs2)
+# define STHA(rd, rs1, rs2) f3a(3, rd, 22, rs1, asi, rs2)
+# define STA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2)
+# define STDA(rd, rs1, rs2) f3a(3, rd, 23, rs1, asi, rs2)
+# define STC(rd, rs1, rs2) f3r(3, rd, 52, rs1, rs2)
+# define STCI(rd, rs1, imm) f3i(3, rd, 52, rs1, imm)
+# define STDC(rd, rs1, rs2) f3r(3, rd, 55, rs1, rs2)
+# define STDCI(rd, rs1, imm) f3i(3, rd, 55, rs1, imm)
+# define STCSR(rd, rs1, rs2) f3r(3, rd, 53, rs1, rs2)
+# define STCSRI(rd, rs1, imm) f3i(3, rd, 53, rs1, imm)
+# define STDCQ(rd, rs1, rs2) f3r(3, rd, 54, rs1, rs2)
+# define STDCQI(rd, rs1, imm) f3i(3, rd, 54, rs1, imm)
+# define LDSTUB(rs1, rs2, rd) f3r(3, rd, 13, rs1, rs2)
+# define LDSTUBI(rs1, imm, rd) f3r(3, rd, 13, rs1, imm)
+# define LDSTUBA(rs1, rs2, asi, rd) f3a(3, rd, 21, rs1, asi, rs2)
+# define SWAP(rs1, rs2, rd) f3r(3, rd, 15, rs1, rs2)
+# define SWAPI(rs1, imm, rd) f3r(3, rd, 15, rs1, imm)
+# define SWAPA(rs1, rs2, asi, rd) f3a(3, rd, 23, rs1, asi, rs2)
+# define NOP() SETHI(0, 0)
+# define HI(im) ((im) >> 10)
+# define LO(im) ((im) & 0x3ff)
+# define SETHI(im, rd) f2r(0, rd, 4, im)
+# define AND(rs1, rs2, rd) f3r(2, rd, 1, rs1, rs2)
+# define ANDI(rs1, imm, rd) f3i(2, rd, 1, rs1, imm)
+# define ANDcc(rs1, rs2, rd) f3r(2, rd, 17, rs1, rs2)
+# define ANDIcc(rs1, imm, rd) f3i(2, rd, 17, rs1, imm)
+# define BTST(rs1, rs2) ANDcc(rs1, rs2, 0)
+# define BTSTI(rs1, imm) ANDIcc(rs1, imm, 0)
+# define ANDN(rs1, rs2, rd) f3r(2, rd, 5, rs1, rs2)
+# define ANDNI(rs1, imm, rd) f3i(2, rd, 5, rs1, imm)
+# define ANDNcc(rs1, rs2, rd) f3r(2, rd, 21, rs1, rs2)
+# define ANDNIcc(rs1, imm, rd) f3i(2, rd, 21, rs1, imm)
+# define OR(rs1, rs2, rd) f3r(2, rd, 2, rs1, rs2)
+# define ORI(rs1, imm, rd) f3i(2, rd, 2, rs1, imm)
+# define ORcc(rs1, rs2, rd) f3r(2, rd, 18, rs1, rs2)
+# define ORIcc(rs1, imm, rd) f3i(2, rd, 18, rs1, imm)
+# define ORN(rs1, rs2, rd) f3r(2, rd, 6, rs1, rs2)
+# define ORNI(rs1, imm, rd) f3i(2, rd, 6, rs1, imm)
+# define ORNcc(rs1, rs2, rd) f3r(2, rd, 22, rs1, rs2)
+# define ORNIcc(rs1, imm, rd) f3i(2, rd, 22, rs1, imm)
+# define XOR(rs1, rs2, rd) f3r(2, rd, 3, rs1, rs2)
+# define XORI(rs1, imm, rd) f3i(2, rd, 3, rs1, imm)
+# define XORcc(rs1, rs2, rd) f3r(2, rd, 19, rs1, rs2)
+# define XORIcc(rs1, imm, rd) f3i(2, rd, 19, rs1, imm)
+# define XNOR(rs1, rs2, rd) f3r(2, rd, 7, rs1, rs2)
+# define XNORI(rs1, imm, rd) f3i(2, rd, 7, rs1, imm)
+# define XNORcc(rs1, rs2, rd) f3r(2, rd, 23, rs1, rs2)
+# define XNORIcc(rs1, imm, rd) f3i(2, rd, 23, rs1, imm)
+# define SLL(rs1, rs2, rd) f3r(2, rd, 37, rs1, rs2)
+# define SLLI(rs1, imm, rd) f3i(2, rd, 37, rs1, imm)
+# define SRL(rs1, rs2, rd) f3r(2, rd, 38, rs1, rs2)
+# define SRLI(rs1, imm, rd) f3i(2, rd, 38, rs1, imm)
+# define SRA(rs1, rs2, rd) f3r(2, rd, 39, rs1, rs2)
+# define SRAI(rs1, imm, rd) f3i(2, rd, 39, rs1, imm)
+# define ADD(rs1, rs2, rd) f3r(2, rd, 0, rs1, rs2)
+# define ADDI(rs1, imm, rd) f3i(2, rd, 0, rs1, imm)
+# define ADDcc(rs1, rs2, rd) f3r(2, rd, 16, rs1, rs2)
+# define ADDIcc(rs1, imm, rd) f3i(2, rd, 16, rs1, imm)
+# define ADDX(rs1, rs2, rd) f3r(2, rd, 8, rs1, rs2)
+# define ADDXI(rs1, imm, rd) f3i(2, rd, 8, rs1, imm)
+# define ADDXcc(rs1, rs2, rd) f3r(2, rd, 24, rs1, rs2)
+# define ADDXIcc(rs1, imm, rd) f3i(2, rd, 24, rs1, imm)
+# define TADDcc(rs1, rs2, rd) f3r(2, rd, 32, rs1, rs2)
+# define TADDIcc(rs1, imm, rd) f3i(2, rd, 32, rs1, imm)
+# define TADDccTV(rs1, rs2, rd) f3r(2, rd, 34, rs1, rs2)
+# define TADDIccTV(rs1, imm, rd) f3i(2, rd, 34, rs1, imm)
+# define SUB(rs1, rs2, rd) f3r(2, rd, 4, rs1, rs2)
+# define NEG(rs1, rd) SUB(0, rs1, rd)
+# define SUBI(rs1, imm, rd) f3i(2, rd, 4, rs1, imm)
+# define SUBcc(rs1, rs2, rd) f3r(2, rd, 20, rs1, rs2)
+# define SUBIcc(rs1, imm, rd) f3i(2, rd, 20, rs1, imm)
+# define CMP(rs1, rs2) SUBcc(rs1, rs2, 0)
+# define CMPI(rs1, imm) SUBIcc(rs1, imm, 0)
+# define SUBX(rs1, rs2, rd) f3r(2, rd, 12, rs1, rs2)
+# define SUBXI(rs1, imm, rd) f3i(2, rd, 12, rs1, imm)
+# define SUBXcc(rs1, rs2, rd) f3r(2, rd, 28, rs1, rs2)
+# define SUBXIcc(rs1, imm, rd) f3i(2, rd, 28, rs1, imm)
+# define TSUBcc(rs1, rs2, rd) f3r(2, rd, 33, rs1, rs2)
+# define TDADDIcc(rs1, imm, rd) f3i(2, rd, 33, rs1, imm)
+# define TSUBccTV(rs1, rs2, rd) f3r(2, rd, 35, rs1, rs2)
+# define TSUBIccTV(rs1, imm, rd) f3i(2, rd, 35, rs1, imm)
+# define MULScc(rs1, rs2, rd) f3r(2, rd, 36, rs1, rs2)
+# define MULSIcc(rs1, imm, rd) f3i(2, rd, 36, rs1, imm)
+# define UMUL(rs1, rs2, rd) f3r(2, rd, 10, rs1, rs2)
+# define UMULI(rs1, imm, rd) f3i(2, rd, 10, rs1, imm)
+# define SMUL(rs1, rs2, rd) f3r(2, rd, 11, rs1, rs2)
+# define SMULI(rs1, imm, rd) f3i(2, rd, 11, rs1, imm)
+# define UMULcc(rs1, rs2, rd) f3r(2, rd, 26, rs1, rs2)
+# define UMULIcc(rs1, imm, rd) f3i(2, rd, 26, rs1, imm)
+# define SMULcc(rs1, rs2, rd) f3r(2, rd, 27, rs1, rs2)
+# define SMULIcc(rs1, imm, rd) f3i(2, rd, 27, rs1, imm)
+# define UDIV(rs1, rs2, rd) f3r(2, rd, 14, rs1, rs2)
+# define UDIVI(rs1, imm, rd) f3i(2, rd, 14, rs1, imm)
+# define SDIV(rs1, rs2, rd) f3r(2, rd, 15, rs1, rs2)
+# define SDIVI(rs1, imm, rd) f3i(2, rd, 15, rs1, imm)
+# define UDIVcc(rs1, rs2, rd) f3r(2, rd, 30, rs1, rs2)
+# define UDIVIcc(rs1, imm, rd) f3i(2, rd, 30, rs1, imm)
+# define SDIVcc(rs1, rs2, rd) f3r(2, rd, 31, rs1, rs2)
+# define SDIVIcc(rs1, imm, rd) f3i(2, rd, 31, rs1, imm)
+# define SAVE(rs1, rs2, rd) f3r(2, rd, 60, rs1, rs2)
+# define SAVEI(rs1, imm, rd) f3i(2, rd, 60, rs1, imm)
+# define RESTORE(rs1, rs2, rd) f3r(2, rd, 61, rs1, rs2)
+# define RESTOREI(rs1, imm, rd) f3i(2, rd, 61, rs1, imm)
+# define SPARC_BA 8 /* always */
+# define SPARC_BN 0 /* never */
+# define SPARC_BNE 9 /* not equal - not Z */
+# define SPARC_BNZ SPARC_BNE
+# define SPARC_BE 1 /* equal - Z */
+# define SPARC_BZ SPARC_BE
+# define SPARC_BG 10 /* greater - not (Z or (N xor
V)) */
+# define SPARC_BLE 2 /* less or equal - Z or (N xor
V) */
+# define SPARC_BGE 11 /* greater or equal - not (N
xor V) */
+# define SPARC_BL 3 /* less - N xor V */
+# define SPARC_BGU 12 /* greater unsigned - not (C or
Z) */
+# define SPARC_BLEU 4 /* less or equal unsigned - C
or Z */
+# define SPARC_BCC 13 /* carry clear - not C */
+# define SPARC_BGEU SPARC_BCC
+# define SPARC_BCS 5 /* carry set - C */
+# define SPARC_BLU SPARC_BCS
+# define SPARC_BPOS 14 /* positive - not N */
+# define SPARC_BNEG 6 /* negative - N */
+# define SPARC_BVC 15 /* overflow clear - not V */
+# define SPARC_BVS 7 /* overflow set - V */
+# define B(cc, imm) f2b(0, 0, cc, 2, imm)
+# define Ba(cc, imm) f2b(0, 1, cc, 2, imm)
+# define BA(imm) B(SPARC_BA, imm)
+# define BAa(imm) Ba(SPARC_BA, imm)
+# define BN(imm) B(SPARC_BN, imm)
+# define BNa(imm) Ba(SPARC_BN, imm)
+# define BNE(imm) B(SPARC_BNE, imm)
+# define BNEa(imm) Ba(SPARC_BNE, imm)
+# define BNZ(imm) BNE(imm)
+# define BNZa(imm) BNEa(imm)
+# define BE(imm) B(SPARC_BE, imm)
+# define BEa(imm) Ba(SPARC_BE, imm)
+# define BZ(imm) BE(imm)
+# define BZa(imm) BEa(imm)
+# define BG(imm) B(SPARC_BG, imm)
+# define BGa(imm) Ba(SPARC_BG, imm)
+# define BLE(imm) B(SPARC_BLE, imm)
+# define BLEa(imm) Ba(SPARC_BLE, imm)
+# define BGE(imm) B(SPARC_BGE, imm)
+# define BGEa(imm) Ba(SPARC_BGE, imm)
+# define BL(imm) B(SPARC_BL, imm)
+# define BLa(imm) Ba(SPARC_BL, imm)
+# define BGU(imm) B(SPARC_BGU, imm)
+# define BGUa(imm) Ba(SPARC_BGU, imm)
+# define BLEU(imm) B(SPARC_BLEU, imm)
+# define BLEUa(imm) Ba(SPARC_BLEU, imm)
+# define BCC(imm) B(SPARC_BCC, imm)
+# define BCCa(imm) Ba(SPARC_BCC, imm)
+# define BGEU(imm) BCC(imm)
+# define BGEUa(imm) BCCa(imm)
+# define BCS(imm) B(SPARC_BCS, imm)
+# define BCSa(imm) Ba(SPARC_BCS, imm)
+# define BLU(imm) BCS(imm)
+# define BLUa(imm) BCSa(imm)
+# define BPOS(imm) B(SPARC_BPOS, imm)
+# define BPOSa(imm) Ba(SPARC_BPOS, imm)
+# define BNEG(imm) B(SPARC_BNEG, imm)
+# define BNEGa(imm) Ba(SPARC_BNEG, imm)
+# define BVC(imm) B(SPARC_BVC, imm)
+# define BVCa(imm) Ba(SPARC_BVC, imm)
+# define BVS(imm) B(SPARC_BVS, imm)
+# define BVSa(imm) Ba(SPARC_BVS, imm)
+# define SPARC_CBA 8 /* always */
+# define SPARC_CBN 0 /* never */
+# define SPARC_CB3 7 /* 3 */
+# define SPARC_CB2 6 /* 2 */
+# define SPARC_CB23 5 /* 2 or 3 */
+# define SPARC_CB1 4 /* 1 */
+# define SPARC_CB13 3 /* 1 or 3 */
+# define SPARC_CB12 2 /* 1 or 2 */
+# define SPARC_CB123 1 /* 1 or 2 or 3 */
+# define SPARC_CB0 9 /* 0 */
+# define SPARC_CB03 10 /* 0 or 3 */
+# define SPARC_CB02 11 /* 0 or 2 */
+# define SPARC_CB023 12 /* 0 or 2 or 3 */
+# define SPARC_CB01 13 /* 0 or 1 */
+# define SPARC_CB013 14 /* 0 or 1 or 3 */
+# define SPARC_CB012 15 /* 0 or 1 or 2 */
+# define CB(cc, imm) f2b(0, 0, cc, 7, imm)
+# define CBa(cc, imm) f2b(0, 1, cc, 7, imm)
+# define CBA(imm) CB(SPARC_CBA, imm)
+# define CBAa(imm) CBa(SPARC_CBA, imm)
+# define CBN(imm) CB(SPARC_CBN, imm)
+# define CBNa(imm) CBa(SPARC_CBN, imm)
+# define CB3(imm) CB(SPARC_CB3, imm)
+# define CB3a(imm) CBa(SPARC_CB3, imm)
+# define CB2(imm) CB(SPARC_CB2, imm)
+# define CB2a(imm) CBa(SPARC_CB2, imm)
+# define CB23(imm) CB(SPARC_CB23, imm)
+# define CB23a(imm) CBa(SPARC_CB23, imm)
+# define CB1(imm) CB(SPARC_CB1, imm)
+# define CB1a(imm) CBa(SPARC_CB1, imm)
+# define CB13(imm) CB(SPARC_CB13, imm)
+# define CB13a(imm) CBa(SPARC_CB13, imm)
+# define CB12(imm) CB(SPARC_CB12, imm)
+# define CB12a(imm) CBa(SPARC_CB12, imm)
+# define CB123(imm) CB(SPARC_CB123, imm)
+# define CB123a(imm) CBa(SPARC_CB123, imm)
+# define CB0(imm) CB(SPARC_CB0, imm)
+# define CB0a(imm) CBa(SPARC_CB0, imm)
+# define CB03(imm) CB(SPARC_CB03, imm)
+# define CB03a(imm) CBa(SPARC_CB03, imm)
+# define CB02(imm) CB(SPARC_CB02, imm)
+# define CB02a(imm) CBa(SPARC_CB02, imm)
+# define CB023(imm) CB(SPARC_CB103, imm)
+# define CB023a(imm) CBa(SPARC_CB023, imm)
+# define CB01(imm) CB(SPARC_CB01, imm)
+# define CB01a(imm) CBa(SPARC_CB01, imm)
+# define CB013(imm) CB(SPARC_CB013, imm)
+# define CB013a(imm) CBa(SPARC_CB013, imm)
+# define CB012(imm) CB(SPARC_CB012, imm)
+# define CB012a(imm) CBa(SPARC_CB012, imm)
+# define CALLI(imm) f1(1, imm)
+# define CALL(r0) JMPL(_O7_REGNO, r0, 0)
+# define RETL() JMPLI(0, _O7_REGNO, 8)
+# define RET() JMPLI(0, _I7_REGNO, 8)
+# define JMPL(rd, rs1, rs2) f3r(2, rd, 56, rs1, rs2)
+# define JMPLI(rd, rs1, imm) f3i(2, rd, 56, rs1, imm)
+# define RETT(rs1, rs2) f3r(2, 0, 57, rs1, rs2)
+# define RETTI(rs1, imm) f3i(2, 0, 57, rs1, imm)
+# define SPARC_TA 8 /* always */
+# define SPARC_TN 0 /* never */
+# define SPARC_TNE 9 /* not equal - not Z */
+# define SPARC_TNZ SPARC_BNE
+# define SPARC_TE 1 /* equal - Z */
+# define SPARC_TZ SPARC_BE
+# define SPARC_TG 10 /* greater - not (Z or (N xor
V)) */
+# define SPARC_TLE 2 /* less or equal - Z or (N xor
V) */
+# define SPARC_TGE 11 /* greater or equal - not (N
xor V) */
+# define SPARC_TL 3 /* less - N xor V */
+# define SPARC_TGU 12 /* greater unsigned - not (C or
Z) */
+# define SPARC_TLEU 4 /* less or equal unsigned - C
or Z */
+# define SPARC_TCC 13 /* carry clear - not C */
+# define SPARC_TGEU SPARC_BCC
+# define SPARC_TCS 5 /* carry set - C */
+# define SPARC_TLU SPARC_BCS
+# define SPARC_TPOS 14 /* positive - not N */
+# define SPARC_TNEG 6 /* negative - N */
+# define SPARC_TVC 15 /* overflow clear - not V */
+# define SPARC_TVS 7 /* overflow set - V */
+# define T(cc, rs1, rs2) f3t(cc, rs1, 0, rs2)
+# define TI(cc, rs1, imm) f3t(cc, rs1, 1, imm)
+# define TA(rs1, rs2) T(SPARC_TA, rs1, rs2)
+# define TAI(rs1, imm) TI(SPARC_TA, rs1, imm)
+# define TN(rs1, rs2) T(SPARC_TN, rs1, rs2)
+# define TNI(rs1, imm) TI(SPARC_TN, rs1, imm)
+# define TNE(rs1, rs2) T(SPARC_TNE, rs1, rs2)
+# define TNEI(rs1, imm) TI(SPARC_TNE, rs1, imm)
+# define TNZ(rs1, rs2) TNE(rs1, rs2)
+# define TNZI(rs1, imm) TNEI(rs1, imm)
+# define TE(rs1, rs2) T(SPARC_TE, rs1, rs2)
+# define TEI(rs1, imm) TI(SPARC_TE, rs1, imm)
+# define TZ(rs1, rs2) TE(rs1, rs2)
+# define TZI(rs1, imm) TEI(rs1, imm)
+# define TG(rs1, rs2) T(SPARC_TG, rs1, rs2)
+# define TGI(rs1, imm) TI(SPARC_TG, rs1, imm)
+# define TLE(rs1, rs2) T(SPARC_TLE, rs1, rs2)
+# define TLEI(rs1, imm) TI(SPARC_TLE, rs1, imm)
+# define TGE(rs1, rs2) T(SPARC_TGE, rs1, rs2)
+# define TGEI(rs1, imm) TI(SPARC_TGE, rs1, imm)
+# define TL(rs1, rs2) T(SPARC_TL, rs1, rs2)
+# define TLI(rs1, imm) TI(SPARC_TL, rs1, imm)
+# define TGU(rs1, rs2) T(SPARC_TGU, rs1, rs2)
+# define TGUI(rs1, imm) TI(SPARC_TGU, rs1, imm)
+# define TLEU(rs1, rs2) T(SPARC_TLEU, rs1, rs2)
+# define TLEUI(rs1, imm) TI(SPARC_TLEU, rs1, imm)
+# define TCC(rs1, rs2) T(SPARC_TCC, rs1, rs2)
+# define TCCI(rs1, imm) TI(SPARC_TCC, rs1, imm)
+# define TGEU(rs1, rs2) TCC(rs1, rs2)
+# define TGEUI(rs1, imm) TCCI(rs1, imm)
+# define TCS(rs1, rs2) T(SPARC_TCC, rs1, rs2)
+# define TCSI(rs1, imm) TI(SPARC_TCC, rs1, imm)
+# define TLU(rs1, rs2) TCS(rs1, rs2)
+# define TLUI(rs1, imm) TCSI(rs1, imm)
+# define TPOS(rs1, rs2) T(SPARC_TPOS, rs1, rs2)
+# define TPOSI(rs1, imm) TI(SPARC_TPOS, rs1, imm)
+# define TNEG(rs1, rs2) T(SPARC_TNEG, rs1, rs2)
+# define TNEGI(rs1, imm) TI(SPARC_TNEG, rs1, imm)
+# define TVC(rs1, rs2) T(SPARC_TVC, rs1, rs2)
+# define TVCI(rs1, imm) TI(SPARC_TVC, rs1, imm)
+# define TVS(rs1, rs2) T(SPARC_TVS, rs1, rs2)
+# define TVSI(rs1, imm) TI(SPARC_TVS, rs1, imm)
+# define RDY(rd) f3i(2, rd, 40, 0, 0)
+# define RDASR(rs1, rd) f3i(2, rd, 40, rs1, 0)
+# define RDPSR(rd) f3i(2, rd, 41, 0, 0)
+# define RDWIM(rd) f3i(2, rd, 42, 0, 0)
+# define RDTBR(rd) f3i(2, rd, 43, 0, 0)
+# define WRY(rs1, rs2) f3r(2, 0, 48, rs1, rs2)
+# define WRYI(rs1, imm) f3i(2, 0, 48, rs1, imm)
+# define WRASR(rs1, rs2, rd) f3r(2, rd, 48, rs1, rs2)
+# define WRASRI(rs1, imm, rd) f3i(2, rd, 48, rs1, imm)
+# define WRPSR(rs1, rs2, rd) f3r(2, rd, 49, rs1, rs2)
+# define WRPSRI(rs1, imm, rd) f3i(2, rd, 49, rs1, imm)
+# define WRWIM(rs1, rs2, rd) f3r(2, rd, 50, rs1, rs2)
+# define WRWIMI(rs1, imm, rd) f3i(2, rd, 50, rs1, imm)
+# define WRTBR(rs1, rs2, rd) f3r(2, rd, 51, rs1, rs2)
+# define WRTBRI(rs1, imm, rd) f3i(2, rd, 51, rs1, imm)
+# define STBAR() f3i(2, 0, 40, 15, 0)
+# define UNIMP(imm) f2r(0, 0, 0, imm)
+# define FLUSH(rs1, rs2) f3r(2, 0, 59, rs1, rs2)
+# define FLUSHI(rs1, im) f3i(2, 0, 59, rs1, imm)
+
+# define nop(i0) _nop(_jit, i0)
+static void _nop(jit_state_t*, jit_int32_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) XNOR(r1, 0, r0)
+# define negr(r0, r1) NEG(r1, r0)
+
+# 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) ADDcc(r1, r2, r0)
+# 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) ADDXcc(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) SUBcc(r1, r2, r0)
+# 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) SUBXcc(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) UMUL(r1, r2, r0)
+# 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);
+
+# define divr(r0, r1, r2) SDIV(r1, r2, r0)
+# 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);
+# define divr_u(r0, r1, r2) UDIV(r1, r2, r0)
+# 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);
+
+# 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) SLL(r1, r2, r0)
+# define lshi(r0, r1, i0) SLLI(r1, i0, r0)
+# define rshr(r0, r1, r2) SRA(r1, r2, r0)
+# define rshi(r0, r1, i0) SRAI(r1, i0, r0)
+# define rshr_u(r0, r1, r2) SRL(r1, r2, r0)
+# define rshi_u(r0, r1, i0) SRLI(r1, i0, r0)
+
+# define htonr(r0,r1) movr(r0,r1)
+# define extr_c(r0,r1) _extr_c(_jit,r0,r1)
+static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+# define extr_uc(r0,r1) andi(r0, r1, 0xff)
+# define extr_s(r0,r1) _extr_s(_jit,r0,r1)
+static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+# define extr_us(r0,r1) _extr_us(_jit,r0,r1)
+static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+
+# define cr(cc, r0, r1, r2) _cr(_jit, cc, r0, r1, r2)
+static void _cr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+# define cw(cc, r0, r1, i0) _cw(_jit, cc, r0, r1, i0)
+static void _cw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+
+# define ltr(r0, r1, r2) cr(SPARC_BL, r0, r1, r2)
+# define lti(r0, r1, i0) cw(SPARC_BL, r0, r1, i0)
+# define ltr_u(r0, r1, r2) cr(SPARC_BLU, r0, r1, r2)
+# define lti_u(r0, r1, i0) cw(SPARC_BLU, r0, r1, i0)
+# define ler(r0, r1, r2) cr(SPARC_BLE, r0, r1, r2)
+# define lei(r0, r1, i0) cw(SPARC_BLE, r0, r1, i0)
+# define ler_u(r0, r1, r2) cr(SPARC_BLEU, r0, r1, r2)
+# define lei_u(r0, r1, i0) cw(SPARC_BLEU, r0, r1, i0)
+# define eqr(r0, r1, r2) cr(SPARC_BE, r0, r1, r2)
+# define eqi(r0, r1, i0) cw(SPARC_BE, r0, r1, i0)
+# define ger(r0, r1, r2) cr(SPARC_BGE, r0, r1, r2)
+# define gei(r0, r1, i0) cw(SPARC_BGE, r0, r1, i0)
+# define ger_u(r0, r1, r2) cr(SPARC_BGEU, r0, r1, r2)
+# define gei_u(r0, r1, i0) cw(SPARC_BGEU, r0, r1, i0)
+# define gtr(r0, r1, r2) cr(SPARC_BG, r0, r1, r2)
+# define gti(r0, r1, i0) cw(SPARC_BG, r0, r1, i0)
+# define gtr_u(r0, r1, r2) cr(SPARC_BGU, r0, r1, r2)
+# define gti_u(r0, r1, i0) cw(SPARC_BGU, r0, r1, i0)
+# define ner(r0, r1, r2) cr(SPARC_BNE, r0, r1, r2)
+# define nei(r0, r1, i0) cw(SPARC_BNE, r0, r1, i0)
+
+# define ldr_c(r0, r1) LDSB(r1, 0, r0)
+# define ldi_c(r0, i0) _ldi_c(_jit, r0, i0)
+static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+# define ldr_uc(r0, r1) LDUB(r1, 0, 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 ldr_s(r0, r1) LDSH(r1, 0, r0)
+# define ldi_s(r0, i0) _ldi_s(_jit, r0, i0)
+static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+# define ldr_us(r0, r1) LDUH(r1, 0, 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 ldr(u, v) ldr_i(u, v)
+# define ldr_i(r0, r1) LD(r1, 0, r0)
+# define ldi(u, v) ldi_i(u, v)
+# define ldi_i(r0, i0) _ldi_i(_jit, r0, i0)
+static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+# define ldxr_c(r0, r1, r2) LDSB(r1, r2, r0)
+# 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 ldxr_uc(r0, r1, r2) LDUB(r1, r2, 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 ldxr_s(r0, r1, r2) LDSH(r1, r2, r0)
+# 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 ldxr_us(r0, r1, r2) LDUH(r1, r2, 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 ldxr(u, v, w) ldxr_i(u, v, w)
+# define ldxr_i(r0, r1, r2) LD(r1, r2, r0)
+# define ldxi(u, v, w) ldxi_i(u, v, w)
+# define ldxi_i(r0, r1, i0) _ldxi_i(_jit, r0, r1, i0)
+static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+# define str_c(r0, r1) STB(r1, r0, 0)
+# define sti_c(i0, r0) _sti_c(_jit, i0, r0)
+static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+# define str_s(r0, r1) STH(r1, r0, 0)
+# define sti_s(i0, r0) _sti_s(_jit, i0, r0)
+static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+# define str(u, v) str_i(u, v)
+# define str_i(r0, r1) STI(r1, r0, 0)
+# define sti(u, v) sti_i(u, v)
+# 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_c(r0, r1, r2) STB(r2, r1, r0)
+# 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 stxr_s(r0, r1, r2) STH(r2, r1, r0)
+# 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 stxr(u, v, w) stxr_i(u, v, w)
+# define stxr_i(r0, r1, r2) ST(r2, r1, r0)
+# define stxi(u, v, w) stxi_i(u, v, w)
+# 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 br(cc, i0, r0, r1) _br(_jit, cc, i0, r0, r1)
+static jit_word_t
+_br(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+# define bw(cc, i0, r0, i1) _bw(_jit, cc, i0, r0, i1)
+static jit_word_t
+_bw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
+# define bltr(i0, r0, r1) br(SPARC_BL, i0, r0, r1)
+# define blti(i0, r0, i1) bw(SPARC_BL, i0, r0, i1)
+# define bltr_u(i0, r0, r1) br(SPARC_BLU, i0, r0, r1)
+# define blti_u(i0, r0, i1) bw(SPARC_BLU, i0, r0, i1)
+# define bler(i0, r0, r1) br(SPARC_BLE, i0, r0, r1)
+# define blei(i0, r0, i1) bw(SPARC_BLE, i0, r0, i1)
+# define bler_u(i0, r0, r1) br(SPARC_BLEU, i0, r0, r1)
+# define blei_u(i0, r0, i1) bw(SPARC_BLEU, i0, r0, i1)
+# define beqr(i0, r0, r1) br(SPARC_BE, i0, r0, r1)
+# define beqi(i0, r0, i1) bw(SPARC_BE, i0, r0, i1)
+# define bger(i0, r0, r1) br(SPARC_BGE, i0, r0, r1)
+# define bgei(i0, r0, i1) bw(SPARC_BGE, i0, r0, i1)
+# define bger_u(i0, r0, r1) br(SPARC_BGEU, i0, r0, r1)
+# define bgei_u(i0, r0, i1) bw(SPARC_BGEU, i0, r0, i1)
+# define bgtr(i0, r0, r1) br(SPARC_BG, i0, r0, r1)
+# define bgti(i0, r0, i1) bw(SPARC_BG, i0, r0, i1)
+# define bgtr_u(i0, r0, r1) br(SPARC_BGU, i0, r0, r1)
+# define bgti_u(i0, r0, i1) bw(SPARC_BGU, i0, r0, i1)
+# define bner(i0, r0, r1) br(SPARC_BNE, i0, r0, r1)
+# define bnei(i0, r0, i1) bw(SPARC_BNE, i0, r0, i1)
+
+# define b_asr(jif,add,sgn,i0,r0,r1) _b_asr(_jit,jif,add,sgn,i0,r0,r1)
+static jit_word_t
+_b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
+ jit_word_t,jit_int32_t,jit_int32_t);
+# define b_asw(jif,add,sgn,i0,r0,i1) _b_asw(_jit,jif,add,sgn,i0,r0,i1)
+static jit_word_t
+_b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
+ jit_word_t,jit_int32_t,jit_word_t);
+# define boaddr(i0, r0, r1) b_asr(1, 1, 1, i0, r0, r1)
+# define boaddi(i0, r0, i1) b_asw(1, 1, 1, i0, r0, i1)
+# define boaddr_u(i0, r0, r1) b_asr(1, 1, 0, i0, r0, r1)
+# define boaddi_u(i0, r0, i1) b_asw(1, 1, 0, i0, r0, i1)
+# define bxaddr(i0, r0, r1) b_asr(0, 1, 1, i0, r0, r1)
+# define bxaddi(i0, r0, i1) b_asw(0, 1, 1, i0, r0, i1)
+# define bxaddr_u(i0, r0, r1) b_asr(0, 1, 0, i0, r0, r1)
+# define bxaddi_u(i0, r0, i1) b_asw(0, 1, 0, i0, r0, i1)
+# define bosubr(i0, r0, r1) b_asr(1, 1, 1, i0, r0, r1)
+# define bosubi(i0, r0, i1) b_asw(1, 1, 1, i0, r0, i1)
+# define bosubr_u(i0, r0, r1) b_asr(1, 1, 0, i0, r0, r1)
+# define bosubi_u(i0, r0, i1) b_asw(1, 1, 0, i0, r0, i1)
+# define bxsubr(i0, r0, r1) b_asr(0, 1, 1, i0, r0, r1)
+# define bxsubi(i0, r0, i1) b_asw(0, 1, 1, i0, r0, i1)
+# define bxsubr_u(i0, r0, r1) b_asr(0, 1, 0, i0, r0, r1)
+# define bxsubi_u(i0, r0, i1) b_asw(0, 1, 0, i0, r0, i1)
+# define bm_r(set, i0, r0, r1) _bm_r(_jit,set,i0,r0,r1)
+static jit_word_t
+_bm_r(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_int32_t);
+# define bm_w(set,i0,r0,i1) _bm_w(_jit,set,i0,r0,i1)
+static jit_word_t
+_bm_w(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_word_t);
+# define bmsr(i0, r0, r1) bm_r(1, i0, r0, r1)
+# define bmsi(i0, r0, i1) bm_w(1, i0, r0, i1)
+# define bmcr(i0, r0, r1) bm_r(0, i0, r0, r1)
+# define bmci(i0, r0, i1) bm_w(0, i0, r0, i1)
+
+# 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(jump, label) _patch_at(_jit, jump, label)
+static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
+#endif
+
+#if CODE
+static void
+_f2r(jit_state_t *_jit,
+ jit_int32_t op, jit_int32_t rd, jit_int32_t op2, jit_int32_t imm22)
+{
+ jit_instr_t v;
+ assert(!(op & 0xfffffffc));
+ assert(!(rd & 0xffffffe0));
+ assert(!(op2 & 0xfffffff8));
+ assert(s22_p(imm22));
+ v.op.b = op;
+ v.rd.b = rd;
+ v.op2.b = op2;
+ v.imm22.b = imm22;
+ ii(v.v);
+}
+
+static void
+_f2b(jit_state_t *_jit,
+ jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
+ jit_int32_t disp22)
+{
+ jit_instr_t v;
+ assert(!(op & 0xfffffffc));
+ assert(!(a & 0xfffffffe));
+ assert(!(cond & 0xfffffff0));
+ assert(!(op2 & 0xfffffff8));
+ assert(s22_p(disp22));
+ v.op.b = op;
+ v.a.b = a;
+ v.cond.b = cond;
+ v.op2.b = op2;
+ v.disp22.b = disp22;
+ ii(v.v);
+}
+
+static void
+_f3r(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
+ jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
+{
+ jit_instr_t v;
+ assert(!(op & 0xfffffffc));
+ assert(!(rd & 0xffffffe0));
+ assert(!(op3 & 0xffffffc0));
+ assert(!(rs1 & 0xffffffe0));
+ assert(!(rs2 & 0xffffffe0));
+ v.op.b = op;
+ v.rd.b = rd;
+ v.op3.b = op3;
+ v.rs1.b = rs1;
+ v.i.b = 0;
+ v.asi.b = 0;
+ v.rs2.b = rs2;
+ ii(v.v);
+}
+
+static void
+_f3i(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
+ jit_int32_t op3, jit_int32_t rs1, jit_int32_t simm13)
+{
+ jit_instr_t v;
+ assert(!(op & 0xfffffffc));
+ assert(!(rd & 0xffffffe0));
+ assert(!(op3 & 0xffffffc0));
+ assert(!(rs1 & 0xffffffe0));
+ assert(s13_p(simm13));
+ v.op.b = op;
+ v.rd.b = rd;
+ v.op3.b = op3;
+ v.rs1.b = rs1;
+ v.i.b = 1;
+ v.simm13.b = simm13;
+ ii(v.v);
+}
+
+static void
+_f3t(jit_state_t *_jit, jit_int32_t cond,
+ jit_int32_t rs1, jit_int32_t i, jit_int32_t rs2_imm7)
+{
+ jit_instr_t v;
+ assert(!(cond & 0xfffffff0));
+ assert(!(i & 0xfffffffe));
+ assert(!(rs1 & 0xffffffe0));
+ v.op.b = 2;
+ v.rd.b = cond;
+ v.op3.b = 58;
+ v.i.b = i;
+ if (i) {
+ assert(s7_p(rs2_imm7));
+ v.res.b = 0;
+ v.imm7.b = rs2_imm7;
+ }
+ else {
+ assert(!(rs2_imm7 & 0xffffffe0));
+ v.asi.b = 0;
+ v.rs2.b = rs2_imm7;
+ }
+ ii(v.v);
+}
+
+static void
+_f3a(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
+ jit_int32_t op3, jit_int32_t rs1, jit_int32_t asi, jit_int32_t rs2)
+{
+ jit_instr_t v;
+ assert(!(op & 0xfffffffc));
+ assert(!(rd & 0xffffffe0));
+ assert(!(op3 & 0xffffffc0));
+ assert(!(rs1 & 0xffffffe0));
+ assert(!(asi & 0xffffff00));
+ assert(!(rs2 & 0xffffffe0));
+ v.op.b = op;
+ v.rd.b = rd;
+ v.op3.b = op3;
+ v.rs1.b = rs1;
+ v.i.b = 0;
+ v.asi.b = asi;
+ v.rs2.b = rs2;
+ ii(v.v);
+}
+
+static void
+_f1(jit_state_t *_jit, jit_int32_t op, jit_int32_t disp30)
+{
+ jit_instr_t v;
+ assert(!(op & 0xfffffffc));
+ assert(s30_p(disp30));
+ v.op.b = op;
+ v.disp30.b = disp30;
+ ii(v.v);
+}
+
+static void
+_nop(jit_state_t *_jit, jit_int32_t i0)
+{
+ while (i0--)
+ NOP();
+}
+
+static void
+_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ if (r0 != r1)
+ ORI(r1, 0, r0);
+}
+
+static void
+_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ if (s13_p(i0))
+ ORI(0, i0, r0);
+ else {
+ SETHI(HI(i0), r0);
+ if (LO(i0))
+ ORI(r0, LO(i0), 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;
+ SETHI(HI(i0), r0);
+ ORI(r0, LO(i0), 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 (s13_p(i0))
+ ADDI(r1, i0, 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;
+ if (s13_p(i0))
+ ADDIcc(r1, i0, r0);
+ else {
+ 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;
+ if (s13_p(i0))
+ ADDXIcc(r1, i0, r0);
+ else {
+ 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;
+ if (s13_p(i0))
+ SUBI(r1, i0, r0);
+ else {
+ 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;
+ if (s13_p(i0))
+ SUBIcc(r1, i0, r0);
+ else {
+ 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;
+ if (s13_p(i0))
+ SUBXIcc(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ subxr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ UMULI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ mulr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ SDIVI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ divr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ UDIVI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ divr_u(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ ANDI(r1, i0, r0);
+ else {
+ 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;
+ if (s13_p(i0))
+ ORI(r1, i0, r0);
+ else {
+ 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;
+ if (s13_p(i0))
+ XORI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ xorr(r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ lshi(r0, r1, 24);
+ rshi(r0, r0, 24);
+}
+
+static void
+_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ lshi(r0, r1, 16);
+ rshi(r0, r0, 16);
+}
+
+static void
+_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ lshi(r0, r1, 16);
+ rshi_u(r0, r0, 16);
+}
+
+static void
+_cr(jit_state_t *_jit, jit_int32_t cc,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ CMP(r1, r2);
+ Ba(cc, 3);
+ movi(r0, 1);
+ movi(r0, 0);
+}
+
+static void
+_cw(jit_state_t *_jit, jit_int32_t cc,
+ jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0)) {
+ CMPI(r1, i0);
+ Ba(cc, 3);
+ movi(r0, 1);
+ movi(r0, 0);
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ cr(cc, r0, r1, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDSBI(0, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_c(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDUBI(0, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_uc(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDSHI(0, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_s(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDUHI(0, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_us(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDI(0, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldr_i(r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDSBI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_c(r0, r1, rn(reg));
+ 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 (s13_p(i0))
+ LDUBI(r1, i0, 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
+_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDSHI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_c(r0, r1, rn(reg));
+ 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 (s13_p(i0))
+ LDUHI(r1, i0, 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
+_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDI(r1, i0, r0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ ldxr_i(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 (s13_p(i0))
+ STBI(r0, 0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ str_c(rn(reg), r0);
+ 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 (s13_p(i0))
+ STHI(r0, 0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ str_s(rn(reg), r0);
+ 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 (s13_p(i0))
+ STI(r0, 0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ str_i(rn(reg), r0);
+ 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 (s13_p(i0))
+ STBI(r1, r0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ stxr_c(r0, rn(reg), r1);
+ 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 (s13_p(i0))
+ STHI(r1, r0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ stxr_s(r0, rn(reg), r1);
+ 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 (s13_p(i0))
+ STI(r1, r0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ stxr_i(r0, rn(reg), r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static jit_word_t
+_br(jit_state_t *_jit, jit_int32_t cc,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ CMP(r0, r1);
+ w = _jit->pc.w;
+ B(cc, (i0 - w) >> 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bw(jit_state_t *_jit, jit_int32_t cc,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (s13_p(i1)) {
+ CMPI(r0, i1);
+ w = _jit->pc.w;
+ B(cc, (i0 - w) >> 2);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = br(cc, i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static jit_word_t
+_b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ if (add)
+ ADDcc(r0, r1, r0);
+ else
+ SUBcc(r0, r1, r0);
+ w = _jit->pc.w;
+ B(sgn ?
+ (jif ? SPARC_BVS : SPARC_BVC) :
+ (jif ? SPARC_BCS : SPARC_BCC),
+ (i0 - w) >> 2);
+ return (w);
+}
+
+static jit_word_t
+_b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (s13_p(i1)) {
+ if (add)
+ ADDcc(r0, i1, r0);
+ else
+ SUBcc(r0, i1, r0);
+ w = _jit->pc.w;
+ B(sgn ?
+ (jif ? SPARC_BVS : SPARC_BVC) :
+ (jif ? SPARC_BCS : SPARC_BCC),
+ (i0 - w) >> 2);
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = b_asr(jif, add, sgn, i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static jit_word_t
+_bm_r(jit_state_t *_jit, jit_bool_t set,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ BTST(r0, r1);
+ w = _jit->pc.w;
+ B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_bm_w(jit_state_t *_jit, jit_bool_t set,
+ jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ if (s13_p(i1)) {
+ BTSTI(r0, i1);
+ w = _jit->pc.w;
+ B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i1);
+ w = bm_r(set, i0, r0, rn(reg));
+ jit_unget_reg(reg);
+ }
+ return (w);
+}
+
+static void
+_jmpr(jit_state_t *_jit, jit_int32_t r0)
+{
+ JMPL(0, r0, 0);
+ NOP();
+}
+
+static void
+_jmpi(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ w = (i0 - w) >> 2;
+ if (s22_p(w)) {
+ BA(w);
+ NOP();
+ }
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ jmpr(rn(reg));
+ }
+}
+
+static jit_word_t
+_jmpi_p(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ w = movi_p(rn(reg), i0);
+ jmpr(rn(reg));
+ jit_unget_reg(reg);
+ return (w);
+}
+
+static void
+_callr(jit_state_t *_jit, jit_int32_t r0)
+{
+ CALL(r0);
+ NOP();
+}
+
+static void
+_calli(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ w = (i0 - _jit->pc.w) >> 2;
+ CALLI(w);
+ NOP();
+}
+
+static jit_word_t
+_calli_p(jit_state_t *_jit, jit_word_t i0)
+{
+ jit_word_t w;
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ w = movi_p(rn(reg), i0);
+ callr(rn(reg));
+ jit_unget_reg(reg);
+ return (w);
+}
+
+static void
+_prolog(jit_state_t *_jit, jit_node_t *node)
+{
+ /* align at 16 bytes boundary */
+ _jit->function->stack = ((stack_framesize - _jit->function->self.aoff)
+ + 15) & -16;
+ SAVEI(_SP_REGNO, -_jit->function->stack, _SP_REGNO);
+
+ /* (most) other backends do not save incoming arguments, so,
+ * only save locals here */
+ if (jit_regset_tstbit(_jit->function->regset, _L0))
+ stxi(0, _SP_REGNO, _L0_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L1))
+ stxi(4, _SP_REGNO, _L1_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L2))
+ stxi(8, _SP_REGNO, _L2_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L3))
+ stxi(12, _SP_REGNO, _L3_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L4))
+ stxi(16, _SP_REGNO, _L4_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L5))
+ stxi(20, _SP_REGNO, _L5_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L6))
+ stxi(24, _SP_REGNO, _L6_REGNO);
+ if (jit_regset_tstbit(_jit->function->regset, _L7))
+ stxi(28, _SP_REGNO, _L7_REGNO);
+}
+
+static void
+_epilog(jit_state_t *_jit, jit_node_t *node)
+{
+ /* (most) other backends do not save incoming arguments, so,
+ * only save locals here */
+ if (jit_regset_tstbit(_jit->function->regset, _L0))
+ ldxi(_L0_REGNO, _SP_REGNO, 0);
+ if (jit_regset_tstbit(_jit->function->regset, _L1))
+ ldxi(_L1_REGNO, _SP_REGNO, 4);
+ if (jit_regset_tstbit(_jit->function->regset, _L2))
+ ldxi(_L2_REGNO, _SP_REGNO, 8);
+ if (jit_regset_tstbit(_jit->function->regset, _L3))
+ ldxi(_L3_REGNO, _SP_REGNO, 12);
+ if (jit_regset_tstbit(_jit->function->regset, _L4))
+ ldxi(_L4_REGNO, _SP_REGNO, 16);
+ if (jit_regset_tstbit(_jit->function->regset, _L5))
+ ldxi(_L5_REGNO, _SP_REGNO, 20);
+ if (jit_regset_tstbit(_jit->function->regset, _L6))
+ ldxi(_L6_REGNO, _SP_REGNO, 24);
+ if (jit_regset_tstbit(_jit->function->regset, _L7))
+ ldxi(_L7_REGNO, _SP_REGNO, 28);
+ RESTOREI(0, 0, 0);
+ RETL();
+ NOP();
+}
+
+static void
+_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
+{
+ jit_instr_t i;
+ union {
+ jit_int32_t *i;
+ jit_word_t w;
+ } u;
+
+ u.w = instr;
+ i.v = u.i[0];
+
+ if (i.op.b == 0) { /* conditional branch */
+ if (i.op2.b == 2 || i.op2.b == 6) { /* int or float condition */
+ i.disp22.b = (label - instr) >> 2;
+ u.i[0] = i.v;
+ }
+ else if (i.op2.b == 4) { /* movi_p */
+ /* SETHI */
+ i.imm22.b = HI(label);
+ u.i[0] = i.v;
+ i.v = u.i[1];
+ if (i.op.b == 2 && i.op3.b == 2) {
+ /* ORI */
+ i.simm13.b = LO(label);
+ u.i[1] = i.v;
+ }
+ else
+ abort();
+ }
+ else
+ abort();
+ }
+ else
+ abort();
+}
+#endif
diff --git a/lib/jit_sparc-fpu.c b/lib/jit_sparc-fpu.c
new file mode 100644
index 0000000..6a8ce6b
--- /dev/null
+++ b/lib/jit_sparc-fpu.c
@@ -0,0 +1,689 @@
+/*
+ * 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 LDF(rs1, rs2, rd) f3r(3, rd, 32, rs1, rs2)
+# define LDFI(rs1, imm, rd) f3i(3, rd, 32, rs1, imm)
+# define LDDF(rs1, rs2, rd) f3r(3, rd, 35, rs1, rs2)
+# define LDDFI(rs1, imm, rd) f3i(3, rd, 35, rs1, imm)
+# define LDFSR(rs1, rs2, rd) f3r(3, rd, 33, rs1, rs2)
+# define LDFSRI(rs1, imm, rd) f3i(3, rd, 33, rs1, imm)
+# define STF(rd, rs1, rs2) f3r(3, rd, 36, rs1, rs2)
+# define STFI(rd, rs1, imm) f3i(3, rd, 36, rs1, imm)
+# define STDF(rd, rs1, rs2) f3r(3, rd, 39, rs1, rs2)
+# define STDFI(rd, rs1, imm) f3i(3, rd, 39, rs1, imm)
+# define STFSR(rd, rs1, rs2) f3r(3, rd, 37, rs1, rs2)
+# define STFSRI(rd, rs1, imm) f3i(3, rd, 37, rs1, imm)
+# define STDFQ(rd, rs1, rs2) f3r(3, rd, 38, rs1, rs2)
+# define STFDFQ(rd, rs1, imm) f3i(3, rd, 38, rs1, imm)
+# define SPARC_FBA 8 /* always - 1 */
+# define SPARC_FBN 0 /* never - 0 */
+# define SPARC_FBU 7 /* unordered - U */
+# define SPARC_FBG 6 /* greater - G */
+# define SPARC_FBUG 5 /* unordered or greater - G or
U */
+# define SPARC_FBL 4 /* less - L */
+# define SPARC_FBUL 5 /* unordered or less - L or U */
+# define SPARC_FBLG 2 /* less or greater - L or G */
+# define SPARC_FBNE 1 /* not equal - L or G or U */
+# define SPARC_FBNZ SPARC_FBNE
+# define SPARC_FBE 9 /* equal - E */
+# define SPARC_FBZ SPARC_FBE
+# define SPARC_FBUE 10 /* unordered or equal - E or U
*/
+# define SPARC_FBGE 11 /* greater or equal - E or G */
+# define SPARC_FBUGE 12 /* unordered or greater or
equal - E or G or U */
+# define SPARC_FBLE 13 /* less or equal - E or L */
+# define SPARC_FBULE 14 /* unordered or less or equal -
E or L or U */
+# define SPARC_FBO 15 /* ordered - E or L or G */
+# define FB(cc, imm) f2b(0, 0, cc, 6, imm)
+# define FBa(cc, imm) f2b(0, 1, cc, 6, imm)
+# define FBA(imm) FB(SPARC_FBA, imm)
+# define FBAa(imm) FBa(SPARC_FBA, imm)
+# define FBN(imm) FB(SPARC_FBN, imm)
+# define FBNa(imm) FBa(SPARC_FBN, imm)
+# define FBU(imm) FB(SPARC_FBU, imm)
+# define FBUa(imm) FBa(SPARC_FBU, imm)
+# define FBG(imm) FB(SPARC_FBG, imm)
+# define FBGa(imm) FBa(SPARC_FBG, imm)
+# define FBUG(imm) FB(SPARC_FBUG, imm)
+# define FBUGa(imm) FBa(SPARC_FBUG, imm)
+# define FBL(imm) FB(SPARC_FBL, imm)
+# define FBLa(imm) FBa(SPARC_FBL, imm)
+# define FBUL(imm) FB(SPARC_FBUL, imm)
+# define FBULa(imm) FBa(SPARC_FBUL, imm)
+# define FBLG(imm) FB(SPARC_FBLG, imm)
+# define FBLGa(imm) FBa(SPARC_FBLG, imm)
+# define FBNE(imm) FB(SPARC_FBNE, imm)
+# define FBNEa(imm) FBa(SPARC_FBNE, imm)
+# define FBE(imm) FB(SPARC_FBE, imm)
+# define FBEa(imm) FBa(SPARC_FBE, imm)
+# define FBUE(imm) FB(SPARC_FBUE, imm)
+# define FBUEa(imm) FBa(SPARC_FBUE, imm)
+# define FBLE(imm) FB(SPARC_FBLE, imm)
+# define FBLEa(imm) FBa(SPARC_FBLE, imm)
+# define FBO(imm) FB(SPARC_FBO, imm)
+# define FBOa(imm) FBa(SPARC_FBO, imm)
+# define FPop1(rd, rs1, opf, rs2) f3f(rd, 52, rs1, opf, rs2)
+# define FPop2(rd, rs1, opf, rs2) f3f(rd, 53, rs1, opf, rs2)
+# define f3f(rd, op3, rs1, opf, rs2) _f3f(_jit, rd, op3, rs1, opf, rs2)
+static void
+_f3f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
jit_int32_t,jit_int32_t);
+# define FITOS(rs2, rd) FPop1(rd, 0, 196, rs2)
+# define FITOD(rs2, rd) FPop1(rd, 0, 200, rs2)
+# define FITOQ(rs2, rd) FPop1(rd, 0, 204, rs2)
+# define FSTOI(rs2, rd) FPop1(rd, 0, 209, rs2)
+# define FDTOI(rs2, rd) FPop1(rd, 0, 210, rs2)
+# define FQTOI(rs2, rd) FPop1(rd, 0, 211, rs2)
+# define FSTOD(rs2, rd) FPop1(rd, 0, 201, rs2)
+# define FSTOQ(rs2, rd) FPop1(rd, 0, 205, rs2)
+# define FDTOS(rs2, rd) FPop1(rd, 0, 198, rs2)
+# define FDTOQ(rs2, rd) FPop1(rd, 0, 206, rs2)
+# define FQTOS(rs2, rd) FPop1(rd, 0, 199, rs2)
+# define FQTOD(rs2, rd) FPop1(rd, 0, 203, rs2)
+# define FMOVS(rs2, rd) FPop1(rd, 0, 1, rs2)
+# define FNEGS(rs2, rd) FPop1(rd, 0, 5, rs2)
+# define FABSS(rs2, rd) FPop1(rd, 0, 9, rs2)
+# define FSQRTS(rs2, rd) FPop1(rd, 0, 41, rs2)
+# define FSQRTD(rs2, rd) FPop1(rd, 0, 42, rs2)
+# define FSQRTQ(rs2, rd) FPop1(rd, 0, 43, rs2)
+# define SPARC_FADDS 65
+# define SPARC_FADDD 66
+# define SPARC_FADDQ 67
+# define SPARC_FSUBS 69
+# define SPARC_FSUBD 70
+# define SPARC_FSUBQ 71
+# define SPARC_FMULS 73
+# define SPARC_FMULD 74
+# define SPARC_FMULQ 75
+# define SPARC_FSMULD 105
+# define SPARC_FDMULQ 110
+# define SPARC_FDIVS 77
+# define SPARC_FDIVD 78
+# define SPARC_FDIVQ 79
+# define FADDS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDS, rs2)
+# define FADDD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDD, rs2)
+# define FADDQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDQ, rs2)
+# define FSUBS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBS, rs2)
+# define FSUBD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBD, rs2)
+# define FSUBQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBQ, rs2)
+# define FMULS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULS, rs2)
+# define FMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULD, rs2)
+# define FMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULQ, rs2)
+# define FSMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSMULD, rs2)
+# define FDMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDMULQ, rs2)
+# define FDIVS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVS, rs2)
+# define FDIVD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVD, rs2)
+# define FDIVQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVQ, rs2)
+# define SPARC_FCMPS 81
+# define SPARC_FCMPD 82
+# define SPARC_FCMPQ 83
+# define SPARC_FCMPES 85
+# define SPARC_FCMPED 86
+# define SPARC_FCMPEQ 87
+# define FCMPS(rs1, rs2) FPop2(0, rs1, SPARC_FCMPS, rs2)
+# define FCMPD(rs1, rs2) FPop2(0, rs1, SPARC_FCMPD, rs2)
+# define FCMPQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPQ, rs2)
+# define FCMPES(rs1, rs2) FPop2(0, rs1, SPARC_FCMPES, rs2)
+# define FCMPED(rs1, rs2) FPop2(0, rs1, SPARC_FCMPED, rs2)
+# define FCMPEQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPEQ, rs2)
+# define CPop1(rd, rs1, opc, rs2) f3f(rd, 54, rs1, opf, rs2)
+# define CPop2(rd, rs1, opc, rs2) f3f(rd, 55, rs1, opf, rs2)
+
+# define extr_f(r0, r1) _extr_f(_jit, r0, r1)
+static void _extr_f(jit_state_t*, jit_int32_t, jit_int32_t);
+# 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 extr_d_f(r0, r1) FSTOD(r1, r0)
+# define movi_f(r0, i0) ldi_f(r0, (jit_word_t)i0)
+# define movr_f(r0, r1) FMOVS(r1, r0)
+# define negr_f(r0, r1) FNEGS(r1, r0)
+# define absr_f(r0, r1) FABSS(r1, r0)
+# define sqrtr_f(r0, r1) FSQRTS(r1, r0)
+
+# define extr_d(r0, r1) _extr_d(_jit, r0, r1)
+static void _extr_d(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 extr_f_d(r0, r1) FDTOS(r1, r0)
+# define movi_d(r0, i0) ldi_d(r0, (jit_word_t)i0)
+# define movr_d(r0, r1) _movr_d(_jit, r0, r1)
+static void _movr_d(jit_state_t*, jit_int32_t, jit_int32_t);
+# define negr_d(r0, r1) _negr_d(_jit, r0, r1)
+static void _negr_d(jit_state_t*, jit_int32_t, jit_int32_t);
+# define absr_d(r0, r1) _absr_d(_jit, r0, r1)
+static void _absr_d(jit_state_t*, jit_int32_t, jit_int32_t);
+# define sqrtr_d(r0, r1) FSQRTD(r1, r0)
+
+# define fop1f(op, r0, r1, i0) _fop1f(_jit, op, r0, r1, i0)
+static void _fop1f(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_float32_t*);
+# define fop1d(op, r0, r1, i0) _fop1d(_jit, op, r0, r1, i0)
+static void _fop1d(jit_state_t*,jit_int32_t,
+ jit_int32_t,jit_int32_t,jit_float64_t*);
+
+# define addr_f(r0, r1, r2) FADDS(r1, r2, r0)
+# define addi_f(r0, r1, i0) fop1f(SPARC_FADDS, r0, r1, i0)
+# define subr_f(r0, r1, r2) FSUBS(r1, r2, r0)
+# define subi_f(r0, r1, i0) fop1f(SPARC_FSUBS, r0, r1, i0)
+# define mulr_f(r0, r1, r2) FMULS(r1, r2, r0)
+# define muli_f(r0, r1, i0) fop1f(SPARC_FMULS, r0, r1, i0)
+# define divr_f(r0, r1, r2) FDIVS(r1, r2, r0)
+# define divi_f(r0, r1, i0) fop1f(SPARC_FDIVS, r0, r1, i0)
+
+# define addr_d(r0, r1, r2) FADDD(r1, r2, r0)
+# define addi_d(r0, r1, i0) fop1d(SPARC_FADDD, r0, r1, i0)
+# define subr_d(r0, r1, r2) FSUBD(r1, r2, r0)
+# define subi_d(r0, r1, i0) fop1d(SPARC_FSUBD, r0, r1, i0)
+# define mulr_d(r0, r1, r2) FMULD(r1, r2, r0)
+# define muli_d(r0, r1, i0) fop1d(SPARC_FMULD, r0, r1, i0)
+# define divr_d(r0, r1, r2) FDIVD(r1, r2, r0)
+# define divi_d(r0, r1, i0) fop1d(SPARC_FDIVD, r0, r1, i0)
+
+#define fcr(cc, r0, r1, r2) _fcr(_jit, cc, r0, r1, r2)
+static void _fcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define fcw(cc, r0, r1, i0) _fcw(_jit, cc, r0, r1, i0)
+static void
+_fcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float32_t*);
+# define ltr_f(r0, r1, r2) fcr(SPARC_FBL, r0, r1, r2)
+# define lti_f(r0, r1, i0) fcw(SPARC_FBL, r0, r1, i0)
+# define ler_f(r0, r1, r2) fcr(SPARC_FBLE, r0, r1, r2)
+# define lei_f(r0, r1, i0) fcw(SPARC_FBLE, r0, r1, i0)
+# define eqr_f(r0, r1, r2) fcr(SPARC_FBE, r0, r1, r2)
+# define eqi_f(r0, r1, i0) fcw(SPARC_FBE, r0, r1, i0)
+# define ger_f(r0, r1, r2) fcr(SPARC_FBGE, r0, r1, r2)
+# define gei_f(r0, r1, i0) fcw(SPARC_FBGE, r0, r1, i0)
+# define gtr_f(r0, r1, r2) fcr(SPARC_FBG, r0, r1, r2)
+# define gti_f(r0, r1, i0) fcw(SPARC_FBG, r0, r1, i0)
+# define ner_f(r0, r1, r2) fcr(SPARC_FBNE, r0, r1, r2)
+# define nei_f(r0, r1, i0) fcw(SPARC_FBNE, r0, r1, i0)
+# define unltr_f(r0, r1, r2) fcr(SPARC_FBUL, r0, r1, r2)
+# define unlti_f(r0, r1, i0) fcw(SPARC_FBUL, r0, r1, i0)
+# define unler_f(r0, r1, r2) fcr(SPARC_FBULE, r0, r1, r2)
+# define unlei_f(r0, r1, i0) fcw(SPARC_FBULE, r0, r1, i0)
+# define uneqr_f(r0, r1, r2) fcr(SPARC_FBUE, r0, r1, r2)
+# define uneqi_f(r0, r1, i0) fcw(SPARC_FBUE, r0, r1, i0)
+# define unger_f(r0, r1, r2) fcr(SPARC_FBUGE, r0, r1, r2)
+# define ungei_f(r0, r1, i0) fcw(SPARC_FBUGE, r0, r1, i0)
+# define ungtr_f(r0, r1, r2) fcr(SPARC_FBUG, r0, r1, r2)
+# define ungti_f(r0, r1, i0) fcw(SPARC_FBUG, r0, r1, i0)
+# define ltgtr_f(r0, r1, r2) fcr(SPARC_FBLG, r0, r1, r2)
+# define ltgti_f(r0, r1, i0) fcw(SPARC_FBLG, r0, r1, i0)
+# define ordr_f(r0, r1, r2) fcr(SPARC_FBO, r0, r1, r2)
+# define ordi_f(r0, r1, i0) fcw(SPARC_FBO, r0, r1, i0)
+# define unordr_f(r0, r1, r2) fcr(SPARC_FBU, r0, r1, r2)
+# define unordi_f(r0, r1, i0) fcw(SPARC_FBU, r0, r1, i0)
+
+#define dcr(cc, r0, r1, r2) _dcr(_jit, cc, r0, r1, r2)
+static void _dcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+#define dcw(cc, r0, r1, i0) _dcw(_jit, cc, r0, r1, i0)
+static void
+_dcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float64_t*);
+# define ltr_d(r0, r1, r2) dcr(SPARC_FBL, r0, r1, r2)
+# define lti_d(r0, r1, i0) dcw(SPARC_FBL, r0, r1, i0)
+# define ler_d(r0, r1, r2) dcr(SPARC_FBLE, r0, r1, r2)
+# define lei_d(r0, r1, i0) dcw(SPARC_FBLE, r0, r1, i0)
+# define eqr_d(r0, r1, r2) dcr(SPARC_FBE, r0, r1, r2)
+# define eqi_d(r0, r1, i0) dcw(SPARC_FBE, r0, r1, i0)
+# define ger_d(r0, r1, r2) dcr(SPARC_FBGE, r0, r1, r2)
+# define gei_d(r0, r1, i0) dcw(SPARC_FBGE, r0, r1, i0)
+# define gtr_d(r0, r1, r2) dcr(SPARC_FBG, r0, r1, r2)
+# define gti_d(r0, r1, i0) dcw(SPARC_FBG, r0, r1, i0)
+# define ner_d(r0, r1, r2) dcr(SPARC_FBNE, r0, r1, r2)
+# define nei_d(r0, r1, i0) dcw(SPARC_FBNE, r0, r1, i0)
+# define unltr_d(r0, r1, r2) dcr(SPARC_FBUL, r0, r1, r2)
+# define unlti_d(r0, r1, i0) dcw(SPARC_FBUL, r0, r1, i0)
+# define unler_d(r0, r1, r2) dcr(SPARC_FBULE, r0, r1, r2)
+# define unlei_d(r0, r1, i0) dcw(SPARC_FBULE, r0, r1, i0)
+# define uneqr_d(r0, r1, r2) dcr(SPARC_FBUE, r0, r1, r2)
+# define uneqi_d(r0, r1, i0) dcw(SPARC_FBUE, r0, r1, i0)
+# define unger_d(r0, r1, r2) dcr(SPARC_FBUGE, r0, r1, r2)
+# define ungei_d(r0, r1, i0) dcw(SPARC_FBUGE, r0, r1, i0)
+# define ungtr_d(r0, r1, r2) dcr(SPARC_FBUG, r0, r1, r2)
+# define ungti_d(r0, r1, i0) dcw(SPARC_FBUG, r0, r1, i0)
+# define ltgtr_d(r0, r1, r2) dcr(SPARC_FBLG, r0, r1, r2)
+# define ltgti_d(r0, r1, i0) dcw(SPARC_FBLG, r0, r1, i0)
+# define ordr_d(r0, r1, r2) dcr(SPARC_FBO, r0, r1, r2)
+# define ordi_d(r0, r1, i0) dcw(SPARC_FBO, r0, r1, i0)
+# define unordr_d(r0, r1, r2) dcr(SPARC_FBU, r0, r1, r2)
+# define unordi_d(r0, r1, i0) dcw(SPARC_FBU, r0, r1, i0)
+
+# define ldr_f(r0, r1) LDF(r1, 0, 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) LDF(r1, r2, 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 str_f(r0, r1) STF(r1, r0, 0)
+# define sti_f(r0, i0) _sti_f(_jit, r0, i0)
+static void _sti_f(jit_state_t*,jit_int32_t,jit_word_t);
+# define stxr_f(r0, r1, r2) STF(r2, r1, r0)
+# define stxi_f(r0, r1, i0) _stxi_f(_jit, r0, r1, i0)
+static void _stxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+
+# define ldr_d(r0, r1) LDDF(r1, 0, 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) LDDF(r1, r2, 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_d(r0, r1) STDF(r1, r0, 0)
+# define sti_d(r0, i0) _sti_d(_jit, r0, i0)
+static void _sti_d(jit_state_t*,jit_int32_t,jit_word_t);
+# define stxr_d(r0, r1, r2) STDF(r2, r1, r0)
+# define stxi_d(r0, r1, i0) _stxi_d(_jit, r0, r1, i0)
+static void _stxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+
+# define fbr(cc, i0, r0, r1) _fbr(_jit, cc, i0, r0, r1)
+static jit_word_t
+_fbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+# define fbw(cc, i0, r0, i1) _fbw(_jit, cc, i0, r0, i1)
+static jit_word_t
+_fbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t*);
+# define bltr_f(i0, r0, r1) fbr(SPARC_FBL, i0, r0, r1)
+# define blti_f(i0, r0, i1) fbw(SPARC_FBL, i0, r0, i1)
+# define bler_f(i0, r0, r1) fbr(SPARC_FBLE, i0, r0, r1)
+# define blei_f(i0, r0, i1) fbw(SPARC_FBLE, i0, r0, i1)
+# define beqr_f(i0, r0, r1) fbr(SPARC_FBE, i0, r0, r1)
+# define beqi_f(i0, r0, i1) fbw(SPARC_FBE, i0, r0, i1)
+# define bger_f(i0, r0, r1) fbr(SPARC_FBGE, i0, r0, r1)
+# define bgei_f(i0, r0, i1) fbw(SPARC_FBGE, i0, r0, i1)
+# define bgtr_f(i0, r0, r1) fbr(SPARC_FBG, i0, r0, r1)
+# define bgti_f(i0, r0, i1) fbw(SPARC_FBG, i0, r0, i1)
+# define bner_f(i0, r0, r1) fbr(SPARC_FBNE, i0, r0, r1)
+# define bnei_f(i0, r0, i1) fbw(SPARC_FBNE, i0, r0, i1)
+# define bunltr_f(i0, r0, r1) fbr(SPARC_FBUL, i0, r0, r1)
+# define bunlti_f(i0, r0, i1) fbw(SPARC_FBUL, i0, r0, i1)
+# define bunler_f(i0, r0, r1) fbr(SPARC_FBULE, i0, r0, r1)
+# define bunlei_f(i0, r0, i1) fbw(SPARC_FBULE, i0, r0, i1)
+# define buneqr_f(i0, r0, r1) fbr(SPARC_FBUE, i0, r0, r1)
+# define buneqi_f(i0, r0, i1) fbw(SPARC_FBUE, i0, r0, i1)
+# define bunger_f(i0, r0, r1) fbr(SPARC_FBUGE, i0, r0, r1)
+# define bungei_f(i0, r0, i1) fbw(SPARC_FBUGE, i0, r0, i1)
+# define bungtr_f(i0, r0, r1) fbr(SPARC_FBUG, i0, r0, r1)
+# define bungti_f(i0, r0, i1) fbw(SPARC_FBUG, i0, r0, i1)
+# define bltgtr_f(i0, r0, r1) fbr(SPARC_FBLG, i0, r0, r1)
+# define bltgti_f(i0, r0, i1) fbw(SPARC_FBLG, i0, r0, i1)
+# define bordr_f(i0, r0, r1) fbr(SPARC_FBO, i0, r0, r1)
+# define bordi_f(i0, r0, i1) fbw(SPARC_FBO, i0, r0, i1)
+# define bunordr_f(i0, r0, r1) fbr(SPARC_FBU, i0, r0, r1)
+# define bunordi_f(i0, r0, i1) fbw(SPARC_FBU, i0, r0, i1)
+# define dbr(cc, i0, r0, r1) _dbr(_jit, cc, i0, r0, r1)
+static jit_word_t
+_dbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+# define dbw(cc, i0, r0, i1) _dbw(_jit, cc, i0, r0, i1)
+static jit_word_t
+_dbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t*);
+# define bltr_d(i0, r0, r1) dbr(SPARC_FBL, i0, r0, r1)
+# define blti_d(i0, r0, i1) dbw(SPARC_FBL, i0, r0, i1)
+# define bler_d(i0, r0, r1) dbr(SPARC_FBLE, i0, r0, r1)
+# define blei_d(i0, r0, i1) dbw(SPARC_FBLE, i0, r0, i1)
+# define beqr_d(i0, r0, r1) dbr(SPARC_FBE, i0, r0, r1)
+# define beqi_d(i0, r0, i1) dbw(SPARC_FBE, i0, r0, i1)
+# define bger_d(i0, r0, r1) dbr(SPARC_FBGE, i0, r0, r1)
+# define bgei_d(i0, r0, i1) dbw(SPARC_FBGE, i0, r0, i1)
+# define bgtr_d(i0, r0, r1) dbr(SPARC_FBG, i0, r0, r1)
+# define bgti_d(i0, r0, i1) dbw(SPARC_FBG, i0, r0, i1)
+# define bner_d(i0, r0, r1) dbr(SPARC_FBNE, i0, r0, r1)
+# define bnei_d(i0, r0, i1) dbw(SPARC_FBNE, i0, r0, i1)
+# define bunltr_d(i0, r0, r1) dbr(SPARC_FBUL, i0, r0, r1)
+# define bunlti_d(i0, r0, i1) dbw(SPARC_FBUL, i0, r0, i1)
+# define bunler_d(i0, r0, r1) dbr(SPARC_FBULE, i0, r0, r1)
+# define bunlei_d(i0, r0, i1) dbw(SPARC_FBULE, i0, r0, i1)
+# define buneqr_d(i0, r0, r1) dbr(SPARC_FBUE, i0, r0, r1)
+# define buneqi_d(i0, r0, i1) dbw(SPARC_FBUE, i0, r0, i1)
+# define bunger_d(i0, r0, r1) dbr(SPARC_FBUGE, i0, r0, r1)
+# define bungei_d(i0, r0, i1) dbw(SPARC_FBUGE, i0, r0, i1)
+# define bungtr_d(i0, r0, r1) dbr(SPARC_FBUG, i0, r0, r1)
+# define bungti_d(i0, r0, i1) dbw(SPARC_FBUG, i0, r0, i1)
+# define bltgtr_d(i0, r0, r1) dbr(SPARC_FBLG, i0, r0, r1)
+# define bltgti_d(i0, r0, i1) dbw(SPARC_FBLG, i0, r0, i1)
+# define bordr_d(i0, r0, r1) dbr(SPARC_FBO, i0, r0, r1)
+# define bordi_d(i0, r0, i1) dbw(SPARC_FBO, i0, r0, i1)
+# define bunordr_d(i0, r0, r1) dbr(SPARC_FBU, i0, r0, r1)
+# define bunordi_d(i0, r0, i1) dbw(SPARC_FBU, i0, r0, i1)
+
+#endif
+
+#if CODE
+static void
+_f3f(jit_state_t *_jit, jit_int32_t rd,
+ jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
+{
+ jit_instr_t v;
+ assert(!(rd & 0xffffffe0));
+ assert(!(op3 & 0xffffffc0));
+ assert(!(rs1 & 0xffffffe0));
+ assert(!(opf & 0xfffffe00));
+ assert(!(rs2 & 0xffffffe0));
+ v.op.b = 2;
+ v.rd.b = rd;
+ v.op3.b = op3;
+ v.rs1.b = rs1;
+ v.opf.b = opf;
+ v.rs2.b = rs2;
+ ii(v.v);
+}
+
+static void
+_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ assert(!(r0 & 1));
+ assert(!(r1 & 1));
+ if (r0 != r1) {
+ FMOVS(r1, r0);
+ FMOVS(r1 + 1, r0 + 1);
+ }
+}
+
+static void
+_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ assert(!(r0 & 1));
+ assert(!(r1 & 1));
+ FNEGS(r1, r0);
+ if (r0 != r1)
+ FMOVS(r1 + 1, r0 + 1);
+}
+
+static void
+_absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ assert(!(r0 & 1));
+ assert(!(r1 & 1));
+ FABSS(r1, r0);
+ if (r0 != r1)
+ FMOVS(r1 + 1, r0 + 1);
+}
+
+static void
+_fop1f(jit_state_t *_jit, jit_int32_t op,
+ jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi_f(rn(reg), i0);
+ FPop1(r0, r1, op, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_fop1d(jit_state_t *_jit, jit_int32_t op,
+ jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_gpr);
+ movi_d(rn(reg), i0);
+ FPop1(r0, r1, op, rn(reg));
+ jit_unget_reg(reg);
+}
+
+static void
+_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ stxi(-8, _FP_REGNO, r1);
+ ldxi_f(r0, _FP_REGNO, -8);
+ FITOS(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_gpr);
+ FSTOI(r1, rn(reg));
+ stxi_f(-8, _FP_REGNO, rn(reg));
+ ldxi_i(r0, _FP_REGNO, -8);
+ jit_unget_reg(reg);
+}
+
+static void
+_fcr(jit_state_t *_jit, jit_int32_t cc,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ FCMPS(r1, r2);
+ FBa(cc, 3);
+ movi(r0, 1);
+ movi(r0, 0);
+}
+
+static void
+_fcw(jit_state_t *_jit, jit_int32_t cc,
+ jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_fpr);
+ movi_f(rn(reg), i0);
+ FCMPS(r1, rn(reg));
+ jit_unget_reg(reg);
+ FBa(cc, 3);
+ movi(r0, 1);
+ movi(r0, 0);
+}
+
+static void
+_dcr(jit_state_t *_jit, jit_int32_t cc,
+ jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+{
+ FCMPD(r1, r2);
+ FBa(cc, 3);
+ movi(r0, 1);
+ movi(r0, 0);
+}
+
+static void
+_dcw(jit_state_t *_jit, jit_int32_t cc,
+ jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
+{
+ jit_int32_t reg;
+ reg = jit_get_reg(jit_class_fpr);
+ movi_d(rn(reg), i0);
+ FCMPD(r1, rn(reg));
+ jit_unget_reg(reg);
+ FBa(cc, 3);
+ movi(r0, 1);
+ movi(r0, 0);
+}
+
+static void
+_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDFI(0, i0, 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 (s13_p(i0))
+ LDFI(r1, i0, 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
+_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ STFI(r0, 0, i0);
+ 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 (s13_p(i0))
+ STFI(r1, r0, i0);
+ else {
+ reg = jit_get_reg(jit_class_gpr);
+ movi(rn(reg), i0);
+ stxr_f(rn(reg), r0, r1);
+ jit_unget_reg(reg);
+ }
+}
+
+static void
+_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+{
+ stxi(-4, _FP_REGNO, r1);
+ stxi(-8, _FP_REGNO, 0);
+ ldxi_d(r0, _FP_REGNO, -8);
+ FITOD(r0, r0);
+}
+
+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_gpr);
+ FDTOI(r1, rn(reg));
+ stxi_d(-8, _FP_REGNO, rn(reg));
+ ldxi_i(r0, _FP_REGNO, -4);
+ jit_unget_reg(reg);
+}
+
+static void
+_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ LDDFI(0, i0, 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 (s13_p(i0))
+ LDDFI(r1, i0, 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_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+{
+ jit_int32_t reg;
+ if (s13_p(i0))
+ STDFI(r0, 0, i0);
+ 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 (s13_p(i0))
+ STDFI(r1, r0, i0);
+ 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
+_fbr(jit_state_t *_jit, jit_int32_t cc,
+ jit_word_t i0, jit_int32_t r0,jit_int32_t r1)
+{
+ jit_word_t w;
+ FCMPS(r0, r1);
+ w = _jit->pc.w;
+ FB(cc, ((i0 - w) >> 2) - 1);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_fbw(jit_state_t *_jit, jit_int32_t cc,
+ 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);
+ FCMPS(r0, rn(reg));
+ jit_unget_reg(reg);
+ w = _jit->pc.w;
+ FB(cc, ((i0 - w) >> 2) - 1);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_dbr(jit_state_t *_jit, jit_int32_t cc,
+ jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+{
+ jit_word_t w;
+ FCMPD(r0, r1);
+ w = _jit->pc.w;
+ FB(cc, ((i0 - w) >> 2) - 1);
+ NOP();
+ return (w);
+}
+
+static jit_word_t
+_dbw(jit_state_t *_jit, jit_int32_t cc,
+ 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);
+ FCMPD(r0, rn(reg));
+ jit_unget_reg(reg);
+ w = _jit->pc.w;
+ FB(cc, ((i0 - w) >> 2) - 1);
+ NOP();
+ return (w);
+}
+#endif
diff --git a/lib/jit_ppc.c b/lib/jit_sparc.c
similarity index 64%
copy from lib/jit_ppc.c
copy to lib/jit_sparc.c
index d63fe79..71c334c 100644
--- a/lib/jit_ppc.c
+++ b/lib/jit_sparc.c
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012 Free Software Foundation, Inc.
+ * 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
@@ -24,82 +24,56 @@
#define patch(instr, node) _patch(_jit, instr, node)
static void _patch(jit_state_t*,jit_word_t,jit_node_t*);
-/* libgcc */
-extern void __clear_cache(void *, void *);
-
#define PROTO 1
-# include "jit_ppc-cpu.c"
-# include "jit_ppc-fpu.c"
+# include "jit_sparc-cpu.c"
+# include "jit_sparc-fpu.c"
#undef PROTO
/*
* Initialization
*/
+int missing_count;
jit_register_t _rvs[] = {
- { rc(gpr) | 0, "r0" },
- { rc(gpr) | 11, "r11" },
- { rc(gpr) | 12, "r12" },
- { rc(gpr) | 13, "r13" },
- { rc(gpr) | 2, "r2" },
- { rc(sav) | rc(gpr) | 14, "r14" },
- { rc(sav) | rc(gpr) | 15, "r15" },
- { rc(sav) | rc(gpr) | 16, "r16" },
- { rc(sav) | rc(gpr) | 17, "r17" },
- { rc(sav) | rc(gpr) | 18, "r18" },
- { rc(sav) | rc(gpr) | 19, "r19" },
- { rc(sav) | rc(gpr) | 20, "r20" },
- { rc(sav) | rc(gpr) | 21, "r21" },
- { rc(sav) | rc(gpr) | 22, "r22" },
- { rc(sav) | rc(gpr) | 23, "r23" },
- { rc(sav) | rc(gpr) | 24, "r24" },
- { rc(sav) | rc(gpr) | 25, "r25" },
- { rc(sav) | rc(gpr) | 26, "r26" },
- { rc(sav) | rc(gpr) | 27, "r27" },
- { rc(sav) | rc(gpr) | 28, "r28" },
- { rc(sav) | rc(gpr) | 29, "r29" },
- { rc(sav) | rc(gpr) | 30, "r30" },
- { rc(sav) | 1, "r1" },
- { rc(sav) | 31, "r31" },
- { rc(arg) | rc(gpr) | 10, "r10" },
- { rc(arg) | rc(gpr) | 9, "r9" },
- { rc(arg) | rc(gpr) | 8, "r8" },
- { rc(arg) | rc(gpr) | 7, "r7" },
- { rc(arg) | rc(gpr) | 6, "r6" },
- { rc(arg) | rc(gpr) | 5, "r5" },
- { rc(arg) | rc(gpr) | 4, "r4" },
- { rc(arg) | rc(gpr) | 3, "r3" },
- { rc(fpr) | 0, "f0" },
- { rc(sav) | rc(fpr) | 14, "f14" },
- { rc(sav) | rc(fpr) | 15, "f15" },
- { rc(sav) | rc(fpr) | 16, "f16" },
- { rc(sav) | rc(fpr) | 17, "f17" },
- { rc(sav) | rc(fpr) | 18, "f18" },
- { rc(sav) | rc(fpr) | 19, "f19" },
- { rc(sav) | rc(fpr) | 20, "f20" },
- { rc(sav) | rc(fpr) | 21, "f21" },
- { rc(sav) | rc(fpr) | 22, "f22" },
- { rc(sav) | rc(fpr) | 23, "f23" },
- { rc(sav) | rc(fpr) | 24, "f24" },
- { rc(sav) | rc(fpr) | 25, "f25" },
- { rc(sav) | rc(fpr) | 26, "f26" },
- { rc(sav) | rc(fpr) | 27, "f27" },
- { rc(sav) | rc(fpr) | 28, "f28" },
- { rc(sav) | rc(fpr) | 29, "f29" },
- { rc(sav) | rc(fpr) | 30, "f30" },
- { rc(sav) | rc(fpr) | 31, "f31" },
- { rc(arg) | rc(fpr) | 13, "f13" },
- { rc(arg) | rc(fpr) | 12, "f12" },
- { rc(arg) | rc(fpr) | 11, "f11" },
- { rc(arg) | rc(fpr) | 10, "f10" },
- { rc(arg) | rc(fpr) | 9, "f9" },
- { rc(arg) | rc(fpr) | 8, "f8" },
- { rc(arg) | rc(fpr) | 7, "f7" },
- { rc(arg) | rc(fpr) | 6, "f6" },
- { rc(arg) | rc(fpr) | 5, "f5" },
- { rc(arg) | rc(fpr) | 4, "f4" },
- { rc(arg) | rc(fpr) | 3, "f3" },
- { rc(arg) | rc(fpr) | 2, "f2" },
- { rc(arg) | rc(fpr) | 1, "f1" },
+ { 0x00, "%g0" },
+ { 0x01, "%g1" },
+ { rc(gpr) | 0x02, "%g2" },
+ { rc(gpr) | 0x03, "%g3" },
+ { rc(gpr) | 0x04, "%g4" },
+ { rc(gpr) | 0x05, "%g5" },
+ { rc(gpr) | 0x06, "%g6" },
+ { rc(gpr) | 0x07, "%g7" },
+ { rc(arg) | rc(gpr) | 0x08, "%o0" },
+ { rc(arg) | rc(gpr) | 0x09, "%o1" },
+ { rc(arg) | rc(gpr) | 0x0a, "%o2" },
+ { rc(arg) | rc(gpr) | 0x0b, "%o3" },
+ { rc(arg) | rc(gpr) | 0x0c, "%o4" },
+ { rc(arg) | rc(gpr) | 0x0d, "%o5" },
+ { rc(sav) | 0x0e, "%sp" },
+ { 0x0f, "%o7" },
+ { rc(sav) | rc(gpr) | 0x10, "%l0" },
+ { rc(sav) | rc(gpr) | 0x11, "%l1" },
+ { rc(sav) | rc(gpr) | 0x12, "%l2" },
+ { rc(sav) | rc(gpr) | 0x13, "%l3" },
+ { rc(sav) | rc(gpr) | 0x14, "%l4" },
+ { rc(sav) | rc(gpr) | 0x15, "%l5" },
+ { rc(sav) | rc(gpr) | 0x16, "%l6" },
+ { rc(sav) | rc(gpr) | 0x17, "%l7" },
+ { 0x18, "%i0" },
+ { 0x19, "%i1" },
+ { 0x1a, "%i2" },
+ { 0x1b, "%i3" },
+ { 0x1c, "%i4" },
+ { 0x1d, "%i5" },
+ { rc(sav) | 0x1e, "%fp" },
+ { 0x1f, "%i7" },
+ { rc(fpr) | 0x00, "%f0" },
+ { rc(fpr) | 0x02, "%f2" },
+ { rc(fpr) | 0x04, "%f4" },
+ { rc(fpr) | 0x06, "%f6" },
+ { rc(fpr) | 0x08, "%f8" },
+ { rc(fpr) | 0x0a, "%f10" },
+ { rc(fpr) | 0x0c, "%f12" },
+ { rc(fpr) | 0x0e, "%f14" },
{ _NOREG, "<none>" },
};
@@ -136,12 +110,12 @@ _jit_prolog(jit_state_t *_jit)
_jit->functions.length += 16;
}
_jit->function = _jit->functions.ptr + _jit->functions.offset++;
- _jit->function->self.size = params_offset;
+ _jit->function->self.size = stack_framesize;
_jit->function->self.argi = _jit->function->self.argf =
- _jit->function->self.alen = 0;
+ _jit->function->self.aoff = _jit->function->self.alen = 0;
/* float conversion */
- _jit->function->self.aoff = alloca_offset - 8;
- _jit->function->self.call = jit_call_default;
+ _jit->function->self.aoff = -8;
+ _jit->function->self.call = jit_call_default;
_jit->function->regoff = calloc(_jit->reglen, sizeof(jit_int32_t));
_jit->function->prolog = jit_new_node_no_link(jit_code_prolog);
@@ -203,7 +177,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
void
_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
{
- if (JIT_RET != u)
+ if (JIT_FRET != u)
jit_movr_f(JIT_FRET, u);
else
jit_live(JIT_FRET);
@@ -234,7 +208,6 @@ _jit_reti_d(jit_state_t *_jit, jit_float64_t u)
jit_ret();
}
-/* must be called internally only */
void
_jit_epilog(jit_state_t *_jit)
{
@@ -249,18 +222,19 @@ _jit_arg(jit_state_t *_jit)
{
jit_int32_t offset;
assert(_jit->function);
- if (_jit->function->self.argi < 8)
+ if (_jit->function->self.argi < 6)
offset = _jit->function->self.argi++;
- else
+ else {
offset = _jit->function->self.size;
- _jit->function->self.size += sizeof(jit_word_t);
+ _jit->function->self.size += sizeof(jit_word_t);
+ }
return (jit_new_node_w(jit_code_arg, offset));
}
jit_bool_t
_jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
{
- return (offset >= 0 && offset < 8);
+ return (offset >= 0 && offset < 6);
}
jit_node_t *
@@ -268,18 +242,19 @@ _jit_arg_f(jit_state_t *_jit)
{
jit_int32_t offset;
assert(_jit->function);
- if (_jit->function->self.argf < 13)
- offset = _jit->function->self.argf++;
- else
+ if (_jit->function->self.argi < 6)
+ offset = _jit->function->self.argi++;
+ else {
offset = _jit->function->self.size;
- _jit->function->self.size += sizeof(jit_float32_t);
+ _jit->function->self.size += sizeof(jit_float32_t);
+ }
return (jit_new_node_w(jit_code_arg_f, offset));
}
jit_bool_t
_jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
{
- return (jit_arg_d_reg_p(offset));
+ return (0);
}
jit_node_t *
@@ -287,126 +262,92 @@ _jit_arg_d(jit_state_t *_jit)
{
jit_int32_t offset;
assert(_jit->function);
- if (_jit->function->self.argf < 13)
- offset = _jit->function->self.argf++;
- else
+ if (_jit->function->self.argi < 5) {
+ offset = _jit->function->self.argi;
+ _jit->function->self.argi += 2;
+ }
+ else if (_jit->function->self.argi < 6) {
+ offset = _jit->function->self.argi++;
+ _jit->function->self.size += sizeof(jit_float32_t);
+ }
+ else {
offset = _jit->function->self.size;
- _jit->function->self.size += sizeof(jit_float64_t);
+ _jit->function->self.size += sizeof(jit_float64_t);
+ }
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 (offset >= 0 && offset < 13);
+ return (0);
}
void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 8)
- jit_extr_c(u, JIT_RA0 - v->u.w);
+ if (v->u.w < 6)
+ jit_extr_c(u, _I0 + v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
- jit_ldxi_c(u, JIT_FP, v->u.w);
-#else
+ assert(__BYTE_ORDER == __BIG_ENDIAN && __WORDSIZE == 32);
jit_ldxi_c(u, JIT_FP,
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int8_t));
-#endif
}
}
void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 8)
- jit_extr_uc(u, JIT_RA0 - v->u.w);
+ if (v->u.w < 6)
+ jit_extr_uc(u, _I0 + v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
- jit_ldxi_uc(u, JIT_FP, v->u.w);
-#else
+ assert(__BYTE_ORDER == __BIG_ENDIAN && __WORDSIZE == 32);
jit_ldxi_uc(u, JIT_FP,
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint8_t));
-#endif
}
}
void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 8)
- jit_extr_s(u, JIT_RA0 - v->u.w);
+ if (v->u.w < 6)
+ jit_extr_s(u, _I0 + v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
- jit_ldxi_s(u, JIT_FP, v->u.w);
-#else
+ assert(__BYTE_ORDER == __BIG_ENDIAN && __WORDSIZE == 32);
jit_ldxi_s(u, JIT_FP,
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int16_t));
-#endif
}
}
void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 8)
- jit_extr_us(u, JIT_RA0 - v->u.w);
+ if (v->u.w < 6)
+ jit_extr_us(u, _I0 + v->u.w);
else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
- jit_ldxi_us(u, JIT_FP, v->u.w);
-#else
+ assert(__BYTE_ORDER == __BIG_ENDIAN && __WORDSIZE == 32);
jit_ldxi_us(u, JIT_FP,
v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint16_t));
-#endif
}
}
void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 8)
- jit_movr(u, JIT_RA0 - v->u.w);
- else {
-#if __BYTE_ORDER == __LITTLE__ENDIAN
- jit_ldxi_i(u, JIT_FP, v->u.w);
-#else
- jit_ldxi_i(u, JIT_FP,
- v->u.w + (__WORDSIZE >> 3) - sizeof(jit_int32_t));
-#endif
- }
-}
-
-#if __WORDSIZE == 64
-void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
-{
- if (v->u.w < 8)
- jit_extr_ui(u, JIT_RA0 - v->u.w);
- else {
-# if __BYTE_ORDER == __LITTLE__ENDIAN
- jit_ldxi_ui(u, JIT_FP, v->u.w);
-# else
- jit_ldxi_ui(u, JIT_FP,
- v->u.w + (__WORDSIZE >> 3) - sizeof(jit_uint32_t));
-# endif
- }
-}
-
-void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
-{
- if (v->u.w < 8)
- jit_movr(u, JIT_RA0 - v->u.w);
+ if (v->u.w < 6)
+ jit_movr(u, _I0 + v->u.w);
else
- jit_ldxi_l(u, JIT_FP, v->u.w);
+ jit_ldxi_i(u, JIT_FP, v->u.w);
}
-#endif
void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 13)
- jit_movr_d(u, JIT_FA0 - v->u.w);
+ assert(_jit->function);
+ if (v->u.w < 6) {
+ jit_stxi(-4, JIT_FP, _I0 + v->u.w);
+ jit_ldxi_f(u, JIT_FP, -4);
+ }
else
jit_ldxi_f(u, JIT_FP, v->u.w);
}
@@ -414,170 +355,130 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u,
jit_node_t *v)
void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
- if (v->u.w < 13)
- jit_movr_d(u, JIT_FA0 - v->u.w);
- else
- jit_ldxi_d(u, JIT_FP, v->u.w);
+ assert(_jit->function);
+ if (v->u.w < 5) {
+ jit_stxi(-8, JIT_FP, _I0 + v->u.w);
+ jit_stxi(-4, JIT_FP, _I0 + v->u.w + 1);
+ jit_ldxi_d(u, JIT_FP, -8);
+ }
+ else if (v->u.w < 6) {
+ jit_stxi(-8, JIT_FP, _I0 + v->u.w);
+ jit_ldxi_f(u, JIT_FP, -8);
+ jit_ldxi_f(u, JIT_FP, stack_framesize);
+ }
+ else {
+ jit_ldxi_f(u, JIT_FP, v->u.w);
+ jit_ldxi_f(u + 1, JIT_FP, v->u.w + 4);
+ }
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
- assert(_jit->function);
- if (_jit->function->call.argi < 8) {
- jit_movr(JIT_RA0 - _jit->function->call.argi, u);
+ if (_jit->function->call.argi < 6) {
+ jit_movr(_O0 + _jit->function->call.argi, u);
++_jit->function->call.argi;
}
- else
- jit_stxi(_jit->function->call.size + params_offset, JIT_SP, u);
- _jit->function->call.size += sizeof(jit_word_t);
+ else {
+ jit_stxi(_jit->function->call.size + stack_framesize, JIT_SP, u);
+ _jit->function->call.size += sizeof(jit_word_t);
+ }
}
void
_jit_pushargi(jit_state_t *_jit, jit_word_t u)
{
- jit_int32_t regno;
- assert(_jit->function);
- if (_jit->function->call.argi < 8) {
- jit_movi(JIT_RA0 - _jit->function->call.argi, u);
+ jit_int32_t regno;
+ if (_jit->function->call.argi < 6) {
+ jit_movi(_O0 + _jit->function->call.argi, u);
++_jit->function->call.argi;
}
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
- jit_stxi(_jit->function->call.size + params_offset, JIT_SP, regno);
+ jit_stxi(_jit->function->call.size + stack_framesize, JIT_SP, regno);
jit_unget_reg(regno);
+ _jit->function->call.size += sizeof(jit_word_t);
}
- _jit->function->call.size += sizeof(jit_word_t);
}
void
_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
{
- assert(_jit->function);
- if (_jit->function->call.argf < 13) {
- jit_movr_d(JIT_FA0 - _jit->function->call.argf, u);
- ++_jit->function->call.argf;
- if (!(_jit->function->call.call & jit_call_varargs)) {
- /* in case of excess arguments */
- if (_jit->function->call.argi < 8)
- _jit->function->call.argi += 2;
- _jit->function->call.size += sizeof(jit_float32_t);
- return;
- }
+ if (_jit->function->call.argi < 6) {
+ jit_stxi_f(-4, JIT_FP, u);
+ jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -4);
+ ++_jit->function->call.argi;
}
- if (_jit->function->call.argi < 8) {
- /* use reserved 8 bytes area */
- jit_stxi_d(alloca_offset - 8, JIT_FP, u);
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 8);
- _jit->function->call.argi++;
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 4);
- _jit->function->call.argi++;
+ else {
+ jit_stxi_f(_jit->function->call.size + stack_framesize, JIT_SP, u);
+ _jit->function->call.size += sizeof(jit_float32_t);
}
- else
- jit_stxi_f(_jit->function->call.size + params_offset, JIT_SP, u);
- _jit->function->call.size += sizeof(jit_float32_t);
}
void
_jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
{
- jit_int32_t regno;
-
- assert(_jit->function);
- if (_jit->function->call.argf < 13) {
- jit_movi_d(JIT_FA0 - _jit->function->call.argf, u);
- ++_jit->function->call.argf;
- if (!(_jit->function->call.call & jit_call_varargs)) {
- /* in case of excess arguments */
- if (_jit->function->call.argi < 8)
- _jit->function->call.argi += 2;
- _jit->function->call.size += sizeof(jit_float32_t);
- return;
- }
- }
+ jit_int32_t regno;
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
- if (_jit->function->call.argi < 8) {
- /* use reserved 8 bytes area */
- jit_stxi_d(alloca_offset - 8, JIT_FP, regno);
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 8);
- _jit->function->call.argi++;
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 4);
- _jit->function->call.argi++;
+ if (_jit->function->call.argi < 6) {
+ jit_stxi_f(-4, JIT_FP, regno);
+ jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -4);
+ ++_jit->function->call.argi;
+ }
+ else {
+ jit_stxi_f(_jit->function->call.size + stack_framesize, JIT_SP, regno);
+ _jit->function->call.size += sizeof(jit_float32_t);
}
- else
- jit_stxi_f(_jit->function->call.size + params_offset, JIT_SP, regno);
- _jit->function->call.size += sizeof(jit_float32_t);
jit_unget_reg(regno);
}
void
_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
{
- assert(_jit->function);
- if (_jit->function->call.argf < 13) {
- jit_movr_d(JIT_FA0 - _jit->function->call.argf, u);
- ++_jit->function->call.argf;
- if (!(_jit->function->call.call & jit_call_varargs)) {
- /* in case of excess arguments */
- if (_jit->function->call.argi < 8)
- _jit->function->call.argi += 2;
- _jit->function->call.size += sizeof(jit_float64_t);
- return;
- }
+ if (_jit->function->call.argi < 5) {
+ jit_stxi_d(-8, JIT_FP, u);
+ jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8);
+ jit_ldxi(_O0 + _jit->function->call.argi + 1, JIT_FP, -4);
+ _jit->function->call.argi += 2;
}
- if (_jit->function->call.argi < 8) {
- /* use reserved 8 bytes area */
- jit_stxi_d(alloca_offset - 8, JIT_FP, u);
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 8);
- _jit->function->call.argi++;
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 4);
- _jit->function->call.argi++;
+ else if (_jit->function->call.argi < 6) {
+ jit_stxi_f(-8, JIT_FP, u);
+ jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8);
+ ++_jit->function->call.argi;
+ jit_stxi_f(stack_framesize, JIT_SP, u + 1);
+ _jit->function->call.size += sizeof(jit_float32_t);
+ }
+ else {
+ jit_stxi_d(_jit->function->call.size + stack_framesize, JIT_SP, u);
+ _jit->function->call.size += sizeof(jit_float64_t);
}
- else
- jit_stxi_d(_jit->function->call.size + params_offset, JIT_SP, u);
- _jit->function->call.size += sizeof(jit_float64_t);
}
void
_jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
{
- jit_int32_t regno;
-
- assert(_jit->function);
- if (_jit->function->call.argf < 13) {
- jit_movi_d(JIT_FA0 - _jit->function->call.argf, u);
- ++_jit->function->call.argf;
- if (!(_jit->function->call.call & jit_call_varargs)) {
- /* in case of excess arguments */
- if (_jit->function->call.argi < 8)
- _jit->function->call.argi += 2;
- _jit->function->call.size += sizeof(jit_float64_t);
- return;
- }
- }
+ jit_int32_t regno;
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
- if (_jit->function->call.argi < 8) {
- /* use reserved 8 bytes area */
- jit_stxi_d(alloca_offset - 8, JIT_FP, regno);
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 8);
- _jit->function->call.argi++;
- jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP,
- alloca_offset - 4);
- _jit->function->call.argi++;
+ if (_jit->function->call.argi < 5) {
+ jit_stxi_d(-8, JIT_FP, regno);
+ jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8);
+ jit_ldxi(_O0 + _jit->function->call.argi + 1, JIT_FP, -4);
+ _jit->function->call.argi += 2;
+ }
+ else if (_jit->function->call.argi < 6) {
+ jit_stxi_d(-8, JIT_FP, regno);
+ jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8);
+ ++_jit->function->call.argi;
+ jit_stxi_f(stack_framesize, JIT_SP, regno + 1);
+ _jit->function->call.size += sizeof(jit_float32_t);
+ }
+ else {
+ jit_stxi_d(_jit->function->call.size + stack_framesize, JIT_SP, regno);
+ _jit->function->call.size += sizeof(jit_float64_t);
}
- else
- jit_stxi_d(_jit->function->call.size + params_offset, JIT_SP, regno);
- _jit->function->call.size += sizeof(jit_float64_t);
jit_unget_reg(regno);
}
@@ -585,19 +486,15 @@ 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 = JIT_RA0 - regno;
- if (regno >= 0 && regno < node->v.w)
- return (1);
- }
- else if (spec & jit_class_fpr) {
- regno = JIT_FA0 - regno;
- if (regno >= 0 && regno < node->w.w)
- return (1);
- }
+ if ((spec & (jit_class_arg|jit_class_gpr)) ==
+ (jit_class_arg|jit_class_gpr)) {
+ regno = _O0 - regno;
+ if (regno >= 0 && regno < node->v.w)
+ return (1);
}
+
return (0);
}
@@ -605,13 +502,15 @@ void
_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
{
jit_node_t *call;
+
assert(_jit->function);
if (_jit->function->self.alen < _jit->function->call.size)
_jit->function->self.alen = _jit->function->call.size;
call = jit_callr(r0);
- call->v.w = _jit->function->call.argi;
- call->w.w = _jit->function->call.argf;
- _jit->function->call.argi = _jit->function->call.argf = 0;
+ call->v.w = _jit->function->self.argi;
+ call->w.w = _jit->function->self.argf;
+ _jit->function->call.argi = _jit->function->call.argf =
+ _jit->function->call.size = 0;
_jit->prepare = 0;
}
@@ -619,13 +518,15 @@ jit_node_t *
_jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
{
jit_node_t *node;
+
assert(_jit->function);
if (_jit->function->self.alen < _jit->function->call.size)
_jit->function->self.alen = _jit->function->call.size;
node = jit_calli(i0);
node->v.w = _jit->function->call.argi;
node->w.w = _jit->function->call.argf;
- _jit->function->call.argi = _jit->function->call.argf = 0;
+ _jit->function->call.argi = _jit->function->call.argf =
+ _jit->function->call.size = 0;
_jit->prepare = 0;
return (node);
}
@@ -633,57 +534,39 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
void
_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
{
- jit_extr_c(r0, JIT_RET);
+ jit_extr_c(r0, _O0);
}
void
_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
{
- jit_extr_uc(r0, JIT_RET);
+ jit_extr_uc(r0, _O0);
}
void
_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
{
- jit_extr_s(r0, JIT_RET);
+ jit_extr_s(r0, _O0);
}
void
_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
{
- jit_extr_us(r0, JIT_RET);
+ jit_extr_us(r0, _O0);
}
void
_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
{
-#if __WORDSIZE == 32
- if (r0 != JIT_RET)
- jit_movr(r0, JIT_RET);
-#else
- jit_extr_i(r0, JIT_RET);
-#endif
-}
-
-#if __WORDSIZE == 64
-void
-_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
-{
- jit_extr_ui(r0, JIT_RET);
-}
-
-void
-_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
-{
- if (r0 != JIT_RET)
- jit_movr(r0, JIT_RET);
+ if (r0 != _O0)
+ jit_movr(r0, _O0);
}
-#endif
void
_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
{
- jit_retval_d(r0);
+ if (r0 != JIT_FRET)
+ jit_movr_f(r0, JIT_FRET);
}
void
@@ -727,23 +610,19 @@ _emit_code(jit_state_t *_jit)
case jit_code_##name##i##type: \
name##i##type(node->u.w, rn(node->v.w)); \
break
+#define case_rf(name, type) \
+ case jit_code_##name##i##type: \
+ assert(node->flag & jit_flag_data); \
+ name##i##type(rn(node->u.w), node->v.n->u.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), \
+ name##i##type(rn(node->u.w), \
rn(node->v.w), node->w.w); \
break
#define case_rrf(name, type, size) \
@@ -809,6 +688,9 @@ _emit_code(jit_state_t *_jit)
node->u.w = _jit->pc.w;
break;
case jit_code_label:
+ if (node->link &&
+ (word = _jit->pc.w & (sizeof(jit_word_t) - 1)))
+ nop(sizeof(jit_word_t) - word);
/* remember label is defined */
node->flag |= jit_flag_patch;
node->u.w = _jit->pc.w;
@@ -827,22 +709,11 @@ _emit_code(jit_state_t *_jit)
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_rrrr(qdiv,);
- case_rrrw(qdiv,);
- case_rrrr(qdiv, _u);
- case_rrrw(qdiv, _u);
- case_rrr(rem,);
- case_rrw(rem,);
- case_rrr(rem, _u);
- case_rrw(rem, _u);
+
case_rrr(and,);
case_rrw(and,);
case_rrr(or,);
@@ -855,31 +726,6 @@ _emit_code(jit_state_t *_jit)
case_rrw(rsh,);
case_rrr(rsh, _u);
case_rrw(rsh, _u);
- case_rr(ext, _c);
- case_rr(ext, _uc);
- case_rr(ext, _s);
- case_rr(ext, _us);
- case_rr(hton,);
- case_rr(neg,);
- case_rr(com,);
- 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(trunc, _f_i);
case_rr(trunc, _d_i);
case_rrr(lt,);
@@ -904,6 +750,62 @@ _emit_code(jit_state_t *_jit)
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_rr(hton,);
+ case_rr(ext, _c);
+ case_rr(ext, _uc);
+ case_rr(ext, _s);
+ case_rr(ext, _us);
+ 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_brr(blt,);
case_brw(blt,);
case_brr(blt, _u);
@@ -924,10 +826,6 @@ _emit_code(jit_state_t *_jit)
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);
@@ -944,46 +842,11 @@ _emit_code(jit_state_t *_jit)
case_brw(bxsub,);
case_brr(bxsub, _u);
case_brw(bxsub, _u);
- case_rrr(ldx, _c);
- case_rrw(ldx, _c);
- case_rr(ld, _uc);
- case_rw(ld, _uc);
- case_rrr(ldx, _uc);
- case_rrw(ldx, _uc);
- case_rr(ld, _s);
- case_rw(ld, _s);
- case_rrr(ldx, _s);
- case_rrw(ldx, _s);
- case_rr(ld, _us);
- case_rw(ld, _us);
- case_rrr(ldx, _us);
- case_rrw(ldx, _us);
- case_rr(ld, _i);
- case_rw(ld, _i);
- case_rrr(ldx, _i);
- case_rrw(ldx, _i);
- case_rr(st, _c);
- case_wr(st, _c);
- case_rrr(stx, _c);
- case_wrr(stx, _c);
- case_rr(st, _s);
- case_wr(st, _s);
- case_rrr(stx, _s);
- case_wrr(stx, _s);
- case_rr(st, _i);
- case_wr(st, _i);
- case_rrr(stx, _i);
- case_wrr(stx, _i);
- 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(ext, _f);
- case_rr(ext, _d_f);
- case_rr(abs, _f);
- case_rr(neg, _f);
- case_rr(sqrt, _f);
+ case_brr(bms,);
+ case_brw(bms,);
+ case_brr(bmc,);
+ case_brw(bmc,);
+
case_rrr(add, _f);
case_rrf(add, _f, 32);
case_rrr(sub, _f);
@@ -992,6 +855,12 @@ _emit_code(jit_state_t *_jit)
case_rrf(mul, _f, 32);
case_rrr(div, _f);
case_rrf(div, _f, 32);
+
+ case_rr(abs, _f);
+ case_rr(neg, _f);
+ case_rr(sqrt, _f);
+ case_rr(ext, _f);
+ case_rr(ext, _d_f);
case_rrr(lt, _f);
case_rrf(lt, _f, 32);
case_rrr(le, _f);
@@ -1020,6 +889,18 @@ _emit_code(jit_state_t *_jit)
case_rrf(ord, _f, 32);
case_rrr(unord, _f);
case_rrf(unord, _f, 32);
+ case_rr(ld, _f);
+ case_rw(ld, _f);
+ case_rrr(ldx, _f);
+ case_rrw(ldx, _f);
+ case_rr(st, _f);
+ case_wr(st, _f);
+ case_rrr(stx, _f);
+ case_wrr(stx, _f);
+
+ case_rr(mov, _f);
+ case_rf(mov, _f);
+
case_brr(blt, _f);
case_brf(blt, _f, 32);
case_brr(ble, _f);
@@ -1048,24 +929,7 @@ _emit_code(jit_state_t *_jit)
case_brf(bord, _f, 32);
case_brr(bunord, _f);
case_brf(bunord, _f, 32);
- case_rr(ld, _f);
- case_rw(ld, _f);
- case_rrr(ldx, _f);
- case_rrw(ldx, _f);
- case_rr(st, _f);
- case_wr(st, _f);
- case_rrr(stx, _f);
- case_wrr(stx, _f);
- 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(ext, _d);
- case_rr(ext, _f_d);
- case_rr(abs, _d);
- case_rr(neg, _d);
- case_rr(sqrt, _d);
+
case_rrr(add, _d);
case_rrf(add, _d, 64);
case_rrr(sub, _d);
@@ -1074,6 +938,12 @@ _emit_code(jit_state_t *_jit)
case_rrf(mul, _d, 64);
case_rrr(div, _d);
case_rrf(div, _d, 64);
+
+ case_rr(abs, _d);
+ case_rr(neg, _d);
+ case_rr(sqrt, _d);
+ case_rr(ext, _d);
+ case_rr(ext, _f_d);
case_rrr(lt, _d);
case_rrf(lt, _d, 64);
case_rrr(le, _d);
@@ -1102,6 +972,18 @@ _emit_code(jit_state_t *_jit)
case_rrf(ord, _d, 64);
case_rrr(unord, _d);
case_rrf(unord, _d, 64);
+ case_rr(ld, _d);
+ case_rw(ld, _d);
+ case_rrr(ldx, _d);
+ case_rrw(ldx, _d);
+ case_rr(st, _d);
+ case_wr(st, _d);
+ case_rrr(stx, _d);
+ case_wrr(stx, _d);
+
+ case_rr(mov, _d);
+ case_rf(mov, _d);
+
case_brr(blt, _d);
case_brf(blt, _d, 64);
case_brr(ble, _d);
@@ -1130,14 +1012,7 @@ _emit_code(jit_state_t *_jit)
case_brf(bord, _d, 64);
case_brr(bunord, _d);
case_brf(bunord, _d, 64);
- case_rr(ld, _d);
- case_rw(ld, _d);
- case_rrr(ldx, _d);
- case_rrw(ldx, _d);
- case_rr(st, _d);
- case_wr(st, _d);
- case_rrr(stx, _d);
- case_wrr(stx, _d);
+
case jit_code_jmpr:
jmpr(rn(node->u.w));
break;
@@ -1145,11 +1020,10 @@ _emit_code(jit_state_t *_jit)
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(_jit->pc.w);
+ word = jmpi_p(_jit->pc.w);
patch(word, node);
}
break;
@@ -1197,12 +1071,18 @@ _emit_code(jit_state_t *_jit)
epilog(node);
_jit->function = NULL;
break;
+
case jit_code_live:
case jit_code_arg:
case jit_code_arg_f: case jit_code_arg_d:
break;
default:
+#if 0
abort();
+#else
+ fprintf(stderr, "code %d not implemented\n", node->code);
+ ++missing_count;
+#endif
}
jit_regarg_clr(node, value);
/* update register live state */
@@ -1215,6 +1095,7 @@ _emit_code(jit_state_t *_jit)
#undef case_rrf
#undef case_rrw
#undef case_rrr
+#undef case_rf
#undef case_wr
#undef case_rw
#undef case_rr
@@ -1225,44 +1106,34 @@ _emit_code(jit_state_t *_jit)
patch_at(_jit->patches.ptr[offset].inst, word);
}
- __clear_cache(_jit->code.ptr, _jit->pc.uc);
-
return (_jit->code.ptr);
}
#define CODE 1
-# include "jit_ppc-cpu.c"
-# include "jit_ppc-fpu.c"
+# include "jit_sparc-cpu.c"
+# include "jit_sparc-fpu.c"
#undef CODE
void
-_emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi(jit_state_t *_jit, jit_gpr_t r0, jit_gpr_t r1, jit_word_t i0)
{
-#if __WORDSIZE == 32
ldxi_i(rn(r0), rn(r1), i0);
-#else
- ldxi_l(rn(r0), rn(r1), i0);
-#endif
}
void
-_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_gpr_t r0, jit_gpr_t r1)
{
-#if __WORDSIZE == 32
stxi_i(i0, rn(r0), rn(r1));
-#else
- stxi_l(i0, rn(r0), rn(r1));
-#endif
}
void
-_emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_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_int32_t r0, jit_int32_t r1)
+_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));
}
@@ -1270,8 +1141,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0,
jit_int32_t r0, jit_int32_t r1)
static void
_patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
{
- jit_int32_t flag;
- jit_word_t *patches;
+ jit_int32_t flag;
assert(node->flag & jit_flag_node);
if (node->code == jit_code_movi)
diff --git a/lib/lightning.c b/lib/lightning.c
index 59ab8a7..c2c7619 100644
--- a/lib/lightning.c
+++ b/lib/lightning.c
@@ -302,18 +302,10 @@ _jit_load(jit_state_t *_jit, jit_int32_t reg)
static jit_word_t
hash_data(jit_pointer_t data, jit_word_t length)
{
+ jit_uint8_t *ptr;
jit_word_t i, key;
- union {
- jit_uint8_t *c;
- jit_word_t *w;
- jit_pointer_t p;
- } ptr;
-
- for (i = 0, key = 0, ptr.p = data; i < length / sizeof(jit_word_t); i++)
- key = (key << (key & 1)) ^ ptr.w[i];
- for (i *= sizeof(jit_word_t); i < length; i++)
- key = (key << (key & 1)) ^ ptr.c[i];
-
+ for (i = key = 0, ptr = data; i < length; i++)
+ key = (key << (key & 1)) ^ ptr[i];
return (key);
}
@@ -2608,4 +2600,6 @@ _patch_register(jit_state_t *_jit, jit_node_t *node,
jit_node_t *link,
# include "jit_arm.c"
#elif defined(__ppc__)
# include "jit_ppc.c"
+#elif defined(__sparc__)
+# include "jit_sparc.c"
#endif
- [Guile-commits] 306/437: x86: Build and pass all tests under cygwin64 (Windows x64), (continued)
- [Guile-commits] 306/437: x86: Build and pass all tests under cygwin64 (Windows x64), Andy Wingo, 2018/07/02
- [Guile-commits] 352/437: Update documentation, Andy Wingo, 2018/07/02
- [Guile-commits] 357/437: Make more readable always true test, Andy Wingo, 2018/07/02
- [Guile-commits] 311/437: Implement jit_frame and jit_tramp interfaces, Andy Wingo, 2018/07/02
- [Guile-commits] 312/437: Use jit_code_last_code as symbolic name of last enum, Andy Wingo, 2018/07/02
- [Guile-commits] 293/437: Do not have assertions with a long type test, Andy Wingo, 2018/07/02
- [Guile-commits] 384/437: ia64: Do not use a dangling pointer for double to integer copy, Andy Wingo, 2018/07/02
- [Guile-commits] 203/437: Make it simpler to add support for more than 64 registers., Andy Wingo, 2018/07/02
- [Guile-commits] 415/437: Build and pass all test cases on Alpha Linux, Andy Wingo, 2018/07/02
- [Guile-commits] 142/437: Make current test cases pass in armv7l., Andy Wingo, 2018/07/02
- [Guile-commits] 188/437: Add framework for sparc port.,
Andy Wingo <=
- [Guile-commits] 227/437: Cosmetic removal of unused macros., Andy Wingo, 2018/07/02
- [Guile-commits] 330/437: Resync with new patch to make functions receive a const argument, Andy Wingo, 2018/07/02
- [Guile-commits] 185/437: Store all annotation information in the read only data buffer., Andy Wingo, 2018/07/02
- [Guile-commits] 170/437: Test and correct test cases in all current backends., Andy Wingo, 2018/07/02
- [Guile-commits] 368/437: Implement jit_allocar for dynamic stack allocation, Andy Wingo, 2018/07/02
- [Guile-commits] 355/437: Update documentation on jit_frame and jit_tramp, Andy Wingo, 2018/07/02
- [Guile-commits] 323/437: misc: Make jit_note and related functions take a const argument, Andy Wingo, 2018/07/02
- [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