deps/lightning/lib/jit_riscv-fpu.c

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