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