added untested port of GNU lightning to ARM

1 files changed, 1107 insertions, 0 deletions

diff --git a/src/runtime/c/pgf/lightning/arm/fp.h b/src/runtime/c/pgf/lightning/arm/fp.h
new file mode 100644
index 000000000..58ed13b52
--- /dev/null
+++ b/src/runtime/c/pgf/lightning/arm/fp.h
@@ -0,0 +1,1107 @@
+/******************************** -*- C -*- ****************************
+ *
+ *	Floating-point support (arm)
+ *
+ ***********************************************************************/
+
+/***********************************************************************
+ *
+ * Copyright 2011 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU lightning.
+ *
+ * GNU lightning is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ * 
+ * GNU lightning is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with GNU lightning; see the file COPYING.LESSER; if not, write to the
+ * Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ *
+ * Authors:
+ *	Paulo Cesar Pereira de Andrade
+ ***********************************************************************/
+
+#ifndef __lightning_fp_arm_h
+#define __lightning_fp_arm_h
+
+#define JIT_FPR_NUM			6
+
+static const jit_fpr_t
+jit_soft_order[6] = {
+    _D0, _D1, _D2, _D3, _D4, _D5
+};
+static const jit_fpr_t
+jit_hard_order[6] = {
+    _D8, _D9, _D10, _D11, _D12, _D13
+};
+#define JIT_FPR(n)							\
+    (jit_hardfp_p() ? jit_hard_order[n] : jit_soft_order[n])
+
+#include "fp-swf.h"
+#include "fp-vfp.h"
+
+#define jit_movr_f(r0, r1)		arm_movr_f(_jit, r0, r1)
+__jit_inline void
+arm_movr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    if (jit_swf_p())	swf_movr_f(_jit, r0, r1);
+    else		vfp_movr_f(_jit, r0, r1);
+}
+
+#define jit_movr_d(r0, r1)		arm_movr_d(_jit, r0, r1)
+__jit_inline void
+arm_movr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    if (jit_swf_p())	swf_movr_d(_jit, r0, r1);
+    else		vfp_movr_d(_jit, r0, r1);
+}
+
+#define jit_movi_f(r0, i0)		arm_movi_f(_jit, r0, i0)
+__jit_inline void
+arm_movi_f(jit_state_t _jit, jit_fpr_t r0, float i0)
+{
+    if (jit_swf_p())	swf_movi_f(_jit, r0, i0);
+    else		vfp_movi_f(_jit, r0, i0);
+}
+
+#define jit_movi_d(r0, i0)		arm_movi_d(_jit, r0, i0)
+__jit_inline void
+arm_movi_d(jit_state_t _jit, jit_fpr_t r0, double i0)
+{
+    if (jit_swf_p())	swf_movi_d(_jit, r0, i0);
+    else		vfp_movi_d(_jit, r0, i0);
+}
+
+#define jit_extr_i_f(r0, r1)		arm_extr_i_f(_jit, r0, r1)
+__jit_inline void
+arm_extr_i_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_extr_i_f(_jit, r0, r1);
+    else		vfp_extr_i_f(_jit, r0, r1);
+}
+
+#define jit_extr_i_d(r0, r1)		arm_extr_i_d(_jit, r0, r1)
+__jit_inline void
+arm_extr_i_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_extr_i_d(_jit, r0, r1);
+    else		vfp_extr_i_d(_jit, r0, r1);
+}
+
+#define jit_extr_d_f(r0, r1)		arm_extr_d_f(_jit, r0, r1)
+static void
+arm_extr_d_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_extr_d_f(_jit, r0, r1);
+    else		vfp_extr_d_f(_jit, r0, r1);
+}
+
+#define jit_extr_f_d(r0, r1)		arm_extr_f_d(_jit, r0, r1)
+static void
+arm_extr_f_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    if (jit_swf_p())	swf_extr_f_d(_jit, r0, r1);
+    else		vfp_extr_f_d(_jit, r0, r1);
+}
+
+#define jit_rintr_f_i(r0, r1)		arm_rintr_f_i(_jit, r0, r1)
+static void
+arm_rintr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_rintr_f_i(_jit, r0, r1);
+    else		vfp_rintr_f_i(_jit, r0, r1);
+}
+
+#define jit_rintr_d_i(r0, r1)		arm_rintr_d_i(_jit, r0, r1)
+static void
+arm_rintr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_rintr_d_i(_jit, r0, r1);
+    else		vfp_rintr_d_i(_jit, r0, r1);
+}
+
+#define jit_roundr_f_i(r0, r1)		arm_roundr_f_i(_jit, r0, r1)
+static void
+arm_roundr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_roundr_f_i(_jit, r0, r1);
+    else		vfp_roundr_f_i(_jit, r0, r1);
+}
+
+#define jit_roundr_d_i(r0, r1)		arm_roundr_d_i(_jit, r0, r1)
+static void
+arm_roundr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_roundr_d_i(_jit, r0, r1);
+    else		vfp_roundr_d_i(_jit, r0, r1);
+}
+
+#define jit_truncr_f_i(r0, r1)		arm_truncr_f_i(_jit, r0, r1)
+static void
+arm_truncr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_truncr_f_i(_jit, r0, r1);
+    else		vfp_truncr_f_i(_jit, r0, r1);
+}
+
+#define jit_truncr_d_i(r0, r1)		arm_truncr_d_i(_jit, r0, r1)
+static void
+arm_truncr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_truncr_d_i(_jit, r0, r1);
+    else		vfp_truncr_d_i(_jit, r0, r1);
+}
+
+#define jit_ceilr_f_i(r0, r1)		arm_ceilr_f_i(_jit, r0, r1)
+static void
+arm_ceilr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_ceilr_f_i(_jit, r0, r1);
+    else		vfp_ceilr_f_i(_jit, r0, r1);
+}
+
+#define jit_ceilr_d_i(r0, r1)		arm_ceilr_d_i(_jit, r0, r1)
+static void
+arm_ceilr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_ceilr_d_i(_jit, r0, r1);
+    else		vfp_ceilr_d_i(_jit, r0, r1);
+}
+
+#define jit_floorr_f_i(r0, r1)		arm_floorr_f_i(_jit, r0, r1)
+static void
+arm_floorr_f_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_floorr_f_i(_jit, r0, r1);
+    else		vfp_floorr_f_i(_jit, r0, r1);
+}
+
+#define jit_floorr_d_i(r0, r1)		arm_floorr_d_i(_jit, r0, r1)
+static void
+arm_floorr_d_i(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_floorr_d_i(_jit, r0, r1);
+    else		vfp_floorr_d_i(_jit, r0, r1);
+}
+
+#define jit_absr_f(r0, r1)		arm_absr_f(_jit, r0, r1)
+static void
+arm_absr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_absr_f(_jit, r0, r1);
+    else		vfp_absr_f(_jit, r0, r1);
+}
+
+#define jit_absr_d(r0, r1)		arm_absr_d(_jit, r0, r1)
+static void
+arm_absr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_absr_d(_jit, r0, r1);
+    else		vfp_absr_d(_jit, r0, r1);
+}
+
+#define jit_negr_f(r0, r1)		arm_negr_f(_jit, r0, r1)
+static void
+arm_negr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_negr_f(_jit, r0, r1);
+    else		vfp_negr_f(_jit, r0, r1);
+}
+
+#define jit_negr_d(r0, r1)		arm_negr_d(_jit, r0, r1)
+static void
+arm_negr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_negr_d(_jit, r0, r1);
+    else		vfp_negr_d(_jit, r0, r1);
+}
+
+#define jit_sqrtr_f(r0, r1)		arm_sqrtr_f(_jit, r0, r1)
+static void
+arm_sqrtr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_sqrtr_f(_jit, r0, r1);
+    else		vfp_sqrtr_f(_jit, r0, r1);
+}
+
+#define jit_sqrtr_d(r0, r1)		arm_sqrtr_d(_jit, r0, r1)
+static void
+arm_sqrtr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_sqrtr_d(_jit, r0, r1);
+    else		vfp_sqrtr_d(_jit, r0, r1);
+}
+
+#define jit_addr_f(r0, r1, r2)		arm_addr_f(_jit, r0, r1, r2)
+static void
+arm_addr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_addr_f(_jit, r0, r1, r2);
+    else		vfp_addr_f(_jit, r0, r1, r2);
+}
+
+#define jit_addr_d(r0, r1, r2)		arm_addr_d(_jit, r0, r1, r2)
+static void
+arm_addr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_addr_d(_jit, r0, r1, r2);
+    else		vfp_addr_d(_jit, r0, r1, r2);
+}
+
+#define jit_subr_f(r0, r1, r2)		arm_subr_f(_jit, r0, r1, r2)
+static void
+arm_subr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_subr_f(_jit, r0, r1, r2);
+    else		vfp_subr_f(_jit, r0, r1, r2);
+}
+
+#define jit_subr_d(r0, r1, r2)		arm_subr_d(_jit, r0, r1, r2)
+static void
+arm_subr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_subr_d(_jit, r0, r1, r2);
+    else		vfp_subr_d(_jit, r0, r1, r2);
+}
+
+#define jit_mulr_f(r0, r1, r2)		arm_mulr_f(_jit, r0, r1, r2)
+static void
+arm_mulr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_mulr_f(_jit, r0, r1, r2);
+    else		vfp_mulr_f(_jit, r0, r1, r2);
+}
+
+#define jit_mulr_d(r0, r1, r2)		arm_mulr_d(_jit, r0, r1, r2)
+static void
+arm_mulr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_mulr_d(_jit, r0, r1, r2);
+    else		vfp_mulr_d(_jit, r0, r1, r2);
+}
+
+#define jit_divr_f(r0, r1, r2)		arm_divr_f(_jit, r0, r1, r2)
+static void
+arm_divr_f(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_divr_f(_jit, r0, r1, r2);
+    else		vfp_divr_f(_jit, r0, r1, r2);
+}
+
+#define jit_divr_d(r0, r1, r2)		arm_divr_d(_jit, r0, r1, r2)
+static void
+arm_divr_d(jit_state_t _jit, jit_fpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_divr_d(_jit, r0, r1, r2);
+    else		vfp_divr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ltr_f(r0, r1, r2)		arm_ltr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ltr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ltr_f(_jit, r0, r1, r2);
+    else		vfp_ltr_f(_jit, r0, r1, r2);
+}
+
+#define jit_ltr_d(r0, r1, r2)		arm_ltr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ltr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ltr_d(_jit, r0, r1, r2);
+    else		vfp_ltr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ler_f(r0, r1, r2)		arm_ler_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ler_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ler_f(_jit, r0, r1, r2);
+    else		vfp_ler_f(_jit, r0, r1, r2);
+}
+
+#define jit_ler_d(r0, r1, r2)		arm_ler_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ler_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ler_d(_jit, r0, r1, r2);
+    else		vfp_ler_d(_jit, r0, r1, r2);
+}
+
+#define jit_eqr_f(r0, r1, r2)		arm_eqr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_eqr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_eqr_f(_jit, r0, r1, r2);
+    else		vfp_eqr_f(_jit, r0, r1, r2);
+}
+
+#define jit_eqr_d(r0, r1, r2)		arm_eqr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_eqr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_eqr_d(_jit, r0, r1, r2);
+    else		vfp_eqr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ger_f(r0, r1, r2)		arm_ger_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ger_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ger_f(_jit, r0, r1, r2);
+    else		vfp_ger_f(_jit, r0, r1, r2);
+}
+
+#define jit_ger_d(r0, r1, r2)		arm_ger_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ger_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ger_d(_jit, r0, r1, r2);
+    else		vfp_ger_d(_jit, r0, r1, r2);
+}
+
+#define jit_gtr_f(r0, r1, r2)		arm_gtr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_gtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_gtr_f(_jit, r0, r1, r2);
+    else		vfp_gtr_f(_jit, r0, r1, r2);
+}
+
+#define jit_gtr_d(r0, r1, r2)		arm_gtr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_gtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_gtr_d(_jit, r0, r1, r2);
+    else		vfp_gtr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ner_f(r0, r1, r2)		arm_ner_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ner_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ner_f(_jit, r0, r1, r2);
+    else		vfp_ner_f(_jit, r0, r1, r2);
+}
+
+#define jit_ner_d(r0, r1, r2)		arm_ner_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ner_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ner_d(_jit, r0, r1, r2);
+    else		vfp_ner_d(_jit, r0, r1, r2);
+}
+
+#define jit_unltr_f(r0, r1, r2)		arm_unltr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_unltr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unltr_f(_jit, r0, r1, r2);
+    else		vfp_unltr_f(_jit, r0, r1, r2);
+}
+
+#define jit_unltr_d(r0, r1, r2)		arm_unltr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_unltr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unltr_d(_jit, r0, r1, r2);
+    else		vfp_unltr_d(_jit, r0, r1, r2);
+}
+
+#define jit_unler_f(r0, r1, r2)		arm_unler_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_unler_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unler_f(_jit, r0, r1, r2);
+    else		vfp_unler_f(_jit, r0, r1, r2);
+}
+
+#define jit_unler_d(r0, r1, r2)		arm_unler_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_unler_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unler_d(_jit, r0, r1, r2);
+    else		vfp_unler_d(_jit, r0, r1, r2);
+}
+
+#define jit_uneqr_f(r0, r1, r2)		arm_uneqr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_uneqr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_uneqr_f(_jit, r0, r1, r2);
+    else		vfp_uneqr_f(_jit, r0, r1, r2);
+}
+
+#define jit_uneqr_d(r0, r1, r2)		arm_uneqr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_uneqr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_uneqr_d(_jit, r0, r1, r2);
+    else		vfp_uneqr_d(_jit, r0, r1, r2);
+}
+
+#define jit_unger_f(r0, r1, r2)		arm_unger_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_unger_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unger_f(_jit, r0, r1, r2);
+    else		vfp_unger_f(_jit, r0, r1, r2);
+}
+
+#define jit_unger_d(r0, r1, r2)		arm_unger_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_unger_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unger_d(_jit, r0, r1, r2);
+    else		vfp_unger_d(_jit, r0, r1, r2);
+}
+
+#define jit_ungtr_f(r0, r1, r2)		arm_ungtr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ungtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ungtr_f(_jit, r0, r1, r2);
+    else		vfp_ungtr_f(_jit, r0, r1, r2);
+}
+
+#define jit_ungtr_d(r0, r1, r2)		arm_ungtr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ungtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ungtr_d(_jit, r0, r1, r2);
+    else		vfp_ungtr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ltgtr_f(r0, r1, r2)		arm_ltgtr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ltgtr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ltgtr_f(_jit, r0, r1, r2);
+    else		vfp_ltgtr_f(_jit, r0, r1, r2);
+}
+
+#define jit_ltgtr_d(r0, r1, r2)		arm_ltgtr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ltgtr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ltgtr_d(_jit, r0, r1, r2);
+    else		vfp_ltgtr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ordr_f(r0, r1, r2)		arm_ordr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ordr_f(_jit, r0, r1, r2);
+    else		vfp_ordr_f(_jit, r0, r1, r2);
+}
+
+#define jit_ordr_d(r0, r1, r2)		arm_ordr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_ordr_d(_jit, r0, r1, r2);
+    else		vfp_ordr_d(_jit, r0, r1, r2);
+}
+
+#define jit_unordr_f(r0, r1, r2)	arm_unordr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_unordr_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unordr_f(_jit, r0, r1, r2);
+    else		vfp_unordr_f(_jit, r0, r1, r2);
+}
+
+#define jit_unordr_d(r0, r1, r2)	arm_unordr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_unordr_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1, jit_fpr_t r2)
+{
+    assert(r1 != JIT_FPRET && r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_unordr_d(_jit, r0, r1, r2);
+    else		vfp_unordr_d(_jit, r0, r1, r2);
+}
+
+#define jit_bltr_f(i0, r0, r1)		arm_bltr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bltr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bltr_f(_jit, i0, r0, r1));
+    return (vfp_bltr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bltr_d(i0, r0, r1)		arm_bltr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bltr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bltr_d(_jit, i0, r0, r1));
+    return (vfp_bltr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bler_f(i0, r0, r1)		arm_bler_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bler_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bler_f(_jit, i0, r0, r1));
+    return (vfp_bler_f(_jit, i0, r0, r1));
+}
+
+#define jit_bler_d(i0, r0, r1)		arm_bler_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bler_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bler_d(_jit, i0, r0, r1));
+    return (vfp_bler_d(_jit, i0, r0, r1));
+}
+
+#define jit_beqr_f(i0, r0, r1)		arm_beqr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_beqr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_beqr_f(_jit, i0, r0, r1));
+    return (vfp_beqr_f(_jit, i0, r0, r1));
+}
+
+#define jit_beqr_d(i0, r0, r1)		arm_beqr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_beqr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_beqr_d(_jit, i0, r0, r1));
+    return (vfp_beqr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bger_f(i0, r0, r1)		arm_bger_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bger_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bger_f(_jit, i0, r0, r1));
+    return (vfp_bger_f(_jit, i0, r0, r1));
+}
+
+#define jit_bger_d(i0, r0, r1)		arm_bger_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bger_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bger_d(_jit, i0, r0, r1));
+    return (vfp_bger_d(_jit, i0, r0, r1));
+}
+
+#define jit_bgtr_f(i0, r0, r1)		arm_bgtr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bgtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bgtr_f(_jit, i0, r0, r1));
+    return (vfp_bgtr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bgtr_d(i0, r0, r1)		arm_bgtr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bgtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bgtr_d(_jit, i0, r0, r1));
+    return (vfp_bgtr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bner_f(i0, r0, r1)		arm_bner_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bner_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bner_f(_jit, i0, r0, r1));
+    return (vfp_bner_f(_jit, i0, r0, r1));
+}
+
+#define jit_bner_d(i0, r0, r1)		arm_bner_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bner_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bner_d(_jit, i0, r0, r1));
+    return (vfp_bner_d(_jit, i0, r0, r1));
+}
+
+#define jit_bunltr_f(i0, r0, r1)	arm_bunltr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunltr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunltr_f(_jit, i0, r0, r1));
+    return (vfp_bunltr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bunltr_d(i0, r0, r1)	arm_bunltr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunltr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunltr_d(_jit, i0, r0, r1));
+    return (vfp_bunltr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bunler_f(i0, r0, r1)	arm_bunler_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunler_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunler_f(_jit, i0, r0, r1));
+    return (vfp_bunler_f(_jit, i0, r0, r1));
+}
+
+#define jit_bunler_d(i0, r0, r1)	arm_bunler_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunler_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunler_d(_jit, i0, r0, r1));
+    return (vfp_bunler_d(_jit, i0, r0, r1));
+}
+
+#define jit_buneqr_f(i0, r0, r1)	arm_buneqr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_buneqr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_buneqr_f(_jit, i0, r0, r1));
+    return (vfp_buneqr_f(_jit, i0, r0, r1));
+}
+
+#define jit_buneqr_d(i0, r0, r1)	arm_buneqr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_buneqr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_buneqr_d(_jit, i0, r0, r1));
+    return (vfp_buneqr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bunger_f(i0, r0, r1)	arm_bunger_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunger_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunger_f(_jit, i0, r0, r1));
+    return (vfp_bunger_f(_jit, i0, r0, r1));
+}
+
+#define jit_bunger_d(i0, r0, r1)	arm_bunger_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunger_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunger_d(_jit, i0, r0, r1));
+    return (vfp_bunger_d(_jit, i0, r0, r1));
+}
+
+#define jit_bungtr_f(i0, r0, r1)	arm_bungtr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bungtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bungtr_f(_jit, i0, r0, r1));
+    return (vfp_bungtr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bungtr_d(i0, r0, r1)	arm_bungtr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bungtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bungtr_d(_jit, i0, r0, r1));
+    return (vfp_bungtr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bltgtr_f(i0, r0, r1)	arm_bltgtr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bltgtr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bltgtr_f(_jit, i0, r0, r1));
+    return (vfp_bltgtr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bltgtr_d(i0, r0, r1)	arm_bltgtr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bltgtr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bltgtr_d(_jit, i0, r0, r1));
+    return (vfp_bltgtr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bordr_f(i0, r0, r1)		arm_bordr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bordr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bordr_f(_jit, i0, r0, r1));
+    return (vfp_bordr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bordr_d(i0, r0, r1)		arm_bordr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bordr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bordr_d(_jit, i0, r0, r1));
+    return (vfp_bordr_d(_jit, i0, r0, r1));
+}
+
+#define jit_bunordr_f(i0, r0, r1)	arm_bunordr_f(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunordr_f(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunordr_f(_jit, i0, r0, r1));
+    return (vfp_bunordr_f(_jit, i0, r0, r1));
+}
+
+#define jit_bunordr_d(i0, r0, r1)	arm_bunordr_d(_jit, i0, r0, r1)
+__jit_inline jit_insn *
+arm_bunordr_d(jit_state_t _jit, jit_insn *i0, jit_fpr_t r0, jit_fpr_t r1)
+{
+    assert(r0 != JIT_FPRET && r1 != JIT_FPRET);
+    if (jit_swf_p())	return (swf_bunordr_d(_jit, i0, r0, r1));
+    return (vfp_bunordr_d(_jit, i0, r0, r1));
+}
+
+#define jit_ldr_f(r0, r1)		arm_ldr_f(_jit, r0, r1)
+__jit_inline void
+arm_ldr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldr_f(_jit, r0, r1);
+    else		vfp_ldr_f(_jit, r0, r1);
+}
+
+#define jit_ldr_d(r0, r1)		arm_ldr_d(_jit, r0, r1)
+__jit_inline void
+arm_ldr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldr_d(_jit, r0, r1);
+    else		vfp_ldr_d(_jit, r0, r1);
+}
+
+#define jit_ldi_f(r0, i0)		arm_ldi_f(_jit, r0, i0)
+__jit_inline void
+arm_ldi_f(jit_state_t _jit, jit_fpr_t r0, void *i0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldi_f(_jit, r0, i0);
+    else		vfp_ldi_f(_jit, r0, i0);
+}
+
+#define jit_ldi_d(r0, i0)		arm_ldi_d(_jit, r0, i0)
+__jit_inline void
+arm_ldi_d(jit_state_t _jit, jit_fpr_t r0, void *i0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldi_d(_jit, r0, i0);
+    else		vfp_ldi_d(_jit, r0, i0);
+}
+
+#define jit_ldxr_f(r0, r1, r2)		arm_ldxr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_ldxr_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldxr_f(_jit, r0, r1, r2);
+    else		vfp_ldxr_f(_jit, r0, r1, r2);
+}
+
+#define jit_ldxr_d(r0, r1, r2)		arm_ldxr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_ldxr_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, jit_gpr_t r2)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldxr_d(_jit, r0, r1, r2);
+    else		vfp_ldxr_d(_jit, r0, r1, r2);
+}
+
+#define jit_ldxi_f(r0, r1, i0)		arm_ldxi_f(_jit, r0, r1, i0)
+__jit_inline void
+arm_ldxi_f(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldxi_f(_jit, r0, r1, i0);
+    else		vfp_ldxi_f(_jit, r0, r1, i0);
+}
+
+#define jit_ldxi_d(r0, r1, i0)		arm_ldxi_d(_jit, r0, r1, i0)
+__jit_inline void
+arm_ldxi_d(jit_state_t _jit, jit_fpr_t r0, jit_gpr_t r1, int i0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_ldxi_d(_jit, r0, r1, i0);
+    else		vfp_ldxi_d(_jit, r0, r1, i0);
+}
+
+#define jit_str_f(r0, r1)		arm_str_f(_jit, r0, r1)
+__jit_inline void
+arm_str_f(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_str_f(_jit, r0, r1);
+    else		vfp_str_f(_jit, r0, r1);
+}
+
+#define jit_str_d(r0, r1)		arm_str_d(_jit, r0, r1)
+__jit_inline void
+arm_str_d(jit_state_t _jit, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_str_d(_jit, r0, r1);
+    else		vfp_str_d(_jit, r0, r1);
+}
+
+#define jit_sti_f(i0, r0)		arm_sti_f(_jit, i0, r0)
+__jit_inline void
+arm_sti_f(jit_state_t _jit, void *i0, jit_fpr_t r0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_sti_f(_jit, i0, r0);
+    else		vfp_sti_f(_jit, i0, r0);
+}
+
+#define jit_sti_d(i0, r0)		arm_sti_d(_jit, i0, r0)
+__jit_inline void
+arm_sti_d(jit_state_t _jit, void *i0, jit_fpr_t r0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_sti_d(_jit, i0, r0);
+    else		vfp_sti_d(_jit, i0, r0);
+}
+
+#define jit_stxr_f(r0, r1, r2)		arm_stxr_f(_jit, r0, r1, r2)
+__jit_inline void
+arm_stxr_f(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2)
+{
+    assert(r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_stxr_f(_jit, r0, r1, r2);
+    else		vfp_stxr_f(_jit, r0, r1, r2);
+}
+
+#define jit_stxr_d(r0, r1, r2)		arm_stxr_d(_jit, r0, r1, r2)
+__jit_inline void
+arm_stxr_d(jit_state_t _jit, jit_gpr_t r0, jit_gpr_t r1, jit_fpr_t r2)
+{
+    assert(r2 != JIT_FPRET);
+    if (jit_swf_p())	swf_stxr_d(_jit, r0, r1, r2);
+    else		vfp_stxr_d(_jit, r0, r1, r2);
+}
+
+#define jit_stxi_f(i0, r0, r1)		arm_stxi_f(_jit, i0, r0, r1)
+__jit_inline void
+arm_stxi_f(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_stxi_f(_jit, i0, r0, r1);
+    else		vfp_stxi_f(_jit, i0, r0, r1);
+}
+
+#define jit_stxi_d(i0, r0, r1)		arm_stxi_d(_jit, i0, r0, r1)
+__jit_inline void
+arm_stxi_d(jit_state_t _jit, int i0, jit_gpr_t r0, jit_fpr_t r1)
+{
+    assert(r1 != JIT_FPRET);
+    if (jit_swf_p())	swf_stxi_d(_jit, i0, r0, r1);
+    else		vfp_stxi_d(_jit, i0, r0, r1);
+}
+
+#define jit_prolog_f(i0)		do {} while (0)
+#define jit_prolog_d(i0)		do {} while (0)
+
+#define jit_prepare_f(i0)		arm_prepare_f(_jit, i0)
+__jit_inline void
+arm_prepare_f(jit_state_t _jit, int i0)
+{
+    assert(i0 >= 0);
+    _jitl.stack_offset += i0 << 2;
+}
+
+#define jit_prepare_d(i0)		arm_prepare_d(_jit, i0)
+__jit_inline void
+arm_prepare_d(jit_state_t _jit, int i0)
+{
+    assert(i0 >= 0);
+    _jitl.stack_offset += i0 << 3;
+}
+
+#define jit_arg_f()			arm_arg_f(_jit)
+__jit_inline int
+arm_arg_f(jit_state_t _jit)
+{
+    int		ofs;
+    if (jit_hardfp_p()) {
+	ofs = _jitl.nextarg_getf++;
+	if (ofs < 16)
+	    return (ofs);
+    }
+    else {
+	ofs = _jitl.nextarg_get++;
+	if (ofs < 4)
+	    return (ofs);
+    }
+    ofs = _jitl.framesize;
+    _jitl.framesize += sizeof(int);
+    return (ofs);
+}
+
+#define jit_arg_d()			arm_arg_d(_jit)
+__jit_inline int
+arm_arg_d(jit_state_t _jit)
+{
+    int		ofs;
+    if (jit_hardfp_p()) {
+	if (_jitl.nextarg_getf & 1)
+	    ++_jitl.nextarg_getf;
+	ofs = _jitl.nextarg_getf;
+	_jitl.nextarg_getf += 2;
+	if (ofs < 16)
+	    return (ofs);
+    }
+    else {
+	if (_jitl.nextarg_get & 1)
+	    ++_jitl.nextarg_get;
+	ofs = _jitl.nextarg_get;
+	_jitl.nextarg_get += 2;
+	if (ofs < 4)
+	    return (ofs);
+    }
+    if (_jitl.framesize & 7)
+	_jitl.framesize += 4;
+    ofs = _jitl.framesize;
+    _jitl.framesize += sizeof(double);
+    return (ofs);
+}
+
+#define jit_getarg_f(r0, i0)		arm_getarg_f(_jit, r0, i0)
+__jit_inline void
+arm_getarg_f(jit_state_t _jit, jit_fpr_t r0, int i0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_getarg_f(_jit, r0, i0);
+    else		vfp_getarg_f(_jit, r0, i0);
+}
+
+#define jit_getarg_d(r0, i0)		arm_getarg_d(_jit, r0, i0)
+__jit_inline void
+arm_getarg_d(jit_state_t _jit, jit_fpr_t r0, int i0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_getarg_d(_jit, r0, i0);
+    else		vfp_getarg_d(_jit, r0, i0);
+}
+
+#define jit_pusharg_f(r0)		arm_pusharg_f(_jit, r0)
+__jit_inline void
+arm_pusharg_f(jit_state_t _jit, jit_fpr_t r0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_pusharg_f(_jit, r0);
+    else		vfp_pusharg_f(_jit, r0);
+}
+
+#define jit_pusharg_d(r0)		arm_pusharg_d(_jit, r0)
+__jit_inline void
+arm_pusharg_d(jit_state_t _jit, jit_fpr_t r0)
+{
+    assert(r0 != JIT_FPRET);
+    if (jit_swf_p())	swf_pusharg_d(_jit, r0);
+    else		vfp_pusharg_d(_jit, r0);
+}
+
+#define jit_retval_f(r0)		arm_retval_f(_jit, r0)
+__jit_inline void
+arm_retval_f(jit_state_t _jit, jit_fpr_t r0)
+{
+    if (r0 != JIT_FPRET) {
+	if (jit_swf_p())	swf_retval_f(_jit, r0);
+	else			vfp_retval_f(_jit, r0);
+    }
+    /* else assume chaining call to jit_retval_f as done in tests/funcfp.c */
+}
+
+#define jit_retval_d(r0)		arm_retval_d(_jit, r0)
+__jit_inline void
+arm_retval_d(jit_state_t _jit, jit_fpr_t r0)
+{
+    if (r0 != JIT_FPRET) {
+	if (jit_swf_p())	swf_retval_d(_jit, r0);
+	else			vfp_retval_d(_jit, r0);
+    }
+    /* else assume chaining call to jit_retval_d as done in tests/funcfp.c */
+}
+
+#endif /* __lightning_fp_arm_h */