deps/lightning/lib/jit_arm-swf.c

   1 /*
   2  * Copyright (C) 2012-2022  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(r1))
 568         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 569     else
 570         movr(_R0_REGNO, r1);
 571     swf_call(i0, fallback, _R1_REGNO);
 572     if (jit_fpr_p(r0))
 573         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 574     else
 575         movr(r0, _R0_REGNO);
 576     jit_unget_reg_args();
 577 }
 578
 579 static void
 580 _swf_dd(jit_state_t *_jit, double (*i0)(double),
 581         jit_int32_t r0, jit_int32_t r1)
 582 {
 583     jit_get_reg_args();
 584     if (jit_fpr_p(r1)) {
 585         if (!jit_thumb_p() && jit_armv5e_p())
 586             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 587         else {
 588             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 589             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 590         }
 591     }
 592     else {
 593         movr(_R0_REGNO, r1);
 594         movr(_R1_REGNO, r1 + 1);
 595     }
 596     swf_call(i0, fallback, _R2_REGNO);
 597     if (jit_fpr_p(r0)) {
 598         if (!jit_thumb_p() && jit_armv5e_p())
 599             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 600         else {
 601             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 602             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 603         }
 604     }
 605     else {
 606         movr(r0, _R0_REGNO);
 607         movr(r0 + 1, _R1_REGNO);
 608     }
 609     jit_unget_reg_args();
 610 }
 611
 612 static void
 613 _swf_fff(jit_state_t *_jit, float (*i0)(float, float),
 614          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 615 {
 616     jit_get_reg_args();
 617     if (jit_fpr_p(r1))
 618         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 619     else
 620         movr(_R0_REGNO, r1);
 621     if (jit_fpr_p(r2))
 622         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
 623     else
 624         movr(_R1_REGNO, r1);
 625     swf_call(i0, fallback, _R3_REGNO);
 626     if (jit_fpr_p(r0))
 627         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 628     else
 629         movr(r0, _R0_REGNO);
 630     jit_unget_reg_args();
 631 }
 632
 633 static void
 634 _swf_ddd(jit_state_t *_jit, double (*i0)(double, double),
 635          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 636 {
 637     jit_get_reg_args();
 638     if (jit_fpr_p(r1)) {
 639         if (!jit_thumb_p() && jit_armv5e_p())
 640             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 641         else {
 642             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 643             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 644         }
 645     }
 646     else {
 647         movr(_R0_REGNO, r1);
 648         movr(_R1_REGNO, r1 + 1);
 649     }
 650     if (jit_fpr_p(r2)) {
 651         if (!jit_thumb_p() && jit_armv5e_p())
 652             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 653         else {
 654             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 655             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
 656         }
 657     }
 658     else {
 659         movr(_R2_REGNO, r2);
 660         movr(_R3_REGNO, r2 + 1);
 661     }
 662     swf_call_with_get_reg(i0, fallback);
 663     if (jit_fpr_p(r0)) {
 664         if (!jit_thumb_p() && jit_armv5e_p())
 665             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 666         else {
 667             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 668             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 669         }
 670     }
 671     else {
 672         movr(r0, _R0_REGNO);
 673         movr(r0 + 1, _R1_REGNO);
 674     }
 675     jit_unget_reg_args();
 676 }
 677
 678 static void
 679 _swf_fff_(jit_state_t *_jit, float (*i0)(float, float),
 680           jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
 681 {
 682     union {
 683         jit_int32_t     i;
 684         jit_float32_t   f;
 685     } data;
 686     jit_get_reg_args();
 687     data.f = i1;
 688     if (jit_fpr_p(r1))
 689         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 690     else
 691         movr(_R0_REGNO, r1);
 692     movi(_R1_REGNO, data.i);
 693     swf_call(i0, fallback, _R3_REGNO);
 694     if (jit_fpr_p(r0))
 695         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 696     else
 697         movr(r0, _R0_REGNO);
 698     jit_unget_reg_args();
 699 }
 700
 701 static void
 702 _swf_rsbi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
 703 {
 704     union {
 705         jit_int32_t     i;
 706         jit_float32_t   f;
 707     } data;
 708     jit_get_reg_args();
 709     data.f = i0;
 710     movi(_R0_REGNO, data.i);
 711     if (jit_fpr_p(r1))
 712         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
 713     else
 714         movr(_R1_REGNO, r1);
 715     swf_call(__aeabi_fsub, fallback, _R3_REGNO);
 716     if (jit_fpr_p(r0))
 717         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 718     else
 719         movr(r0, _R0_REGNO);
 720     jit_unget_reg_args();
 721 }
 722
 723 static void
 724 _swf_ddd_(jit_state_t *_jit, double (*i0)(double, double),
 725           jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
 726 {
 727     union {
 728         jit_int32_t     i[2];
 729         jit_float64_t   d;
 730     } data;
 731     jit_get_reg_args();
 732
 733     data.d = i1;
 734     if (jit_fpr_p(r1)) {
 735         if (!jit_thumb_p() && jit_armv5e_p())
 736             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 737         else {
 738             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 739             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 740         }
 741     }
 742     else {
 743         movr(_R0_REGNO, r1);
 744         movr(_R1_REGNO, r1 + 1);
 745     }
 746     movi(_R2_REGNO, data.i[0]);
 747     movi(_R3_REGNO, data.i[1]);
 748     swf_call_with_get_reg(i0, fallback);
 749     if (jit_fpr_p(r0)) {
 750         if (!jit_thumb_p() && jit_armv5e_p())
 751             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 752         else {
 753             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 754             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 755         }
 756     }
 757     else {
 758         movr(r0, _R0_REGNO);
 759         movr(r0 + 1, _R1_REGNO);
 760     }
 761     jit_unget_reg_args();
 762 }
 763
 764 static void
 765 _swf_rsbi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
 766 {
 767     union {
 768         jit_int32_t     i[2];
 769         jit_float64_t   d;
 770     } data;
 771     jit_get_reg_args();
 772     data.d = i0;
 773     movi(_R0_REGNO, data.i[0]);
 774     movi(_R1_REGNO, data.i[1]);
 775     if (jit_fpr_p(r1)) {
 776         if (!jit_thumb_p() && jit_armv5e_p())
 777             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
 778         else {
 779             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
 780             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
 781         }
 782     }
 783     else {
 784         movr(_R2_REGNO, r1);
 785         movr(_R3_REGNO, r1 + 1);
 786     }
 787     swf_call_with_get_reg(__aeabi_dsub, fallback);
 788     if (jit_fpr_p(r0)) {
 789         if (!jit_thumb_p() && jit_armv5e_p())
 790             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 791         else {
 792             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
 793             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
 794         }
 795     }
 796     else {
 797         movr(r0, _R0_REGNO);
 798         movr(r0 + 1, _R1_REGNO);
 799     }
 800     jit_unget_reg_args();
 801 }
 802
 803 static void
 804 _swf_iff(jit_state_t *_jit, int (*i0)(float, float),
 805          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 806 {
 807     jit_get_reg_args();
 808     if (jit_fpr_p(r1))
 809         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 810     else
 811         movr(_R0_REGNO, r1);
 812     if (jit_fpr_p(r2))
 813         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
 814     else
 815         movr(_R1_REGNO, r2);
 816     swf_call(i0, fallback, _R2_REGNO);
 817     movr(r0, _R0_REGNO);
 818     jit_unget_reg_args();
 819 }
 820
 821 static void
 822 _swf_idd(jit_state_t *_jit, int (*i0)(double, double),
 823          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 824 {
 825     jit_get_reg_args();
 826     if (jit_fpr_p(r1)) {
 827         if (!jit_thumb_p() && jit_armv5e_p())
 828             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 829         else {
 830             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 831             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 832         }
 833     }
 834     else {
 835         movr(_R0_REGNO, r1);
 836         movr(_R1_REGNO, r1 + 1);
 837     }
 838     if (jit_fpr_p(r2)) {
 839         if (!jit_thumb_p() && jit_armv5e_p())
 840             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 841         else {
 842             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 843             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
 844         }
 845     }
 846     else {
 847         movr(_R2_REGNO, r2);
 848         movr(_R3_REGNO, r2 + 1);
 849     }
 850     swf_call_with_get_reg(i0, fallback);
 851     movr(r0, _R0_REGNO);
 852     jit_unget_reg_args();
 853 }
 854
 855 static void
 856 _swf_iff_(jit_state_t *_jit, int (*i0)(float, float),
 857           jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
 858 {
 859     union {
 860         jit_int32_t     i;
 861         jit_float32_t   f;
 862     } data;
 863     jit_get_reg_args();
 864     data.f = i1;
 865     if (jit_fpr_p(r1))
 866         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 867     else
 868         movr(_R0_REGNO, r1);
 869     movi(_R1_REGNO, data.i);
 870     swf_call(i0, fallback, _R2_REGNO);
 871     movr(r0, _R0_REGNO);
 872     jit_unget_reg_args();
 873 }
 874
 875 static void
 876 _swf_idd_(jit_state_t *_jit, int (*i0)(double, double),
 877           jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
 878 {
 879     union {
 880         jit_int32_t     i[2];
 881         jit_float64_t   d;
 882     } data;
 883     jit_get_reg_args();
 884     data.d = i1;
 885     if (jit_fpr_p(r1)) {
 886         if (!jit_thumb_p() && jit_armv5e_p())
 887             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 888         else {
 889             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 890             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 891         }
 892     }
 893     else {
 894         movr(_R0_REGNO, r1);
 895         movr(_R1_REGNO, r1 + 1);
 896     }
 897     movi(_R2_REGNO, data.i[0]);
 898     movi(_R3_REGNO, data.i[1]);
 899     swf_call_with_get_reg(i0, fallback);
 900     movr(r0, _R0_REGNO);
 901     jit_unget_reg_args();
 902 }
 903
 904 static void
 905 _swf_iunff(jit_state_t *_jit, int (*i0)(float, float),
 906            jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 907 {
 908     jit_word_t          instr;
 909     jit_get_reg_args();
 910     if (jit_fpr_p(r1))
 911         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 912     else
 913         movr(_R0_REGNO, r1);
 914     if (jit_fpr_p(r2))
 915         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r2) + 8);
 916     else
 917         movr(_R1_REGNO, r2);
 918     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
 919     if (jit_thumb_p()) {
 920         T1_CMPI(_R0_REGNO, 0);
 921         IT(ARM_CC_NE);
 922         if (r0 < 8)
 923             T1_MOVI(r0, 1);
 924         else
 925             T2_MOVI(r0, 1);
 926         instr = _jit->pc.w;
 927         T2_CC_B(ARM_CC_NE, 0);
 928     }
 929     else {
 930         CMPI(_R0_REGNO, 0);
 931         CC_MOVI(ARM_CC_NE, r0, 1);
 932         instr = _jit->pc.w;
 933         CC_B(ARM_CC_NE, 0);
 934     }
 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(i0, fallback, _R2_REGNO);
 944     movr(r0, _R0_REGNO);
 945     patch_at(arm_patch_jump, instr, _jit->pc.w);
 946     jit_unget_reg_args();
 947 }
 948
 949 static void
 950 _swf_iundd(jit_state_t *_jit, int (*i0)(double, double),
 951            jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 952 {
 953     jit_word_t          instr;
 954     jit_get_reg_args();
 955     if (jit_fpr_p(r1)) {
 956         if (!jit_thumb_p() && jit_armv5e_p())
 957             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 958         else {
 959             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 960             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
 961         }
 962     }
 963     else {
 964         movr(_R0_REGNO, r1);
 965         movr(_R1_REGNO, r1 + 1);
 966     }
 967     if (jit_fpr_p(r2)) {
 968         if (!jit_thumb_p() && jit_armv5e_p())
 969             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 970         else {
 971             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
 972             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
 973         }
 974     }
 975     else {
 976         movr(_R2_REGNO, r2);
 977         movr(_R3_REGNO, r2 + 1);
 978     }
 979     swf_call_with_get_reg(__aeabi_dcmpun, dcmpun);
 980     if (jit_thumb_p()) {
 981         T1_CMPI(_R0_REGNO, 0);
 982         IT(ARM_CC_NE);
 983         if (r0 < 8)
 984             T1_MOVI(r0, 1);
 985         else
 986             T2_MOVI(r0, 1);
 987         instr = _jit->pc.w;
 988         T2_CC_B(ARM_CC_NE, 0);
 989     }
 990     else {
 991         CMPI(_R0_REGNO, 0);
 992         CC_MOVI(ARM_CC_NE, r0, 1);
 993         instr = _jit->pc.w;
 994         CC_B(ARM_CC_NE, 0);
 995     }
 996     if (jit_fpr_p(r1)) {
 997         if (!jit_thumb_p() && jit_armv5e_p())
 998             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
 999         else {
1000             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1001             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1002         }
1003     }
1004     else {
1005         movr(_R0_REGNO, r1);
1006         movr(_R1_REGNO, r1 + 1);
1007     }
1008     if (jit_fpr_p(r2)) {
1009         if (!jit_thumb_p() && jit_armv5e_p())
1010             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
1011         else {
1012             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r2) + 8);
1013             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r2) + 4);
1014         }
1015     }
1016     else {
1017         movr(_R2_REGNO, r2);
1018         movr(_R3_REGNO, r2 + 1);
1019     }
1020     swf_call_with_get_reg(i0, fallback);
1021     movr(r0, _R0_REGNO);
1022     patch_at(arm_patch_jump, instr, _jit->pc.w);
1023     jit_unget_reg_args();
1024 }
1025
1026 static void
1027 _swf_iunff_(jit_state_t *_jit, int (*i0)(float, float),
1028             jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
1029 {
1030     jit_word_t          instr;
1031     union {
1032         jit_int32_t     i;
1033         jit_float32_t   f;
1034     } data;
1035     jit_get_reg_args();
1036     data.f = i1;
1037     if (jit_fpr_p(r1))
1038         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1039     else
1040         movr(_R0_REGNO, r1);
1041     movi(_R1_REGNO, data.i);
1042     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
1043     if (jit_thumb_p()) {
1044         T1_CMPI(_R0_REGNO, 0);
1045         IT(ARM_CC_NE);
1046         if (r0 < 8)
1047             T1_MOVI(r0, 1);
1048         else
1049             T2_MOVI(r0, 1);
1050         instr = _jit->pc.w;
1051         T2_CC_B(ARM_CC_NE, 0);
1052     }
1053     else {
1054         CMPI(_R0_REGNO, 0);
1055         CC_MOVI(ARM_CC_NE, r0, 1);
1056         instr = _jit->pc.w;
1057         CC_B(ARM_CC_NE, 0);
1058     }
1059     if (jit_fpr_p(r1))
1060         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1061     else
1062         movr(_R0_REGNO, r1);
1063     movi(_R1_REGNO, data.i);
1064     swf_call(i0, fallback, _R2_REGNO);
1065     movr(r0, _R0_REGNO);
1066     patch_at(arm_patch_jump, instr, _jit->pc.w);
1067     jit_unget_reg_args();
1068 }
1069
1070 static void
1071 _swf_iundd_(jit_state_t *_jit, int (*i0)(double, double),
1072             jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
1073 {
1074     jit_word_t          instr;
1075     union {
1076         jit_int32_t     i[2];
1077         jit_float64_t   d;
1078     } data;
1079     jit_get_reg_args();
1080     data.d = i1;
1081     if (jit_fpr_p(r1)) {
1082         if (!jit_thumb_p() && jit_armv5e_p())
1083             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1084         else {
1085             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1086             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1087         }
1088     }
1089     else {
1090         movr(_R0_REGNO, r1);
1091         movr(_R1_REGNO, r1 + 1);
1092     }
1093     movi(_R2_REGNO, data.i[0]);
1094     movi(_R3_REGNO, data.i[1]);
1095     swf_call_with_get_reg(__aeabi_dcmpun, dcmpun);
1096     if (jit_thumb_p()) {
1097         T1_CMPI(_R0_REGNO, 0);
1098         IT(ARM_CC_NE);
1099         if (r0 < 8)
1100             T1_MOVI(r0, 1);
1101         else
1102             T2_MOVI(r0, 1);
1103         instr = _jit->pc.w;
1104         T2_CC_B(ARM_CC_NE, 0);
1105     }
1106     else {
1107         CMPI(_R0_REGNO, 0);
1108         CC_MOVI(ARM_CC_NE, r0, 1);
1109         instr = _jit->pc.w;
1110         CC_B(ARM_CC_NE, 0);
1111     }
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(i0, fallback);
1127     movr(r0, _R0_REGNO);
1128     patch_at(arm_patch_jump, instr, _jit->pc.w);
1129     jit_unget_reg_args();
1130 }
1131
1132 static jit_word_t
1133 _swf_bff(jit_state_t *_jit, int (*i0)(float, float), int cc,
1134          jit_word_t i1, jit_int32_t r0, jit_int32_t r1)
1135 {
1136     jit_word_t          w, d;
1137     jit_get_reg_args();
1138     if (jit_fpr_p(r0))
1139         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1140     else
1141         movr(_R0_REGNO, r0);
1142     if (jit_fpr_p(r1))
1143         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
1144     else
1145         movr(_R1_REGNO, r1);
1146     swf_call(i0, fallback, _R2_REGNO);
1147     if (jit_thumb_p()) {
1148         T1_CMPI(_R0_REGNO, 0);
1149         w = _jit->pc.w;
1150         d = ((i1 - w) >> 1) - 2;
1151         assert(_s20P(d));
1152         T2_CC_B(cc, encode_thumb_cc_jump(d));
1153     }
1154     else {
1155         CMPI(_R0_REGNO, 0);
1156         w = _jit->pc.w;
1157         d = ((i1 - w) >> 2) - 2;
1158         assert(_s24P(d));
1159         CC_B(cc, d & 0x00ffffff);
1160     }
1161     jit_unget_reg_args();
1162     return (w);
1163 }
1164
1165 static jit_word_t
1166 _swf_bdd(jit_state_t *_jit, int (*i0)(double, double), int cc,
1167          jit_word_t i1, jit_int32_t r0, jit_int32_t r1)
1168 {
1169     jit_word_t          w, d;
1170     jit_get_reg_args();
1171     if (jit_fpr_p(r0)) {
1172         if (!jit_thumb_p() && jit_armv5e_p())
1173             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1174         else {
1175             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1176             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1177         }
1178     }
1179     else {
1180         movr(_R0_REGNO, r0);
1181         movr(_R1_REGNO, r0 + 1);
1182     }
1183     if (jit_fpr_p(r1)) {
1184         if (!jit_thumb_p() && jit_armv5e_p())
1185             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1186         else {
1187             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1188             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
1189         }
1190     }
1191     else {
1192         movr(_R2_REGNO, r1);
1193         movr(_R3_REGNO, r1 + 1);
1194     }
1195     swf_call_with_get_reg(i0, fallback);
1196     if (jit_thumb_p()) {
1197         T1_CMPI(_R0_REGNO, 0);
1198         w = _jit->pc.w;
1199         d = ((i1 - w) >> 1) - 2;
1200         assert(_s20P(d));
1201         T2_CC_B(cc, encode_thumb_cc_jump(d));
1202     }
1203     else {
1204         CMPI(_R0_REGNO, 0);
1205         w = _jit->pc.w;
1206         d = ((i1 - w) >> 2) - 2;
1207         assert(_s24P(d));
1208         CC_B(cc, d & 0x00ffffff);
1209     }
1210     jit_unget_reg_args();
1211     return (w);
1212 }
1213
1214 static jit_word_t
1215 _swf_bff_(jit_state_t *_jit, int (*i0)(float, float), int cc,
1216           jit_word_t i1, jit_int32_t r0, jit_float32_t i2)
1217 {
1218     union {
1219         jit_int32_t     i;
1220         jit_float32_t   f;
1221     } data;
1222     jit_word_t          w, d;
1223     jit_get_reg_args();
1224     data.f = i2;
1225     if (jit_fpr_p(r0))
1226         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1227     else
1228         movr(_R0_REGNO, r0);
1229     movi(_R1_REGNO, data.i);
1230     swf_call(i0, fallback, _R2_REGNO);
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_bdd_(jit_state_t *_jit, int (*i0)(double, double), int cc,
1251           jit_word_t i1, jit_int32_t r0, jit_float64_t i2)
1252 {
1253     jit_word_t          w, d;
1254     union {
1255         jit_int32_t     i[2];
1256         jit_float64_t   d;
1257     } data;
1258     jit_get_reg_args();
1259     data.d = i2;
1260     if (jit_fpr_p(r0)) {
1261         if (!jit_thumb_p() && jit_armv5e_p())
1262             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1263         else {
1264             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1265             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1266         }
1267     }
1268     else {
1269         movr(_R0_REGNO, r0);
1270         movr(_R1_REGNO, r0 + 1);
1271     }
1272     movi(_R2_REGNO, data.i[0]);
1273     movi(_R3_REGNO, data.i[1]);
1274     swf_call_with_get_reg(i0, fallback);
1275     if (jit_thumb_p()) {
1276         T1_CMPI(_R0_REGNO, 0);
1277         w = _jit->pc.w;
1278         d = ((i1 - w) >> 1) - 2;
1279         assert(_s20P(d));
1280         T2_CC_B(cc, encode_thumb_cc_jump(d));
1281     }
1282     else {
1283         CMPI(_R0_REGNO, 0);
1284         w = _jit->pc.w;
1285         d = ((i1 - w) >> 2) - 2;
1286         assert(_s24P(d));
1287         CC_B(cc, d & 0x00ffffff);
1288     }
1289     jit_unget_reg_args();
1290     return (w);
1291 }
1292
1293 static jit_word_t
1294 _swf_bunff(jit_state_t *_jit, int eq,
1295            jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1296 {
1297     jit_word_t          w, d, j0, j1;
1298     jit_get_reg_args();
1299     if (jit_fpr_p(r0))
1300         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1301     else
1302         movr(_R0_REGNO, r0);
1303     if (jit_fpr_p(r1))
1304         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
1305     else
1306         movr(_R1_REGNO, r1);
1307     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
1308     /* if unordered */
1309     if (jit_thumb_p()) {
1310         T1_CMPI(_R0_REGNO, 0);
1311         j0 = _jit->pc.w;
1312         T2_CC_B(ARM_CC_NE, 0);
1313     }
1314     else {
1315         CMPI(_R0_REGNO, 0);
1316         j0 = _jit->pc.w;
1317         CC_B(ARM_CC_NE, 0);
1318     }
1319     if (jit_fpr_p(r0))
1320         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1321     else
1322         movr(_R0_REGNO, r0);
1323     if (jit_fpr_p(r1))
1324         swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 8);
1325     else
1326         movr(_R1_REGNO, r1);
1327     swf_call(__aeabi_fcmpeq, fcmpeq, _R2_REGNO);
1328     if (jit_thumb_p()) {
1329         T1_CMPI(_R0_REGNO, 0);
1330         j1 = _jit->pc.w;
1331         if (eq) {
1332             T2_CC_B(ARM_CC_EQ, 0);
1333             patch_at(arm_patch_jump, j0, _jit->pc.w);
1334         }
1335         else
1336             T2_CC_B(ARM_CC_NE, 0);
1337         w = _jit->pc.w;
1338         d = ((i0 - w) >> 1) - 2;
1339         assert(_s24P(d));
1340         T2_B(encode_thumb_jump(d));
1341     }
1342     else {
1343         CMPI(_R0_REGNO, 0);
1344         j1 = _jit->pc.w;
1345         if (eq) {
1346             CC_B(ARM_CC_EQ, 0);
1347             patch_at(arm_patch_jump, j0, _jit->pc.w);
1348         }
1349         else
1350             CC_B(ARM_CC_NE, 0);
1351         w = _jit->pc.w;
1352         d = ((i0 - w) >> 2) - 2;
1353         assert(_s24P(d));
1354         B(d & 0x00ffffff);
1355     }
1356     if (!eq)
1357         patch_at(arm_patch_jump, j0, _jit->pc.w);
1358     patch_at(arm_patch_jump, j1, _jit->pc.w);
1359     jit_unget_reg_args();
1360     return (w);
1361 }
1362
1363 static jit_word_t
1364 _swf_bundd(jit_state_t *_jit, int eq,
1365            jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1366 {
1367     jit_word_t          w, d, j0, j1;
1368     jit_get_reg_args();
1369     if (jit_fpr_p(r0)) {
1370         if (!jit_thumb_p() && jit_armv5e_p())
1371             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1372         else {
1373             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1374             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1375         }
1376     }
1377     else {
1378         movr(_R0_REGNO, r0);
1379         movr(_R1_REGNO, r0 + 1);
1380     }
1381     if (jit_fpr_p(r1)) {
1382         if (!jit_thumb_p() && jit_armv5e_p())
1383             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1384         else {
1385             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1386             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
1387         }
1388     }
1389     else {
1390         movr(_R2_REGNO, r0);
1391         movr(_R3_REGNO, r0 + 1);
1392     }
1393     swf_call_with_get_reg(__aeabi_dcmpun, dcmpun);
1394     /* if unordered */
1395     if (jit_thumb_p()) {
1396         T1_CMPI(_R0_REGNO, 0);
1397         j0 = _jit->pc.w;
1398         T2_CC_B(ARM_CC_NE, 0);
1399     }
1400     else {
1401         CMPI(_R0_REGNO, 0);
1402         j0 = _jit->pc.w;
1403         CC_B(ARM_CC_NE, 0);
1404     }
1405     if (jit_fpr_p(r0)) {
1406         if (!jit_thumb_p() && jit_armv5e_p())
1407             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1408         else {
1409             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1410             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1411         }
1412     }
1413     else {
1414         movr(_R0_REGNO, r0);
1415         movr(_R1_REGNO, r0 + 1);
1416     }
1417     if (jit_fpr_p(r1)) {
1418         if (!jit_thumb_p() && jit_armv5e_p())
1419             LDRDIN(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1420         else {
1421             swf_ldrin(_R2_REGNO, _FP_REGNO, swf_off(r1) + 8);
1422             swf_ldrin(_R3_REGNO, _FP_REGNO, swf_off(r1) + 4);
1423         }
1424     }
1425     else {
1426         movr(_R2_REGNO, r0);
1427         movr(_R3_REGNO, r0 + 1);
1428     }
1429     swf_call_with_get_reg(__aeabi_dcmpeq, dcmpeq);
1430     if (jit_thumb_p()) {
1431         T1_CMPI(_R0_REGNO, 0);
1432         j1 = _jit->pc.w;
1433         if (eq) {
1434             T2_CC_B(ARM_CC_EQ, 0);
1435             patch_at(arm_patch_jump, j0, _jit->pc.w);
1436         }
1437         else
1438             T2_CC_B(ARM_CC_NE, 0);
1439         w = _jit->pc.w;
1440         d = ((i0 - w) >> 1) - 2;
1441         assert(_s24P(d));
1442         T2_B(encode_thumb_jump(d));
1443     }
1444     else {
1445         CMPI(_R0_REGNO, 0);
1446         j1 = _jit->pc.w;
1447         if (eq) {
1448             CC_B(ARM_CC_EQ, 0);
1449             patch_at(arm_patch_jump, j0, _jit->pc.w);
1450         }
1451         else
1452             CC_B(ARM_CC_NE, 0);
1453         w = _jit->pc.w;
1454         d = ((i0 - w) >> 2) - 2;
1455         assert(_s24P(d));
1456         B(d & 0x00ffffff);
1457     }
1458     if (!eq)
1459         patch_at(arm_patch_jump, j0, _jit->pc.w);
1460     patch_at(arm_patch_jump, j1, _jit->pc.w);
1461     jit_unget_reg_args();
1462     return (w);
1463 }
1464
1465 static jit_word_t
1466 _swf_bunff_(jit_state_t *_jit, int eq,
1467             jit_word_t i0, jit_int32_t r0, jit_float32_t i1)
1468 {
1469     union {
1470         jit_int32_t     i;
1471         jit_float32_t   f;
1472     } data;
1473     jit_word_t          w, d, j0, j1;
1474     data.f = i1;
1475     jit_get_reg_args();
1476     if (jit_fpr_p(r0))
1477         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1478     else
1479         movr(_R0_REGNO, r0);
1480     movi(_R1_REGNO, data.i);
1481     swf_call(__aeabi_fcmpun, fcmpun, _R2_REGNO);
1482     /* if unordered */
1483     if (jit_thumb_p()) {
1484         T1_CMPI(_R0_REGNO, 0);
1485         j0 = _jit->pc.w;
1486         T2_CC_B(ARM_CC_NE, 0);
1487     }
1488     else {
1489         CMPI(_R0_REGNO, 0);
1490         j0 = _jit->pc.w;
1491         CC_B(ARM_CC_NE, 0);
1492     }
1493     if (jit_fpr_p(r0))
1494         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1495     else
1496         movr(_R0_REGNO, r0);
1497     movi(_R1_REGNO, data.i);
1498     swf_call(__aeabi_fcmpeq, fcmpeq, _R2_REGNO);
1499     if (jit_thumb_p()) {
1500         T1_CMPI(_R0_REGNO, 0);
1501         j1 = _jit->pc.w;
1502         if (eq) {
1503             T2_CC_B(ARM_CC_EQ, 0);
1504             patch_at(arm_patch_jump, j0, _jit->pc.w);
1505         }
1506         else
1507             T2_CC_B(ARM_CC_NE, 0);
1508         w = _jit->pc.w;
1509         d = ((i0 - w) >> 1) - 2;
1510         assert(_s24P(d));
1511         T2_B(encode_thumb_jump(d));
1512     }
1513     else {
1514         CMPI(_R0_REGNO, 0);
1515         j1 = _jit->pc.w;
1516         if (eq) {
1517             CC_B(ARM_CC_EQ, 0);
1518             patch_at(arm_patch_jump, j0, _jit->pc.w);
1519         }
1520         else
1521             CC_B(ARM_CC_NE, 0);
1522         w = _jit->pc.w;
1523         d = ((i0 - w) >> 2) - 2;
1524         assert(_s24P(d));
1525         B(d & 0x00ffffff);
1526     }
1527     if (!eq)
1528         patch_at(arm_patch_jump, j0, _jit->pc.w);
1529     patch_at(arm_patch_jump, j1, _jit->pc.w);
1530     jit_unget_reg_args();
1531     return (w);
1532 }
1533
1534 static jit_word_t
1535 _swf_bundd_(jit_state_t *_jit, int eq,
1536             jit_word_t i0, jit_int32_t r0, jit_float64_t i1)
1537 {
1538     jit_word_t          w, d, j0, j1;
1539     union {
1540         jit_int32_t     i[2];
1541         jit_float64_t   d;
1542     } data;
1543     jit_get_reg_args();
1544     data.d = i1;
1545     if (jit_fpr_p(r0)) {
1546         if (!jit_thumb_p() && jit_armv5e_p())
1547             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1548         else {
1549             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1550             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1551         }
1552     }
1553     else {
1554         movr(_R0_REGNO, r0);
1555         movr(_R1_REGNO, r0 + 1);
1556     }
1557     movi(_R2_REGNO, data.i[0]);
1558     movi(_R3_REGNO, data.i[1]);
1559     swf_call_with_get_reg(__aeabi_dcmpun, fcmpun);
1560     /* if unordered */
1561     if (jit_thumb_p()) {
1562         T1_CMPI(_R0_REGNO, 0);
1563         j0 = _jit->pc.w;
1564         T2_CC_B(ARM_CC_NE, 0);
1565     }
1566     else {
1567         CMPI(_R0_REGNO, 0);
1568         j0 = _jit->pc.w;
1569         CC_B(ARM_CC_NE, 0);
1570     }
1571     if (jit_fpr_p(r0)) {
1572         if (!jit_thumb_p() && jit_armv5e_p())
1573             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1574         else {
1575             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1576             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1577         }
1578     }
1579     else {
1580         movr(_R0_REGNO, r0);
1581         movr(_R1_REGNO, r0 + 1);
1582     }
1583     movi(_R2_REGNO, data.i[0]);
1584     movi(_R3_REGNO, data.i[1]);
1585     swf_call_with_get_reg(__aeabi_dcmpeq, fcmpeq);
1586     if (jit_thumb_p()) {
1587         T1_CMPI(_R0_REGNO, 0);
1588         j1 = _jit->pc.w;
1589         if (eq) {
1590             T2_CC_B(ARM_CC_EQ, 0);
1591             patch_at(arm_patch_jump, j0, _jit->pc.w);
1592         }
1593         else
1594             T2_CC_B(ARM_CC_NE, 0);
1595         w = _jit->pc.w;
1596         d = ((i0 - w) >> 1) - 2;
1597         assert(_s24P(d));
1598         T2_B(encode_thumb_jump(d));
1599     }
1600     else {
1601         CMPI(_R0_REGNO, 0);
1602         j1 = _jit->pc.w;
1603         if (eq) {
1604             CC_B(ARM_CC_EQ, 0);
1605             patch_at(arm_patch_jump, j0, _jit->pc.w);
1606         }
1607         else
1608             CC_B(ARM_CC_NE, 0);
1609         w = _jit->pc.w;
1610         d = ((i0 - w) >> 2) - 2;
1611         assert(_s24P(d));
1612         B(d & 0x00ffffff);
1613     }
1614     if (!eq)
1615         patch_at(arm_patch_jump, j0, _jit->pc.w);
1616     patch_at(arm_patch_jump, j1, _jit->pc.w);
1617     jit_unget_reg_args();
1618     return (w);
1619 }
1620
1621 static void
1622 _swf_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1623 {
1624     jit_get_reg_args();
1625     movr(_R0_REGNO, r1);
1626     swf_call(__aeabi_i2f, i2f, _R1_REGNO);
1627     if (jit_fpr_p(r0))
1628         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1629     else
1630         movr(r0, _R0_REGNO);
1631     jit_unget_reg_args();
1632 }
1633
1634 static void
1635 _swf_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1636 {
1637     jit_get_reg_args();
1638     movr(_R0_REGNO, r1);
1639     swf_call(__aeabi_i2d, i2d, _R2_REGNO);
1640     if (jit_fpr_p(r0)) {
1641         if (!jit_thumb_p() && jit_armv5e_p())
1642             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1643         else {
1644             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1645             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1646         }
1647     }
1648     else {
1649         movr(r0, _R0_REGNO);
1650         movr(r0 + 1, _R1_REGNO);
1651     }
1652     jit_unget_reg_args();
1653 }
1654
1655 static void
1656 _swf_extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1657 {
1658     jit_get_reg_args();
1659     if (jit_fpr_p(r1)) {
1660         if (!jit_thumb_p() && jit_armv5e_p())
1661             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1662         else {
1663             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1664             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1665         }
1666     }
1667     else {
1668         movr(_R0_REGNO, r1);
1669         movr(_R1_REGNO, r1 + 1);
1670     }
1671     swf_call(__aeabi_d2f, d2f, _R2_REGNO);
1672     if (jit_fpr_p(r0))
1673         swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1674     else
1675         movr(r0, _R0_REGNO);
1676     jit_unget_reg_args();
1677 }
1678
1679 static void
1680 _swf_extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1681 {
1682     jit_get_reg_args();
1683     if (jit_fpr_p(r1))
1684         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1685     else
1686         movr(_R0_REGNO, r1);
1687     swf_call(__aeabi_f2d, f2d, _R1_REGNO);
1688     if (jit_fpr_p(r0)) {
1689         if (!jit_thumb_p() && jit_armv5e_p())
1690             STRDIN(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1691         else {
1692             swf_strin(_R0_REGNO, _FP_REGNO, swf_off(r0) + 8);
1693             swf_strin(_R1_REGNO, _FP_REGNO, swf_off(r0) + 4);
1694         }
1695     }
1696     else {
1697         movr(r0, _R0_REGNO);
1698         movr(r0 + 1, _R1_REGNO);
1699     }
1700     jit_unget_reg_args();
1701 }
1702
1703 static void
1704 _swf_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1705 {
1706 #if !NAN_TO_INT_IS_ZERO
1707     jit_word_t          is_nan;
1708     jit_word_t          fast_not_nan;
1709     jit_word_t          slow_not_nan;
1710 #endif
1711     jit_get_reg_args();
1712     if (jit_fpr_p(r1))
1713         swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1714     else
1715         movr(_R0_REGNO, r1);
1716 #if !NAN_TO_INT_IS_ZERO
1717     /* >> based on fragment of __aeabi_fcmpun */
1718     lshi(_R2_REGNO, _R0_REGNO, 1);
1719     if (jit_thumb_p())
1720         torrrs(THUMB2_MVN|ARM_S, _R0_REGNO, _R3_REGNO, _R2_REGNO,
1721                encode_thumb_shift(24, ARM_ASR));
1722     else
1723         corrrs(ARM_CC_AL, ARM_MVN|ARM_S|ARM_ASR,
1724                _R0_REGNO, _R3_REGNO, _R2_REGNO, 24);
1725     fast_not_nan = _jit->pc.w;
1726     if (jit_thumb_p()) {
1727         T2_CC_B(ARM_CC_NE, 0);
1728         tshift(THUMB2_LSLI|ARM_S, _R0_REGNO, _R3_REGNO, 9);
1729     }
1730     else {
1731         CC_B(ARM_CC_NE, 0);
1732         cshift(ARM_CC_AL, ARM_S|ARM_LSL, _R0_REGNO, _R3_REGNO, _R0_REGNO, 9);
1733     }
1734     slow_not_nan = _jit->pc.w;
1735     if (jit_thumb_p())
1736         T2_CC_B(ARM_CC_EQ, 0);
1737     else
1738         CC_B(ARM_CC_EQ, 0);
1739     movi(r0, 0x80000000);
1740     is_nan = _jit->pc.w;
1741     if (jit_thumb_p())
1742         T2_B(0);
1743     else
1744         B(0);
1745     patch_at(arm_patch_jump, fast_not_nan, _jit->pc.w);
1746     patch_at(arm_patch_jump, slow_not_nan, _jit->pc.w);
1747     /* << based on fragment of __aeabi_fcmpun */
1748 #endif
1749     swf_call(__aeabi_f2iz, f2iz, _R2_REGNO);
1750     movr(r0, _R0_REGNO);
1751 #if !NAN_TO_INT_IS_ZERO
1752     patch_at(arm_patch_jump, is_nan, _jit->pc.w);
1753 #endif
1754     jit_unget_reg_args();
1755 }
1756
1757 static void
1758 _swf_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1759 {
1760 #if !NAN_TO_INT_IS_ZERO
1761     jit_word_t          is_nan;
1762     jit_word_t          fast_not_nan;
1763     jit_word_t          slow_not_nan;
1764 #endif
1765     jit_get_reg_args();
1766     if (jit_fpr_p(r1)) {
1767         if (!jit_thumb_p() && jit_armv5e_p())
1768             LDRDIN(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1769         else {
1770             swf_ldrin(_R0_REGNO, _FP_REGNO, swf_off(r1) + 8);
1771             swf_ldrin(_R1_REGNO, _FP_REGNO, swf_off(r1) + 4);
1772         }
1773     }
1774     else {
1775         movr(_R0_REGNO, r1);
1776         movr(_R1_REGNO, r1 + 1);
1777     }
1778 #if !NAN_TO_INT_IS_ZERO
1779     /* >> based on fragment of __aeabi_dcmpun */
1780     lshi(_R3_REGNO, _R1_REGNO, 1);
1781     if (jit_thumb_p())
1782         torrrs(THUMB2_MVN|ARM_S, _R0_REGNO, _R3_REGNO, _R3_REGNO,
1783                encode_thumb_shift(21, ARM_ASR));
1784     else
1785         corrrs(ARM_CC_AL, ARM_MVN|ARM_S|ARM_ASR,
1786                _R0_REGNO, _R3_REGNO, _R3_REGNO, 21);
1787     fast_not_nan = _jit->pc.w;
1788     if (jit_thumb_p()) {
1789         T2_CC_B(ARM_CC_NE, 0);
1790         torrrs(THUMB2_ORR|ARM_S, _R0_REGNO, _R3_REGNO, _R1_REGNO,
1791                encode_thumb_shift(12, ARM_LSL));
1792     }
1793     else {
1794         CC_B(ARM_CC_NE, 0);
1795         corrrs(ARM_CC_AL, ARM_ORR|ARM_S|ARM_LSL,
1796                _R0_REGNO, _R3_REGNO, _R1_REGNO, 12);
1797     }
1798     slow_not_nan = _jit->pc.w;
1799     if (jit_thumb_p())
1800         T2_CC_B(ARM_CC_EQ, 0);
1801     else
1802         CC_B(ARM_CC_EQ, 0);
1803     movi(r0, 0x80000000);
1804     is_nan = _jit->pc.w;
1805     if (jit_thumb_p())
1806         T2_B(0);
1807     else
1808         B(0);
1809     patch_at(arm_patch_jump, fast_not_nan, _jit->pc.w);
1810     patch_at(arm_patch_jump, slow_not_nan, _jit->pc.w);
1811     /* << based on fragment of __aeabi_dcmpun */
1812 #endif
1813     swf_call(__aeabi_d2iz, d2iz, _R3_REGNO);
1814     movr(r0, _R0_REGNO);
1815 #if !NAN_TO_INT_IS_ZERO
1816     patch_at(arm_patch_jump, is_nan, _jit->pc.w);
1817 #endif
1818     jit_unget_reg_args();
1819 }
1820
1821 static void
1822 _swf_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1823 {
1824     jit_int32_t         reg;
1825     if (r0 != r1) {
1826         if (jit_fpr_p(r1)) {
1827             reg = jit_get_reg(jit_class_gpr);
1828             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1829             if (jit_fpr_p(r0))
1830                 swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1831             else
1832                 movr(r0, rn(reg));
1833             jit_unget_reg(reg);
1834         }
1835         else if (jit_fpr_p(r0))
1836             swf_strin(r1, _FP_REGNO, swf_off(r0) + 8);
1837         else
1838             movr(r0, r1);
1839     }
1840 }
1841
1842 static void
1843 _swf_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1844 {
1845     jit_int32_t         reg;
1846     if (r0 != r1) {
1847         if (jit_fpr_p(r1)) {
1848             if (!jit_thumb_p() && jit_armv5e_p() &&
1849                 (reg = jit_get_reg_pair()) != JIT_NOREG) {
1850                 LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1851                 if (jit_fpr_p(r0))
1852                     STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1853                 else {
1854                     movr(r0, rn(reg));
1855                     movr(r0 + 1, rn(reg) + 1);
1856                 }
1857                 jit_unget_reg_pair(reg);
1858             }
1859             else {
1860                 reg = jit_get_reg(jit_class_gpr);
1861                 swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1862                 if (jit_fpr_p(r0))
1863                     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1864                 else
1865                     movr(r0, rn(reg));
1866                 swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
1867                 if (jit_fpr_p(r0))
1868                     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
1869                 else
1870                     movr(r0 + 1, rn(reg));
1871                 jit_unget_reg(reg);
1872             }
1873         }
1874         else if (jit_fpr_p(r0)) {
1875             if (!jit_thumb_p() && jit_armv5e_p() && !(r1 & 1))
1876                 STRDIN(r1, _FP_REGNO, swf_off(r0) + 8);
1877             else {
1878                 swf_strin(r1, _FP_REGNO, swf_off(r0) + 8);
1879                 swf_strin(r1 + 1, _FP_REGNO, swf_off(r0) + 4);
1880             }
1881         }
1882         else {
1883             movr(r0, r1);
1884             movr(r0 + 1, r1 + 1);
1885         }
1886     }
1887 }
1888
1889 static void
1890 _swf_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
1891 {
1892     union {
1893         jit_int32_t     i;
1894         jit_float32_t   f;
1895     } data;
1896     jit_int32_t         reg;
1897     data.f = i0;
1898     if (jit_fpr_p(r0)) {
1899         reg = jit_get_reg(jit_class_gpr);
1900         movi(rn(reg), data.i);
1901         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1902         jit_unget_reg(reg);
1903     }
1904     else
1905         movi(r0, data.i);
1906 }
1907
1908 static void
1909 _swf_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
1910 {
1911     jit_int32_t         reg;
1912     union {
1913         jit_int32_t     i[2];
1914         jit_float64_t   d;
1915     } data;
1916     data.d = i0;
1917     if (jit_fpr_p(r0)) {
1918         if (!jit_thumb_p() && jit_armv5e_p() &&
1919             (reg = jit_get_reg_pair()) != JIT_NOREG) {
1920             movi(rn(reg), data.i[0]);
1921             movi(rn(reg) + 1, data.i[1]);
1922             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1923             jit_unget_reg_pair(reg);
1924         }
1925         else {
1926             reg = jit_get_reg(jit_class_gpr);
1927             movi(rn(reg), data.i[0]);
1928             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1929             movi(rn(reg), data.i[1]);
1930             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
1931             jit_unget_reg(reg);
1932         }
1933     }
1934     else {
1935         movi(r0, data.i[0]);
1936         movi(r0 + 1, data.i[1]);
1937     }
1938 }
1939
1940 static void
1941 _swf_absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1942 {
1943     jit_int32_t         reg;
1944     if (jit_fpr_p(r1)) {
1945         reg = jit_get_reg(jit_class_gpr);
1946         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1947         swf_bici(rn(reg), rn(reg), 0x80000000);
1948         if (jit_fpr_p(r0))
1949             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1950         else
1951             movr(r0, rn(reg));
1952         jit_unget_reg(reg);
1953     }
1954     else if (jit_fpr_p(r0)) {
1955         reg = jit_get_reg(jit_class_gpr);
1956         movr(rn(reg), r1);
1957         swf_bici(rn(reg), rn(reg), 0x80000000);
1958         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1959         jit_unget_reg(reg);
1960     }
1961     else
1962         swf_bici(r0, r1, 0x80000000);
1963 }
1964
1965 static void
1966 _swf_absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1967 {
1968     jit_int32_t         reg;
1969     if (jit_fpr_p(r1)) {
1970         if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
1971             r0 != r1 && (reg = jit_get_reg_pair()) != JIT_NOREG) {
1972             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1973             swf_bici(rn(reg) + 1, rn(reg) + 1, 0x80000000);
1974             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1975             jit_unget_reg_pair(reg);
1976         }
1977         else {
1978             reg = jit_get_reg(jit_class_gpr);
1979             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
1980             swf_bici(rn(reg), rn(reg), 0x80000000);
1981             if (jit_fpr_p(r0)) {
1982                 swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
1983                 if (r0 != r1) {
1984                     swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1985                     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
1986                 }
1987             }
1988             else {
1989                 movr(r0, rn(reg));
1990                 swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
1991                 movr(r0 + 1, rn(reg));
1992             }
1993             jit_unget_reg(reg);
1994         }
1995     }
1996     else if (jit_fpr_p(r0)) {
1997         reg = jit_get_reg(jit_class_gpr);
1998         movr(rn(reg), r1);
1999         swf_bici(rn(reg), rn(reg), 0x80000000);
2000         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2001         movr(rn(reg), r1 + 1);
2002         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2003         jit_unget_reg(reg);
2004     }
2005     else {
2006         swf_bici(r0, r1, 0x80000000);
2007         if (r0 != r1)
2008             movr(r0 + 1, r1 + 1);
2009     }
2010 }
2011
2012 static void
2013 _swf_negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2014 {
2015     jit_int32_t         reg;
2016     if (jit_fpr_p(r1)) {
2017         reg = jit_get_reg(jit_class_gpr);
2018         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2019         xori(rn(reg), rn(reg), 0x80000000);
2020         if (jit_fpr_p(r0))
2021             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2022         else
2023             movr(r0, rn(reg));
2024         jit_unget_reg(reg);
2025     }
2026     else if (jit_fpr_p(r0)) {
2027         reg = jit_get_reg(jit_class_gpr);
2028         movr(rn(reg), r1);
2029         xori(rn(reg), rn(reg), 0x80000000);
2030         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2031         jit_unget_reg(reg);
2032     }
2033     else
2034         xori(r0, r1, 0x80000000);
2035 }
2036
2037 static void
2038 _swf_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2039 {
2040     jit_int32_t         reg;
2041     if (jit_fpr_p(r1)) {
2042         if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
2043             r0 != r1 && (reg = jit_get_reg_pair()) != JIT_NOREG) {
2044             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2045             EORI(rn(reg) + 1, rn(reg) + 1, encode_arm_immediate(0x80000000));
2046             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2047             jit_unget_reg_pair(reg);
2048         }
2049         else {
2050             reg = jit_get_reg(jit_class_gpr);
2051             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
2052             xori(rn(reg), rn(reg), 0x80000000);
2053             if (jit_fpr_p(r0)) {
2054                 swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2055                 if (r0 != r1) {
2056                     swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2057                     swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2058                 }
2059             }
2060             else {
2061                 movr(r0, rn(reg));
2062                 swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2063                 movr(r0 + 1, rn(reg));
2064             }
2065             jit_unget_reg(reg);
2066         }
2067     }
2068     else if (jit_fpr_p(r0)) {
2069         reg = jit_get_reg(jit_class_gpr);
2070         movr(rn(reg), r1);
2071         xori(rn(reg), rn(reg), 0x80000000);
2072         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2073         movr(rn(reg), r1 + 1);
2074         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2075         jit_unget_reg(reg);
2076     }
2077     else {
2078         xori(r0, r1, 0x80000000);
2079         if (r0 != r1)
2080             movr(r0 + 1, r1 + 1);
2081     }
2082 }
2083
2084 static void
2085 _swf_ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2086 {
2087     swf_iff(__aeabi_fcmpeq, r0, r1, r2);
2088     xori(r0, r0, 1);
2089 }
2090
2091 static void
2092 _swf_nei_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
2093 {
2094     swf_iff_(__aeabi_fcmpeq, r0, r1, i0);
2095     xori(r0, r0, 1);
2096 }
2097
2098 static void
2099 _swf_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2100 {
2101     swf_idd(__aeabi_dcmpeq, r0, r1, r2);
2102     xori(r0, r0, 1);
2103 }
2104
2105 static void
2106 _swf_nei_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
2107 {
2108     swf_idd_(__aeabi_dcmpeq, r0, r1, i0);
2109     xori(r0, r0, 1);
2110 }
2111
2112 static void
2113 _swf_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2114 {
2115     swf_iunff(__aeabi_fcmpeq, r0, r1, r2);
2116     xori(r0, r0, 1);
2117 }
2118
2119 static void
2120 _swf_ltgti_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
2121 {
2122     swf_iunff_(__aeabi_fcmpeq, r0, r1, i0);
2123     xori(r0, r0, 1);
2124 }
2125
2126 static void
2127 _swf_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2128 {
2129     swf_iundd(__aeabi_dcmpeq, r0, r1, r2);
2130     xori(r0, r0, 1);
2131 }
2132
2133 static void
2134 _swf_ltgti_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
2135 {
2136     swf_iundd_(__aeabi_dcmpeq, r0, r1, i0);
2137     xori(r0, r0, 1);
2138 }
2139
2140 static void
2141 _swf_ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2142 {
2143     swf_iff(__aeabi_fcmpun, r0, r1, r2);
2144     xori(r0, r0, 1);
2145 }
2146
2147 static void
2148 _swf_ordi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
2149 {
2150     swf_iff_(__aeabi_fcmpun, r0, r1, i0);
2151     xori(r0, r0, 1);
2152 }
2153
2154 static void
2155 _swf_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2156 {
2157     swf_idd(__aeabi_dcmpun, r0, r1, r2);
2158     xori(r0, r0, 1);
2159 }
2160
2161 static void
2162 _swf_ordi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
2163 {
2164     swf_idd_(__aeabi_dcmpun, r0, r1, i0);
2165     xori(r0, r0, 1);
2166 }
2167
2168 static void
2169 _swf_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2170 {
2171     jit_int32_t         reg;
2172     if (jit_fpr_p(r0)) {
2173         reg = jit_get_reg(jit_class_gpr);
2174         ldxi_i(rn(reg), r1, 0);
2175         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2176         jit_unget_reg(reg);
2177     }
2178     else
2179         ldxi_i(r0, r1, 0);
2180 }
2181
2182 static void
2183 _swf_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2184 {
2185     jit_int32_t         reg;
2186     if (jit_fpr_p(r0)) {
2187         if (!jit_thumb_p() && jit_armv5e_p() &&
2188             (reg = jit_get_reg_pair()) != JIT_NOREG) {
2189             LDRDI(rn(reg), r1, 0);
2190             STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2191             jit_unget_reg_pair(reg);
2192         }
2193         else {
2194             reg = jit_get_reg(jit_class_gpr);
2195             ldxi_i(rn(reg), r1, 0);
2196             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2197             ldxi_i(rn(reg), r1, 4);
2198             swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4);
2199             jit_unget_reg(reg);
2200         }
2201     }
2202     else if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2203         LDRDI(r0, r1, 0);
2204     else {
2205         ldxi_i(r0, r1, 0);
2206         ldxi_i(r0 + 1, r1, 4);
2207     }
2208 }
2209
2210 static void
2211 _swf_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2212 {
2213     jit_int32_t         reg;
2214     if (jit_fpr_p(r0)) {
2215         reg = jit_get_reg(jit_class_gpr);
2216         ldi_i(rn(reg), i0);
2217         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2218         jit_unget_reg(reg);
2219     }
2220     else
2221         ldi_i(r0, i0);
2222 }
2223
2224 static void
2225 _swf_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2226 {
2227     jit_int32_t         rg0, rg1;
2228     if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
2229         (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2230         movi(rn(rg0), i0);
2231         LDRDI(rn(rg0), rn(rg0), 0);
2232         STRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2233         jit_unget_reg_pair(rg0);
2234     }
2235     else {
2236         rg1 = jit_get_reg(jit_class_gpr);
2237         movi(rn(rg1), i0);
2238         if (jit_fpr_p(r0)) {
2239             rg0 = jit_get_reg(jit_class_gpr);
2240             ldxi_i(rn(rg0), rn(rg1), 0);
2241             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2242             ldxi_i(rn(rg0), rn(rg1), 4);
2243             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2244             jit_unget_reg(rg0);
2245         }
2246         else if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2247             LDRDI(r0, rn(rg1), 0);
2248         else {
2249             ldxi_i(r0, rn(rg1), 0);
2250             ldxi_i(r0 + 1, rn(rg1), 0);
2251         }
2252         jit_unget_reg(rg1);
2253     }
2254 }
2255
2256 static void
2257 _swf_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2258 {
2259     jit_int32_t         reg;
2260     if (jit_fpr_p(r0)) {
2261         reg = jit_get_reg(jit_class_gpr);
2262         ldxr_i(rn(reg), r1, r2);
2263         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2264         jit_unget_reg(reg);
2265     }
2266     else
2267         ldxr_i(r0, r1, r2);
2268 }
2269
2270 static void
2271 _swf_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2272 {
2273     jit_int32_t         rg0, rg1;
2274     if (jit_fpr_p(r0)) {
2275         if (!jit_thumb_p() && jit_armv5e_p() &&
2276             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2277             LDRD(rn(rg0), r1, r2);
2278             STRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2279             jit_unget_reg_pair(rg0);
2280         }
2281         else {
2282             rg1 = jit_get_reg(jit_class_gpr);
2283             addr(rn(rg1), r1, r2);
2284             rg0 = jit_get_reg(jit_class_gpr);
2285             ldxi_i(rn(rg0), rn(rg1), 0);
2286             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2287             ldxi_i(rn(rg0), rn(rg1), 4);
2288             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2289             jit_unget_reg(rg0);
2290             jit_unget_reg(rg1);
2291         }
2292     }
2293     else {
2294         if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2295             LDRD(r0, r1, r2);
2296         else {
2297             rg1 = jit_get_reg(jit_class_gpr);
2298             addr(rn(rg1), r1, r2);
2299             ldxi_i(r0, rn(rg1), 0);
2300             ldxi_i(r0 + 1, rn(rg1), 4);
2301             jit_unget_reg(rg1);
2302         }
2303     }
2304 }
2305
2306 static void
2307 _swf_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2308 {
2309     jit_int32_t         reg;
2310     if (jit_fpr_p(r0)) {
2311         reg = jit_get_reg(jit_class_gpr);
2312         ldxi_i(rn(reg), r1, i0);
2313         swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2314         jit_unget_reg(reg);
2315     }
2316     else
2317         ldxi_i(r0, r1, i0);
2318 }
2319
2320 static void
2321 _swf_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2322 {
2323     jit_int32_t         rg0, rg1;
2324     if (jit_fpr_p(r0)) {
2325         if (!jit_thumb_p() && jit_armv5e_p() &&
2326             ((i0 >= 0 && i0 <= 255) || (i0 < 0 && i0 >= -255)) &&
2327             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2328             if (i0 >= 0)
2329                 LDRDI(rn(rg0), r1, i0);
2330             else
2331                 LDRDIN(rn(rg0), r1, -i0);
2332             STRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2333             jit_unget_reg_pair(rg0);
2334         }
2335         else if (i0 >= 0 && i0 + 4 <= 4095) {
2336             rg0 = jit_get_reg(jit_class_gpr);
2337             ldxi_i(rn(rg0), r1, i0);
2338             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2339             ldxi_i(rn(rg0), r1, i0 + 4);
2340             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2341             jit_unget_reg(rg0);
2342         }
2343         else if (i0 < 0 && ((jit_thumb_p() && i0 >= -255) ||
2344                             (!jit_thumb_p() && i0 >= -4095))) {
2345             rg0 = jit_get_reg(jit_class_gpr);
2346             swf_ldrin(rn(rg0), r1, -i0);
2347             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2348             swf_ldrin(rn(rg0), r1, -(i0 + 4));
2349             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2350             jit_unget_reg(rg0);
2351         }
2352         else {
2353             rg0 = jit_get_reg(jit_class_gpr);
2354             rg1 = jit_get_reg(jit_class_gpr);
2355             addi(rn(rg1), r1, i0);
2356             ldxi_i(rn(rg0), rn(rg1), 0);
2357             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2358             ldxi_i(rn(rg0), rn(rg1), 4);
2359             swf_strin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2360             jit_unget_reg(rg1);
2361             jit_unget_reg(rg0);
2362         }
2363     }
2364     else {
2365         if (!jit_thumb_p() && jit_armv5e_p() &&
2366             i0 >= 0 && i0 <= 255 && !(r0 & 1))
2367             LDRDI(r0, r1, i0);
2368         else if (!jit_thumb_p() && jit_armv5e_p() &&
2369                  i0 < 0 && i0 >= -255 && !(r0 & 1))
2370             LDRDIN(r0, r1, -i0);
2371         else if (i0 >= 0 && i0 + 4 <= 4095) {
2372             ldxi_i(r0, r1, i0);
2373             ldxi_i(r0 + 1, r1, i0 + 4);
2374         }
2375         else if (i0 < 0 && i0 >= -4095) {
2376             swf_ldrin(r0, r1, -i0);
2377             swf_ldrin(r0 + 1, r1, -(i0 + 4));
2378         }
2379         else {
2380             rg0 = jit_get_reg(jit_class_gpr);
2381             addi(rn(rg0), r1, i0);
2382             ldxi_i(r0, rn(rg0), 0);
2383             ldxi_i(r0 + 1, rn(rg0), 4);
2384             jit_unget_reg(rg0);
2385         }
2386     }
2387 }
2388
2389 static void
2390 _swf_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2391 {
2392     jit_int32_t         reg;
2393     if (jit_fpr_p(r1)) {
2394         reg = jit_get_reg(jit_class_gpr);
2395         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2396         stxi_i(0, r0, rn(reg));
2397         jit_unget_reg(reg);
2398     }
2399     else
2400         str_i(r0, r1);
2401 }
2402
2403 static void
2404 _swf_str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2405 {
2406     jit_int32_t         reg;
2407     if (jit_fpr_p(r1)) {
2408         if (!jit_thumb_p() && jit_armv5e_p() &&
2409             (reg = jit_get_reg_pair()) != JIT_NOREG) {
2410             LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2411             STRDI(rn(reg), r0, 0);
2412             jit_unget_reg_pair(reg);
2413         }
2414         else {
2415             reg = jit_get_reg(jit_class_gpr);
2416             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2417             stxi_i(0, r0, rn(reg));
2418             swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4);
2419             stxi_i(4, r0, rn(reg));
2420             jit_unget_reg(reg);
2421         }
2422     }
2423     else {
2424         if (!jit_thumb_p() && jit_armv5e_p() && !(r1 & 1))
2425             STRDI(r1, r0, 0);
2426         else {
2427             stxi_i(0, r0, r1);
2428             stxi_i(4, r0, r1 + 1);
2429         }
2430     }
2431 }
2432
2433 static void
2434 _swf_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2435 {
2436     jit_int32_t         reg;
2437     if (jit_fpr_p(r0)) {
2438         reg = jit_get_reg(jit_class_gpr);
2439         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
2440         sti_i(i0, rn(reg));
2441         jit_unget_reg(reg);
2442     }
2443     else
2444         sti_i(i0, r0);
2445 }
2446
2447 static void
2448 _swf_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2449 {
2450     jit_int32_t         rg0, rg1;
2451     if (jit_fpr_p(r0)) {
2452         if (!jit_thumb_p() && jit_armv5e_p() &&
2453             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2454             rg1 = jit_get_reg(jit_class_gpr);
2455             movi(rn(rg1), i0);
2456             LDRDIN(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2457             STRDI(rn(rg0), rn(rg1), 0);
2458             jit_unget_reg(rg1);
2459             jit_unget_reg_pair(rg0);
2460         }
2461         else {
2462             rg1 = jit_get_reg(jit_class_gpr);
2463             movi(rn(rg1), i0);
2464             rg0 = jit_get_reg(jit_class_gpr);
2465             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r0) + 8);
2466             stxi_i(0, rn(rg1), rn(rg0));
2467             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r0) + 4);
2468             stxi_i(4, rn(rg1), rn(rg0));
2469             jit_unget_reg(rg1);
2470             jit_unget_reg(rg0);
2471         }
2472     }
2473     else {
2474         rg1 = jit_get_reg(jit_class_gpr);
2475         movi(rn(rg1), i0);
2476         if (!jit_thumb_p() && jit_armv5e_p() && !(r0 & 1))
2477             STRDI(r0, rn(rg1), 0);
2478         else {
2479             stxi_i(0, rn(rg1), r0);
2480             stxi_i(4, rn(rg1), r0 + 1);
2481         }
2482         jit_unget_reg(rg1);
2483     }
2484 }
2485
2486 static void
2487 _swf_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2488 {
2489     jit_int32_t         reg;
2490     if (jit_fpr_p(r2)) {
2491         reg = jit_get_reg(jit_class_gpr);
2492         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r2) + 8);
2493         stxr_i(r1, r0, rn(reg));
2494         jit_unget_reg(reg);
2495     }
2496     else
2497         stxr_i(r0, r1, r2);
2498 }
2499
2500 static void
2501 _swf_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2502 {
2503     jit_int32_t         rg0, rg1;
2504     if (jit_fpr_p(r2)) {
2505         if (!jit_thumb_p() && jit_armv5e_p() &&
2506             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2507             LDRDIN(rn(rg0), _FP_REGNO, swf_off(r2) + 8);
2508             STRD(rn(rg0), r0, r1);
2509             jit_unget_reg_pair(rg0);
2510         }
2511         else {
2512             rg1 = jit_get_reg(jit_class_gpr);
2513             addr(rn(rg1), r0, r1);
2514             rg0 = jit_get_reg(jit_class_gpr);
2515             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r2) + 8);
2516             stxi_i(0, rn(rg1), rn(rg0));
2517             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r2) + 4);
2518             stxi_i(4, rn(rg1), rn(rg0));
2519             jit_unget_reg(rg0);
2520             jit_unget_reg(rg1);
2521         }
2522     }
2523     else {
2524         if (!jit_thumb_p() && jit_armv5e_p() && !(r2 & 1))
2525             STRD(r0, r1, r2);
2526         else {
2527             rg1 = jit_get_reg(jit_class_gpr);
2528             addr(rn(rg1), r0, r1);
2529             stxi_i(0, rn(rg1), r2);
2530             stxi_i(4, rn(rg1), r2 + 1);
2531             jit_unget_reg(rg1);
2532         }
2533     }
2534 }
2535
2536 static void
2537 _swf_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2538 {
2539     jit_int32_t         reg;
2540     if (jit_fpr_p(r1)) {
2541         reg = jit_get_reg(jit_class_gpr);
2542         swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
2543         stxi_i(i0, r0, rn(reg));
2544         jit_unget_reg(reg);
2545     }
2546     else
2547         stxi_i(i0, r0, r1);
2548 }
2549
2550 static void
2551 _swf_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2552 {
2553     jit_int32_t         rg0, rg1;
2554     if (jit_fpr_p(r1)) {
2555         if (!jit_thumb_p() && jit_armv5e_p() &&
2556             ((i0 >= 0 && i0 <= 255) || (i0 < 0 && i0 >= -255)) &&
2557             (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
2558             LDRDIN(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2559             if (i0 >= 0 && i0 <= 255)
2560                 STRDI(rn(rg0), r0, i0);
2561             else
2562                 STRDIN(rn(rg0), r0, -i0);
2563             jit_unget_reg_pair(rg0);
2564         }
2565         else if (i0 >= 0 && i0 + 4 <= 4095) {
2566             rg0 = jit_get_reg(jit_class_gpr);
2567             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2568             stxi_i(i0, r0, rn(rg0));
2569             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 4);
2570             stxi_i(i0 + 4, r0, rn(rg0));
2571             jit_unget_reg(rg0);
2572         }
2573         else if (i0 < 0 && ((jit_thumb_p() && i0 >= -255) ||
2574                             (!jit_thumb_p() && i0 >= -4095))) {
2575             rg0 = jit_get_reg(jit_class_gpr);
2576             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2577             swf_strin(rn(rg0), r0, -i0);
2578             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 4);
2579             swf_strin(rn(rg0), r0, -(i0 + 4));
2580             jit_unget_reg(rg0);
2581         }
2582         else {
2583             rg1 = jit_get_reg(jit_class_gpr);
2584             addi(rn(rg1), r0, i0);
2585             rg0 = jit_get_reg(jit_class_gpr);
2586             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 8);
2587             stxi_i(0, rn(rg1), rn(rg0));
2588             swf_ldrin(rn(rg0), _FP_REGNO, swf_off(r1) + 4);
2589             stxi_i(4, rn(rg1), rn(rg0));
2590             jit_unget_reg(rg0);
2591             jit_unget_reg(rg1);
2592         }
2593     }
2594     else {
2595         if (!jit_thumb_p() && jit_armv5e_p() &&
2596             i0 >= 0 && i0 <= 255 && !(r1 & 1))
2597             STRDI(r1, r0, i0);
2598         else if (!jit_thumb_p() && jit_armv5e_p() &&
2599                  i0 < 0 && i0 >= -255 && !(r1 & 1))
2600             STRDIN(r1, r0, -i0);
2601         else if (i0 >= 0 && i0 + 4 <= 4095) {
2602             stxi_i(i0, r0, r1);
2603             stxi_i(i0 + 4, r0, r1 + 1);
2604         }
2605         else if (i0 < 0 && ((jit_thumb_p() && i0 >= 255) ||
2606                             (!jit_thumb_p() && i0 >= -4095))) {
2607             swf_strin(r1, r0, -i0);
2608             swf_strin(r1 + 1, r0, -(i0 + 4));
2609         }
2610         else {
2611             rg1 = jit_get_reg(jit_class_gpr);
2612             addi(rn(rg1), r0, i0);
2613             stxi_i(0, rn(rg1), r1);
2614             stxi_i(4, rn(rg1), r1 + 1);
2615             jit_unget_reg(rg1);
2616         }
2617     }
2618 }
2619
2620 static void
2621 _swf_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2622 {
2623     jit_int32_t         reg;
2624
2625     assert(_jitc->function->self.call & jit_call_varargs);
2626
2627     /* Adjust pointer. */
2628     reg = jit_get_reg(jit_class_gpr);
2629     andi(rn(reg), r1, 7);
2630     addr(r1, r1, rn(reg));
2631     jit_unget_reg(reg);
2632
2633     /* Load argument. */
2634     swf_ldr_d(r0, r1);
2635
2636     /* Update stack pointer. */
2637     addi(r1, r1, sizeof(jit_float64_t));
2638 }
2639
2640 #endif