deps/lightning/lib/jit_arm-swf.c

   1 /*
   2  * Copyright (C) 2012-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 /* match vfpv3 result */
  22 #define NAN_TO_INT_IS_ZERO              1
  23 extern float    sqrtf(float);
  24 extern double   sqrt(double);
  25 extern float    __addsf3(float, float);
  26 extern double   __adddf3(double, double);
  27 extern float    __aeabi_fsub(float, float);
  28 extern double   __aeabi_dsub(double, double);
  29 extern float    __aeabi_fmul(float, float);
  30 extern double   __aeabi_dmul(double, double);
  31 extern float    __aeabi_fdiv(float, float);
  32 extern double   __aeabi_ddiv(double, double);
  33 extern float    __aeabi_i2f(int);
  34 extern double   __aeabi_i2d(int);
  35 extern float    __aeabi_d2f(double);
  36 extern double   __aeabi_f2d(float);
  37 extern int      __aeabi_f2iz(float);
  38 extern int      __aeabi_d2iz(double);
  39 extern int      __aeabi_fcmplt(float, float);
  40 extern int      __aeabi_dcmplt(double, double);
  41 extern int      __aeabi_fcmple(float, float);
  42 extern int      __aeabi_dcmple(double, double);
  43 extern int      __aeabi_fcmpeq(float, float);
  44 extern int      __aeabi_dcmpeq(double, double);
  45 extern int      __aeabi_fcmpge(float, float);
  46 extern int      __aeabi_dcmpge(double, double);
  47 extern int      __aeabi_fcmpgt(float, float);
  48 extern int      __aeabi_dcmpgt(double, double);
  49 extern int      __aeabi_fcmpun(float, float);
  50 extern int      __aeabi_dcmpun(double, double);
  51 #  define swf_ff(i0,r0,r1)              _swf_ff(_jit,i0,r0,r1)
  52 static void
  53 _swf_ff(jit_state_t*,float(*)(float),jit_int32_t,jit_int32_t) maybe_unused;
  54 #  define swf_dd(i0,r0,r1)              _swf_dd(_jit,i0,r0,r1)
  55 static void
  56 _swf_dd(jit_state_t*,double(*)(double),jit_int32_t,jit_int32_t) maybe_unused;
  57 #  define swf_fff(i0,r0,r1,r2)          _swf_fff(_jit,i0,r0,r1,r2)
  58 static void _swf_fff(jit_state_t*,float(*)(float,float),
  59                      jit_int32_t,jit_int32_t,jit_int32_t);
  60 #  define swf_ddd(i0,r0,r1,r2)          _swf_ddd(_jit,i0,r0,r1,r2)
  61 static void _swf_ddd(jit_state_t*,double(*)(double,double),
  62                      jit_int32_t,jit_int32_t,jit_int32_t);
  63 #  define swf_fff_(i0,r0,r1,i1)         _swf_fff_(_jit,i0,r0,r1,i1)
  64 static void _swf_fff_(jit_state_t*,float(*)(float,float),
  65                       jit_int32_t,jit_int32_t,jit_float32_t);
  66 #  define swf_ddd_(i0,r0,r1,i1)         _swf_ddd_(_jit,i0,r0,r1,i1)
  67 static void _swf_ddd_(jit_state_t*,double(*)(double,double),
  68                       jit_int32_t,jit_int32_t,jit_float64_t);
  69 #  define swf_iff(i0,r0,r1,r2)          _swf_iff(_jit,i0,r0,r1,r2)
  70 static void _swf_iff(jit_state_t*,int(*)(float,float),
  71                      jit_int32_t,jit_int32_t,jit_int32_t);
  72 #  define swf_idd(i0,r0,r1,r2)          _swf_idd(_jit,i0,r0,r1,r2)
  73 static void _swf_idd(jit_state_t*,int(*)(double,double),
  74                      jit_int32_t,jit_int32_t,jit_int32_t);
  75 #  define swf_iff_(i0,r0,r1,r2)         _swf_iff_(_jit,i0,r0,r1,r2)
  76 static void _swf_iff_(jit_state_t*,int(*)(float,float),
  77                       jit_int32_t,jit_int32_t,jit_float32_t);
  78 #  define swf_idd_(i0,r0,r1,r2)         _swf_idd_(_jit,i0,r0,r1,r2)
  79 static void _swf_idd_(jit_state_t*,int(*)(double,double),
  80                       jit_int32_t,jit_int32_t,jit_float64_t);
  81 #  define swf_iunff(i0,r0,r1,r2)        _swf_iunff(_jit,i0,r0,r1,r2)
  82 static void _swf_iunff(jit_state_t*,int(*)(float,float),
  83                        jit_int32_t,jit_int32_t,jit_int32_t);
  84 #  define swf_iundd(i0,r0,r1,r2)        _swf_iundd(_jit,i0,r0,r1,r2)
  85 static void _swf_iundd(jit_state_t*,int(*)(double,double),
  86                        jit_int32_t,jit_int32_t,jit_int32_t);
  87 #  define swf_iunff_(i0,r0,r1,i1)       _swf_iunff_(_jit,i0,r0,r1,i1)
  88 static void _swf_iunff_(jit_state_t*,int(*)(float,float),
  89                         jit_int32_t,jit_int32_t,jit_float32_t);
  90 #  define swf_iundd_(i0,r0,r1,i1)       _swf_iundd_(_jit,i0,r0,r1,i1)
  91 static void _swf_iundd_(jit_state_t*,int(*)(double,double),
  92                         jit_int32_t,jit_int32_t,jit_float64_t);
  93 #  define swf_bff(i0,cc,i1,r0,r1)       _swf_bff(_jit,i0,cc,i1,r0,r1)
  94 static jit_word_t _swf_bff(jit_state_t*,int(*)(float,float),int,
  95                            jit_word_t,jit_int32_t,jit_int32_t);
  96 #  define swf_bdd(i0,cc,i1,r0,r1)       _swf_bdd(_jit,i0,cc,i1,r0,r1)
  97 static jit_word_t _swf_bdd(jit_state_t*,int(*)(double,double),int,
  98                            jit_word_t,jit_int32_t,jit_int32_t);
  99 #  define swf_bff_(i0,cc,i1,r0,i2)      _swf_bff_(_jit,i0,cc,i1,r0,i2)
 100 static jit_word_t _swf_bff_(jit_state_t*,int(*)(float,float),int,
 101                             jit_word_t,jit_int32_t,jit_float32_t);
 102 #  define swf_bdd_(i0,cc,i1,r0,i2)      _swf_bdd_(_jit,i0,cc,i1,r0,i2)
 103 static jit_word_t _swf_bdd_(jit_state_t*,int(*)(double,double),int,
 104                             jit_word_t,jit_int32_t,jit_float64_t);
 105 #  define swf_bunff(eq,i0,r0,r1)        _swf_bunff(_jit,eq,i0,r0,r1)
 106 static jit_word_t _swf_bunff(jit_state_t*,int,
 107                              jit_word_t,jit_int32_t,jit_int32_t);
 108 #  define swf_bundd(eq,i0,r0,r1)        _swf_bundd(_jit,eq,i0,r0,r1)
 109 static jit_word_t _swf_bundd(jit_state_t*,int,
 110                              jit_word_t,jit_int32_t,jit_int32_t);
 111 #  define swf_bunff_(eq,i0,r0,i1)       _swf_bunff_(_jit,eq,i0,r0,i1)
 112 static jit_word_t _swf_bunff_(jit_state_t*,int,
 113                               jit_word_t,jit_int32_t,jit_float32_t);
 114 #  define swf_bundd_(eq,i0,r0,i1)       _swf_bundd_(_jit,eq,i0,r0,i1)
 115 static jit_word_t _swf_bundd_(jit_state_t*,int,
 116                               jit_word_t,jit_int32_t,jit_float64_t);
 117 #  define swf_extr_f(r0,r1)             _swf_extr_f(_jit,r0,r1)
 118 static void _swf_extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 119 #  define swf_extr_d(r0,r1)             _swf_extr_d(_jit,r0,r1)
 120 static void _swf_extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 121 #  define swf_extr_d_f(r0,r1)           _swf_extr_d_f(_jit,r0,r1)
 122 static void _swf_extr_d_f(jit_state_t*,jit_int32_t,jit_int32_t);
 123 #  define swf_extr_f_d(r0,r1)           _swf_extr_f_d(_jit,r0,r1)
 124 static void _swf_extr_f_d(jit_state_t*,jit_int32_t,jit_int32_t);
 125 #  define swf_truncr_f_i(r0,r1)         _swf_truncr_f_i(_jit,r0,r1)
 126 static void _swf_truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
 127 #  define swf_truncr_d_i(r0,r1)         _swf_truncr_d_i(_jit,r0,r1)
 128 static void _swf_truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
 129 #  define swf_movr_f(r0,r1)             _swf_movr_f(_jit,r0,r1)
 130 static void _swf_movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 131 #  define swf_movi_f(r0,i0)             _swf_movi_f(_jit,r0,i0)
 132 static void _swf_movi_f(jit_state_t*,jit_int32_t,jit_float32_t);
 133 #  define swf_movr_w_f(r0, r1)          _swf_movr_w_f(_jit, r0, r1)
 134 static void _swf_movr_w_f(jit_state_t*,jit_int32_t,jit_int32_t);
 135 #  define swf_movr_f_w(r0, r1)          _swf_movr_f_w(_jit, r0, r1)
 136 static void _swf_movr_f_w(jit_state_t*,jit_int32_t,jit_int32_t);
 137 #define swf_movi_w_f(r0, i0)            _swf_movi_w_f(_jit, r0, i0)
 138 static void _swf_movi_w_f(jit_state_t*, jit_int32_t, jit_word_t);
 139 #  define swf_movr_d(r0,r1)             _swf_movr_d(_jit,r0,r1)
 140 static void _swf_movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 141 #  define swf_movi_d(r0,i0)             _swf_movi_d(_jit,r0,i0)
 142 static void _swf_movi_d(jit_state_t*,jit_int32_t,jit_float64_t);
 143 #  define swf_movr_ww_d(r0, r1, r2)     _swf_movr_ww_d(_jit, r0, r1, r2)
 144 static void _swf_movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 145 #  define swf_movr_d_ww(r0, r1, r2)     _swf_movr_d_ww(_jit, r0, r1, r2)
 146 static void _swf_movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 147 #  define swf_movi_ww_d(r0, i0, i1)     _swf_movi_ww_d(_jit, r0, i0, i1)
 148 static void _swf_movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 149 #  define swf_absr_f(r0,r1)             _swf_absr_f(_jit,r0,r1)
 150 static void _swf_absr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 151 #  define swf_absr_d(r0,r1)             _swf_absr_d(_jit,r0,r1)
 152 static void _swf_absr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 153 #  define swf_negr_f(r0,r1)             _swf_negr_f(_jit,r0,r1)
 154 static void _swf_negr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 155 #  define swf_negr_d(r0,r1)             _swf_negr_d(_jit,r0,r1)
 156 static void _swf_negr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 157 #  define swf_sqrtr_f(r0,r1)            swf_ff(sqrtf,r0,r1)
 158 #  define swf_sqrtr_d(r0,r1)            swf_dd(sqrt,r0,r1)
 159 #  define swf_fmar_f(r0,r1,r2,r3)       _swf_fmar_f(_jit,r0,r1,r2,r3)
 160 static void _swf_fmar_f(jit_state_t*,
 161                         jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 162 #  define swf_fmsr_f(r0,r1,r2,r3)       _swf_fmsr_f(_jit,r0,r1,r2,r3)
 163 static void _swf_fmsr_f(jit_state_t*,
 164                         jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 165 #  define swf_fmar_d(r0,r1,r2,r3)       _swf_fmar_d(_jit,r0,r1,r2,r3)
 166 static void _swf_fmar_d(jit_state_t*,
 167                         jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 168 #  define swf_fmsr_d(r0,r1,r2,r3)       _swf_fmsr_d(_jit,r0,r1,r2,r3)
 169 static void _swf_fmsr_d(jit_state_t*,
 170                         jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 171 #  define swf_fnmar_f(r0,r1,r2,r3)      _swf_fnmar_f(_jit,r0,r1,r2,r3)
 172 static void _swf_fnmar_f(jit_state_t*,
 173                          jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 174 #  define swf_fnmsr_f(r0,r1,r2,r3)      _swf_fnmsr_f(_jit,r0,r1,r2,r3)
 175 static void _swf_fnmsr_f(jit_state_t*,
 176                          jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 177 #  define swf_fnmar_d(r0,r1,r2,r3)      _swf_fnmar_d(_jit,r0,r1,r2,r3)
 178 static void _swf_fnmar_d(jit_state_t*,
 179                          jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 180 #  define swf_fnmsr_d(r0,r1,r2,r3)      _swf_fnmsr_d(_jit,r0,r1,r2,r3)
 181 static void _swf_fnmsr_d(jit_state_t*,
 182                          jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 183 #  define swf_addr_f(r0,r1,r2)          swf_fff(__addsf3,r0,r1,r2)
 184 #  define swf_addi_f(r0,r1,i0)          swf_fff_(__addsf3,r0,r1,i0)
 185 #  define swf_addr_d(r0,r1,r2)          swf_ddd(__adddf3,r0,r1,r2)
 186 #  define swf_addi_d(r0,r1,i0)          swf_ddd_(__adddf3,r0,r1,i0)
 187 #  define swf_subr_f(r0,r1,r2)          swf_fff(__aeabi_fsub,r0,r1,r2)
 188 #  define swf_subi_f(r0,r1,i0)          swf_fff_(__aeabi_fsub,r0,r1,i0)
 189 #  define swf_subr_d(r0,r1,r2)          swf_ddd(__aeabi_dsub,r0,r1,r2)
 190 #  define swf_subi_d(r0,r1,i0)          swf_ddd_(__aeabi_dsub,r0,r1,i0)
 191 #  define swf_rsbr_f(r0, r1, r2)        swf_subr_f(r0, r2, r1)
 192 #  define swf_rsbi_f(r0, r1, i0)        _swf_rsbi_f(_jit, r0, r1, i0)
 193 static void _swf_rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
 194 #  define swf_rsbr_d(r0, r1, r2)        swf_subr_d(r0, r2, r1)
 195 #  define swf_rsbi_d(r0, r1, i0)        _swf_rsbi_d(_jit, r0, r1, i0)
 196 static void _swf_rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 197 #  define swf_mulr_f(r0,r1,r2)          swf_fff(__aeabi_fmul,r0,r1,r2)
 198 #  define swf_muli_f(r0,r1,i0)          swf_fff_(__aeabi_fmul,r0,r1,i0)
 199 #  define swf_mulr_d(r0,r1,r2)          swf_ddd(__aeabi_dmul,r0,r1,r2)
 200 #  define swf_muli_d(r0,r1,i0)          swf_ddd_(__aeabi_dmul,r0,r1,i0)
 201 #  define swf_divr_f(r0,r1,r2)          swf_fff(__aeabi_fdiv,r0,r1,r2)
 202 #  define swf_divi_f(r0,r1,i0)          swf_fff_(__aeabi_fdiv,r0,r1,i0)
 203 #  define swf_divr_d(r0,r1,r2)          swf_ddd(__aeabi_ddiv,r0,r1,r2)
 204 #  define swf_divi_d(r0,r1,i0)          swf_ddd_(__aeabi_ddiv,r0,r1,i0)
 205 #  define swf_ltr_f(r0,r1,r2)           swf_iff(__aeabi_fcmplt,r0,r1,r2)
 206 #  define swf_lti_f(r0,r1,i0)           swf_iff_(__aeabi_fcmplt,r0,r1,i0)
 207 #  define swf_ltr_d(r0,r1,r2)           swf_idd(__aeabi_dcmplt,r0,r1,r2)
 208 #  define swf_lti_d(r0,r1,i0)           swf_idd_(__aeabi_dcmplt,r0,r1,i0)
 209 #  define swf_ler_f(r0,r1,r2)           swf_iff(__aeabi_fcmple,r0,r1,r2)
 210 #  define swf_lei_f(r0,r1,i0)           swf_iff_(__aeabi_fcmple,r0,r1,i0)
 211 #  define swf_ler_d(r0,r1,r2)           swf_idd(__aeabi_dcmple,r0,r1,r2)
 212 #  define swf_lei_d(r0,r1,i0)           swf_idd_(__aeabi_dcmple,r0,r1,i0)
 213 #  define swf_eqr_f(r0,r1,r2)           swf_iff(__aeabi_fcmpeq,r0,r1,r2)
 214 #  define swf_eqi_f(r0,r1,i0)           swf_iff_(__aeabi_fcmpeq,r0,r1,i0)
 215 #  define swf_eqr_d(r0,r1,r2)           swf_idd(__aeabi_dcmpeq,r0,r1,r2)
 216 #  define swf_eqi_d(r0,r1,i0)           swf_idd_(__aeabi_dcmpeq,r0,r1,i0)
 217 #  define swf_ger_f(r0,r1,r2)           swf_iff(__aeabi_fcmpge,r0,r1,r2)
 218 #  define swf_gei_f(r0,r1,i0)           swf_iff_(__aeabi_fcmpge,r0,r1,i0)
 219 #  define swf_ger_d(r0,r1,r2)           swf_idd(__aeabi_dcmpge,r0,r1,r2)
 220 #  define swf_gei_d(r0,r1,i0)           swf_idd_(__aeabi_dcmpge,r0,r1,i0)
 221 #  define swf_gtr_f(r0,r1,r2)           swf_iff(__aeabi_fcmpgt,r0,r1,r2)
 222 #  define swf_gti_f(r0,r1,i0)           swf_iff_(__aeabi_fcmpgt,r0,r1,i0)
 223 #  define swf_gtr_d(r0,r1,r2)           swf_idd(__aeabi_dcmpgt,r0,r1,r2)
 224 #  define swf_gti_d(r0,r1,i0)           swf_idd_(__aeabi_dcmpgt,r0,r1,i0)
 225 #  define swf_ner_f(r0,r1,r2)           _swf_ner_f(_jit,r0,r1,r2)
 226 static void _swf_ner_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 227 #  define swf_nei_f(r0,r1,i0)           _swf_nei_f(_jit,r0,r1,i0)
 228 static void _swf_nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
 229 #  define swf_ner_d(r0,r1,r2)           _swf_ner_d(_jit,r0,r1,r2)
 230 static void _swf_ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 231 #  define swf_nei_d(r0,r1,i0)           _swf_nei_d(_jit,r0,r1,i0)
 232 static void _swf_nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 233 #  define swf_unltr_f(r0,r1,r2)         swf_iunff(__aeabi_fcmplt,r0,r1,r2)
 234 #  define swf_unlti_f(r0,r1,i0)         swf_iunff_(__aeabi_fcmplt,r0,r1,i0)
 235 #  define swf_unltr_d(r0,r1,r2)         swf_iundd(__aeabi_dcmplt,r0,r1,r2)
 236 #  define swf_unlti_d(r0,r1,i0)         swf_iundd_(__aeabi_dcmplt,r0,r1,i0)
 237 #  define swf_unler_f(r0,r1,r2)         swf_iunff(__aeabi_fcmple,r0,r1,r2)
 238 #  define swf_unlei_f(r0,r1,i0)         swf_iunff_(__aeabi_fcmple,r0,r1,i0)
 239 #  define swf_unler_d(r0,r1,r2)         swf_iundd(__aeabi_dcmple,r0,r1,r2)
 240 #  define swf_unlei_d(r0,r1,i0)         swf_iundd_(__aeabi_dcmple,r0,r1,i0)
 241 #  define swf_uneqr_f(r0,r1,r2)         swf_iunff(__aeabi_fcmpeq,r0,r1,r2)
 242 #  define swf_uneqi_f(r0,r1,i0)         swf_iunff_(__aeabi_fcmpeq,r0,r1,i0)
 243 #  define swf_uneqr_d(r0,r1,r2)         swf_iundd(__aeabi_dcmpeq,r0,r1,r2)
 244 #  define swf_uneqi_d(r0,r1,i0)         swf_iundd_(__aeabi_dcmpeq,r0,r1,i0)
 245 #  define swf_unger_f(r0,r1,r2)         swf_iunff(__aeabi_fcmpge,r0,r1,r2)
 246 #  define swf_ungei_f(r0,r1,i0)         swf_iunff_(__aeabi_fcmpge,r0,r1,i0)
 247 #  define swf_unger_d(r0,r1,r2)         swf_iundd(__aeabi_dcmpge,r0,r1,r2)
 248 #  define swf_ungei_d(r0,r1,i0)         swf_iundd_(__aeabi_dcmpge,r0,r1,i0)
 249 #  define swf_ungtr_f(r0,r1,r2)         swf_iunff(__aeabi_fcmpgt,r0,r1,r2)
 250 #  define swf_ungti_f(r0,r1,i0)         swf_iunff_(__aeabi_fcmpgt,r0,r1,i0)
 251 #  define swf_ungtr_d(r0,r1,r2)         swf_iundd(__aeabi_dcmpgt,r0,r1,r2)
 252 #  define swf_ungti_d(r0,r1,i0)         swf_iundd_(__aeabi_dcmpgt,r0,r1,i0)
 253 #  define swf_ltgtr_f(r0,r1,r2)         _swf_ltgtr_f(_jit,r0,r1,r2)
 254 static void _swf_ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 255 #  define swf_ltgti_f(r0,r1,i0)         _swf_ltgti_f(_jit,r0,r1,i0)
 256 static void _swf_ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
 257 #  define swf_ltgtr_d(r0,r1,r2)         _swf_ltgtr_d(_jit,r0,r1,r2)
 258 static void _swf_ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 259 #  define swf_ltgti_d(r0,r1,i0)         _swf_ltgti_d(_jit,r0,r1,i0)
 260 static void _swf_ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 261 #  define swf_ordr_f(r0,r1,r2)          _swf_ordr_f(_jit,r0,r1,r2)
 262 static void _swf_ordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 263 #  define swf_ordi_f(r0,r1,i0)          _swf_ordi_f(_jit,r0,r1,i0)
 264 static void _swf_ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
 265 #  define swf_ordr_d(r0,r1,r2)          _swf_ordr_d(_jit,r0,r1,r2)
 266 static void _swf_ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 267 #  define swf_ordi_d(r0,r1,i0)          _swf_ordi_d(_jit,r0,r1,i0)
 268 static void _swf_ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 269 #  define swf_unordr_f(r0,r1,r2)        swf_iunff(__aeabi_fcmpun,r0,r1,r2)
 270 #  define swf_unordi_f(r0,r1,i0)        swf_iunff_(__aeabi_fcmpun,r0,r1,i0)
 271 #  define swf_unordr_d(r0,r1,r2)        swf_iundd(__aeabi_dcmpun,r0,r1,r2)
 272 #  define swf_unordi_d(r0,r1,i0)        swf_iundd_(__aeabi_dcmpun,r0,r1,i0)
 273 #  define swf_bltr_f(i0,r0,r1)          swf_bff(__aeabi_fcmplt,ARM_CC_NE,i0,r0,r1)
 274 #  define swf_blti_f(i0,r0,i1)          swf_bff_(__aeabi_fcmplt,ARM_CC_NE,i0,r0,i1)
 275 #  define swf_bltr_d(i0,r0,r1)          swf_bdd(__aeabi_dcmplt,ARM_CC_NE,i0,r0,r1)
 276 #  define swf_blti_d(i0,r0,i1)          swf_bdd_(__aeabi_dcmplt,ARM_CC_NE,i0,r0,i1)
 277 #  define swf_bler_f(i0,r0,r1)          swf_bff(__aeabi_fcmple,ARM_CC_NE,i0,r0,r1)
 278 #  define swf_blei_f(i0,r0,i1)          swf_bff_(__aeabi_fcmple,ARM_CC_NE,i0,r0,i1)
 279 #  define swf_bler_d(i0,r0,r1)          swf_bdd(__aeabi_dcmple,ARM_CC_NE,i0,r0,r1)
 280 #  define swf_blei_d(i0,r0,i1)          swf_bdd_(__aeabi_dcmple,ARM_CC_NE,i0,r0,i1)
 281 #  define swf_beqr_f(i0,r0,r1)          swf_bff(__aeabi_fcmpeq,ARM_CC_NE,i0,r0,r1)
 282 #  define swf_beqi_f(i0,r0,i1)          swf_bff_(__aeabi_fcmpeq,ARM_CC_NE,i0,r0,i1)
 283 #  define swf_beqr_d(i0,r0,r1)          swf_bdd(__aeabi_dcmpeq,ARM_CC_NE,i0,r0,r1)
 284 #  define swf_beqi_d(i0,r0,i1)          swf_bdd_(__aeabi_dcmpeq,ARM_CC_NE,i0,r0,i1)
 285 #  define swf_bger_f(i0,r0,r1)          swf_bff(__aeabi_fcmpge,ARM_CC_NE,i0,r0,r1)
 286 #  define swf_bgei_f(i0,r0,i1)          swf_bff_(__aeabi_fcmpge,ARM_CC_NE,i0,r0,i1)
 287 #  define swf_bger_d(i0,r0,r1)          swf_bdd(__aeabi_dcmpge,ARM_CC_NE,i0,r0,r1)
 288 #  define swf_bgei_d(i0,r0,i1)          swf_bdd_(__aeabi_dcmpge,ARM_CC_NE,i0,r0,i1)
 289 #  define swf_bgtr_f(i0,r0,r1)          swf_bff(__aeabi_fcmpgt,ARM_CC_NE,i0,r0,r1)
 290 #  define swf_bgti_f(i0,r0,i1)          swf_bff_(__aeabi_fcmpgt,ARM_CC_NE,i0,r0,i1)
 291 #  define swf_bgtr_d(i0,r0,r1)          swf_bdd(__aeabi_dcmpgt,ARM_CC_NE,i0,r0,r1)
 292 #  define swf_bgti_d(i0,r0,i1)          swf_bdd_(__aeabi_dcmpgt,ARM_CC_NE,i0,r0,i1)
 293 #  define swf_bner_f(i0,r0,r1)          swf_bff(__aeabi_fcmpeq,ARM_CC_EQ,i0,r0,r1)
 294 #  define swf_bnei_f(i0,r0,i1)          swf_bff_(__aeabi_fcmpeq,ARM_CC_EQ,i0,r0,i1)
 295 #  define swf_bner_d(i0,r0,r1)          swf_bdd(__aeabi_dcmpeq,ARM_CC_EQ,i0,r0,r1)
 296 #  define swf_bnei_d(i0,r0,i1)          swf_bdd_(__aeabi_dcmpeq,ARM_CC_EQ,i0,r0,i1)
 297 #  define swf_bunltr_f(i0,r0,r1)        swf_bff(__aeabi_fcmpge,ARM_CC_EQ,i0,r0,r1)
 298 #  define swf_bunlti_f(i0,r0,i1)        swf_bff_(__aeabi_fcmpge,ARM_CC_EQ,i0,r0,i1)
 299 #  define swf_bunltr_d(i0,r0,r1)        swf_bdd(__aeabi_dcmpge,ARM_CC_EQ,i0,r0,r1)
 300 #  define swf_bunlti_d(i0,r0,i1)        swf_bdd_(__aeabi_dcmpge,ARM_CC_EQ,i0,r0,i1)
 301 #  define swf_bunler_f(i0,r0,r1)        swf_bff(__aeabi_fcmpgt,ARM_CC_EQ,i0,r0,r1)
 302 #  define swf_bunlei_f(i0,r0,i1)        swf_bff_(__aeabi_fcmpgt,ARM_CC_EQ,i0,r0,i1)
 303 #  define swf_bunler_d(i0,r0,r1)        swf_bdd(__aeabi_dcmpgt,ARM_CC_EQ,i0,r0,r1)
 304 #  define swf_bunlei_d(i0,r0,i1)        swf_bdd_(__aeabi_dcmpgt,ARM_CC_EQ,i0,r0,i1)
 305 #  define swf_buneqr_f(i0,r0,r1)        swf_bunff(1,i0,r0,r1)
 306 #  define swf_buneqi_f(i0,r0,i1)        swf_bunff_(1,i0,r0,i1)
 307 #  define swf_buneqr_d(i0,r0,r1)        swf_bundd(1,i0,r0,r1)
 308 #  define swf_buneqi_d(i0,r0,i1)        swf_bundd_(1,i0,r0,i1)
 309 #  define swf_bunger_f(i0,r0,r1)        swf_bff(__aeabi_fcmplt,ARM_CC_EQ,i0,r0,r1)
 310 #  define swf_bungei_f(i0,r0,i1)        swf_bff_(__aeabi_fcmplt,ARM_CC_EQ,i0,r0,i1)
 311 #  define swf_bunger_d(i0,r0,r1)        swf_bdd(__aeabi_dcmplt,ARM_CC_EQ,i0,r0,r1)
 312 #  define swf_bungei_d(i0,r0,i1)        swf_bdd_(__aeabi_dcmplt,ARM_CC_EQ,i0,r0,i1)
 313 #  define swf_bungtr_f(i0,r0,r1)        swf_bff(__aeabi_fcmple,ARM_CC_EQ,i0,r0,r1)
 314 #  define swf_bungti_f(i0,r0,i1)        swf_bff_(__aeabi_fcmple,ARM_CC_EQ,i0,r0,i1)
 315 #  define swf_bungtr_d(i0,r0,r1)        swf_bdd(__aeabi_dcmple,ARM_CC_EQ,i0,r0,r1)
 316 #  define swf_bungti_d(i0,r0,i1)        swf_bdd_(__aeabi_dcmple,ARM_CC_EQ,i0,r0,i1)
 317 #  define swf_bltgtr_f(i0,r0,r1)        swf_bunff(0,i0,r0,r1)
 318 #  define swf_bltgti_f(i0,r0,i1)        swf_bunff_(0,i0,r0,i1)
 319 #  define swf_bltgtr_d(i0,r0,r1)        swf_bundd(0,i0,r0,r1)
 320 #  define swf_bltgti_d(i0,r0,i1)        swf_bundd_(0,i0,r0,i1)
 321 #  define swf_bordr_f(i0,r0,r1)         swf_bff(__aeabi_fcmpun,ARM_CC_EQ,i0,r0,r1)
 322 #  define swf_bordi_f(i0,r0,i1)         swf_bff_(__aeabi_fcmpun,ARM_CC_EQ,i0,r0,i1)
 323 #  define swf_bordr_d(i0,r0,r1)         swf_bdd(__aeabi_dcmpun,ARM_CC_EQ,i0,r0,r1)
 324 #  define swf_bordi_d(i0,r0,i1)         swf_bdd_(__aeabi_dcmpun,ARM_CC_EQ,i0,r0,i1)
 325 #  define swf_bunordr_f(i0,r0,r1)       swf_bff(__aeabi_fcmpun,ARM_CC_NE,i0,r0,r1)
 326 #  define swf_bunordi_f(i0,r0,i1)       swf_bff_(__aeabi_fcmpun,ARM_CC_NE,i0,r0,i1)
 327 #  define swf_bunordr_d(i0,r0,r1)       swf_bdd(__aeabi_dcmpun,ARM_CC_NE,i0,r0,r1)
 328 #  define swf_bunordi_d(i0,r0,i1)       swf_bdd_(__aeabi_dcmpun,ARM_CC_NE,i0,r0,i1)
 329 #  define swf_ldr_f(r0,r1)              _swf_ldr_f(_jit,r0,r1)
 330 static void _swf_ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 331 #  define swf_ldr_d(r0,r1)              _swf_ldr_d(_jit,r0,r1)
 332 static void _swf_ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 333 #  define swf_ldi_f(r0,i0)              _swf_ldi_f(_jit,r0,i0)
 334 static void _swf_ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 335 #  define swf_ldi_d(r0,i0)              _swf_ldi_d(_jit,r0,i0)
 336 static void _swf_ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 337 #  define swf_ldxr_f(r0,r1,r2)          _swf_ldxr_f(_jit,r0,r1,r2)
 338 static void _swf_ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 339 #  define swf_ldxr_d(r0,r1,r2)          _swf_ldxr_d(_jit,r0,r1,r2)
 340 static void _swf_ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 341 #  define swf_ldxi_f(r0,r1,i0)          _swf_ldxi_f(_jit,r0,r1,i0)
 342 static void _swf_ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 343 #  define swf_ldxi_d(r0,r1,i0)          _swf_ldxi_d(_jit,r0,r1,i0)
 344 static void _swf_ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 345 #  define swf_unldr_x(r0, r1, i0)       _swf_unldr_x(_jit, r0, r1, i0)
 346 static void _swf_unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 347 #  define swf_unldi_x(r0, i0, i1)       _swf_unldi_x(_jit, r0, i0, i1)
 348 static void _swf_unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 349 #  define swf_str_f(r0,r1)              _swf_str_f(_jit,r0,r1)
 350 static void _swf_str_f(jit_state_t*,jit_int32_t,jit_int32_t);
 351 #  define swf_str_d(r0,r1)              _swf_str_d(_jit,r0,r1)
 352 static void _swf_str_d(jit_state_t*,jit_int32_t,jit_int32_t);
 353 #  define swf_sti_f(r0,i0)              _swf_sti_f(_jit,r0,i0)
 354 static void _swf_sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 355 #define swf_unstr_x(r0, r1, i0)         _swf_unstr_x(_jit, r0, r1, i0)
 356 static void _swf_unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 357 #define swf_unsti_x(i0, r0, i1)         _swf_unsti_x(_jit, i0, r0, i1)
 358 static void _swf_unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 359 #  define swf_sti_d(r0,i0)              _swf_sti_d(_jit,r0,i0)
 360 static void _swf_sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 361 #  define swf_stxr_f(r0,r1,r2)          _swf_stxr_f(_jit,r0,r1,r2)
 362 static void _swf_stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 363 #  define swf_stxr_d(r0,r1,r2)          _swf_stxr_d(_jit,r0,r1,r2)
 364 static void _swf_stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 365 #  define swf_stxi_f(r0,r1,i0)          _swf_stxi_f(_jit,r0,r1,i0)
 366 static void _swf_stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 367 #  define swf_stxi_d(r0,r1,i0)          _swf_stxi_d(_jit,r0,r1,i0)
 368 static void _swf_stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 369 #  define swf_vaarg_d(r0, r1)           _swf_vaarg_d(_jit, r0, r1)
 370 static void _swf_vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 371 #endif
 372
 373 #if CODE
 374 #define swf_off(rn)                     ((rn - 16) << 2)
 375
 376 #define swf_call(function, label, regno)                                \
 377     do {                                                                \
 378         jit_word_t      d;                                              \
 379         if (!jit_exchange_p()) {                                        \
 380             if (jit_thumb_p())                                          \
 381                 d = (((jit_word_t)function - _jit->pc.w) >> 1) - 2;     \
 382             else                                                        \
 383                 d = (((jit_word_t)function - _jit->pc.w) >> 2) - 2;     \
 384             if (_s24P(d)) {                                             \
 385                 if (jit_thumb_p())                                      \
 386                     T2_BLI(encode_thumb_jump(d));                       \
 387                 else                                                    \
 388                     BLI(d & 0x00ffffff);                                \
 389             }                                                           \
 390             else                                                        \
 391                 goto label;                                             \
 392         }                                                               \
 393         else {                                                          \
 394         label:                                                          \
 395             movi(regno, (jit_word_t)function);                          \
 396             if (jit_thumb_p())                                          \
 397                 T1_BLX(regno);                                          \
 398             else                                                        \
 399                 BLX(regno);                                             \
 400         }                                                               \
 401     } while (0)
 402 #define swf_call_with_get_reg(function, label)                          \
 403     do {                                                                \
 404         jit_word_t      d;                                              \
 405         jit_int32_t     reg;                                            \
 406         if (!jit_exchange_p()) {                                        \
 407             if (jit_thumb_p())                                          \
 408                 d = (((jit_word_t)function - _jit->pc.w) >> 1) - 2;     \
 409             else                                                        \
 410                 d = (((jit_word_t)function - _jit->pc.w) >> 2) - 2;     \
 411             if (_s24P(d)) {                                             \
 412                 if (jit_thumb_p())                                      \
 413                     T2_BLI(encode_thumb_jump(d));                       \
 414                 else                                                    \
 415                     BLI(d & 0x00ffffff);                                \
 416             }                                                           \
 417             else                                                        \
 418                 goto label;                                             \
 419         }                                                               \
 420         else {                                                          \
 421         label:                                                          \
 422             reg = jit_get_reg(jit_class_gpr);                           \
 423             movi(rn(reg), (jit_word_t)function);                        \
 424             if (jit_thumb_p())                                          \
 425                 T1_BLX(rn(reg));                                        \
 426             else                                                        \
 427                 BLX(rn(reg));                                           \
 428             jit_unget_reg(reg);                                         \
 429         }                                                               \
 430     } while (0)
 431 #define swf_ldrin(rt, rn, im)                                           \
 432     do {                                                                \
 433         if (jit_thumb_p())      T2_LDRIN(rt, rn, im);                   \
 434         else                    LDRIN(rt, rn, im);                      \
 435     } while (0)
 436 #define swf_strin(rt, rn, im)                                           \
 437     do {                                                                \
 438         if (jit_thumb_p())      T2_STRIN(rt, rn, im);                   \
 439         else                    STRIN(rt, rn, im);                      \
 440     } while (0)
 441 #define swf_bici(rt, rn, im)                                            \
 442     do {                                                                \
 443         if (jit_thumb_p())                                              \
 444             T2_BICI(rt, rn, encode_thumb_immediate(im));                \
 445         else                                                            \
 446             BICI(rt, rn, encode_arm_immediate(im));                     \
 447     } while (0)
 448
 449 #if !defined(__GNUC__)
 450 float __addsf3(float u, float v)
 451 {
 452     return (u + v);
 453 }
 454
 455 double
 456 __adddf3(double u, double v)
 457 {
 458     return (u + v);
 459 }
 460
 461 float
 462 __aeabi_fsub(float u, float v)
 463 {
 464     return (u - v);
 465 }
 466
 467 double
 468 __aeabi_dsub(double u, double v)
 469 {
 470     return (u - v);
 471 }
 472
 473 float
 474 __aeabi_fmul(float u, float v)
 475 {
 476     return (u * v);
 477 }
 478
 479 double
 480 __aeabi_dmul(double u, double v)
 481 {
 482     return (u * v);
 483 }
 484
 485 float
 486 __aeabi_fdiv(float u, float v)
 487 {
 488     return (u / v);
 489 }
 490
 491 double
 492 __aeabi_ddiv(double u, double v)
 493 {
 494     return (u / v);
 495 }
 496
 497 float
 498 __aeabi_i2f(int u)
 499 {
 500     return (u);
 501 }
 502
 503 double
 504 __aeabi_i2d(int u)
 505 {
 506     return (u);
 507 }
 508
 509 float
 510 __aeabi_d2f(double u)
 511 {
 512     return (u);
 513 }
 514
 515 double
 516 __aeabi_f2d(float u)
 517 {
 518     return (u);
 519 }
 520
 521 extern int
 522 __aeabi_f2iz(float u)
 523 {
 524     return (u);
 525 }
 526
 527 int
 528 __aeabi_d2iz(double u)
 529 {
 530     return (u);
 531 }
 532
 533 int
 534 __aeabi_fcmplt(float u, float v)
 535 {
 536     return (u < v);
 537 }
 538
 539 int
 540 __aeabi_dcmplt(double u, double v)
 541 {
 542     return (u < v);
 543 }
 544
 545 int
 546 __aeabi_fcmple(float u, float v)
 547 {
 548     return (u <= v);
 549 }
 550
 551 int
 552 __aeabi_dcmple(double u, double v)
 553 {
 554     return (u <= v);
 555 }
 556
 557 int
 558 __aeabi_fcmpeq(float u, float v)
 559 {
 560     return (u == v);
 561 }
 562
 563 int
 564 __aeabi_dcmpeq(double u, double v)
 565 {
 566     return (u == v);
 567 }
 568
 569 int
 570 __aeabi_fcmpge(float u, float v)
 571 {
 572     return (u >= v);
 573 }
 574
 575 int
 576 __aeabi_dcmpge(double u, double v)
 577 {
 578     return (u >= v);
 579 }
 580
 581 int
 582 __aeabi_fcmpgt(float u, float v)
 583 {
 584     return (u > v);
 585 }
 586
 587 int
 588 __aeabi_dcmpgt(double u, double v)
 589 {
 590     return (u > v);
 591 }
 592
 593 int
 594 __aeabi_fcmpun(float u, float v)
 595 {
 596     return ((u != u) || (v != v));
 597 }
 598
 599 int
 600 __aeabi_dcmpun(double u, double v)
 601 {
 602     return ((u != u) || (v != v));
 603 }
 604 #endif
 605
 606 static void
 607 _swf_ff(jit_state_t *_jit, float(*i0)(float),
 608         jit_int32_t r0, jit_int32_t r1)
 609 {
 610     jit_get_reg_args();
 611     if (jit_fpr_p(r0) || jit_fpr_p(r1))
 612         CHECK_SWF_OFFSET();
 613     if (jit_fpr_p(r1))
 614         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 615     else
 616         movr(_R0_REGNO, r1);
 617     swf_call(i0, fallback, _R1_REGNO);
 618     if (jit_fpr_p(r0))
 619         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 620     else
 621         movr(r0, _R0_REGNO);
 622     jit_unget_reg_args();
 623 }
 624
 625 static void
 626 _swf_dd(jit_state_t *_jit, double (*i0)(double),
 627         jit_int32_t r0, jit_int32_t r1)
 628 {
 629     jit_get_reg_args();
 630     if (jit_fpr_p(r0) || jit_fpr_p(r1))
 631         CHECK_SWF_OFFSET();
 632     if (jit_fpr_p(r1)) {
 633         if (!jit_thumb_p() && jit_armv5e_p())
 634             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 635         else {
 636             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 637             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 638         }
 639     }
 640     else {
 641         movr(_R0_REGNO, r1);
 642         movr(_R1_REGNO, r1 + 1);
 643     }
 644     swf_call(i0, fallback, _R2_REGNO);
 645     if (jit_fpr_p(r0)) {
 646         if (!jit_thumb_p() && jit_armv5e_p())
 647             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 648         else {
 649             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 650             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 651         }
 652     }
 653     else {
 654         movr(r0, _R0_REGNO);
 655         movr(r0 + 1, _R1_REGNO);
 656     }
 657     jit_unget_reg_args();
 658 }
 659
 660 static void
 661 _swf_fff(jit_state_t *_jit, float (*i0)(float, float),
 662          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 663 {
 664     jit_get_reg_args();
 665     if (jit_fpr_p(r0) || jit_fpr_p(r1) || jit_fpr_p(r2))
 666         CHECK_SWF_OFFSET();
 667     if (jit_fpr_p(r1))
 668         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 669     else
 670         movr(_R0_REGNO, r1);
 671     if (jit_fpr_p(r2))
 672         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
 673     else
 674         movr(_R1_REGNO, r1);
 675     swf_call(i0, fallback, _R3_REGNO);
 676     if (jit_fpr_p(r0))
 677         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 678     else
 679         movr(r0, _R0_REGNO);
 680     jit_unget_reg_args();
 681 }
 682
 683 static void
 684 _swf_ddd(jit_state_t *_jit, double (*i0)(double, double),
 685          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 686 {
 687     jit_get_reg_args();
 688     if (jit_fpr_p(r0) || jit_fpr_p(r1) || jit_fpr_p(r2))
 689         CHECK_SWF_OFFSET();
 690     if (jit_fpr_p(r1)) {
 691         if (!jit_thumb_p() && jit_armv5e_p())
 692             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 693         else {
 694             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 695             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 696         }
 697     }
 698     else {
 699         movr(_R0_REGNO, r1);
 700         movr(_R1_REGNO, r1 + 1);
 701     }
 702     if (jit_fpr_p(r2)) {
 703         if (!jit_thumb_p() && jit_armv5e_p())
 704             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 705         else {
 706             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 707             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
 708         }
 709     }
 710     else {
 711         movr(_R2_REGNO, r2);
 712         movr(_R3_REGNO, r2 + 1);
 713     }
 714     swf_call_with_get_reg(i0, fallback);
 715     if (jit_fpr_p(r0)) {
 716         if (!jit_thumb_p() && jit_armv5e_p())
 717             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 718         else {
 719             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 720             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 721         }
 722     }
 723     else {
 724         movr(r0, _R0_REGNO);
 725         movr(r0 + 1, _R1_REGNO);
 726     }
 727     jit_unget_reg_args();
 728 }
 729
 730 static void
 731 _swf_fff_(jit_state_t *_jit, float (*i0)(float, float),
 732           jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
 733 {
 734     union {
 735         jit_int32_t     i;
 736         jit_float32_t   f;
 737     } data;
 738     jit_get_reg_args();
 739     if (jit_fpr_p(r0) || jit_fpr_p(r1))
 740         CHECK_SWF_OFFSET();
 741     data.f = i1;
 742     if (jit_fpr_p(r1))
 743         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 744     else
 745         movr(_R0_REGNO, r1);
 746     movi(_R1_REGNO, data.i);
 747     swf_call(i0, fallback, _R3_REGNO);
 748     if (jit_fpr_p(r0))
 749         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 750     else
 751         movr(r0, _R0_REGNO);
 752     jit_unget_reg_args();
 753 }
 754
 755 static void
 756 _swf_rsbi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
 757 {
 758     union {
 759         jit_int32_t     i;
 760         jit_float32_t   f;
 761     } data;
 762     jit_get_reg_args();
 763     if (jit_fpr_p(r0) || jit_fpr_p(r1))
 764         CHECK_SWF_OFFSET();
 765     data.f = i0;
 766     movi(_R0_REGNO, data.i);
 767     if (jit_fpr_p(r1))
 768         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
 769     else
 770         movr(_R1_REGNO, r1);
 771     swf_call(__aeabi_fsub, fallback, _R3_REGNO);
 772     if (jit_fpr_p(r0))
 773         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 774     else
 775         movr(r0, _R0_REGNO);
 776     jit_unget_reg_args();
 777 }
 778
 779 static void
 780 _swf_ddd_(jit_state_t *_jit, double (*i0)(double, double),
 781           jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
 782 {
 783     union {
 784         jit_int32_t     i[2];
 785         jit_float64_t   d;
 786     } data;
 787     jit_get_reg_args();
 788     if (jit_fpr_p(r0) || jit_fpr_p(r1))
 789         CHECK_SWF_OFFSET();
 790     data.d = i1;
 791     if (jit_fpr_p(r1)) {
 792         if (!jit_thumb_p() && jit_armv5e_p())
 793             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 794         else {
 795             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 796             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 797         }
 798     }
 799     else {
 800         movr(_R0_REGNO, r1);
 801         movr(_R1_REGNO, r1 + 1);
 802     }
 803     movi(_R2_REGNO, data.i[0]);
 804     movi(_R3_REGNO, data.i[1]);
 805     swf_call_with_get_reg(i0, fallback);
 806     if (jit_fpr_p(r0)) {
 807         if (!jit_thumb_p() && jit_armv5e_p())
 808             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 809         else {
 810             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 811             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 812         }
 813     }
 814     else {
 815         movr(r0, _R0_REGNO);
 816         movr(r0 + 1, _R1_REGNO);
 817     }
 818     jit_unget_reg_args();
 819 }
 820
 821 static void
 822 _swf_rsbi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
 823 {
 824     union {
 825         jit_int32_t     i[2];
 826         jit_float64_t   d;
 827     } data;
 828     jit_get_reg_args();
 829     if (jit_fpr_p(r0) || jit_fpr_p(r1))
 830         CHECK_SWF_OFFSET();
 831     data.d = i0;
 832     movi(_R0_REGNO, data.i[0]);
 833     movi(_R1_REGNO, data.i[1]);
 834     if (jit_fpr_p(r1)) {
 835         if (!jit_thumb_p() && jit_armv5e_p())
 836             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
 837         else {
 838             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
 839             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
 840         }
 841     }
 842     else {
 843         movr(_R2_REGNO, r1);
 844         movr(_R3_REGNO, r1 + 1);
 845     }
 846     swf_call_with_get_reg(__aeabi_dsub, fallback);
 847     if (jit_fpr_p(r0)) {
 848         if (!jit_thumb_p() && jit_armv5e_p())
 849             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 850         else {
 851             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 852             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 853         }
 854     }
 855     else {
 856         movr(r0, _R0_REGNO);
 857         movr(r0 + 1, _R1_REGNO);
 858     }
 859     jit_unget_reg_args();
 860 }
 861
 862 static void
 863 _swf_iff(jit_state_t *_jit, int (*i0)(float, float),
 864          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 865 {
 866     jit_get_reg_args();
 867     if (jit_fpr_p(r1) || jit_fpr_p(r2))
 868         CHECK_SWF_OFFSET();
 869     if (jit_fpr_p(r1))
 870         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 871     else
 872         movr(_R0_REGNO, r1);
 873     if (jit_fpr_p(r2))
 874         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
 875     else
 876         movr(_R1_REGNO, r2);
 877     swf_call(i0, fallback, _R2_REGNO);
 878     movr(r0, _R0_REGNO);
 879     jit_unget_reg_args();
 880 }
 881
 882 static void
 883 _swf_idd(jit_state_t *_jit, int (*i0)(double, double),
 884          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 885 {
 886     jit_get_reg_args();
 887     if (jit_fpr_p(r1) || jit_fpr_p(r2))
 888         CHECK_SWF_OFFSET();
 889     if (jit_fpr_p(r1)) {
 890         if (!jit_thumb_p() && jit_armv5e_p())
 891             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 892         else {
 893             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 894             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 895         }
 896     }
 897     else {
 898         movr(_R0_REGNO, r1);
 899         movr(_R1_REGNO, r1 + 1);
 900     }
 901     if (jit_fpr_p(r2)) {
 902         if (!jit_thumb_p() && jit_armv5e_p())
 903             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 904         else {
 905             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 906             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
 907         }
 908     }
 909     else {
 910         movr(_R2_REGNO, r2);
 911         movr(_R3_REGNO, r2 + 1);
 912     }
 913     swf_call_with_get_reg(i0, fallback);
 914     movr(r0, _R0_REGNO);
 915     jit_unget_reg_args();
 916 }
 917
 918 static void
 919 _swf_iff_(jit_state_t *_jit, int (*i0)(float, float),
 920           jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
 921 {
 922     union {
 923         jit_int32_t     i;
 924         jit_float32_t   f;
 925     } data;
 926     jit_get_reg_args();
 927     if (jit_fpr_p(r1))
 928         CHECK_SWF_OFFSET();
 929     data.f = i1;
 930     if (jit_fpr_p(r1))
 931         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 932     else
 933         movr(_R0_REGNO, r1);
 934     movi(_R1_REGNO, data.i);
 935     swf_call(i0, fallback, _R2_REGNO);
 936     movr(r0, _R0_REGNO);
 937     jit_unget_reg_args();
 938 }
 939
 940 static void
 941 _swf_idd_(jit_state_t *_jit, int (*i0)(double, double),
 942           jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
 943 {
 944     union {
 945         jit_int32_t     i[2];
 946         jit_float64_t   d;
 947     } data;
 948     jit_get_reg_args();
 949     if (jit_fpr_p(r1))
 950         CHECK_SWF_OFFSET();
 951     data.d = i1;
 952     if (jit_fpr_p(r1)) {
 953         if (!jit_thumb_p() && jit_armv5e_p())
 954             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 955         else {
 956             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 957             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 958         }
 959     }
 960     else {
 961         movr(_R0_REGNO, r1);
 962         movr(_R1_REGNO, r1 + 1);
 963     }
 964     movi(_R2_REGNO, data.i[0]);
 965     movi(_R3_REGNO, data.i[1]);
 966     swf_call_with_get_reg(i0, fallback);
 967     movr(r0, _R0_REGNO);
 968     jit_unget_reg_args();
 969 }
 970
 971 static void
 972 _swf_iunff(jit_state_t *_jit, int (*i0)(float, float),
 973            jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 974 {
 975     jit_word_t          instr;
 976     jit_get_reg_args();
 977     if (jit_fpr_p(r1) || jit_fpr_p(r2))
 978         CHECK_SWF_OFFSET();
 979     if (jit_fpr_p(r1))
 980         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 981     else
 982         movr(_R0_REGNO, r1);
 983     if (jit_fpr_p(r2))
 984         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
 985     else
 986         movr(_R1_REGNO, r2);
 987     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
 988     if (jit_thumb_p()) {
 989         T1_CMPI(_R0_REGNO, 0);
 990         IT(ARM_CC_NE);
 991         if (r0 < 8)
 992             T1_MOVI(r0, 1);
 993         else
 994             T2_MOVI(r0, 1);
 995         instr = _jit->pc.w;
 996         T2_CC_B(ARM_CC_NE, 0);
 997     }
 998     else {
 999         CMPI(_R0_REGNO, 0);
1000         CC_MOVI(ARM_CC_NE, r0, 1);
1001         instr = _jit->pc.w;
1002         CC_B(ARM_CC_NE, 0);
1003     }
1004     if (jit_fpr_p(r1))
1005         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1006     else
1007         movr(_R0_REGNO, r1);
1008     if (jit_fpr_p(r2))
1009         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
1010     else
1011         movr(_R1_REGNO, r2);
1012     swf_call(i0, fallback, _R2_REGNO);
1013     movr(r0, _R0_REGNO);
1014     patch_at(arm_patch_jump, instr, _jit->pc.w);
1015     jit_unget_reg_args();
1016 }
1017
1018 static void
1019 _swf_iundd(jit_state_t *_jit, int (*i0)(double, double),
1020            jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1021 {
1022     jit_word_t          instr;
1023     jit_get_reg_args();
1024     if (jit_fpr_p(r1) || jit_fpr_p(r2))
1025         CHECK_SWF_OFFSET();
1026     if (jit_fpr_p(r1)) {
1027         if (!jit_thumb_p() && jit_armv5e_p())
1028             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1029         else {
1030             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1031             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1032         }
1033     }
1034     else {
1035         movr(_R0_REGNO, r1);
1036         movr(_R1_REGNO, r1 + 1);
1037     }
1038     if (jit_fpr_p(r2)) {
1039         if (!jit_thumb_p() && jit_armv5e_p())
1040             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
1041         else {
1042             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
1043             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
1044         }
1045     }
1046     else {
1047         movr(_R2_REGNO, r2);
1048         movr(_R3_REGNO, r2 + 1);
1049     }
1050     swf_call_with_get_reg(__aeabi_dcmpun, dcmpun);
1051     if (jit_thumb_p()) {
1052         T1_CMPI(_R0_REGNO, 0);
1053         IT(ARM_CC_NE);
1054         if (r0 < 8)
1055             T1_MOVI(r0, 1);
1056         else
1057             T2_MOVI(r0, 1);
1058         instr = _jit->pc.w;
1059         T2_CC_B(ARM_CC_NE, 0);
1060     }
1061     else {
1062         CMPI(_R0_REGNO, 0);
1063         CC_MOVI(ARM_CC_NE, r0, 1);
1064         instr = _jit->pc.w;
1065         CC_B(ARM_CC_NE, 0);
1066     }
1067     if (jit_fpr_p(r1)) {
1068         if (!jit_thumb_p() && jit_armv5e_p())
1069             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1070         else {
1071             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1072             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1073         }
1074     }
1075     else {
1076         movr(_R0_REGNO, r1);
1077         movr(_R1_REGNO, r1 + 1);
1078     }
1079     if (jit_fpr_p(r2)) {
1080         if (!jit_thumb_p() && jit_armv5e_p())
1081             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
1082         else {
1083             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
1084             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
1085         }
1086     }
1087     else {
1088         movr(_R2_REGNO, r2);
1089         movr(_R3_REGNO, r2 + 1);
1090     }
1091     swf_call_with_get_reg(i0, fallback);
1092     movr(r0, _R0_REGNO);
1093     patch_at(arm_patch_jump, instr, _jit->pc.w);
1094     jit_unget_reg_args();
1095 }
1096
1097 static void
1098 _swf_iunff_(jit_state_t *_jit, int (*i0)(float, float),
1099             jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
1100 {
1101     jit_word_t          instr;
1102     union {
1103         jit_int32_t     i;
1104         jit_float32_t   f;
1105     } data;
1106     jit_get_reg_args();
1107     if (jit_fpr_p(r1))
1108         CHECK_SWF_OFFSET();
1109     data.f = i1;
1110     if (jit_fpr_p(r1))
1111         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1112     else
1113         movr(_R0_REGNO, r1);
1114     movi(_R1_REGNO, data.i);
1115     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
1116     if (jit_thumb_p()) {
1117         T1_CMPI(_R0_REGNO, 0);
1118         IT(ARM_CC_NE);
1119         if (r0 < 8)
1120             T1_MOVI(r0, 1);
1121         else
1122             T2_MOVI(r0, 1);
1123         instr = _jit->pc.w;
1124         T2_CC_B(ARM_CC_NE, 0);
1125     }
1126     else {
1127         CMPI(_R0_REGNO, 0);
1128         CC_MOVI(ARM_CC_NE, r0, 1);
1129         instr = _jit->pc.w;
1130         CC_B(ARM_CC_NE, 0);
1131     }
1132     if (jit_fpr_p(r1))
1133         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1134     else
1135         movr(_R0_REGNO, r1);
1136     movi(_R1_REGNO, data.i);
1137     swf_call(i0, fallback, _R2_REGNO);
1138     movr(r0, _R0_REGNO);
1139     patch_at(arm_patch_jump, instr, _jit->pc.w);
1140     jit_unget_reg_args();
1141 }
1142
1143 static void
1144 _swf_iundd_(jit_state_t *_jit, int (*i0)(double, double),
1145             jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
1146 {
1147     jit_word_t          instr;
1148     union {
1149         jit_int32_t     i[2];
1150         jit_float64_t   d;
1151     } data;
1152     jit_get_reg_args();
1153     if (jit_fpr_p(r1))
1154         CHECK_SWF_OFFSET();
1155     data.d = i1;
1156     if (jit_fpr_p(r1)) {
1157         if (!jit_thumb_p() && jit_armv5e_p())
1158             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1159         else {
1160             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1161             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1162         }
1163     }
1164     else {
1165         movr(_R0_REGNO, r1);
1166         movr(_R1_REGNO, r1 + 1);
1167     }
1168     movi(_R2_REGNO, data.i[0]);
1169     movi(_R3_REGNO, data.i[1]);
1170     swf_call_with_get_reg(__aeabi_dcmpun, dcmpun);
1171     if (jit_thumb_p()) {
1172         T1_CMPI(_R0_REGNO, 0);
1173         IT(ARM_CC_NE);
1174         if (r0 < 8)
1175             T1_MOVI(r0, 1);
1176         else
1177             T2_MOVI(r0, 1);
1178         instr = _jit->pc.w;
1179         T2_CC_B(ARM_CC_NE, 0);
1180     }
1181     else {
1182         CMPI(_R0_REGNO, 0);
1183         CC_MOVI(ARM_CC_NE, r0, 1);
1184         instr = _jit->pc.w;
1185         CC_B(ARM_CC_NE, 0);
1186     }
1187     if (jit_fpr_p(r1)) {
1188         if (!jit_thumb_p() && jit_armv5e_p())
1189             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1190         else {
1191             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1192             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1193         }
1194     }
1195     else {
1196         movr(_R0_REGNO, r1);
1197         movr(_R1_REGNO, r1 + 1);
1198     }
1199     movi(_R2_REGNO, data.i[0]);
1200     movi(_R3_REGNO, data.i[1]);
1201     swf_call_with_get_reg(i0, fallback);
1202     movr(r0, _R0_REGNO);
1203     patch_at(arm_patch_jump, instr, _jit->pc.w);
1204     jit_unget_reg_args();
1205 }
1206
1207 static jit_word_t
1208 _swf_bff(jit_state_t *_jit, int (*i0)(float, float), int cc,
1209          jit_word_t i1, jit_int32_t r0, jit_int32_t r1)
1210 {
1211     jit_word_t          w, d;
1212     jit_get_reg_args();
1213     if (jit_fpr_p(r0) || jit_fpr_p(r1))
1214         CHECK_SWF_OFFSET();
1215     if (jit_fpr_p(r0))
1216         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1217     else
1218         movr(_R0_REGNO, r0);
1219     if (jit_fpr_p(r1))
1220         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
1221     else
1222         movr(_R1_REGNO, r1);
1223     swf_call(i0, fallback, _R2_REGNO);
1224     if (jit_thumb_p()) {
1225         T1_CMPI(_R0_REGNO, 0);
1226         w = _jit->pc.w;
1227         d = ((i1 - w) >> 1) - 2;
1228         assert(_s20P(d));
1229         T2_CC_B(cc, encode_thumb_cc_jump(d));
1230     }
1231     else {
1232         CMPI(_R0_REGNO, 0);
1233         w = _jit->pc.w;
1234         d = ((i1 - w) >> 2) - 2;
1235         assert(_s24P(d));
1236         CC_B(cc, d & 0x00ffffff);
1237     }
1238     jit_unget_reg_args();
1239     return (w);
1240 }
1241
1242 static jit_word_t
1243 _swf_bdd(jit_state_t *_jit, int (*i0)(double, double), int cc,
1244          jit_word_t i1, jit_int32_t r0, jit_int32_t r1)
1245 {
1246     jit_word_t          w, d;
1247     jit_get_reg_args();
1248     if (jit_fpr_p(r0) || jit_fpr_p(r1))
1249         CHECK_SWF_OFFSET();
1250     if (jit_fpr_p(r0)) {
1251         if (!jit_thumb_p() && jit_armv5e_p())
1252             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1253         else {
1254             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1255             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1256         }
1257     }
1258     else {
1259         movr(_R0_REGNO, r0);
1260         movr(_R1_REGNO, r0 + 1);
1261     }
1262     if (jit_fpr_p(r1)) {
1263         if (!jit_thumb_p() && jit_armv5e_p())
1264             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1265         else {
1266             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1267             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
1268         }
1269     }
1270     else {
1271         movr(_R2_REGNO, r1);
1272         movr(_R3_REGNO, r1 + 1);
1273     }
1274     swf_call_with_get_reg(i0, fallback);
1275     if (jit_thumb_p()) {
1276         T1_CMPI(_R0_REGNO, 0);
1277         w = _jit->pc.w;
1278         d = ((i1 - w) >> 1) - 2;
1279         assert(_s20P(d));
1280         T2_CC_B(cc, encode_thumb_cc_jump(d));
1281     }
1282     else {
1283         CMPI(_R0_REGNO, 0);
1284         w = _jit->pc.w;
1285         d = ((i1 - w) >> 2) - 2;
1286         assert(_s24P(d));
1287         CC_B(cc, d & 0x00ffffff);
1288     }
1289     jit_unget_reg_args();
1290     return (w);
1291 }
1292
1293 static jit_word_t
1294 _swf_bff_(jit_state_t *_jit, int (*i0)(float, float), int cc,
1295           jit_word_t i1, jit_int32_t r0, jit_float32_t i2)
1296 {
1297     union {
1298         jit_int32_t     i;
1299         jit_float32_t   f;
1300     } data;
1301     jit_word_t          w, d;
1302     jit_get_reg_args();
1303     if (jit_fpr_p(r0))
1304         CHECK_SWF_OFFSET();
1305     data.f = i2;
1306     if (jit_fpr_p(r0))
1307         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1308     else
1309         movr(_R0_REGNO, r0);
1310     movi(_R1_REGNO, data.i);
1311     swf_call(i0, fallback, _R2_REGNO);
1312     if (jit_thumb_p()) {
1313         T1_CMPI(_R0_REGNO, 0);
1314         w = _jit->pc.w;
1315         d = ((i1 - w) >> 1) - 2;
1316         assert(_s20P(d));
1317         T2_CC_B(cc, encode_thumb_cc_jump(d));
1318     }
1319     else {
1320         CMPI(_R0_REGNO, 0);
1321         w = _jit->pc.w;
1322         d = ((i1 - w) >> 2) - 2;
1323         assert(_s24P(d));
1324         CC_B(cc, d & 0x00ffffff);
1325     }
1326     jit_unget_reg_args();
1327     return (w);
1328 }
1329
1330 static jit_word_t
1331 _swf_bdd_(jit_state_t *_jit, int (*i0)(double, double), int cc,
1332           jit_word_t i1, jit_int32_t r0, jit_float64_t i2)
1333 {
1334     jit_word_t          w, d;
1335     union {
1336         jit_int32_t     i[2];
1337         jit_float64_t   d;
1338     } data;
1339     jit_get_reg_args();
1340     if (jit_fpr_p(r0))
1341         CHECK_SWF_OFFSET();
1342     data.d = i2;
1343     if (jit_fpr_p(r0)) {
1344         if (!jit_thumb_p() && jit_armv5e_p())
1345             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1346         else {
1347             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1348             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1349         }
1350     }
1351     else {
1352         movr(_R0_REGNO, r0);
1353         movr(_R1_REGNO, r0 + 1);
1354     }
1355     movi(_R2_REGNO, data.i[0]);
1356     movi(_R3_REGNO, data.i[1]);
1357     swf_call_with_get_reg(i0, fallback);
1358     if (jit_thumb_p()) {
1359         T1_CMPI(_R0_REGNO, 0);
1360         w = _jit->pc.w;
1361         d = ((i1 - w) >> 1) - 2;
1362         assert(_s20P(d));
1363         T2_CC_B(cc, encode_thumb_cc_jump(d));
1364     }
1365     else {
1366         CMPI(_R0_REGNO, 0);
1367         w = _jit->pc.w;
1368         d = ((i1 - w) >> 2) - 2;
1369         assert(_s24P(d));
1370         CC_B(cc, d & 0x00ffffff);
1371     }
1372     jit_unget_reg_args();
1373     return (w);
1374 }
1375
1376 static jit_word_t
1377 _swf_bunff(jit_state_t *_jit, int eq,
1378            jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1379 {
1380     jit_word_t          w, d, j0, j1;
1381     jit_get_reg_args();
1382     if (jit_fpr_p(r0) || jit_fpr_p(r1))
1383         CHECK_SWF_OFFSET();
1384     if (jit_fpr_p(r0))
1385         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1386     else
1387         movr(_R0_REGNO, r0);
1388     if (jit_fpr_p(r1))
1389         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
1390     else
1391         movr(_R1_REGNO, r1);
1392     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
1393     /* if unordered */
1394     if (jit_thumb_p()) {
1395         T1_CMPI(_R0_REGNO, 0);
1396         j0 = _jit->pc.w;
1397         T2_CC_B(ARM_CC_NE, 0);
1398     }
1399     else {
1400         CMPI(_R0_REGNO, 0);
1401         j0 = _jit->pc.w;
1402         CC_B(ARM_CC_NE, 0);
1403     }
1404     if (jit_fpr_p(r0))
1405         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1406     else
1407         movr(_R0_REGNO, r0);
1408     if (jit_fpr_p(r1))
1409         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
1410     else
1411         movr(_R1_REGNO, r1);
1412     swf_call(__aeabi_fcmpeq, fcmpeq, _R2_REGNO);
1413     if (jit_thumb_p()) {
1414         T1_CMPI(_R0_REGNO, 0);
1415         j1 = _jit->pc.w;
1416         if (eq) {
1417             T2_CC_B(ARM_CC_EQ, 0);
1418             patch_at(arm_patch_jump, j0, _jit->pc.w);
1419         }
1420         else
1421             T2_CC_B(ARM_CC_NE, 0);
1422         w = _jit->pc.w;
1423         d = ((i0 - w) >> 1) - 2;
1424         assert(_s24P(d));
1425         T2_B(encode_thumb_jump(d));
1426     }
1427     else {
1428         CMPI(_R0_REGNO, 0);
1429         j1 = _jit->pc.w;
1430         if (eq) {
1431             CC_B(ARM_CC_EQ, 0);
1432             patch_at(arm_patch_jump, j0, _jit->pc.w);
1433         }
1434         else
1435             CC_B(ARM_CC_NE, 0);
1436         w = _jit->pc.w;
1437         d = ((i0 - w) >> 2) - 2;
1438         assert(_s24P(d));
1439         B(d & 0x00ffffff);
1440     }
1441     if (!eq)
1442         patch_at(arm_patch_jump, j0, _jit->pc.w);
1443     patch_at(arm_patch_jump, j1, _jit->pc.w);
1444     jit_unget_reg_args();
1445     return (w);
1446 }
1447
1448 static jit_word_t
1449 _swf_bundd(jit_state_t *_jit, int eq,
1450            jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1451 {
1452     jit_word_t          w, d, j0, j1;
1453     jit_get_reg_args();
1454     if (jit_fpr_p(r0) || jit_fpr_p(r1))
1455         CHECK_SWF_OFFSET();
1456     if (jit_fpr_p(r0)) {
1457         if (!jit_thumb_p() && jit_armv5e_p())
1458             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1459         else {
1460             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1461             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1462         }
1463     }
1464     else {
1465         movr(_R0_REGNO, r0);
1466         movr(_R1_REGNO, r0 + 1);
1467     }
1468     if (jit_fpr_p(r1)) {
1469         if (!jit_thumb_p() && jit_armv5e_p())
1470             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1471         else {
1472             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1473             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
1474         }
1475     }
1476     else {
1477         movr(_R2_REGNO, r0);
1478         movr(_R3_REGNO, r0 + 1);
1479     }
1480     swf_call_with_get_reg(__aeabi_dcmpun, dcmpun);
1481     /* if unordered */
1482     if (jit_thumb_p()) {
1483         T1_CMPI(_R0_REGNO, 0);
1484         j0 = _jit->pc.w;
1485         T2_CC_B(ARM_CC_NE, 0);
1486     }
1487     else {
1488         CMPI(_R0_REGNO, 0);
1489         j0 = _jit->pc.w;
1490         CC_B(ARM_CC_NE, 0);
1491     }
1492     if (jit_fpr_p(r0)) {
1493         if (!jit_thumb_p() && jit_armv5e_p())
1494             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1495         else {
1496             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1497             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1498         }
1499     }
1500     else {
1501         movr(_R0_REGNO, r0);
1502         movr(_R1_REGNO, r0 + 1);
1503     }
1504     if (jit_fpr_p(r1)) {
1505         if (!jit_thumb_p() && jit_armv5e_p())
1506             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1507         else {
1508             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1509             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
1510         }
1511     }
1512     else {
1513         movr(_R2_REGNO, r0);
1514         movr(_R3_REGNO, r0 + 1);
1515     }
1516     swf_call_with_get_reg(__aeabi_dcmpeq, dcmpeq);
1517     if (jit_thumb_p()) {
1518         T1_CMPI(_R0_REGNO, 0);
1519         j1 = _jit->pc.w;
1520         if (eq) {
1521             T2_CC_B(ARM_CC_EQ, 0);
1522             patch_at(arm_patch_jump, j0, _jit->pc.w);
1523         }
1524         else
1525             T2_CC_B(ARM_CC_NE, 0);
1526         w = _jit->pc.w;
1527         d = ((i0 - w) >> 1) - 2;
1528         assert(_s24P(d));
1529         T2_B(encode_thumb_jump(d));
1530     }
1531     else {
1532         CMPI(_R0_REGNO, 0);
1533         j1 = _jit->pc.w;
1534         if (eq) {
1535             CC_B(ARM_CC_EQ, 0);
1536             patch_at(arm_patch_jump, j0, _jit->pc.w);
1537         }
1538         else
1539             CC_B(ARM_CC_NE, 0);
1540         w = _jit->pc.w;
1541         d = ((i0 - w) >> 2) - 2;
1542         assert(_s24P(d));
1543         B(d & 0x00ffffff);
1544     }
1545     if (!eq)
1546         patch_at(arm_patch_jump, j0, _jit->pc.w);
1547     patch_at(arm_patch_jump, j1, _jit->pc.w);
1548     jit_unget_reg_args();
1549     return (w);
1550 }
1551
1552 static jit_word_t
1553 _swf_bunff_(jit_state_t *_jit, int eq,
1554             jit_word_t i0, jit_int32_t r0, jit_float32_t i1)
1555 {
1556     union {
1557         jit_int32_t     i;
1558         jit_float32_t   f;
1559     } data;
1560     jit_word_t          w, d, j0, j1;
1561     data.f = i1;
1562     jit_get_reg_args();
1563     if (jit_fpr_p(r0))
1564         CHECK_SWF_OFFSET();
1565     if (jit_fpr_p(r0))
1566         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1567     else
1568         movr(_R0_REGNO, r0);
1569     movi(_R1_REGNO, data.i);
1570     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
1571     /* if unordered */
1572     if (jit_thumb_p()) {
1573         T1_CMPI(_R0_REGNO, 0);
1574         j0 = _jit->pc.w;
1575         T2_CC_B(ARM_CC_NE, 0);
1576     }
1577     else {
1578         CMPI(_R0_REGNO, 0);
1579         j0 = _jit->pc.w;
1580         CC_B(ARM_CC_NE, 0);
1581     }
1582     if (jit_fpr_p(r0))
1583         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1584     else
1585         movr(_R0_REGNO, r0);
1586     movi(_R1_REGNO, data.i);
1587     swf_call(__aeabi_fcmpeq, fcmpeq, _R2_REGNO);
1588     if (jit_thumb_p()) {
1589         T1_CMPI(_R0_REGNO, 0);
1590         j1 = _jit->pc.w;
1591         if (eq) {
1592             T2_CC_B(ARM_CC_EQ, 0);
1593             patch_at(arm_patch_jump, j0, _jit->pc.w);
1594         }
1595         else
1596             T2_CC_B(ARM_CC_NE, 0);
1597         w = _jit->pc.w;
1598         d = ((i0 - w) >> 1) - 2;
1599         assert(_s24P(d));
1600         T2_B(encode_thumb_jump(d));
1601     }
1602     else {
1603         CMPI(_R0_REGNO, 0);
1604         j1 = _jit->pc.w;
1605         if (eq) {
1606             CC_B(ARM_CC_EQ, 0);
1607             patch_at(arm_patch_jump, j0, _jit->pc.w);
1608         }
1609         else
1610             CC_B(ARM_CC_NE, 0);
1611         w = _jit->pc.w;
1612         d = ((i0 - w) >> 2) - 2;
1613         assert(_s24P(d));
1614         B(d & 0x00ffffff);
1615     }
1616     if (!eq)
1617         patch_at(arm_patch_jump, j0, _jit->pc.w);
1618     patch_at(arm_patch_jump, j1, _jit->pc.w);
1619     jit_unget_reg_args();
1620     return (w);
1621 }
1622
1623 static jit_word_t
1624 _swf_bundd_(jit_state_t *_jit, int eq,
1625             jit_word_t i0, jit_int32_t r0, jit_float64_t i1)
1626 {
1627     jit_word_t          w, d, j0, j1;
1628     union {
1629         jit_int32_t     i[2];
1630         jit_float64_t   d;
1631     } data;
1632     jit_get_reg_args();
1633     if (jit_fpr_p(r0))
1634         CHECK_SWF_OFFSET();
1635     data.d = i1;
1636     if (jit_fpr_p(r0)) {
1637         if (!jit_thumb_p() && jit_armv5e_p())
1638             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1639         else {
1640             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1641             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1642         }
1643     }
1644     else {
1645         movr(_R0_REGNO, r0);
1646         movr(_R1_REGNO, r0 + 1);
1647     }
1648     movi(_R2_REGNO, data.i[0]);
1649     movi(_R3_REGNO, data.i[1]);
1650     swf_call_with_get_reg(__aeabi_dcmpun, fcmpun);
1651     /* if unordered */
1652     if (jit_thumb_p()) {
1653         T1_CMPI(_R0_REGNO, 0);
1654         j0 = _jit->pc.w;
1655         T2_CC_B(ARM_CC_NE, 0);
1656     }
1657     else {
1658         CMPI(_R0_REGNO, 0);
1659         j0 = _jit->pc.w;
1660         CC_B(ARM_CC_NE, 0);
1661     }
1662     if (jit_fpr_p(r0)) {
1663         if (!jit_thumb_p() && jit_armv5e_p())
1664             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1665         else {
1666             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1667             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1668         }
1669     }
1670     else {
1671         movr(_R0_REGNO, r0);
1672         movr(_R1_REGNO, r0 + 1);
1673     }
1674     movi(_R2_REGNO, data.i[0]);
1675     movi(_R3_REGNO, data.i[1]);
1676     swf_call_with_get_reg(__aeabi_dcmpeq, fcmpeq);
1677     if (jit_thumb_p()) {
1678         T1_CMPI(_R0_REGNO, 0);
1679         j1 = _jit->pc.w;
1680         if (eq) {
1681             T2_CC_B(ARM_CC_EQ, 0);
1682             patch_at(arm_patch_jump, j0, _jit->pc.w);
1683         }
1684         else
1685             T2_CC_B(ARM_CC_NE, 0);
1686         w = _jit->pc.w;
1687         d = ((i0 - w) >> 1) - 2;
1688         assert(_s24P(d));
1689         T2_B(encode_thumb_jump(d));
1690     }
1691     else {
1692         CMPI(_R0_REGNO, 0);
1693         j1 = _jit->pc.w;
1694         if (eq) {
1695             CC_B(ARM_CC_EQ, 0);
1696             patch_at(arm_patch_jump, j0, _jit->pc.w);
1697         }
1698         else
1699             CC_B(ARM_CC_NE, 0);
1700         w = _jit->pc.w;
1701         d = ((i0 - w) >> 2) - 2;
1702         assert(_s24P(d));
1703         B(d & 0x00ffffff);
1704     }
1705     if (!eq)
1706         patch_at(arm_patch_jump, j0, _jit->pc.w);
1707     patch_at(arm_patch_jump, j1, _jit->pc.w);
1708     jit_unget_reg_args();
1709     return (w);
1710 }
1711
1712 static void
1713 _swf_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1714 {
1715     jit_get_reg_args();
1716     if (jit_fpr_p(r0))
1717         CHECK_SWF_OFFSET();
1718     movr(_R0_REGNO, r1);
1719     swf_call(__aeabi_i2f, i2f, _R1_REGNO);
1720     if (jit_fpr_p(r0))
1721         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1722     else
1723         movr(r0, _R0_REGNO);
1724     jit_unget_reg_args();
1725 }
1726
1727 static void
1728 _swf_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1729 {
1730     jit_get_reg_args();
1731     if (jit_fpr_p(r0))
1732         CHECK_SWF_OFFSET();
1733     movr(_R0_REGNO, r1);
1734     swf_call(__aeabi_i2d, i2d, _R2_REGNO);
1735     if (jit_fpr_p(r0)) {
1736         if (!jit_thumb_p() && jit_armv5e_p())
1737             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1738         else {
1739             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1740             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1741         }
1742     }
1743     else {
1744         movr(r0, _R0_REGNO);
1745         movr(r0 + 1, _R1_REGNO);
1746     }
1747     jit_unget_reg_args();
1748 }
1749
1750 static void
1751 _swf_extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1752 {
1753     jit_get_reg_args();
1754     if (jit_fpr_p(r0) || jit_fpr_p(r1))
1755         CHECK_SWF_OFFSET();
1756     if (jit_fpr_p(r1)) {
1757         if (!jit_thumb_p() && jit_armv5e_p())
1758             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1759         else {
1760             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1761             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1762         }
1763     }
1764     else {
1765         movr(_R0_REGNO, r1);
1766         movr(_R1_REGNO, r1 + 1);
1767     }
1768     swf_call(__aeabi_d2f, d2f, _R2_REGNO);
1769     if (jit_fpr_p(r0))
1770         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1771     else
1772         movr(r0, _R0_REGNO);
1773     jit_unget_reg_args();
1774 }
1775
1776 static void
1777 _swf_extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1778 {
1779     jit_get_reg_args();
1780     if (jit_fpr_p(r0) || jit_fpr_p(r1))
1781         CHECK_SWF_OFFSET();
1782     if (jit_fpr_p(r1))
1783         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1784     else
1785         movr(_R0_REGNO, r1);
1786     swf_call(__aeabi_f2d, f2d, _R1_REGNO);
1787     if (jit_fpr_p(r0)) {
1788         if (!jit_thumb_p() && jit_armv5e_p())
1789             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1790         else {
1791             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1792             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1793         }
1794     }
1795     else {
1796         movr(r0, _R0_REGNO);
1797         movr(r0 + 1, _R1_REGNO);
1798     }
1799     jit_unget_reg_args();
1800 }
1801
1802 static void
1803 _swf_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1804 {
1805 #if !NAN_TO_INT_IS_ZERO
1806     jit_word_t          is_nan;
1807     jit_word_t          fast_not_nan;
1808     jit_word_t          slow_not_nan;
1809 #endif
1810     jit_get_reg_args();
1811     if (jit_fpr_p(r1))
1812         CHECK_SWF_OFFSET();
1813     if (jit_fpr_p(r1))
1814         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1815     else
1816         movr(_R0_REGNO, r1);
1817 #if !NAN_TO_INT_IS_ZERO
1818     /* >> based on fragment of __aeabi_fcmpun */
1819     lshi(_R2_REGNO, _R0_REGNO, 1);
1820     if (jit_thumb_p())
1821         torrrs(THUMB2_MVN|ARM_S, _R0_REGNO, _R3_REGNO, _R2_REGNO,
1822                encode_thumb_shift(24, ARM_ASR));
1823     else
1824         corrrs(ARM_CC_AL, ARM_MVN|ARM_S|ARM_ASR,
1825                _R0_REGNO, _R3_REGNO, _R2_REGNO, 24);
1826     fast_not_nan = _jit->pc.w;
1827     if (jit_thumb_p()) {
1828         T2_CC_B(ARM_CC_NE, 0);
1829         tshift(THUMB2_LSLI|ARM_S, _R0_REGNO, _R3_REGNO, 9);
1830     }
1831     else {
1832         CC_B(ARM_CC_NE, 0);
1833         cshift(ARM_CC_AL, ARM_S|ARM_LSL, _R0_REGNO, _R3_REGNO, _R0_REGNO, 9);
1834     }
1835     slow_not_nan = _jit->pc.w;
1836     if (jit_thumb_p())
1837         T2_CC_B(ARM_CC_EQ, 0);
1838     else
1839         CC_B(ARM_CC_EQ, 0);
1840     movi(r0, 0x80000000);
1841     is_nan = _jit->pc.w;
1842     if (jit_thumb_p())
1843         T2_B(0);
1844     else
1845         B(0);
1846     patch_at(arm_patch_jump, fast_not_nan, _jit->pc.w);
1847     patch_at(arm_patch_jump, slow_not_nan, _jit->pc.w);
1848     /* << based on fragment of __aeabi_fcmpun */
1849 #endif
1850     swf_call(__aeabi_f2iz, f2iz, _R2_REGNO);
1851     movr(r0, _R0_REGNO);
1852 #if !NAN_TO_INT_IS_ZERO
1853     patch_at(arm_patch_jump, is_nan, _jit->pc.w);
1854 #endif
1855     jit_unget_reg_args();
1856 }
1857
1858 static void
1859 _swf_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1860 {
1861 #if !NAN_TO_INT_IS_ZERO
1862     jit_word_t          is_nan;
1863     jit_word_t          fast_not_nan;
1864     jit_word_t          slow_not_nan;
1865 #endif
1866     jit_get_reg_args();
1867     if (jit_fpr_p(r1))
1868         CHECK_SWF_OFFSET();
1869     if (jit_fpr_p(r1)) {
1870         if (!jit_thumb_p() && jit_armv5e_p())
1871             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1872         else {
1873             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1874             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1875         }
1876     }
1877     else {
1878         movr(_R0_REGNO, r1);
1879         movr(_R1_REGNO, r1 + 1);
1880     }
1881 #if !NAN_TO_INT_IS_ZERO
1882     /* >> based on fragment of __aeabi_dcmpun */
1883     lshi(_R3_REGNO, _R1_REGNO, 1);
1884     if (jit_thumb_p())
1885         torrrs(THUMB2_MVN|ARM_S, _R0_REGNO, _R3_REGNO, _R3_REGNO,
1886                encode_thumb_shift(21, ARM_ASR));
1887     else
1888         corrrs(ARM_CC_AL, ARM_MVN|ARM_S|ARM_ASR,
1889                _R0_REGNO, _R3_REGNO, _R3_REGNO, 21);
1890     fast_not_nan = _jit->pc.w;
1891     if (jit_thumb_p()) {
1892         T2_CC_B(ARM_CC_NE, 0);
1893         torrrs(THUMB2_ORR|ARM_S, _R0_REGNO, _R3_REGNO, _R1_REGNO,
1894                encode_thumb_shift(12, ARM_LSL));
1895     }
1896     else {
1897         CC_B(ARM_CC_NE, 0);
1898         corrrs(ARM_CC_AL, ARM_ORR|ARM_S|ARM_LSL,
1899                _R0_REGNO, _R3_REGNO, _R1_REGNO, 12);
1900     }
1901     slow_not_nan = _jit->pc.w;
1902     if (jit_thumb_p())
1903         T2_CC_B(ARM_CC_EQ, 0);
1904     else
1905         CC_B(ARM_CC_EQ, 0);
1906     movi(r0, 0x80000000);
1907     is_nan = _jit->pc.w;
1908     if (jit_thumb_p())
1909         T2_B(0);
1910     else
1911         B(0);
1912     patch_at(arm_patch_jump, fast_not_nan, _jit->pc.w);
1913     patch_at(arm_patch_jump, slow_not_nan, _jit->pc.w);
1914     /* << based on fragment of __aeabi_dcmpun */
1915 #endif
1916     swf_call(__aeabi_d2iz, d2iz, _R3_REGNO);
1917     movr(r0, _R0_REGNO);
1918 #if !NAN_TO_INT_IS_ZERO
1919     patch_at(arm_patch_jump, is_nan, _jit->pc.w);
1920 #endif
1921     jit_unget_reg_args();
1922 }
1923
1924 static void
1925 _swf_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1926 {
1927     jit_int32_t         reg;
1928     if (r0 != r1) {
1929         assert(jit_fpr_p(r0) && jit_fpr_p(r1));
1930         CHECK_SWF_OFFSET();
1931         reg = jit_get_reg(jit_class_gpr);
1932         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1933         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1934         jit_unget_reg(reg);
1935     }
1936 }
1937
1938 static void
1939 _swf_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
1940 {
1941     union {
1942         jit_int32_t     i;
1943         jit_float32_t   f;
1944     } data;
1945     jit_int32_t         reg;
1946     assert(jit_fpr_p(r0));
1947     CHECK_SWF_OFFSET();
1948     data.f = i0;
1949     reg = jit_get_reg(jit_class_gpr);
1950     movi(rn(reg), data.i);
1951     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1952     jit_unget_reg(reg);
1953 }
1954
1955 static void
1956 _swf_movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1957 {
1958     assert(jit_fpr_p(r0));
1959     CHECK_SWF_OFFSET();
1960     swf_strin(r1, _FP_REGNO, swf_off(r0) + 8);
1961 }
1962
1963 static void
1964 _swf_movr_f_w(jit_state_t *_jit ,jit_int32_t r0, jit_int32_t r1)
1965 {
1966     assert(jit_fpr_p(r1));
1967     CHECK_SWF_OFFSET();
1968     swf_ldrin(r0, _FP_REGNO, swf_off(r1) + 8);
1969 }
1970
1971 static void
1972 _swf_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1973 {
1974     jit_int32_t         reg;
1975     CHECK_SWF_OFFSET();
1976     reg = jit_get_reg(jit_class_gpr);
1977     movi(rn(reg), i0);
1978     swf_movr_w_f(r0, rn(reg));
1979     jit_unget_reg(reg);
1980 }
1981
1982 static void
1983 _swf_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1984 {
1985     jit_int32_t         reg;
1986     if (r0 != r1) {
1987         assert(jit_fpr_p(r0) && jit_fpr_p(r1));
1988         CHECK_SWF_OFFSET();
1989         if (!jit_thumb_p() && jit_armv5e_p() &&
1990             (reg = jit_get_reg_pair()) != JIT_NOREG) {
1991             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1992             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1993             jit_unget_reg_pair(reg);
1994         }
1995         else {
1996             reg = jit_get_reg(jit_class_gpr);
1997             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1998             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1999             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
2000             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2001             jit_unget_reg(reg);
2002         }
2003     }
2004 }
2005
2006 static void
2007 _swf_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
2008 {
2009     jit_int32_t         reg;
2010     union {
2011         jit_int32_t     i[2];
2012         jit_float64_t   d;
2013     } data;
2014     assert(jit_fpr_p(r0));
2015     CHECK_SWF_OFFSET();
2016     data.d = i0;
2017     if (!jit_thumb_p() && jit_armv5e_p() &&
2018         (reg = jit_get_reg_pair()) != JIT_NOREG) {
2019         movi(rn(reg), data.i[0]);
2020         movi(rn(reg) + 1, data.i[1]);
2021         STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2022         jit_unget_reg_pair(reg);
2023     }
2024     else {
2025         reg = jit_get_reg(jit_class_gpr);
2026         movi(rn(reg), data.i[0]);
2027         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2028         movi(rn(reg), data.i[1]);
2029         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2030         jit_unget_reg(reg);
2031     }
2032 }
2033
2034 static void
2035 _swf_movr_ww_d(jit_state_t *_jit,
2036                jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2037 {
2038     assert(jit_fpr_p(r0));
2039     CHECK_SWF_OFFSET();
2040     swf_strin(r1, _FP_REGNO, swf_off(r0) + 8);
2041     swf_strin(r2, _FP_REGNO, swf_off(r0) + 4);
2042 }
2043
2044 static void
2045 _swf_movr_d_ww(jit_state_t *_jit,
2046                jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2047 {
2048     assert(jit_fpr_p(r2));
2049     CHECK_SWF_OFFSET();
2050     swf_ldrin(r0, _FP_REGNO, swf_off(r2) + 8);
2051     swf_ldrin(r1, _FP_REGNO, swf_off(r2) + 4);
2052 }
2053
2054 static void
2055 _swf_movi_ww_d(jit_state_t *_jit,
2056                jit_int32_t r0, jit_word_t i0, jit_word_t i1)
2057 {
2058     jit_int32_t         reg;
2059     assert(jit_fpr_p(r0));
2060     CHECK_SWF_OFFSET();
2061     reg = jit_get_reg(jit_class_gpr);
2062     movi(rn(reg), i0);
2063     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2064     movi(rn(reg), i1);
2065     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2066     jit_unget_reg(reg);
2067 }
2068
2069 static void
2070 _swf_absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2071 {
2072     jit_int32_t         reg;
2073     if (jit_fpr_p(r0) || jit_fpr_p(r1))
2074         CHECK_SWF_OFFSET();
2075     if (jit_fpr_p(r1)) {
2076         reg = jit_get_reg(jit_class_gpr);
2077         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2078         swf_bici(rn(reg), rn(reg), 0x80000000);
2079         if (jit_fpr_p(r0))
2080             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2081         else
2082             movr(r0, rn(reg));
2083         jit_unget_reg(reg);
2084     }
2085     else if (jit_fpr_p(r0)) {
2086         reg = jit_get_reg(jit_class_gpr);
2087         movr(rn(reg), r1);
2088         swf_bici(rn(reg), rn(reg), 0x80000000);
2089         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2090         jit_unget_reg(reg);
2091     }
2092     else
2093         swf_bici(r0, r1, 0x80000000);
2094 }
2095
2096 static void
2097 _swf_absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2098 {
2099     jit_int32_t         reg;
2100     if (jit_fpr_p(r0) || jit_fpr_p(r1))
2101         CHECK_SWF_OFFSET();
2102     if (jit_fpr_p(r1)) {
2103         if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
2104             r0 != r1 && (reg = jit_get_reg_pair()) != JIT_NOREG) {
2105             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2106             swf_bici(rn(reg) + 1, rn(reg) + 1, 0x80000000);
2107             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2108             jit_unget_reg_pair(reg);
2109         }
2110         else {
2111             reg = jit_get_reg(jit_class_gpr);
2112             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
2113             swf_bici(rn(reg), rn(reg), 0x80000000);
2114             if (jit_fpr_p(r0)) {
2115                 swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2116                 if (r0 != r1) {
2117                     swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2118                     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2119                 }
2120             }
2121             else {
2122                 movr(r0, rn(reg));
2123                 swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2124                 movr(r0 + 1, rn(reg));
2125             }
2126             jit_unget_reg(reg);
2127         }
2128     }
2129     else if (jit_fpr_p(r0)) {
2130         reg = jit_get_reg(jit_class_gpr);
2131         movr(rn(reg), r1);
2132         swf_bici(rn(reg), rn(reg), 0x80000000);
2133         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2134         movr(rn(reg), r1 + 1);
2135         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2136         jit_unget_reg(reg);
2137     }
2138     else {
2139         swf_bici(r0, r1, 0x80000000);
2140         if (r0 != r1)
2141             movr(r0 + 1, r1 + 1);
2142     }
2143 }
2144
2145 static void
2146 _swf_negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2147 {
2148     jit_int32_t         reg;
2149     if (jit_fpr_p(r0) || jit_fpr_p(r1))
2150         CHECK_SWF_OFFSET();
2151     if (jit_fpr_p(r1)) {
2152         reg = jit_get_reg(jit_class_gpr);
2153         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2154         xori(rn(reg), rn(reg), 0x80000000);
2155         if (jit_fpr_p(r0))
2156             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2157         else
2158             movr(r0, rn(reg));
2159         jit_unget_reg(reg);
2160     }
2161     else if (jit_fpr_p(r0)) {
2162         reg = jit_get_reg(jit_class_gpr);
2163         movr(rn(reg), r1);
2164         xori(rn(reg), rn(reg), 0x80000000);
2165         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2166         jit_unget_reg(reg);
2167     }
2168     else
2169         xori(r0, r1, 0x80000000);
2170 }
2171
2172 static void
2173 _swf_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2174 {
2175     jit_int32_t         reg;
2176     if (jit_fpr_p(r0) || jit_fpr_p(r1))
2177         CHECK_SWF_OFFSET();
2178     if (jit_fpr_p(r1)) {
2179         if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
2180             r0 != r1 && (reg = jit_get_reg_pair()) != JIT_NOREG) {
2181             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2182             EORI(rn(reg) + 1, rn(reg) + 1, encode_arm_immediate(0x80000000));
2183             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2184             jit_unget_reg_pair(reg);
2185         }
2186         else {
2187             reg = jit_get_reg(jit_class_gpr);
2188             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
2189             xori(rn(reg), rn(reg), 0x80000000);
2190             if (jit_fpr_p(r0)) {
2191                 swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2192                 if (r0 != r1) {
2193                     swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2194                     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2195                 }
2196             }
2197             else {
2198                 movr(r0, rn(reg));
2199                 swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2200                 movr(r0 + 1, rn(reg));
2201             }
2202             jit_unget_reg(reg);
2203         }
2204     }
2205     else if (jit_fpr_p(r0)) {
2206         reg = jit_get_reg(jit_class_gpr);
2207         movr(rn(reg), r1);
2208         xori(rn(reg), rn(reg), 0x80000000);
2209         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2210         movr(rn(reg), r1 + 1);
2211         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2212         jit_unget_reg(reg);
2213     }
2214     else {
2215         xori(r0, r1, 0x80000000);
2216         if (r0 != r1)
2217             movr(r0 + 1, r1 + 1);
2218     }
2219 }
2220
2221 static void
2222 _swf_fmar_f(jit_state_t *_jit,
2223             jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2224 {
2225     jit_int32_t         t0;
2226     if (r0 != r3) {
2227         swf_mulr_f(r0, r1, r2);
2228         swf_addr_f(r0, r0, r3);
2229     }
2230     else {
2231         t0 = jit_get_reg(jit_class_fpr);
2232         swf_mulr_f(rn(t0), r1, r2);
2233         swf_addr_f(r0, rn(t0), r3);
2234         jit_unget_reg(t0);
2235     }
2236 }
2237
2238 static void
2239 _swf_fmsr_f(jit_state_t *_jit,
2240             jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2241 {
2242     jit_int32_t         t0;
2243     if (r0 != r3) {
2244         swf_mulr_f(r0, r1, r2);
2245         swf_subr_f(r0, r0, r3);
2246     }
2247     else {
2248         t0 = jit_get_reg(jit_class_fpr);
2249         swf_mulr_f(rn(t0), r1, r2);
2250         swf_subr_f(r0, rn(t0), r3);
2251         jit_unget_reg(t0);
2252     }
2253 }
2254
2255 static void
2256 _swf_fnmar_f(jit_state_t *_jit,
2257              jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2258 {
2259     jit_int32_t         t0;
2260     t0 = jit_get_reg(jit_class_fpr);
2261     swf_negr_f(rn(t0), r1);
2262     swf_mulr_f(rn(t0), rn(t0), r2);
2263     swf_subr_f(r0, rn(t0), r3);
2264     jit_unget_reg(t0);
2265 }
2266
2267 static void
2268 _swf_fnmsr_f(jit_state_t *_jit,
2269              jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2270 {
2271     jit_int32_t         t0;
2272     t0 = jit_get_reg(jit_class_fpr);
2273     swf_negr_f(rn(t0), r1);
2274     swf_mulr_f(rn(t0), rn(t0), r2);
2275     swf_addr_f(r0, rn(t0), r3);
2276     jit_unget_reg(t0);
2277 }
2278
2279 static void
2280 _swf_fmar_d(jit_state_t *_jit,
2281             jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2282 {
2283     jit_int32_t         t0;
2284     if (r0 != r3) {
2285         swf_mulr_d(r0, r1, r2);
2286         swf_addr_d(r0, r0, r3);
2287     }
2288     else {
2289         t0 = jit_get_reg(jit_class_fpr);
2290         swf_mulr_d(rn(t0), r1, r2);
2291         swf_addr_d(r0, rn(t0), r3);
2292         jit_unget_reg(t0);
2293     }
2294 }
2295
2296 static void
2297 _swf_fmsr_d(jit_state_t *_jit,
2298             jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2299 {
2300     jit_int32_t         t0;
2301     if (r0 != r3) {
2302         swf_mulr_d(r0, r1, r2);
2303         swf_subr_d(r0, r0, r3);
2304     }
2305     else {
2306         t0 = jit_get_reg(jit_class_fpr);
2307         swf_mulr_d(rn(t0), r1, r2);
2308         swf_subr_d(r0, rn(t0), r3);
2309         jit_unget_reg(t0);
2310     }
2311 }
2312
2313 static void
2314 _swf_fnmar_d(jit_state_t *_jit,
2315              jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2316 {
2317     jit_int32_t         t0;
2318     t0 = jit_get_reg(jit_class_fpr);
2319     swf_negr_d(rn(t0), r1);
2320     swf_mulr_d(rn(t0), rn(t0), r2);
2321     swf_subr_d(r0, rn(t0), r3);
2322     jit_unget_reg(t0);
2323 }
2324
2325 static void
2326 _swf_fnmsr_d(jit_state_t *_jit,
2327              jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2328 {
2329     jit_int32_t         t0;
2330     t0 = jit_get_reg(jit_class_fpr);
2331     swf_negr_d(rn(t0), r1);
2332     swf_mulr_d(rn(t0), rn(t0), r2);
2333     swf_addr_d(r0, rn(t0), r3);
2334     jit_unget_reg(t0);
2335 }
2336
2337 static void
2338 _swf_ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2339 {
2340     swf_iff(__aeabi_fcmpeq, r0, r1, r2);
2341     xori(r0, r0, 1);
2342 }
2343
2344 static void
2345 _swf_nei_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
2346 {
2347     swf_iff_(__aeabi_fcmpeq, r0, r1, i0);
2348     xori(r0, r0, 1);
2349 }
2350
2351 static void
2352 _swf_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2353 {
2354     swf_idd(__aeabi_dcmpeq, r0, r1, r2);
2355     xori(r0, r0, 1);
2356 }
2357
2358 static void
2359 _swf_nei_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
2360 {
2361     swf_idd_(__aeabi_dcmpeq, r0, r1, i0);
2362     xori(r0, r0, 1);
2363 }
2364
2365 static void
2366 _swf_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2367 {
2368     swf_iunff(__aeabi_fcmpeq, r0, r1, r2);
2369     xori(r0, r0, 1);
2370 }
2371
2372 static void
2373 _swf_ltgti_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
2374 {
2375     swf_iunff_(__aeabi_fcmpeq, r0, r1, i0);
2376     xori(r0, r0, 1);
2377 }
2378
2379 static void
2380 _swf_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2381 {
2382     swf_iundd(__aeabi_dcmpeq, r0, r1, r2);
2383     xori(r0, r0, 1);
2384 }
2385
2386 static void
2387 _swf_ltgti_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
2388 {
2389     swf_iundd_(__aeabi_dcmpeq, r0, r1, i0);
2390     xori(r0, r0, 1);
2391 }
2392
2393 static void
2394 _swf_ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2395 {
2396     swf_iff(__aeabi_fcmpun, r0, r1, r2);
2397     xori(r0, r0, 1);
2398 }
2399
2400 static void
2401 _swf_ordi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
2402 {
2403     swf_iff_(__aeabi_fcmpun, r0, r1, i0);
2404     xori(r0, r0, 1);
2405 }
2406
2407 static void
2408 _swf_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2409 {
2410     swf_idd(__aeabi_dcmpun, r0, r1, r2);
2411     xori(r0, r0, 1);
2412 }
2413
2414 static void
2415 _swf_ordi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
2416 {
2417     swf_idd_(__aeabi_dcmpun, r0, r1, i0);
2418     xori(r0, r0, 1);
2419 }
2420
2421 static void
2422 _swf_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2423 {
2424     jit_int32_t         reg;
2425     if (jit_fpr_p(r0)) {
2426         CHECK_SWF_OFFSET();
2427         reg = jit_get_reg(jit_class_gpr);
2428         ldxi_i(rn(reg), r1, 0);
2429         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2430         jit_unget_reg(reg);
2431     }
2432     else
2433         ldxi_i(r0, r1, 0);
2434 }
2435
2436 static void
2437 _swf_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2438 {
2439     jit_int32_t         reg;
2440     if (jit_fpr_p(r0)) {
2441         CHECK_SWF_OFFSET();
2442         if (!jit_thumb_p() && jit_armv5e_p() &&
2443             (reg = jit_get_reg_pair()) != JIT_NOREG) {
2444             LDRDI(rn(reg), r1, 0);
2445             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2446             jit_unget_reg_pair(reg);
2447         }
2448         else {
2449             reg = jit_get_reg(jit_class_gpr);
2450             ldxi_i(rn(reg), r1, 0);
2451             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2452             ldxi_i(rn(reg), r1, 4);
2453             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2454             jit_unget_reg(reg);
2455         }
2456     }
2457     else if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2458         LDRDI(r0, r1, 0);
2459     else {
2460         ldxi_i(r0, r1, 0);
2461         ldxi_i(r0 + 1, r1, 4);
2462     }
2463 }
2464
2465 static void
2466 _swf_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2467 {
2468     jit_int32_t         reg;
2469     if (jit_fpr_p(r0)) {
2470         CHECK_SWF_OFFSET();
2471         reg = jit_get_reg(jit_class_gpr);
2472         ldi_i(rn(reg), i0);
2473         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2474         jit_unget_reg(reg);
2475     }
2476     else
2477         ldi_i(r0, i0);
2478 }
2479
2480 static void
2481 _swf_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2482 {
2483     jit_int32_t         rg0, rg1;
2484     if (jit_fpr_p(r0))
2485         CHECK_SWF_OFFSET();
2486     if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
2487         (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2488         movi(rn(rg0), i0);
2489         LDRDI(rn(rg0), rn(rg0), 0);
2490         STRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2491         jit_unget_reg_pair(rg0);
2492     }
2493     else {
2494         rg1 = jit_get_reg(jit_class_gpr);
2495         movi(rn(rg1), i0);
2496         if (jit_fpr_p(r0)) {
2497             rg0 = jit_get_reg(jit_class_gpr);
2498             ldxi_i(rn(rg0), rn(rg1), 0);
2499             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2500             ldxi_i(rn(rg0), rn(rg1), 4);
2501             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2502             jit_unget_reg(rg0);
2503         }
2504         else if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2505             LDRDI(r0, rn(rg1), 0);
2506         else {
2507             ldxi_i(r0, rn(rg1), 0);
2508             ldxi_i(r0 + 1, rn(rg1), 0);
2509         }
2510         jit_unget_reg(rg1);
2511     }
2512 }
2513
2514 static void
2515 _swf_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2516 {
2517     jit_int32_t         reg;
2518     if (jit_fpr_p(r0)) {
2519         CHECK_SWF_OFFSET();
2520         reg = jit_get_reg(jit_class_gpr);
2521         ldxr_i(rn(reg), r1, r2);
2522         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2523         jit_unget_reg(reg);
2524     }
2525     else
2526         ldxr_i(r0, r1, r2);
2527 }
2528
2529 static void
2530 _swf_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2531 {
2532     jit_int32_t         rg0, rg1;
2533     if (jit_fpr_p(r0)) {
2534         CHECK_SWF_OFFSET();
2535         if (!jit_thumb_p() && jit_armv5e_p() &&
2536             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2537             LDRD(rn(rg0), r1, r2);
2538             STRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2539             jit_unget_reg_pair(rg0);
2540         }
2541         else {
2542             rg1 = jit_get_reg(jit_class_gpr);
2543             addr(rn(rg1), r1, r2);
2544             rg0 = jit_get_reg(jit_class_gpr);
2545             ldxi_i(rn(rg0), rn(rg1), 0);
2546             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2547             ldxi_i(rn(rg0), rn(rg1), 4);
2548             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2549             jit_unget_reg(rg0);
2550             jit_unget_reg(rg1);
2551         }
2552     }
2553     else {
2554         if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2555             LDRD(r0, r1, r2);
2556         else {
2557             rg1 = jit_get_reg(jit_class_gpr);
2558             addr(rn(rg1), r1, r2);
2559             ldxi_i(r0, rn(rg1), 0);
2560             ldxi_i(r0 + 1, rn(rg1), 4);
2561             jit_unget_reg(rg1);
2562         }
2563     }
2564 }
2565
2566 static void
2567 _swf_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2568 {
2569     jit_int32_t         reg;
2570     if (jit_fpr_p(r0))
2571         CHECK_SWF_OFFSET();
2572     if (jit_fpr_p(r0)) {
2573         reg = jit_get_reg(jit_class_gpr);
2574         ldxi_i(rn(reg), r1, i0);
2575         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2576         jit_unget_reg(reg);
2577     }
2578     else
2579         ldxi_i(r0, r1, i0);
2580 }
2581
2582 static void
2583 _swf_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2584 {
2585     jit_int32_t         t0, r2;
2586     jit_int32_t         t1, r3;
2587     assert(i0 == 4 || i0 == 8);
2588     if (jit_unaligned_p()) {
2589         t0 = fallback_jit_get_reg(jit_class_gpr);
2590         r2 = rn(t0);
2591         if (i0 == 4) {
2592             unldr(r2, r1, 4);
2593             swf_movr_w_f(r0, r2);
2594         }
2595         else {
2596             t1 = fallback_jit_get_reg(jit_class_gpr);
2597             r3 = rn(t1);
2598 #if __BYTE_ORDER == __LITTLE_ENDIAN
2599             unldr(r2, r1, 4);
2600             addi(r3, r1, 4);
2601             unldr(r3, r3, 4);
2602 #else
2603             unldr(r3, r1, 4);
2604             addi(r2, r1, 4);
2605             unldr(r2, r2, 4);
2606 #endif
2607             swf_movr_ww_d(r0, r2, r3);
2608             jit_unget_reg(t1);
2609         }
2610         jit_unget_reg(t0);
2611     }
2612     else {
2613         if (i0 == 4)
2614             swf_ldr_f(r0, r1);
2615         else
2616             swf_ldr_d(r0, r1);
2617     }
2618 }
2619
2620 static void
2621 _swf_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
2622 {
2623    jit_int32_t          t0, r2;
2624     jit_int32_t         t1, r3;
2625     assert(i1 == 4 || i1 == 8);
2626     if (jit_unaligned_p()) {
2627         t0 = fallback_jit_get_reg(jit_class_gpr);
2628         r2 = rn(t0);
2629         if (i1 == 4) {
2630             unldi(r2, i0, 4);
2631             swf_movr_w_f(r0, r2);
2632         }
2633         else {
2634             t1 = fallback_jit_get_reg(jit_class_gpr);
2635             r3 = rn(t1);
2636 #if __BYTE_ORDER == __LITTLE_ENDIAN
2637             unldi(r2, i0, 4);
2638             unldi(r3, i0 + 4, 4);
2639 #else
2640             unldi(r3, i0, 4);
2641             unldi(r2, i0 + 4, 4);
2642 #endif
2643             swf_movr_ww_d(r0, r3, r2);
2644             jit_unget_reg(t1);
2645         }
2646         jit_unget_reg(t0);
2647     }
2648     else {
2649         if (i0 == 4)
2650             swf_ldi_f(r0, i0);
2651         else
2652             swf_ldi_d(r0, i0);
2653     }
2654 }
2655
2656 static void
2657 _swf_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2658 {
2659     jit_int32_t         rg0, rg1;
2660     if (jit_fpr_p(r0)) {
2661         CHECK_SWF_OFFSET();
2662         if (!jit_thumb_p() && jit_armv5e_p() &&
2663             ((i0 >= 0 && i0 <= 255) || (i0 < 0 && i0 >= -255)) &&
2664             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2665             if (i0 >= 0)
2666                 LDRDI(rn(rg0), r1, i0);
2667             else
2668                 LDRDIN(rn(rg0), r1, -i0);
2669             STRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2670             jit_unget_reg_pair(rg0);
2671         }
2672         else if (i0 >= 0 && i0 + 4 <= 4095) {
2673             rg0 = jit_get_reg(jit_class_gpr);
2674             ldxi_i(rn(rg0), r1, i0);
2675             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2676             ldxi_i(rn(rg0), r1, i0 + 4);
2677             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2678             jit_unget_reg(rg0);
2679         }
2680         else if (i0 < 0 && ((jit_thumb_p() && i0 >= -255) ||
2681                             (!jit_thumb_p() && i0 >= -4095))) {
2682             rg0 = jit_get_reg(jit_class_gpr);
2683             swf_ldrin(rn(rg0), r1, -i0);
2684             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2685             swf_ldrin(rn(rg0), r1, -(i0 + 4));
2686             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2687             jit_unget_reg(rg0);
2688         }
2689         else {
2690             rg0 = jit_get_reg(jit_class_gpr);
2691             rg1 = jit_get_reg(jit_class_gpr);
2692             addi(rn(rg1), r1, i0);
2693             ldxi_i(rn(rg0), rn(rg1), 0);
2694             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2695             ldxi_i(rn(rg0), rn(rg1), 4);
2696             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2697             jit_unget_reg(rg1);
2698             jit_unget_reg(rg0);
2699         }
2700     }
2701     else {
2702         if (!jit_thumb_p() && jit_armv5e_p() &&
2703             i0 >= 0 && i0 <= 255 && !(r0 & 1))
2704             LDRDI(r0, r1, i0);
2705         else if (!jit_thumb_p() && jit_armv5e_p() &&
2706                  i0 < 0 && i0 >= -255 && !(r0 & 1))
2707             LDRDIN(r0, r1, -i0);
2708         else if (i0 >= 0 && i0 + 4 <= 4095) {
2709             ldxi_i(r0, r1, i0);
2710             ldxi_i(r0 + 1, r1, i0 + 4);
2711         }
2712         else if (i0 < 0 && i0 >= -4095) {
2713             swf_ldrin(r0, r1, -i0);
2714             swf_ldrin(r0 + 1, r1, -(i0 + 4));
2715         }
2716         else {
2717             rg0 = jit_get_reg(jit_class_gpr);
2718             addi(rn(rg0), r1, i0);
2719             ldxi_i(r0, rn(rg0), 0);
2720             ldxi_i(r0 + 1, rn(rg0), 4);
2721             jit_unget_reg(rg0);
2722         }
2723     }
2724 }
2725
2726 static void
2727 _swf_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2728 {
2729     jit_int32_t         reg;
2730     if (jit_fpr_p(r1)) {
2731         CHECK_SWF_OFFSET();
2732         reg = jit_get_reg(jit_class_gpr);
2733         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2734         stxi_i(0, r0, rn(reg));
2735         jit_unget_reg(reg);
2736     }
2737     else
2738         str_i(r0, r1);
2739 }
2740
2741 static void
2742 _swf_str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2743 {
2744     jit_int32_t         reg;
2745     if (jit_fpr_p(r1)) {
2746         CHECK_SWF_OFFSET();
2747         if (!jit_thumb_p() && jit_armv5e_p() &&
2748             (reg = jit_get_reg_pair()) != JIT_NOREG) {
2749             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2750             STRDI(rn(reg), r0, 0);
2751             jit_unget_reg_pair(reg);
2752         }
2753         else {
2754             reg = jit_get_reg(jit_class_gpr);
2755             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2756             stxi_i(0, r0, rn(reg));
2757             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
2758             stxi_i(4, r0, rn(reg));
2759             jit_unget_reg(reg);
2760         }
2761     }
2762     else {
2763         if (!jit_thumb_p() && jit_armv5e_p() && !(r1 & 1))
2764             STRDI(r1, r0, 0);
2765         else {
2766             stxi_i(0, r0, r1);
2767             stxi_i(4, r0, r1 + 1);
2768         }
2769     }
2770 }
2771
2772 static void
2773 _swf_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2774 {
2775     jit_int32_t         reg;
2776     if (jit_fpr_p(r0)) {
2777         CHECK_SWF_OFFSET();
2778         reg = jit_get_reg(jit_class_gpr);
2779         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2780         sti_i(i0, rn(reg));
2781         jit_unget_reg(reg);
2782     }
2783     else
2784         sti_i(i0, r0);
2785 }
2786
2787 static void
2788 _swf_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2789 {
2790     jit_int32_t         t0, r2;
2791     jit_int32_t         t1, r3;
2792     assert(i0 == 4 || i0 == 8);
2793     if (jit_unaligned_p()) {
2794         t0 = fallback_jit_get_reg(jit_class_gpr);
2795         r2 = rn(t0);
2796         if (i0 == 4) {
2797             swf_movr_f_w(r2, r1);
2798             unstr(r0, r2, 4);
2799         }
2800         else {
2801             t1 = fallback_jit_get_reg(jit_class_gpr);
2802             r3 = rn(t1);
2803             swf_movr_d_ww(r2, r3, r1);
2804 #if __BYTE_ORDER == __LITTLE_ENDIAN
2805             unstr(r0, r2, 4);
2806             addi(r2, r0, 4);
2807             unstr(r2, r3, 4);
2808 #else
2809             unstr(r0, r3, 4);
2810             addi(r3, r0, 4);
2811             unstr(r3, r2, 4);
2812 #endif
2813             jit_unget_reg(t1);
2814         }
2815         jit_unget_reg(t0);
2816     }
2817     else {
2818         if (i0 == 4)
2819             swf_str_f(r0, r1);
2820         else
2821             swf_str_d(r0, r1);
2822     }
2823 }
2824
2825 static void
2826 _swf_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2827 {
2828     jit_int32_t         t0, r2;
2829     jit_int32_t         t1, r3;
2830     assert(i1 == 4 || i1 == 8);
2831     if (jit_unaligned_p()) {
2832         t0 = fallback_jit_get_reg(jit_class_gpr);
2833         r2 = rn(t0);
2834         if (i1 == 4) {
2835             swf_movr_f_w(r2, r0);
2836             unsti(i0, r2, 4);
2837         }
2838         else {
2839             t1 = fallback_jit_get_reg(jit_class_gpr);
2840             r3 = rn(t1);
2841             swf_movr_d_ww(r2, r3, r0);
2842 #if __BYTE_ORDER == __LITTLE_ENDIAN
2843             unsti(i0, r3, 4);
2844             unsti(i0 + 4, r2, 4);
2845 #else
2846             unsti(i0, r2, 4);
2847             unsti(i0 + 4, r3, 4);
2848 #endif
2849             jit_unget_reg(t1);
2850         }
2851         jit_unget_reg(t0);
2852     }
2853     else {
2854         if (i1 == 4)
2855             swf_sti_f(i0, r0);
2856         else
2857             swf_sti_d(i0, r0);
2858     }
2859 }
2860
2861 static void
2862 _swf_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2863 {
2864     jit_int32_t         rg0, rg1;
2865     if (jit_fpr_p(r0)) {
2866         CHECK_SWF_OFFSET();
2867         if (!jit_thumb_p() && jit_armv5e_p() &&
2868             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2869             rg1 = jit_get_reg(jit_class_gpr);
2870             movi(rn(rg1), i0);
2871             LDRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2872             STRDI(rn(rg0), rn(rg1), 0);
2873             jit_unget_reg(rg1);
2874             jit_unget_reg_pair(rg0);
2875         }
2876         else {
2877             rg1 = jit_get_reg(jit_class_gpr);
2878             movi(rn(rg1), i0);
2879             rg0 = jit_get_reg(jit_class_gpr);
2880             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2881             stxi_i(0, rn(rg1), rn(rg0));
2882             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2883             stxi_i(4, rn(rg1), rn(rg0));
2884             jit_unget_reg(rg1);
2885             jit_unget_reg(rg0);
2886         }
2887     }
2888     else {
2889         rg1 = jit_get_reg(jit_class_gpr);
2890         movi(rn(rg1), i0);
2891         if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2892             STRDI(r0, rn(rg1), 0);
2893         else {
2894             stxi_i(0, rn(rg1), r0);
2895             stxi_i(4, rn(rg1), r0 + 1);
2896         }
2897         jit_unget_reg(rg1);
2898     }
2899 }
2900
2901 static void
2902 _swf_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2903 {
2904     jit_int32_t         reg;
2905     if (jit_fpr_p(r2)) {
2906         CHECK_SWF_OFFSET();
2907         reg = jit_get_reg(jit_class_gpr);
2908         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r2) + 8);
2909         stxr_i(r1, r0, rn(reg));
2910         jit_unget_reg(reg);
2911     }
2912     else
2913         stxr_i(r0, r1, r2);
2914 }
2915
2916 static void
2917 _swf_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2918 {
2919     jit_int32_t         rg0, rg1;
2920     if (jit_fpr_p(r2)) {
2921         CHECK_SWF_OFFSET();
2922         if (!jit_thumb_p() && jit_armv5e_p() &&
2923             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2924             LDRDIN(rn(rg0), _FP_REGNO, swf_off(r2) + 8);
2925             STRD(rn(rg0), r0, r1);
2926             jit_unget_reg_pair(rg0);
2927         }
2928         else {
2929             rg1 = jit_get_reg(jit_class_gpr);
2930             addr(rn(rg1), r0, r1);
2931             rg0 = jit_get_reg(jit_class_gpr);
2932             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r2) + 8);
2933             stxi_i(0, rn(rg1), rn(rg0));
2934             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r2) + 4);
2935             stxi_i(4, rn(rg1), rn(rg0));
2936             jit_unget_reg(rg0);
2937             jit_unget_reg(rg1);
2938         }
2939     }
2940     else {
2941         if (!jit_thumb_p() && jit_armv5e_p() && !(r2 & 1))
2942             STRD(r0, r1, r2);
2943         else {
2944             rg1 = jit_get_reg(jit_class_gpr);
2945             addr(rn(rg1), r0, r1);
2946             stxi_i(0, rn(rg1), r2);
2947             stxi_i(4, rn(rg1), r2 + 1);
2948             jit_unget_reg(rg1);
2949         }
2950     }
2951 }
2952
2953 static void
2954 _swf_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2955 {
2956     jit_int32_t         reg;
2957     if (jit_fpr_p(r1)) {
2958         CHECK_SWF_OFFSET();
2959         reg = jit_get_reg(jit_class_gpr);
2960         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2961         stxi_i(i0, r0, rn(reg));
2962         jit_unget_reg(reg);
2963     }
2964     else
2965         stxi_i(i0, r0, r1);
2966 }
2967
2968 static void
2969 _swf_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2970 {
2971     jit_int32_t         rg0, rg1;
2972     if (jit_fpr_p(r1)) {
2973         CHECK_SWF_OFFSET();
2974         if (!jit_thumb_p() && jit_armv5e_p() &&
2975             ((i0 >= 0 && i0 <= 255) || (i0 < 0 && i0 >= -255)) &&
2976             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2977             LDRDIN(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2978             if (i0 >= 0 && i0 <= 255)
2979                 STRDI(rn(rg0), r0, i0);
2980             else
2981                 STRDIN(rn(rg0), r0, -i0);
2982             jit_unget_reg_pair(rg0);
2983         }
2984         else if (i0 >= 0 && i0 + 4 <= 4095) {
2985             rg0 = jit_get_reg(jit_class_gpr);
2986             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2987             stxi_i(i0, r0, rn(rg0));
2988             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 4);
2989             stxi_i(i0 + 4, r0, rn(rg0));
2990             jit_unget_reg(rg0);
2991         }
2992         else if (i0 < 0 && ((jit_thumb_p() && i0 >= -255) ||
2993                             (!jit_thumb_p() && i0 >= -4095))) {
2994             rg0 = jit_get_reg(jit_class_gpr);
2995             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2996             swf_strin(rn(rg0), r0, -i0);
2997             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 4);
2998             swf_strin(rn(rg0), r0, -(i0 + 4));
2999             jit_unget_reg(rg0);
3000         }
3001         else {
3002             rg1 = jit_get_reg(jit_class_gpr);
3003             addi(rn(rg1), r0, i0);
3004             rg0 = jit_get_reg(jit_class_gpr);
3005             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
3006             stxi_i(0, rn(rg1), rn(rg0));
3007             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 4);
3008             stxi_i(4, rn(rg1), rn(rg0));
3009             jit_unget_reg(rg0);
3010             jit_unget_reg(rg1);
3011         }
3012     }
3013     else {
3014         if (!jit_thumb_p() && jit_armv5e_p() &&
3015             i0 >= 0 && i0 <= 255 && !(r1 & 1))
3016             STRDI(r1, r0, i0);
3017         else if (!jit_thumb_p() && jit_armv5e_p() &&
3018                  i0 < 0 && i0 >= -255 && !(r1 & 1))
3019             STRDIN(r1, r0, -i0);
3020         else if (i0 >= 0 && i0 + 4 <= 4095) {
3021             stxi_i(i0, r0, r1);
3022             stxi_i(i0 + 4, r0, r1 + 1);
3023         }
3024         else if (i0 < 0 && ((jit_thumb_p() && i0 >= 255) ||
3025                             (!jit_thumb_p() && i0 >= -4095))) {
3026             swf_strin(r1, r0, -i0);
3027             swf_strin(r1 + 1, r0, -(i0 + 4));
3028         }
3029         else {
3030             rg1 = jit_get_reg(jit_class_gpr);
3031             addi(rn(rg1), r0, i0);
3032             stxi_i(0, rn(rg1), r1);
3033             stxi_i(4, rn(rg1), r1 + 1);
3034             jit_unget_reg(rg1);
3035         }
3036     }
3037 }
3038
3039 static void
3040 _swf_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3041 {
3042     jit_int32_t         reg;
3043
3044     assert(_jitc->function->self.call & jit_call_varargs);
3045
3046     /* Adjust pointer. */
3047     reg = jit_get_reg(jit_class_gpr);
3048     andi(rn(reg), r1, 7);
3049     addr(r1, r1, rn(reg));
3050     jit_unget_reg(reg);
3051
3052     /* Load argument. */
3053     swf_ldr_d(r0, r1);
3054
3055     /* Update stack pointer. */
3056     addi(r1, r1, sizeof(jit_float64_t));
3057 }
3058
3059 #endif