deps/lightning/lib/jit_riscv-fpu.c

   1 /*
   2  * Copyright (C) 2019  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 /*
  22  * RV32F Standard Extension
  23  */
  24 #  define FLW(rd, rs1, im)              Itype(7, rd, 2, rs1, im)
  25 #  define FSW(rs1, rs2, imm)            Stype(39, 2, rs1, rs2, imm)
  26 #  define FMADD_S(rd, rs1, rs2, rs3)    R4type(67, rd, 0, rs1, rs2, 0, rs3)
  27 #  define FMSUB_S(rd, rs1, rs2, rs3)    R4type(71, rd, 0, rs1, rs2, 0, rs3)
  28 #  define FNMSUB_S(rd, rs1, rs2, rs3)   R4type(75, rd, 0, rs1, rs2, 0, rs3)
  29 #  define FNMADD_S(rd, rs1, rs2, rs3)   R4type(79, rd, 0, rs1, rs2, 0, rs3)
  30 #  define FADD_S(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 0)
  31 #  define FSUB_S(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 4)
  32 #  define FMUL_S(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 8)
  33 #  define FDIV_S(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 12)
  34 #  define FSQRT_S(rd, rs1)              Rtype(83, rd, 0, rs1, 0, 44)
  35 #  define FSGNJ_S(rd, rs1, rs2)         Rtype(83, rd, 0, rs1, rs2, 16)
  36 #  define FSGNJN_S(rd, rs1, rs2)        Rtype(83, rd, 1, rs1, rs2, 16)
  37 #  define FSGNJX_S(rd, rs1, rs2)        Rtype(83, rd, 2, rs1, rs2, 16)
  38 #  define FMIN_S(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 20)
  39 #  define FMAX_S(rd, rs1, rs2)          Rtype(83, rd, 1, rs1, rs2, 20)
  40 #  define FCVT_W_S(rd, rs1)             Rtype(83, rd, 0, rs1, 0, 96)
  41 #  define FCVT_WU_S(rd, rs1)            Rtype(83, rd, 1, rs1, 1, 96)
  42 #  define FMV_X_W(rd, rs1)              Rtype(83, rd, 0, rs1, 0, 112)
  43 #  define FEQ_S(rd, rs1, rs2)           Rtype(83, rd, 2, rs1, rs2, 80)
  44 #  define FLT_S(rd, rs1, rs2)           Rtype(83, rd, 1, rs1, rs2, 80)
  45 #  define FLE_S(rd, rs1, rs2)           Rtype(83, rd, 0, rs1, rs2, 80)
  46 #  define FCLASS_S(rd, rs1)             Rtype(83, rd, 1, rs1, 0, 112)
  47 #  define FCVT_S_W(rd, rs1)             Rtype(83, rd, 0, rs1, 0, 104)
  48 #  define FCVT_S_WU(rd, rs1)            Rtype(83, rd, 0, rs1, 1, 104)
  49 #  define FMV_W_X(rd, rs1)              Rtype(83, rd, 0, rs1, 0, 120)
  50 /*
  51  * RV64F Standard Extension (in addition to RV32F)
  52  */
  53 #  define FCVT_L_S(rd, rs1)             Rtype(83, rd, 0, rs1, 2, 96)
  54 #  define FCVT_LU_S(rd, rs1)            Rtype(83, rd, 0, rs1, 3, 96)
  55 #  define FCVT_S_L(rd, rs1)             Rtype(83, rd, 0, rs1, 2, 104)
  56 #  define FCVT_S_LU(rd, rs1)            Rtype(83, rd, 0, rs1, 3, 104)
  57 /*
  58  * RV32D Standard Extension
  59  */
  60 #  define FLD(rd, rs1, im)              Itype(7, rd, 3, rs1, im)
  61 #  define FSD(rs1, rs2, imm)            Stype(39, 3, rs1, rs2, imm)
  62 #  define FMADD_D(rd, rs1, rs2, rs3)    R4type(67, rd, 0, rs1, rs2, 1, rs3)
  63 #  define FMSUB_D(rd, rs1, rs2, rs3)    R4type(71, rd, 0, rs1, rs2, 1, rs3)
  64 #  define FNMSUB_D(rd, rs1, rs2, rs3)   R4type(75, rd, 0, rs1, rs2, 1, rs3)
  65 #  define FNMADD_D(rd, rs1, rs2, rs3)   R4type(79, rd, 0, rs1, rs2, 1, rs3)
  66 #  define FADD_D(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 1)
  67 #  define FSUB_D(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 5)
  68 #  define FMUL_D(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 9)
  69 #  define FDIV_D(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 13)
  70 #  define FSQRT_D(rd, rs1)              Rtype(83, rd, 0, rs1, 0, 45)
  71 #  define FSGNJ_D(rd, rs1, rs2)         Rtype(83, rd, 0, rs1, rs2, 17)
  72 #  define FSGNJN_D(rd, rs1, rs2)        Rtype(83, rd, 1, rs1, rs2, 17)
  73 #  define FSGNJX_D(rd, rs1, rs2)        Rtype(83, rd, 2, rs1, rs2, 17)
  74 #  define FMIN_D(rd, rs1, rs2)          Rtype(83, rd, 0, rs1, rs2, 21)
  75 #  define FMAX_D(rd, rs1, rs2)          Rtype(83, rd, 1, rs1, rs2, 21)
  76 #  define FCVT_S_D(rd, rs1)             Rtype(83, rd, 0, rs1, 1, 32)
  77 #  define FCVT_D_S(rd, rs1)             Rtype(83, rd, 0, rs1, 0, 33)
  78 #  define FEQ_D(rd, rs1, rs2)           Rtype(83, rd, 2, rs1, rs2, 81)
  79 #  define FLT_D(rd, rs1, rs2)           Rtype(83, rd, 1, rs1, rs2, 81)
  80 #  define FLE_D(rd, rs1, rs2)           Rtype(83, rd, 0, rs1, rs2, 81)
  81 #  define FCLASS_D(rd, rs1)             Rtype(83, rd, 1, rs1, 0, 113)
  82 #  define FCVT_W_D(rd, rs1)             Rtype(83, rd, 0, rs1, 0, 97)
  83 #  define FCVT_WU_D(rd, rs1)            Rtype(83, rd, 0, rs1, 1, 97)
  84 #  define FCVT_D_W(rd, rs1)             Rtype(83, rd, 0, rs1, 0, 105)
  85 #  define FCVT_D_WU(rd, rs1)            Rtype(83, rd, 0, rs1, 1, 105)
  86 /*
  87  * RV64D Standard Extension (in addition to RV32D)
  88  */
  89 #  define FCVT_L_D(rd, rs1)             Rtype(83, rd, 0, rs1, 2, 97)
  90 #  define FCVT_LU_D(rd, rs1)            Rtype(83, rd, 0, rs1, 3, 97)
  91 #  define FMV_X_D(rd, rs1)              Rtype(83, rd, 0, rs1, 0, 113)
  92 #  define FCVT_D_L(rd, rs1)             Rtype(83, rd, 0, rs1, 2, 105)
  93 #  define FCVT_D_LU(rd, rs1)            Rtype(83, rd, 0, rs1, 3, 105)
  94 #  define FMV_D_X(rd, rs1)              Rtype(83, rd, 0, rs1, 0, 121)
  95 /*
  96  * Pseudo instructions
  97  */
  98 #  define FMV_S(r0, r1)                 FSGNJ_S(r0, r1, r1)
  99 #  define FABS_S(r0, r1)                FSGNJX_S(r0, r1, r1)
 100 #  define FNEG_S(r0, r1)                FSGNJN_S(r0, r1, r1)
 101 #  define FMV_D(r0, r1)                 FSGNJ_D(r0, r1, r1)
 102 #  define FABS_D(r0, r1)                FSGNJX_D(r0, r1, r1)
 103 #  define FNEG_D(r0, r1)                FSGNJN_D(r0, r1, r1)
 104
 105 /*
 106  * Lightning instructions
 107  */
 108 #  define truncr_f_i(r0, r1)            FCVT_W_S(r0, r1)
 109 #  define truncr_d_i(r0, r1)            FCVT_W_D(r0, r1)
 110 #  define truncr_f_l(r0, r1)            FCVT_L_S(r0, r1)
 111 #  define truncr_d_l(r0, r1)            FCVT_L_D(r0, r1)
 112 #  define addr_f(r0, r1, r2)            FADD_S(r0, r1, r2)
 113 #  define addi_f(r0, r1, im)            _addi_f(_jit, r0, r1, im)
 114 static void _addi_f(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float32_t);
 115 #  define subr_f(r0, r1, r2)            FSUB_S(r0, r1, r2)
 116 #  define subi_f(r0, r1, im)            _subi_f(_jit, r0, r1, im)
 117 static void _subi_f(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float32_t);
 118 #  define rsbr_f(r0, r1, r2)            FSUB_S(r0, r2, r1)
 119 #  define rsbi_f(r0, r1, im)            _rsbi_f(_jit, r0, r1, im)
 120 static void _rsbi_f(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float32_t);
 121 #  define mulr_f(r0, r1, r2)            FMUL_S(r0, r1, r2)
 122 #  define muli_f(r0, r1, im)            _muli_f(_jit, r0, r1, im)
 123 static void _muli_f(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float32_t);
 124 #  define divr_f(r0, r1, r2)            FDIV_S(r0, r1, r2)
 125 #  define divi_f(r0, r1, im)            _divi_f(_jit, r0, r1, im)
 126 static void _divi_f(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float32_t);
 127 #  define absr_f(r0, r1)                FABS_S(r0, r1)
 128 #  define negr_f(r0, r1)                FNEG_S(r0, r1)
 129 #  define sqrtr_f(r0, r1)               FSQRT_S(r0, r1)
 130 #  define extr_f(r0, r1)                FCVT_S_L(r0, r1)
 131 #  define ldr_f(r0, r1)                 FLW(r0, r1, 0)
 132 #  define ldi_f(r0, im)                 _ldi_f(_jit, r0, im)
 133 static void _ldi_f(jit_state_t*, jit_int32_t, jit_word_t);
 134 #  define ldxr_f(r0, r1, r2)            _ldxr_f(_jit, r0, r1, r2)
 135 static void _ldxr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 136 #  define ldxi_f(r0, r1, i0)            _ldxi_f(_jit, r0, r1, i0)
 137 static void _ldxi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 138 #  define str_f(r0, r1)                 FSW(r0, r1, 0)
 139 #  define sti_f(im, r0)                 _sti_f(_jit, im, r0)
 140 static void _sti_f(jit_state_t*, jit_word_t, jit_int32_t);
 141 #  define stxr_f(r0, r1, r2)            _stxr_f(_jit, r0, r1, r2)
 142 static void _stxr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 143 #  define stxi_f(im, r0, r1)            _stxi_f(_jit, im, r0, r1)
 144 static void _stxi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 145 #  define movr_f(r0, r1)                FMV_S(r0, r1)
 146 #  define movi_f(r0, im)                _movi_f(_jit, r0, im)
 147 static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t);
 148 #  define movr_f_w(r0, r1)              FMV_X_W(r0, r1)
 149 #  define movi_f_w(r0, im)              _movi_f_w(_jit, r0, im)
 150 static void _movi_f_w(jit_state_t*, jit_int32_t, jit_float32_t);
 151 #  define movr_w_f(r0, r1)              FMV_W_X(r0, r1)
 152 #  define extr_d_f(r0, r1)              FCVT_S_D(r0, r1)
 153 #  define ltr_f(r0, r1, r2)             FLT_S(r0, r1, r2)
 154 #  define lti_f(r0, r1, im)             _lti_f(_jit, r0, r1, im)
 155 static void _lti_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 156 #  define ler_f(r0, r1, r2)             FLE_S(r0, r1, r2)
 157 #  define lei_f(r0, r1, im)             _lei_f(_jit, r0, r1, im)
 158 static void _lei_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 159 #  define eqr_f(r0, r1, r2)             FEQ_S(r0, r1, r2)
 160 #  define eqi_f(r0, r1, im)             _eqi_f(_jit, r0, r1, im)
 161 static void _eqi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 162 #  define ger_f(r0, r1, r2)             FLE_S(r0, r2, r1)
 163 #  define gei_f(r0, r1, im)             _gei_f(_jit, r0, r1, im)
 164 static void _gei_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 165 #  define gtr_f(r0, r1, r2)             FLT_S(r0, r2, r1)
 166 #  define gti_f(r0, r1, im)             _gti_f(_jit, r0, r1, im)
 167 static void _gti_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 168 #  define ner_f(r0, r1, r2)             _ner_f(_jit, r0, r1, r2)
 169 static void _ner_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 170 #  define nei_f(r0, r1, im)             _nei_f(_jit, r0, r1, im)
 171 static void _nei_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 172 #  define unltr_f(r0, r1, r2)           _unltr_f(_jit, r0, r1, r2)
 173 static void _unltr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 174 #  define unlti_f(r0, r1, im)           _unlti_f(_jit, r0, r1, im)
 175 static void _unlti_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 176 #  define unler_f(r0, r1, r2)           _unler_f(_jit, r0, r1, r2)
 177 static void _unler_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 178 #  define unlei_f(r0, r1, im)           _unlei_f(_jit, r0, r1, im)
 179 static void _unlei_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 180 #  define uneqr_f(r0, r1, r2)           _uneqr_f(_jit, r0, r1, r2)
 181 static void _uneqr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 182 #  define uneqi_f(r0, r1, im)           _uneqi_f(_jit, r0, r1, im)
 183 static void _uneqi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 184 #  define unger_f(r0, r1, r2)           _unger_f(_jit, r0, r1, r2)
 185 static void _unger_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 186 #  define ungei_f(r0, r1, im)           _ungei_f(_jit, r0, r1, im)
 187 static void _ungei_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 188 #  define ungtr_f(r0, r1, r2)           _ungtr_f(_jit, r0, r1, r2)
 189 static void _ungtr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 190 #  define ungti_f(r0, r1, im)           _ungti_f(_jit, r0, r1, im)
 191 static void _ungti_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 192 #  define ltgtr_f(r0, r1, r2)           _ltgtr_f(_jit, r0, r1, r2)
 193 static void _ltgtr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 194 #  define ltgti_f(r0, r1, im)           _ltgti_f(_jit, r0, r1, im)
 195 static void _ltgti_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 196 #  define ordr_f(r0, r1, r2)            _ordr_f(_jit, r0, r1, r2)
 197 static void _ordr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 198 #  define ordi_f(r0, r1, im)            _ordi_f(_jit, r0, r1, im)
 199 static void _ordi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 200 #  define unordr_f(r0, r1, r2)          _unordr_f(_jit, r0, r1, r2)
 201 static void _unordr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 202 #  define unordi_f(r0, r1, im)          _unordi_f(_jit, r0, r1, im)
 203 static void _unordi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t);
 204 #  define bltr_f(br, r0, r1)            _bltr_f(_jit,br,r0,r1)
 205 static jit_word_t _bltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 206 #  define blti_f(br, r0, im)            _blti_f(_jit,br,r0,im)
 207 static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 208 #  define bler_f(br, r0, r1)            _bler_f(_jit,br,r0,r1)
 209 static jit_word_t _bler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 210 #  define blei_f(br, r0, im)            _blei_f(_jit,br,r0,im)
 211 static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 212 #  define beqr_f(br, r0, r1)            _beqr_f(_jit,br,r0,r1)
 213 static jit_word_t _beqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 214 #  define beqi_f(br, r0, im)            _beqi_f(_jit,br,r0,im)
 215 static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 216 #  define bger_f(br, r0, r1)            _bger_f(_jit,br,r0,r1)
 217 static jit_word_t _bger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 218 #  define bgei_f(br, r0, im)            _bgei_f(_jit,br,r0,im)
 219 static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 220 #  define bgtr_f(br, r0, r1)            _bgtr_f(_jit,br,r0,r1)
 221 static jit_word_t _bgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 222 #  define bgti_f(br, r0, im)            _bgti_f(_jit,br,r0,im)
 223 static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 224 #  define bner_f(br, r0, r1)            _bner_f(_jit,br,r0,r1)
 225 static jit_word_t _bner_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 226 #  define bnei_f(br, r0, im)            _bnei_f(_jit,br,r0,im)
 227 static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 228 #  define bunltr_f(br, r0, r1)          _bunltr_f(_jit,br,r0,r1)
 229 static jit_word_t _bunltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 230 #  define bunlti_f(br, r0, im)          _bunlti_f(_jit,br,r0,im)
 231 static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 232 #  define bunler_f(br, r0, r1)          _bunler_f(_jit,br,r0,r1)
 233 static jit_word_t _bunler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 234 #  define bunlei_f(br, r0, im)          _bunlei_f(_jit,br,r0,im)
 235 static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 236 #  define buneqr_f(br, r0, r1)          _buneqr_f(_jit,br,r0,r1)
 237 static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 238 #  define buneqi_f(br, r0, im)          _buneqi_f(_jit,br,r0,im)
 239 static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 240 #  define bunger_f(br, r0, r1)          _bunger_f(_jit,br,r0,r1)
 241 static jit_word_t _bunger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 242 #  define bungei_f(br, r0, im)          _bungei_f(_jit,br,r0,im)
 243 static jit_word_t _bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 244 #  define bungtr_f(br, r0, r1)          _bungtr_f(_jit,br,r0,r1)
 245 static jit_word_t _bungtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 246 #  define bungti_f(br, r0, im)          _bungti_f(_jit,br,r0,im)
 247 static jit_word_t _bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 248 #  define bltgtr_f(br, r0, r1)          _bltgtr_f(_jit,br,r0,r1)
 249 static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 250 #  define bltgti_f(br, r0, im)          _bltgti_f(_jit,br,r0,im)
 251 static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 252 #  define bordr_f(br, r0, r1)           _bordr_f(_jit,br,r0,r1)
 253 static jit_word_t _bordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 254 #  define bordi_f(br, r0, im)           _bordi_f(_jit,br,r0,im)
 255 static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 256 #  define bunordr_f(br, r0, r1)         _bunordr_f(_jit,br,r0,r1)
 257 static jit_word_t _bunordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 258 #  define bunordi_f(br, r0, im)         _bunordi_f(_jit,br,r0,im)
 259 static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
 260 #  define addr_d(r0, r1, r2)            FADD_D(r0, r1, r2)
 261 #  define addi_d(r0, r1, im)            _addi_d(_jit, r0, r1, im)
 262 static void _addi_d(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float64_t);
 263 #  define subr_d(r0, r1, r2)            FSUB_D(r0, r1, r2)
 264 #  define subi_d(r0, r1, im)            _subi_d(_jit, r0, r1, im)
 265 static void _subi_d(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float64_t);
 266 #  define rsbr_d(r0, r1, r2)            FSUB_D(r0, r2, r1)
 267 #  define rsbi_d(r0, r1, im)            _rsbi_d(_jit, r0, r1, im)
 268 static void _rsbi_d(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float64_t);
 269 #  define mulr_d(r0, r1, r2)            FMUL_D(r0, r1, r2)
 270 #  define muli_d(r0, r1, im)            _muli_d(_jit, r0, r1, im)
 271 static void _muli_d(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float64_t);
 272 #  define divr_d(r0, r1, r2)            FDIV_D(r0, r1, r2)
 273 #  define divi_d(r0, r1, im)            _divi_d(_jit, r0, r1, im)
 274 static void _divi_d(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float64_t);
 275 #  define absr_d(r0, r1)                FABS_D(r0, r1)
 276 #  define negr_d(r0, r1)                FNEG_D(r0, r1)
 277 #  define sqrtr_d(r0, r1)               FSQRT_D(r0, r1)
 278 #  define extr_d(r0, r1)                FCVT_D_L(r0, r1)
 279 #  define ldr_d(r0, r1)                 FLD(r0, r1, 0)
 280 #  define ldi_d(r0, im)                 _ldi_d(_jit, r0, im)
 281 static void _ldi_d(jit_state_t*, jit_int32_t, jit_word_t);
 282 #  define ldxr_d(r0, r1, r2)            _ldxr_d(_jit, r0, r1, r2)
 283 static void _ldxr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 284 #  define ldxi_d(r0, r1, i0)            _ldxi_d(_jit, r0, r1, i0)
 285 static void _ldxi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 286 #  define str_d(r0, r1)                 FSD(r0, r1, 0)
 287 #  define sti_d(im, r0)                 _sti_d(_jit, im, r0)
 288 static void _sti_d(jit_state_t*, jit_word_t, jit_int32_t);
 289 #  define stxr_d(r0, r1, r2)            _stxr_d(_jit, r0, r1, r2)
 290 static void _stxr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 291 #  define stxi_d(im, r0, r1)            _stxi_d(_jit, im, r0, r1)
 292 static void _stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 293 #  define movr_d(r0, r1)                FMV_D(r0, r1)
 294 #  define movi_d(r0, im)                _movi_d(_jit, r0, im)
 295 static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t);
 296 #  define movr_d_w(r0, r1)              FMV_X_D(r0, r1)
 297 #  define movi_d_w(r0, im)              _movi_d_w(_jit, r0, im)
 298 static void _movi_d_w(jit_state_t*, jit_int32_t, jit_float64_t);
 299 #  define movr_w_d(r0, r1)              FMV_D_X(r0, r1)
 300 #  define extr_f_d(r0, r1)              FCVT_D_S(r0, r1)
 301 #  define ltr_d(r0, r1, r2)             FLT_D(r0, r1, r2)
 302 #  define lti_d(r0, r1, r2)             _lti_d(_jit, r0, r1, r2)
 303 static void _lti_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 304 #  define ler_d(r0, r1, r2)             FLE_D(r0, r1, r2)
 305 #  define lei_d(r0, r1, r2)             _lei_d(_jit, r0, r1, r2)
 306 static void _lei_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 307 #  define eqr_d(r0, r1, r2)             FEQ_D(r0, r1, r2)
 308 #  define eqi_d(r0, r1, r2)             _eqi_d(_jit, r0, r1, r2)
 309 static void _eqi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 310 #  define ger_d(r0, r1, r2)             FLE_D(r0, r2, r1)
 311 #  define gei_d(r0, r1, r2)             _gei_d(_jit, r0, r1, r2)
 312 static void _gei_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 313 #  define gtr_d(r0, r1, r2)             FLT_D(r0, r2, r1)
 314 #  define gti_d(r0, r1, r2)             _gti_d(_jit, r0, r1, r2)
 315 static void _gti_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 316 #  define ner_d(r0, r1, r2)             _ner_d(_jit, r0, r1, r2)
 317 static void _ner_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 318 #  define nei_d(r0, r1, r2)             _nei_d(_jit, r0, r1, r2)
 319 static void _nei_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 320 #  define unltr_d(r0, r1, r2)           _unltr_d(_jit, r0, r1, r2)
 321 static void _unltr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 322 #  define unlti_d(r0, r1, im)           _unlti_d(_jit, r0, r1, im)
 323 static void _unlti_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 324 #  define unler_d(r0, r1, r2)           _unler_d(_jit, r0, r1, r2)
 325 static void _unler_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 326 #  define unlei_d(r0, r1, im)           _unlei_d(_jit, r0, r1, im)
 327 static void _unlei_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 328 #  define uneqr_d(r0, r1, r2)           _uneqr_d(_jit, r0, r1, r2)
 329 static void _uneqr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 330 #  define uneqi_d(r0, r1, im)           _uneqi_d(_jit, r0, r1, im)
 331 static void _uneqi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 332 #  define unger_d(r0, r1, r2)           _unger_d(_jit, r0, r1, r2)
 333 static void _unger_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 334 #  define ungei_d(r0, r1, im)           _ungei_d(_jit, r0, r1, im)
 335 static void _ungei_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 336 #  define ungtr_d(r0, r1, r2)           _ungtr_d(_jit, r0, r1, r2)
 337 static void _ungtr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 338 #  define ungti_d(r0, r1, im)           _ungti_d(_jit, r0, r1, im)
 339 static void _ungti_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 340 #  define ltgtr_d(r0, r1, r2)           _ltgtr_d(_jit, r0, r1, r2)
 341 static void _ltgtr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 342 #  define ltgti_d(r0, r1, im)           _ltgti_d(_jit, r0, r1, im)
 343 static void _ltgti_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 344 #  define ordr_d(r0, r1, r2)            _ordr_d(_jit, r0, r1, r2)
 345 static void _ordr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 346 #  define ordi_d(r0, r1, im)            _ordi_d(_jit, r0, r1, im)
 347 static void _ordi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 348 #  define unordr_d(r0, r1, r2)          _unordr_d(_jit, r0, r1, r2)
 349 static void _unordr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 350 #  define unordi_d(r0, r1, im)          _unordi_d(_jit, r0, r1, im)
 351 static void _unordi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t);
 352 #  define bltr_d(br, r0, r1)            _bltr_d(_jit,br,r0,r1)
 353 static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 354 #  define blti_d(br, r0, im)            _blti_d(_jit,br,r0,im)
 355 static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 356 #  define bler_d(br, r0, r1)            _bler_d(_jit,br,r0,r1)
 357 static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 358 #  define blei_d(br, r0, im)            _blei_d(_jit,br,r0,im)
 359 static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 360 #  define beqr_d(br, r0, r1)            _beqr_d(_jit,br,r0,r1)
 361 static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 362 #  define beqi_d(br, r0, im)            _beqi_d(_jit,br,r0,im)
 363 static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 364 #  define bger_d(br, r0, r1)            _bger_d(_jit,br,r0,r1)
 365 static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 366 #  define bgei_d(br, r0, im)            _bgei_d(_jit,br,r0,im)
 367 static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 368 #  define bgtr_d(br, r0, r1)            _bgtr_d(_jit,br,r0,r1)
 369 static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 370 #  define bgti_d(br, r0, im)            _bgti_d(_jit,br,r0,im)
 371 static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 372 #  define bner_d(br, r0, r1)            _bner_d(_jit,br,r0,r1)
 373 static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 374 #  define bnei_d(br, r0, im)            _bnei_d(_jit,br,r0,im)
 375 static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 376 #  define bunltr_d(br, r0, r1)          _bunltr_d(_jit,br,r0,r1)
 377 static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 378 #  define bunlti_d(br, r0, im)          _bunlti_d(_jit,br,r0,im)
 379 static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 380 #  define bunler_d(br, r0, r1)          _bunler_d(_jit,br,r0,r1)
 381 static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 382 #  define bunlei_d(br, r0, im)          _bunlei_d(_jit,br,r0,im)
 383 static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 384 #  define buneqr_d(br, r0, r1)          _buneqr_d(_jit,br,r0,r1)
 385 static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 386 #  define buneqi_d(br, r0, im)          _buneqi_d(_jit,br,r0,im)
 387 static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 388 #  define bunger_d(br, r0, r1)          _bunger_d(_jit,br,r0,r1)
 389 static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 390 #  define bungei_d(br, r0, im)          _bungei_d(_jit,br,r0,im)
 391 static jit_word_t _bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 392 #  define bungtr_d(br, r0, r1)          _bungtr_d(_jit,br,r0,r1)
 393 static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 394 #  define bungti_d(br, r0, im)          _bungti_d(_jit,br,r0,im)
 395 static jit_word_t _bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 396 #  define bltgtr_d(br, r0, r1)          _bltgtr_d(_jit,br,r0,r1)
 397 static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 398 #  define bltgti_d(br, r0, im)          _bltgti_d(_jit,br,r0,im)
 399 static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 400 #  define bordr_d(br, r0, r1)           _bordr_d(_jit,br,r0,r1)
 401 static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 402 #  define bordi_d(br, r0, im)           _bordi_d(_jit,br,r0,im)
 403 static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 404 #  define bunordr_d(br, r0, r1)         _bunordr_d(_jit,br,r0,r1)
 405 static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 406 #  define bunordi_d(br, r0, im)         _bunordi_d(_jit,br,r0,im)
 407 static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
 408 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 409 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 410 #endif /* PROTO */
 411
 412 #if CODE
 413 #  define fpr_opi(name, type, size)                                     \
 414 static void                                                             \
 415 _##name##i_##type(jit_state_t *_jit,                                    \
 416                   jit_int32_t r0, jit_int32_t r1,                       \
 417                   jit_float##size##_t i0)                               \
 418 {                                                                       \
 419     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
 420     movi_##type(rn(reg), i0);                                           \
 421     name##r_##type(r0, r1, rn(reg));                                    \
 422     jit_unget_reg(reg);                                                 \
 423 }
 424 #  define fopi(name)                    fpr_opi(name, f, 32)
 425 #  define dopi(name)                    fpr_opi(name, d, 64)
 426
 427 fopi(add)
 428 fopi(sub)
 429 fopi(rsb)
 430 fopi(mul)
 431 fopi(div)
 432
 433 static void
 434 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 435 {
 436     jit_int32_t         t0;
 437     if (simm12_p(i0))
 438         FLW(r0, _ZERO_REGNO, i0);
 439     else {
 440         t0 = jit_get_reg(jit_class_gpr);
 441         movi(rn(t0), i0);
 442         ldr_f(r0, rn(t0));
 443         jit_unget_reg(t0);
 444     }
 445 }
 446
 447 static void
 448 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 449 {
 450     jit_int32_t         t0;
 451     t0 = jit_get_reg(jit_class_gpr);
 452     addr(rn(t0), r1, r2);
 453     ldr_f(r0, rn(t0));
 454     jit_unget_reg(t0);
 455 }
 456
 457 static void
 458 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 459 {
 460     jit_int32_t         t0;
 461     if (simm12_p(i0))
 462         FLW(r0, r1, i0);
 463     else {
 464         t0 = jit_get_reg(jit_class_gpr);
 465         addi(rn(t0), r1, i0);
 466         ldr_f(r0, rn(t0));
 467         jit_unget_reg(t0);
 468     }
 469 }
 470
 471 static void
 472 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 473 {
 474     jit_int32_t         t0;
 475     if (simm12_p(i0))
 476         FSW(r0, _ZERO_REGNO, i0);
 477     else {
 478         t0 = jit_get_reg(jit_class_gpr);
 479         movi(rn(t0), i0);
 480         str_f(rn(t0), r0);
 481         jit_unget_reg(t0);
 482     }
 483 }
 484
 485 static void
 486 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 487 {
 488     jit_int32_t         t0;
 489     t0 = jit_get_reg(jit_class_gpr);
 490     addr(rn(t0), r0, r1);
 491     str_f(rn(t0), r2);
 492     jit_unget_reg(t0);
 493 }
 494
 495 static void
 496 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 497 {
 498     jit_int32_t         t0;
 499     if (simm12_p(i0))
 500         FSW(r0, r1, i0);
 501     else {
 502         t0 = jit_get_reg(jit_class_gpr);
 503         addi(rn(t0), r0, i0);
 504         str_f(rn(t0), r1);
 505         jit_unget_reg(t0);
 506     }
 507 }
 508
 509 static void
 510 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
 511 {
 512     union {
 513         jit_int32_t      i;
 514         jit_float32_t    f;
 515     } data;
 516     jit_int32_t          reg;
 517     data.f = i0;
 518     if (data.i == 0)
 519         movr_w_f(r0, _ZERO_REGNO);
 520     else {
 521         reg = jit_get_reg(jit_class_gpr);
 522         movi(rn(reg), data.i);
 523         movr_w_f(r0, rn(reg));
 524         jit_unget_reg(reg);
 525     }
 526 }
 527
 528 static void
 529 _movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
 530 {
 531     union {
 532         jit_int32_t     i;
 533         jit_float32_t   f;
 534     } data;
 535     data.f = i0;
 536     movi(r0, data.i);
 537 }
 538
 539 fopi(lt)
 540 fopi(le)
 541 fopi(eq)
 542 fopi(ge)
 543 fopi(gt)
 544
 545 static void
 546 _ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 547 {
 548     eqr_f(r0, r1, r2);
 549     xori(r0, r0, 1);
 550 }
 551 fopi(ne)
 552
 553 #  define fpr_bopi(name, type, size)                                    \
 554 static jit_word_t                                                       \
 555 _b##name##i_##type(jit_state_t *_jit,                                   \
 556                   jit_word_t i0, jit_int32_t r0,                        \
 557                   jit_float##size##_t i1)                               \
 558 {                                                                       \
 559     jit_word_t          word;                                           \
 560     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
 561                                           jit_class_nospill);           \
 562     movi_##type(rn(reg), i1);                                           \
 563     word = b##name##r_##type(i0, r0, rn(reg));                          \
 564     jit_unget_reg(reg);                                                 \
 565     return (word);                                                      \
 566 }
 567 #  define fbopi(name)                   fpr_bopi(name, f, 32)
 568 #  define dbopi(name)                   fpr_bopi(name, d, 64)
 569
 570 #  define unop(CLASS, OP)                                               \
 571     jit_word_t          w;                                              \
 572     jit_int32_t         t0, t1;                                         \
 573     t0 = jit_get_reg(jit_class_gpr);                                    \
 574     FCLASS_##CLASS(rn(t0), r1);                                         \
 575     t1 = jit_get_reg(jit_class_gpr);                                    \
 576     FCLASS_##CLASS(rn(t1), r2);                                         \
 577     orr(rn(t0), rn(t0), rn(t1));                                        \
 578     jit_unget_reg(t1);                                                  \
 579     rshi(rn(t0), rn(t0), 8);                                            \
 580     ltr(r0, _ZERO_REGNO, rn(t0));                                       \
 581     jit_unget_reg(t0);                                                  \
 582     w = _jit->pc.w;                                                     \
 583     BLT(_ZERO_REGNO, r0, 0);                                            \
 584     OP(r0, r1, r2);                                                     \
 585     patch_at(w, _jit->pc.w)
 586
 587 static void
 588 _unltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 589 {
 590     unop(S, ltr_f);
 591 }
 592 fopi(unlt)
 593
 594 static void
 595 _unler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 596 {
 597     unop(S, ler_f);
 598 }
 599 fopi(unle)
 600
 601 static void
 602 _uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 603 {
 604     unop(S, eqr_f);
 605 }
 606 fopi(uneq)
 607
 608 static void
 609 _unger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 610 {
 611     unop(S, ger_f);
 612 }
 613 fopi(unge)
 614
 615 static void
 616 _ungtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 617 {
 618     unop(S, gtr_f);
 619 }
 620 fopi(ungt)
 621
 622 static void
 623 _ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 624 {
 625     jit_word_t          w0, w1;
 626     jit_int32_t         t0, t1;
 627     t0 = jit_get_reg(jit_class_gpr);
 628     FCLASS_S(rn(t0), r1);
 629     t1 = jit_get_reg(jit_class_gpr);
 630     FCLASS_S(rn(t1), r2);
 631     orr(rn(t0), rn(t0), rn(t1));
 632     jit_unget_reg(t1);
 633     rshi(rn(t0), rn(t0), 8);
 634     ltr(r0, _ZERO_REGNO, rn(t0));
 635     jit_unget_reg(t0);
 636     w0 = _jit->pc.w;
 637     BEQ(_ZERO_REGNO, r0, 0);
 638     movr(r0, _ZERO_REGNO);
 639     w1 = _jit->pc.w;
 640     JAL(_ZERO_REGNO, 0);
 641     patch_at(w0, _jit->pc.w);
 642     ner_f(r0, r1, r2);
 643     patch_at(w1, _jit->pc.w);
 644 }
 645 fopi(ltgt)
 646
 647 static void
 648 _ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 649 {
 650     jit_int32_t         t0, t1;
 651     t0 = jit_get_reg(jit_class_gpr);
 652     FCLASS_S(rn(t0), r1);
 653     t1 = jit_get_reg(jit_class_gpr);
 654     FCLASS_S(rn(t1), r2);
 655     orr(rn(t0), rn(t0), rn(t1));
 656     jit_unget_reg(t1);
 657     rshi(rn(t0), rn(t0), 8);
 658     eqr(r0, _ZERO_REGNO, rn(t0));
 659     jit_unget_reg(t0);
 660 }
 661 fopi(ord)
 662
 663 static void
 664 _unordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 665 {
 666     jit_int32_t         t0, t1;
 667     t0 = jit_get_reg(jit_class_gpr);
 668     FCLASS_S(rn(t0), r1);
 669     t1 = jit_get_reg(jit_class_gpr);
 670     FCLASS_S(rn(t1), r2);
 671     orr(rn(t0), rn(t0), rn(t1));
 672     jit_unget_reg(t1);
 673     rshi(rn(t0), rn(t0), 8);
 674     ltr(r0, _ZERO_REGNO, rn(t0));
 675     jit_unget_reg(t0);
 676 }
 677 fopi(unord)
 678
 679 static jit_word_t
 680 _bltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 681 {
 682     jit_word_t          w;
 683     jit_int32_t         t0;
 684     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 685     ltr_f(rn(t0), r1, r2);
 686     w = bner(i0, _ZERO_REGNO, rn(t0));
 687     jit_unget_reg(t0);
 688     return (w);
 689 }
 690 fbopi(lt)
 691
 692 static jit_word_t
 693 _bler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 694 {
 695     jit_word_t          w;
 696     jit_int32_t         t0;
 697     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 698     ler_f(rn(t0), r1, r2);
 699     w = bner(i0, _ZERO_REGNO, rn(t0));
 700     jit_unget_reg(t0);
 701     return (w);
 702 }
 703 fbopi(le)
 704
 705 static jit_word_t
 706 _beqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 707 {
 708     jit_word_t          w;
 709     jit_int32_t         t0;
 710     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 711     eqr_f(rn(t0), r1, r2);
 712     w = bner(i0, _ZERO_REGNO, rn(t0));
 713     jit_unget_reg(t0);
 714     return (w);
 715 }
 716 fbopi(eq)
 717
 718 static jit_word_t
 719 _bger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 720 {
 721     jit_word_t          w;
 722     jit_int32_t         t0;
 723     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 724     ger_f(rn(t0), r1, r2);
 725     w = bner(i0, _ZERO_REGNO, rn(t0));
 726     jit_unget_reg(t0);
 727     return (w);
 728 }
 729 fbopi(ge)
 730
 731 static jit_word_t
 732 _bgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 733 {
 734     jit_word_t          w;
 735     jit_int32_t         t0;
 736     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 737     gtr_f(rn(t0), r1, r2);
 738     w = bner(i0, _ZERO_REGNO, rn(t0));
 739     jit_unget_reg(t0);
 740     return (w);
 741 }
 742 fbopi(gt)
 743
 744 static jit_word_t
 745 _bner_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 746 {
 747     jit_word_t          w;
 748     jit_int32_t         t0;
 749     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 750     eqr_f(rn(t0), r1, r2);
 751     w = beqr(i0, _ZERO_REGNO, rn(t0));
 752     jit_unget_reg(t0);
 753     return (w);
 754 }
 755 fbopi(ne)
 756
 757 static jit_word_t
 758 _bunltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 759 {
 760     jit_word_t          w;
 761     jit_int32_t         t0;
 762     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 763     unltr_f(rn(t0), r1, r2);
 764     w = bner(i0, _ZERO_REGNO, rn(t0));
 765     jit_unget_reg(t0);
 766     return (w);
 767 }
 768 fbopi(unlt)
 769
 770 static jit_word_t
 771 _bunler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 772 {
 773     jit_word_t          w;
 774     jit_int32_t         t0;
 775     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 776     unler_f(rn(t0), r1, r2);
 777     w = bner(i0, _ZERO_REGNO, rn(t0));
 778     jit_unget_reg(t0);
 779     return (w);
 780 }
 781 fbopi(unle)
 782
 783 static jit_word_t
 784 _buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 785 {
 786     jit_word_t          w;
 787     jit_int32_t         t0;
 788     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 789     uneqr_f(rn(t0), r1, r2);
 790     w = bner(i0, _ZERO_REGNO, rn(t0));
 791     jit_unget_reg(t0);
 792     return (w);
 793 }
 794 fbopi(uneq)
 795
 796 static jit_word_t
 797 _bunger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 798 {
 799     jit_word_t          w;
 800     jit_int32_t         t0;
 801     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 802     unger_f(rn(t0), r1, r2);
 803     w = bner(i0, _ZERO_REGNO, rn(t0));
 804     jit_unget_reg(t0);
 805     return (w);
 806 }
 807 fbopi(unge)
 808
 809 static jit_word_t
 810 _bungtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 811 {
 812     jit_word_t          w;
 813     jit_int32_t         t0;
 814     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 815     ungtr_f(rn(t0), r1, r2);
 816     w = bner(i0, _ZERO_REGNO, rn(t0));
 817     jit_unget_reg(t0);
 818     return (w);
 819 }
 820 fbopi(ungt)
 821
 822 static jit_word_t
 823 _bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 824 {
 825     jit_word_t          w;
 826     jit_int32_t         t0;
 827     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 828     ltgtr_f(rn(t0), r1, r2);
 829     w = bner(i0, _ZERO_REGNO, rn(t0));
 830     jit_unget_reg(t0);
 831     return (w);
 832 }
 833 fbopi(ltgt)
 834
 835 static jit_word_t
 836 _bordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 837 {
 838     jit_word_t          w;
 839     jit_int32_t         t0;
 840     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 841     ordr_f(rn(t0), r1, r2);
 842     w = bner(i0, _ZERO_REGNO, rn(t0));
 843     jit_unget_reg(t0);
 844     return (w);
 845 }
 846 fbopi(ord)
 847
 848 static jit_word_t
 849 _bunordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
 850 {
 851     jit_word_t          w;
 852     jit_int32_t         t0;
 853     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
 854     unordr_f(rn(t0), r1, r2);
 855     w = bner(i0, _ZERO_REGNO, rn(t0));
 856     jit_unget_reg(t0);
 857     return (w);
 858 }
 859 fbopi(unord)
 860
 861 dopi(add)
 862 dopi(sub)
 863 dopi(rsb)
 864 dopi(mul)
 865 dopi(div)
 866
 867 static void
 868 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 869 {
 870     jit_int32_t         t0;
 871     if (simm12_p(i0))
 872         FLD(r0, _ZERO_REGNO, i0);
 873     else {
 874         t0 = jit_get_reg(jit_class_gpr);
 875         movi(rn(t0), i0);
 876         ldr_d(r0, rn(t0));
 877         jit_unget_reg(t0);
 878     }
 879 }
 880
 881 static void
 882 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 883 {
 884     jit_int32_t         t0;
 885     t0 = jit_get_reg(jit_class_gpr);
 886     addr(rn(t0), r1, r2);
 887     ldr_d(r0, rn(t0));
 888     jit_unget_reg(t0);
 889 }
 890
 891 static void
 892 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 893 {
 894     jit_int32_t         t0;
 895     if (simm12_p(i0))
 896         FLD(r0, r1, i0);
 897     else {
 898         t0 = jit_get_reg(jit_class_gpr);
 899         addi(rn(t0), r1, i0);
 900         ldr_d(r0, rn(t0));
 901         jit_unget_reg(t0);
 902     }
 903 }
 904
 905 static void
 906 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 907 {
 908     jit_int32_t         t0;
 909     if (simm12_p(i0))
 910         FSD(r0, _ZERO_REGNO, i0);
 911     else {
 912         t0 = jit_get_reg(jit_class_gpr);
 913         movi(rn(t0), i0);
 914         str_d(rn(t0), r0);
 915         jit_unget_reg(t0);
 916     }
 917 }
 918
 919 static void
 920 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 921 {
 922     jit_int32_t         t0;
 923     t0 = jit_get_reg(jit_class_gpr);
 924     addr(rn(t0), r0, r1);
 925     str_d(rn(t0), r2);
 926     jit_unget_reg(t0);
 927 }
 928
 929 static void
 930 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 931 {
 932     jit_int32_t         t0;
 933     if (simm12_p(i0))
 934         FSD(r0, r1, i0);
 935     else {
 936         t0 = jit_get_reg(jit_class_gpr);
 937         addi(rn(t0), r0, i0);
 938         str_d(rn(t0), r1);
 939         jit_unget_reg(t0);
 940     }
 941 }
 942
 943 static void
 944 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
 945 {
 946     union {
 947         jit_word_t       w;
 948         jit_float64_t    d;
 949     } data;
 950     jit_int32_t          reg;
 951     data.d = i0;
 952     if (data.w == 0)
 953         movr_w_d(r0, _ZERO_REGNO);
 954     else {
 955         reg = jit_get_reg(jit_class_gpr);
 956         movi(rn(reg), data.w);
 957         movr_w_d(r0, rn(reg));
 958         jit_unget_reg(reg);
 959     }
 960 }
 961
 962 static void
 963 _movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
 964 {
 965     union {
 966         jit_int64_t     l;
 967         jit_float64_t   d;
 968     } data;
 969     data.d = i0;
 970     movi(r0, data.l);
 971 }
 972
 973 dopi(lt)
 974 dopi(le)
 975 dopi(eq)
 976 dopi(ge)
 977 dopi(gt)
 978
 979 static void
 980 _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 981 {
 982     eqr_d(r0, r1, r2);
 983     xori(r0, r0, 1);
 984 }
 985 dopi(ne)
 986
 987 static void
 988 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 989 {
 990     unop(D, ltr_d);
 991 }
 992 dopi(unlt)
 993
 994 static void
 995 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 996 {
 997     unop(D, ler_d);
 998 }
 999 dopi(unle)
1000
1001 static void
1002 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1003 {
1004     unop(D, eqr_d);
1005 }
1006 dopi(uneq)
1007
1008 static void
1009 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1010 {
1011     unop(D, ger_d);
1012 }
1013 dopi(unge)
1014
1015 static void
1016 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1017 {
1018     unop(D, gtr_d);
1019 }
1020 dopi(ungt)
1021
1022 static void
1023 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1024 {
1025     jit_word_t          w0, w1;
1026     jit_int32_t         t0, t1;
1027     t0 = jit_get_reg(jit_class_gpr);
1028     FCLASS_D(rn(t0), r1);
1029     t1 = jit_get_reg(jit_class_gpr);
1030     FCLASS_D(rn(t1), r2);
1031     orr(rn(t0), rn(t0), rn(t1));
1032     jit_unget_reg(t1);
1033     rshi(rn(t0), rn(t0), 8);
1034     ltr(r0, _ZERO_REGNO, rn(t0));
1035     jit_unget_reg(t0);
1036     w0 = _jit->pc.w;
1037     BEQ(_ZERO_REGNO, r0, 0);
1038     movr(r0, _ZERO_REGNO);
1039     w1 = _jit->pc.w;
1040     JAL(_ZERO_REGNO, 0);
1041     patch_at(w0, _jit->pc.w);
1042     ner_d(r0, r1, r2);
1043     patch_at(w1, _jit->pc.w);
1044 }
1045 dopi(ltgt)
1046
1047 static void
1048 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1049 {
1050     jit_int32_t         t0, t1;
1051     t0 = jit_get_reg(jit_class_gpr);
1052     FCLASS_D(rn(t0), r1);
1053     t1 = jit_get_reg(jit_class_gpr);
1054     FCLASS_D(rn(t1), r2);
1055     orr(rn(t0), rn(t0), rn(t1));
1056     jit_unget_reg(t1);
1057     rshi(rn(t0), rn(t0), 8);
1058     eqr(r0, _ZERO_REGNO, rn(t0));
1059     jit_unget_reg(t0);
1060 }
1061 dopi(ord)
1062
1063 static void
1064 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1065 {
1066     jit_int32_t         t0, t1;
1067     t0 = jit_get_reg(jit_class_gpr);
1068     FCLASS_D(rn(t0), r1);
1069     t1 = jit_get_reg(jit_class_gpr);
1070     FCLASS_D(rn(t1), r2);
1071     orr(rn(t0), rn(t0), rn(t1));
1072     jit_unget_reg(t1);
1073     rshi(rn(t0), rn(t0), 8);
1074     ltr(r0, _ZERO_REGNO, rn(t0));
1075     jit_unget_reg(t0);
1076 }
1077 dopi(unord)
1078
1079 static jit_word_t
1080 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1081 {
1082     jit_word_t          w;
1083     jit_int32_t         t0;
1084     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1085     ltr_d(rn(t0), r1, r2);
1086     w = bner(i0, _ZERO_REGNO, rn(t0));
1087     jit_unget_reg(t0);
1088     return (w);
1089 }
1090 dbopi(lt)
1091
1092 static jit_word_t
1093 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1094 {
1095     jit_word_t          w;
1096     jit_int32_t         t0;
1097     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1098     ler_d(rn(t0), r1, r2);
1099     w = bner(i0, _ZERO_REGNO, rn(t0));
1100     jit_unget_reg(t0);
1101     return (w);
1102 }
1103 dbopi(le)
1104
1105 static jit_word_t
1106 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1107 {
1108     jit_word_t          w;
1109     jit_int32_t         t0;
1110     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1111     eqr_d(rn(t0), r1, r2);
1112     w = bner(i0, _ZERO_REGNO, rn(t0));
1113     jit_unget_reg(t0);
1114     return (w);
1115 }
1116 dbopi(eq)
1117
1118 static jit_word_t
1119 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1120 {
1121     jit_word_t          w;
1122     jit_int32_t         t0;
1123     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1124     ger_d(rn(t0), r1, r2);
1125     w = bner(i0, _ZERO_REGNO, rn(t0));
1126     jit_unget_reg(t0);
1127     return (w);
1128 }
1129 dbopi(ge)
1130
1131 static jit_word_t
1132 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1133 {
1134     jit_word_t          w;
1135     jit_int32_t         t0;
1136     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1137     gtr_d(rn(t0), r1, r2);
1138     w = bner(i0, _ZERO_REGNO, rn(t0));
1139     jit_unget_reg(t0);
1140     return (w);
1141 }
1142 dbopi(gt)
1143
1144 static jit_word_t
1145 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1146 {
1147     jit_word_t          w;
1148     jit_int32_t         t0;
1149     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1150     eqr_d(rn(t0), r1, r2);
1151     w = beqr(i0, _ZERO_REGNO, rn(t0));
1152     jit_unget_reg(t0);
1153     return (w);
1154 }
1155 dbopi(ne)
1156
1157 static jit_word_t
1158 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1159 {
1160     jit_word_t          w;
1161     jit_int32_t         t0;
1162     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1163     unltr_d(rn(t0), r1, r2);
1164     w = bner(i0, _ZERO_REGNO, rn(t0));
1165     jit_unget_reg(t0);
1166     return (w);
1167 }
1168 dbopi(unlt)
1169
1170 static jit_word_t
1171 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1172 {
1173     jit_word_t          w;
1174     jit_int32_t         t0;
1175     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1176     unler_d(rn(t0), r1, r2);
1177     w = bner(i0, _ZERO_REGNO, rn(t0));
1178     jit_unget_reg(t0);
1179     return (w);
1180 }
1181 dbopi(unle)
1182
1183 static jit_word_t
1184 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1185 {
1186     jit_word_t          w;
1187     jit_int32_t         t0;
1188     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1189     uneqr_d(rn(t0), r1, r2);
1190     w = bner(i0, _ZERO_REGNO, rn(t0));
1191     jit_unget_reg(t0);
1192     return (w);
1193 }
1194 dbopi(uneq)
1195
1196 static jit_word_t
1197 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1198 {
1199     jit_word_t          w;
1200     jit_int32_t         t0;
1201     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1202     unger_d(rn(t0), r1, r2);
1203     w = bner(i0, _ZERO_REGNO, rn(t0));
1204     jit_unget_reg(t0);
1205     return (w);
1206 }
1207 dbopi(unge)
1208
1209 static jit_word_t
1210 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1211 {
1212     jit_word_t          w;
1213     jit_int32_t         t0;
1214     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1215     ungtr_d(rn(t0), r1, r2);
1216     w = bner(i0, _ZERO_REGNO, rn(t0));
1217     jit_unget_reg(t0);
1218     return (w);
1219 }
1220 dbopi(ungt)
1221
1222 static jit_word_t
1223 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1224 {
1225     jit_word_t          w;
1226     jit_int32_t         t0;
1227     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1228     ltgtr_d(rn(t0), r1, r2);
1229     w = bner(i0, _ZERO_REGNO, rn(t0));
1230     jit_unget_reg(t0);
1231     return (w);
1232 }
1233 dbopi(ltgt)
1234
1235 static jit_word_t
1236 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1237 {
1238     jit_word_t          w;
1239     jit_int32_t         t0;
1240     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1241     ordr_d(rn(t0), r1, r2);
1242     w = bner(i0, _ZERO_REGNO, rn(t0));
1243     jit_unget_reg(t0);
1244     return (w);
1245 }
1246 dbopi(ord)
1247
1248 static jit_word_t
1249 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1250 {
1251     jit_word_t          w;
1252     jit_int32_t         t0;
1253     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1254     unordr_d(rn(t0), r1, r2);
1255     w = bner(i0, _ZERO_REGNO, rn(t0));
1256     jit_unget_reg(t0);
1257     return (w);
1258 }
1259 dbopi(unord)
1260
1261 static void
1262 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1263 {
1264     assert(_jitc->function->self.call & jit_call_varargs);
1265     /* Load argument. */
1266     ldr_d(r0, r1);
1267     /* Update va_list. */
1268     addi(r1, r1, sizeof(jit_float64_t));
1269 }
1270
1271 #endif /* CODE */