deps/lightning/lib/jit_sparc-fpu.c

   1 /*
   2  * Copyright (C) 2013-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 #  if __WORDSIZE == 32
  22 #    define FPR(r)                      (r)
  23 #    define CLASS_SNG                   jit_class_fpr
  24 #    define CLASS_DBL                   jit_class_fpr
  25 #  else
  26 #    define single_precision_p(r)       ((r) >= 0 && (r) <= 31)
  27 #    define FPR(r)                      ((r) > 31 ? (r) - 31 : (r))
  28 #    define CLASS_SNG                   (jit_class_fpr | jit_class_sng)
  29 #    define CLASS_DBL                   (jit_class_fpr | jit_class_dbl)
  30 #  endif
  31 #  define LDF(rs1, rs2, rd)             f3r(3, FPR(rd), 32, FPR(rs1), FPR(rs2))
  32 #  define LDFI(rs1, imm, rd)            f3i(3, FPR(rd), 32, FPR(rs1), imm)
  33 #  define LDDF(rs1, rs2, rd)            f3r(3, FPR(rd), 35, FPR(rs1), FPR(rs2))
  34 #  define LDDFI(rs1, imm, rd)           f3i(3, FPR(rd), 35, FPR(rs1), imm)
  35 #  define LDFSR(rs1, rs2, rd)           f3r(3, FPR(rd), 33, FPR(rs1), FPR(rs2))
  36 #  define LDFSRI(rs1, imm, rd)          f3i(3, FPR(rd), 33, FPR(rs1), imm)
  37 #  define STF(rd, rs1, rs2)             f3r(3, FPR(rd), 36, FPR(rs1), FPR(rs2))
  38 #  define STFI(rd, rs1, imm)            f3i(3, FPR(rd), 36, FPR(rs1), imm)
  39 #  define STDF(rd, rs1, rs2)            f3r(3, FPR(rd), 39, FPR(rs1), FPR(rs2))
  40 #  define STDFI(rd, rs1, imm)           f3i(3, FPR(rd), 39, FPR(rs1), imm)
  41 #  define STFSR(rd, rs1, rs2)           f3r(3, FPR(rd), 37, FPR(rs1), FPR(rs2))
  42 #  define STFSRI(rd, rs1, imm)          f3i(3, FPR(rd), 37, FPR(rs1), imm)
  43 #  define STDFQ(rd, rs1, rs2)           f3r(3, FPR(rd), 38, FPR(rs1), FPR(rs2))
  44 #  define STFDFQ(rd, rs1, imm)          f3i(3, FPR(rd), 38, FPR(rs1), imm)
  45 #  define SPARC_FBA                     8       /* always - 1 */
  46 #  define SPARC_FBN                     0       /* never - 0 */
  47 #  define SPARC_FBU                     7       /* unordered - U */
  48 #  define SPARC_FBG                     6       /* greater - G */
  49 #  define SPARC_FBUG                    5       /* unordered or greater - G or U */
  50 #  define SPARC_FBL                     4       /* less - L */
  51 #  define SPARC_FBUL                    3       /* unordered or less - L or U */
  52 #  define SPARC_FBLG                    2       /* less or greater - L or G */
  53 #  define SPARC_FBNE                    1       /* not equal - L or G or U */
  54 #  define SPARC_FBNZ                    SPARC_FBNE
  55 #  define SPARC_FBE                     9       /* equal - E */
  56 #  define SPARC_FBZ                     SPARC_FBE
  57 #  define SPARC_FBUE                    10      /* unordered or equal - E or U */
  58 #  define SPARC_FBGE                    11      /* greater or equal - E or G */
  59 #  define SPARC_FBUGE                   12      /* unordered or greater or equal - E or G or U */
  60 #  define SPARC_FBLE                    13      /* less or equal - E or L */
  61 #  define SPARC_FBULE                   14      /* unordered or less or equal - E or L or U */
  62 #  define SPARC_FBO                     15      /* ordered - E or L or G */
  63 #  define FB(cc, imm)                   f2b(0, 0, cc, 6, imm)
  64 #  define FBa(cc, imm)                  f2b(0, 1, cc, 6, imm)
  65 #  define FBA(imm)                      FB(SPARC_FBA, imm)
  66 #  define FBAa(imm)                     FBa(SPARC_FBA, imm)
  67 #  define FBN(imm)                      FB(SPARC_FBN, imm)
  68 #  define FBNa(imm)                     FBa(SPARC_FBN, imm)
  69 #  define FBU(imm)                      FB(SPARC_FBU, imm)
  70 #  define FBUa(imm)                     FBa(SPARC_FBU, imm)
  71 #  define FBG(imm)                      FB(SPARC_FBG, imm)
  72 #  define FBGa(imm)                     FBa(SPARC_FBG, imm)
  73 #  define FBUG(imm)                     FB(SPARC_FBUG, imm)
  74 #  define FBUGa(imm)                    FBa(SPARC_FBUG, imm)
  75 #  define FBL(imm)                      FB(SPARC_FBL, imm)
  76 #  define FBLa(imm)                     FBa(SPARC_FBL, imm)
  77 #  define FBUL(imm)                     FB(SPARC_FBUL, imm)
  78 #  define FBULa(imm)                    FBa(SPARC_FBUL, imm)
  79 #  define FBLG(imm)                     FB(SPARC_FBLG, imm)
  80 #  define FBLGa(imm)                    FBa(SPARC_FBLG, imm)
  81 #  define FBNE(imm)                     FB(SPARC_FBNE, imm)
  82 #  define FBNEa(imm)                    FBa(SPARC_FBNE, imm)
  83 #  define FBE(imm)                      FB(SPARC_FBE, imm)
  84 #  define FBEa(imm)                     FBa(SPARC_FBE, imm)
  85 #  define FBUE(imm)                     FB(SPARC_FBUE, imm)
  86 #  define FBUEa(imm)                    FBa(SPARC_FBUE, imm)
  87 #  define FBLE(imm)                     FB(SPARC_FBLE, imm)
  88 #  define FBLEa(imm)                    FBa(SPARC_FBLE, imm)
  89 #  define FBO(imm)                      FB(SPARC_FBO, imm)
  90 #  define FBOa(imm)                     FBa(SPARC_FBO, imm)
  91 #  define FPop1(rd, rs1, opf, rs2)      f3f(rd, 52, rs1, opf, rs2)
  92 #  define FPop2(rd, rs1, opf, rs2)      f3f(rd, 53, rs1, opf, rs2)
  93 #  define f3f(rd, op3, rs1, opf, rs2)   _f3f(_jit, rd, op3, rs1, opf, rs2)
  94 static void
  95 _f3f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t);
  96 #  define FITOS(rs2, rd)                FPop1(rd, 0, 196, rs2)
  97 #  define FITOD(rs2, rd)                FPop1(rd, 0, 200, rs2)
  98 #  define FITOQ(rs2, rd)                FPop1(rd, 0, 204, rs2)
  99 #  if __WORDSIZE == 64
 100 #    define FXTOS(rs2, rd)              FPop1(rd, 0, 132, rs2)
 101 #    define FXTOD(rs2, rd)              FPop1(rd, 0, 136, rs2)
 102 #    define FxTOQ(rs2, rd)              FPop1(rd, 0, 140, rs2)
 103 #  endif
 104 #  define FSTOI(rs2, rd)                FPop1(rd, 0, 209, rs2)
 105 #  define FDTOI(rs2, rd)                FPop1(rd, 0, 210, rs2)
 106 #  define FQTOI(rs2, rd)                FPop1(rd, 0, 211, rs2)
 107 #  define FSTOX(rs2, rd)                FPop1(rd, 0, 129, rs2)
 108 #  define FDTOX(rs2, rd)                FPop1(rd, 0, 130, rs2)
 109 #  define FQTOX(rs2, rd)                FPop1(rd, 0, 131, rs2)
 110 #  define FSTOD(rs2, rd)                FPop1(rd, 0, 201, rs2)
 111 #  define FSTOQ(rs2, rd)                FPop1(rd, 0, 205, rs2)
 112 #  define FDTOS(rs2, rd)                FPop1(rd, 0, 198, rs2)
 113 #  define FDTOQ(rs2, rd)                FPop1(rd, 0, 206, rs2)
 114 #  define FQTOS(rs2, rd)                FPop1(rd, 0, 199, rs2)
 115 #  define FQTOD(rs2, rd)                FPop1(rd, 0, 203, rs2)
 116 #  define FMOVS(rs2, rd)                FPop1(rd, 0,   1, rs2)
 117 #  define FMOVD(rs2, rd)                FPop1(rd, 0,   2, rs2)
 118 #  define FMOVQ(rs2, rd)                FPop1(rd, 0,   3, rs2)
 119 #  define FNEGS(rs2, rd)                FPop1(rd, 0,   5, rs2)
 120 #  define FNEGD(rs2, rd)                FPop1(rd, 0,   6, rs2)
 121 #  define FNEGQ(rs2, rd)                FPop1(rd, 0,   7, rs2)
 122 #  define FABSS(rs2, rd)                FPop1(rd, 0,   9, rs2)
 123 #  define FABSD(rs2, rd)                FPop1(rd, 0,  10, rs2)
 124 #  define FABSQ(rs2, rd)                FPop1(rd, 0,  11, rs2)
 125 #  define FSQRTS(rs2, rd)               FPop1(rd, 0,  41, rs2)
 126 #  define FSQRTD(rs2, rd)               FPop1(rd, 0,  42, rs2)
 127 #  define FSQRTQ(rs2, rd)               FPop1(rd, 0,  43, rs2)
 128 #  define SPARC_FADDS                   65
 129 #  define SPARC_FADDD                   66
 130 #  define SPARC_FADDQ                   67
 131 #  define SPARC_FSUBS                   69
 132 #  define SPARC_FSUBD                   70
 133 #  define SPARC_FSUBQ                   71
 134 #  define SPARC_FMULS                   73
 135 #  define SPARC_FMULD                   74
 136 #  define SPARC_FMULQ                   75
 137 #  define SPARC_FSMULD                  105
 138 #  define SPARC_FDMULQ                  110
 139 #  define SPARC_FDIVS                   77
 140 #  define SPARC_FDIVD                   78
 141 #  define SPARC_FDIVQ                   79
 142 #  define FADDS(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FADDS, rs2)
 143 #  define FADDD(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FADDD, rs2)
 144 #  define FADDQ(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FADDQ, rs2)
 145 #  define FSUBS(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FSUBS, rs2)
 146 #  define FSUBD(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FSUBD, rs2)
 147 #  define FSUBQ(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FSUBQ, rs2)
 148 #  define FMULS(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FMULS, rs2)
 149 #  define FMULD(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FMULD, rs2)
 150 #  define FMULQ(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FMULQ, rs2)
 151 #  define FSMULD(rs1, rs2, rd)          FPop1(rd, rs1,  SPARC_FSMULD, rs2)
 152 #  define FDMULQ(rs1, rs2, rd)          FPop1(rd, rs1,  SPARC_FDMULQ, rs2)
 153 #  define FDIVS(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FDIVS, rs2)
 154 #  define FDIVD(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FDIVD, rs2)
 155 #  define FDIVQ(rs1, rs2, rd)           FPop1(rd, rs1,  SPARC_FDIVQ, rs2)
 156 #  define SPARC_FCMPS                   81
 157 #  define SPARC_FCMPD                   82
 158 #  define SPARC_FCMPQ                   83
 159 #  define SPARC_FCMPES                  85
 160 #  define SPARC_FCMPED                  86
 161 #  define SPARC_FCMPEQ                  87
 162 #  define FCMPS(rs1, rs2)               FPop2(0, rs1, SPARC_FCMPS, rs2)
 163 #  define FCMPD(rs1, rs2)               FPop2(0, rs1, SPARC_FCMPD, rs2)
 164 #  define FCMPQ(rs1, rs2)               FPop2(0, rs1, SPARC_FCMPQ, rs2)
 165 #  define FCMPES(rs1, rs2)              FPop2(0, rs1, SPARC_FCMPES, rs2)
 166 #  define FCMPED(rs1, rs2)              FPop2(0, rs1, SPARC_FCMPED, rs2)
 167 #  define FCMPEQ(rs1, rs2)              FPop2(0, rs1, SPARC_FCMPEQ, rs2)
 168 #  define CPop1(rd, rs1, opc, rs2)      f3f(rd, 54, rs1, opf, rs2)
 169 #  define CPop2(rd, rs1, opc, rs2)      f3f(rd, 55, rs1, opf, rs2)
 170 #  define extr_f(r0, r1)                _extr_f(_jit, r0, r1)
 171 static void _extr_f(jit_state_t*, jit_int32_t, jit_int32_t);
 172 #  if __WORDSIZSE == 32
 173 #    define truncr_f(r0, r1)            truncr_f_i(r0, r1)
 174 #  define truncr_d(r0, r1)              truncr_d_i(r0, r1)
 175 #  else
 176 #    define truncr_f(r0, r1)            truncr_f_l(r0, r1)
 177 #  define truncr_d(r0, r1)              truncr_d_l(r0, r1)
 178 #  endif
 179 #  define truncr_f_i(r0, r1)            _truncr_f_i(_jit, r0, r1)
 180 static void _truncr_f_i(jit_state_t*, jit_int32_t, jit_int32_t);
 181 #  if __WORDSIZE == 64
 182 #    define truncr_f_l(r0, r1)          _truncr_f_l(_jit, r0, r1)
 183 static void _truncr_f_l(jit_state_t*, jit_int32_t, jit_int32_t);
 184 #  endif
 185 #  if __WORDSIZE == 32
 186 #    define extr_d_f(r0, r1)            FDTOS(r1, r0)
 187 #  else
 188 #    define extr_d_f(r0, r1)            _extr_d_f(_jit, r0, r1)
 189 static void _extr_d_f(jit_state_t*, jit_int32_t, jit_int32_t);
 190 #  endif
 191 #  define movi_f(r0, i0)                _movi_f(_jit, r0, i0)
 192 #  if __WORDSIZE == 32
 193 #    define movr_f(r0, r1)              FMOVS(r1, r0)
 194 #  else
 195 #    define movr_f(r0, r1)              _movr_f(_jit, r0, r1)
 196 static void _movr_f(jit_state_t*, jit_int32_t, jit_int32_t);
 197 #  endif
 198 static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t*);
 199 #  if __WORDSIZE == 32
 200 #    define negr_f(r0, r1)              FNEGS(r1, r0)
 201 #    define absr_f(r0, r1)              FABSS(r1, r0)
 202 #    define sqrtr_f(r0, r1)             FSQRTS(r1, r0)
 203 #  else
 204 #    define negr_f(r0, r1)              _negr_f(_jit, r0, r1)
 205 static void _negr_f(jit_state_t*, jit_int32_t, jit_int32_t);
 206 #    define absr_f(r0, r1)              _absr_f(_jit, r0, r1)
 207 static void _absr_f(jit_state_t*, jit_int32_t, jit_int32_t);
 208 #    define sqrtr_f(r0, r1)             _sqrtr_f(_jit, r0, r1)
 209 static void _sqrtr_f(jit_state_t*, jit_int32_t, jit_int32_t);
 210 #  endif
 211 #  define extr_d(r0, r1)                _extr_d(_jit, r0, r1)
 212 static void _extr_d(jit_state_t*, jit_int32_t, jit_int32_t);
 213 #  define truncr_d_i(r0, r1)            _truncr_d_i(_jit, r0, r1)
 214 static void _truncr_d_i(jit_state_t*, jit_int32_t, jit_int32_t);
 215 #  if __WORDSIZE == 64
 216 #    define truncr_d_l(r0, r1)          _truncr_d_l(_jit, r0, r1)
 217 static void _truncr_d_l(jit_state_t*, jit_int32_t, jit_int32_t);
 218 #  endif
 219 #  if __WORDSIZE == 32
 220 #    define extr_f_d(r0, r1)            FSTOD(r1, r0)
 221 #  else
 222 #    define extr_f_d(r0, r1)            _extr_f_d(_jit, r0, r1)
 223 static void _extr_f_d(jit_state_t*, jit_int32_t, jit_int32_t);
 224 #  endif
 225 #  define movi_d(r0, i0)                _movi_d(_jit, r0, i0)
 226 static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t*);
 227 #  if __WORDSIZE == 32
 228 #  define movr_d(r0, r1)                _movr_d(_jit, r0, r1)
 229 static void _movr_d(jit_state_t*, jit_int32_t, jit_int32_t);
 230 #  define negr_d(r0, r1)                _negr_d(_jit, r0, r1)
 231 static void _negr_d(jit_state_t*, jit_int32_t, jit_int32_t);
 232 #  define absr_d(r0, r1)                _absr_d(_jit, r0, r1)
 233 static void _absr_d(jit_state_t*, jit_int32_t, jit_int32_t);
 234 #  else
 235 #    define movr_d(r0, r1)              FMOVD(r1, r0)
 236 #    define negr_d(r0, r1)              FNEGD(r1, r0)
 237 #    define absr_d(r0, r1)              FABSD(r1, r0)
 238 #  endif
 239 #  define sqrtr_d(r0, r1)               FSQRTD(r1, r0)
 240 #  define fop1f(op, r0, r1, i0)         _fop1f(_jit, op, r0, r1, i0)
 241 static void _fop1f(jit_state_t*,jit_int32_t,
 242                    jit_int32_t,jit_int32_t,jit_float32_t*);
 243 #  define rfop1f(op, r0, r1, i0)        _rfop1f(_jit, op, r0, r1, i0)
 244 static void _rfop1f(jit_state_t*,jit_int32_t,
 245                     jit_int32_t,jit_int32_t,jit_float32_t*);
 246 #  define fop1d(op, r0, r1, i0)         _fop1d(_jit, op, r0, r1, i0)
 247 static void _fop1d(jit_state_t*,jit_int32_t,
 248                    jit_int32_t,jit_int32_t,jit_float64_t*);
 249 #  define rfop1d(op, r0, r1, i0)        _rfop1d(_jit, op, r0, r1, i0)
 250 static void _rfop1d(jit_state_t*,jit_int32_t,
 251                     jit_int32_t,jit_int32_t,jit_float64_t*);
 252 #  if __WORDSIZE == 32
 253 #    define addr_f(r0, r1, r2)          FADDS(r1, r2, r0)
 254 #    define subr_f(r0, r1, r2)          FSUBS(r1, r2, r0)
 255 #    define mulr_f(r0, r1, r2)          FMULS(r1, r2, r0)
 256 #    define divr_f(r0, r1, r2)          FDIVS(r1, r2, r0)
 257 #  else
 258 #    define fop2f(op, r0, r1, r2)       _fop2f(_jit, op, r0, r1, r2)
 259 static void _fop2f(jit_state_t*, jit_int32_t,
 260                    jit_int32_t, jit_int32_t, jit_int32_t);
 261 #    define addr_f(r0, r1, r2)          fop2f(SPARC_FADDS, r0, r1, r2)
 262 #    define subr_f(r0, r1, r2)          fop2f(SPARC_FSUBS, r0, r1, r2)
 263 #    define mulr_f(r0, r1, r2)          fop2f(SPARC_FMULS, r0, r1, r2)
 264 #    define divr_f(r0, r1, r2)          fop2f(SPARC_FDIVS, r0, r1, r2)
 265 #  endif
 266 #  define addi_f(r0, r1, i0)            fop1f(SPARC_FADDS, r0, r1, i0)
 267 #  define subi_f(r0, r1, i0)            fop1f(SPARC_FSUBS, r0, r1, i0)
 268 #  define rsbr_f(r0, r1, r2)            subr_f(r0, r2, r1)
 269 #  define rsbi_f(r0, r1, i0)            rfop1f(SPARC_FSUBS, r0, r1, i0)
 270 #  define rsbr_d(r0, r1, r2)            subr_d(r0, r2, r1)
 271 #  define rsbi_d(r0, r1, i0)            rfop1d(SPARC_FSUBD, r0, r1, i0)
 272 #  define muli_f(r0, r1, i0)            fop1f(SPARC_FMULS, r0, r1, i0)
 273 #  define divi_f(r0, r1, i0)            fop1f(SPARC_FDIVS, r0, r1, i0)
 274 #  define addr_d(r0, r1, r2)            FADDD(r1, r2, r0)
 275 #  define addi_d(r0, r1, i0)            fop1d(SPARC_FADDD, r0, r1, i0)
 276 #  define subr_d(r0, r1, r2)            FSUBD(r1, r2, r0)
 277 #  define subi_d(r0, r1, i0)            fop1d(SPARC_FSUBD, r0, r1, i0)
 278 #  define rsbr_d(r0, r1, r2)            subr_d(r0, r2, r1)
 279 #  define rsbi_d(r0, r1, i0)            rfop1d(SPARC_FSUBD, r0, r1, i0)
 280 #  define mulr_d(r0, r1, r2)            FMULD(r1, r2, r0)
 281 #  define muli_d(r0, r1, i0)            fop1d(SPARC_FMULD, r0, r1, i0)
 282 #  define divr_d(r0, r1, r2)            FDIVD(r1, r2, r0)
 283 #  define divi_d(r0, r1, i0)            fop1d(SPARC_FDIVD, r0, r1, i0)
 284 #define fcr(cc, r0, r1, r2)             _fcr(_jit, cc, r0, r1, r2)
 285 static void _fcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 286 #define fcw(cc, r0, r1, i0)             _fcw(_jit, cc, r0, r1, i0)
 287 static void
 288 _fcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float32_t*);
 289 #  define ltr_f(r0, r1, r2)             fcr(SPARC_FBL, r0, r1, r2)
 290 #  define lti_f(r0, r1, i0)             fcw(SPARC_FBL, r0, r1, i0)
 291 #  define ler_f(r0, r1, r2)             fcr(SPARC_FBLE, r0, r1, r2)
 292 #  define lei_f(r0, r1, i0)             fcw(SPARC_FBLE, r0, r1, i0)
 293 #  define eqr_f(r0, r1, r2)             fcr(SPARC_FBE, r0, r1, r2)
 294 #  define eqi_f(r0, r1, i0)             fcw(SPARC_FBE, r0, r1, i0)
 295 #  define ger_f(r0, r1, r2)             fcr(SPARC_FBGE, r0, r1, r2)
 296 #  define gei_f(r0, r1, i0)             fcw(SPARC_FBGE, r0, r1, i0)
 297 #  define gtr_f(r0, r1, r2)             fcr(SPARC_FBG, r0, r1, r2)
 298 #  define gti_f(r0, r1, i0)             fcw(SPARC_FBG, r0, r1, i0)
 299 #  define ner_f(r0, r1, r2)             fcr(SPARC_FBNE, r0, r1, r2)
 300 #  define nei_f(r0, r1, i0)             fcw(SPARC_FBNE, r0, r1, i0)
 301 #  define unltr_f(r0, r1, r2)           fcr(SPARC_FBUL, r0, r1, r2)
 302 #  define unlti_f(r0, r1, i0)           fcw(SPARC_FBUL, r0, r1, i0)
 303 #  define unler_f(r0, r1, r2)           fcr(SPARC_FBULE, r0, r1, r2)
 304 #  define unlei_f(r0, r1, i0)           fcw(SPARC_FBULE, r0, r1, i0)
 305 #  define uneqr_f(r0, r1, r2)           fcr(SPARC_FBUE, r0, r1, r2)
 306 #  define uneqi_f(r0, r1, i0)           fcw(SPARC_FBUE, r0, r1, i0)
 307 #  define unger_f(r0, r1, r2)           fcr(SPARC_FBUGE, r0, r1, r2)
 308 #  define ungei_f(r0, r1, i0)           fcw(SPARC_FBUGE, r0, r1, i0)
 309 #  define ungtr_f(r0, r1, r2)           fcr(SPARC_FBUG, r0, r1, r2)
 310 #  define ungti_f(r0, r1, i0)           fcw(SPARC_FBUG, r0, r1, i0)
 311 #  define ltgtr_f(r0, r1, r2)           fcr(SPARC_FBLG, r0, r1, r2)
 312 #  define ltgti_f(r0, r1, i0)           fcw(SPARC_FBLG, r0, r1, i0)
 313 #  define ordr_f(r0, r1, r2)            fcr(SPARC_FBO, r0, r1, r2)
 314 #  define ordi_f(r0, r1, i0)            fcw(SPARC_FBO, r0, r1, i0)
 315 #  define unordr_f(r0, r1, r2)          fcr(SPARC_FBU, r0, r1, r2)
 316 #  define unordi_f(r0, r1, i0)          fcw(SPARC_FBU, r0, r1, i0)
 317 #define dcr(cc, r0, r1, r2)             _dcr(_jit, cc, r0, r1, r2)
 318 static void _dcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 319 #define dcw(cc, r0, r1, i0)             _dcw(_jit, cc, r0, r1, i0)
 320 static void
 321 _dcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float64_t*);
 322 #  define ltr_d(r0, r1, r2)             dcr(SPARC_FBL, r0, r1, r2)
 323 #  define lti_d(r0, r1, i0)             dcw(SPARC_FBL, r0, r1, i0)
 324 #  define ler_d(r0, r1, r2)             dcr(SPARC_FBLE, r0, r1, r2)
 325 #  define lei_d(r0, r1, i0)             dcw(SPARC_FBLE, r0, r1, i0)
 326 #  define eqr_d(r0, r1, r2)             dcr(SPARC_FBE, r0, r1, r2)
 327 #  define eqi_d(r0, r1, i0)             dcw(SPARC_FBE, r0, r1, i0)
 328 #  define ger_d(r0, r1, r2)             dcr(SPARC_FBGE, r0, r1, r2)
 329 #  define gei_d(r0, r1, i0)             dcw(SPARC_FBGE, r0, r1, i0)
 330 #  define gtr_d(r0, r1, r2)             dcr(SPARC_FBG, r0, r1, r2)
 331 #  define gti_d(r0, r1, i0)             dcw(SPARC_FBG, r0, r1, i0)
 332 #  define ner_d(r0, r1, r2)             dcr(SPARC_FBNE, r0, r1, r2)
 333 #  define nei_d(r0, r1, i0)             dcw(SPARC_FBNE, r0, r1, i0)
 334 #  define unltr_d(r0, r1, r2)           dcr(SPARC_FBUL, r0, r1, r2)
 335 #  define unlti_d(r0, r1, i0)           dcw(SPARC_FBUL, r0, r1, i0)
 336 #  define unler_d(r0, r1, r2)           dcr(SPARC_FBULE, r0, r1, r2)
 337 #  define unlei_d(r0, r1, i0)           dcw(SPARC_FBULE, r0, r1, i0)
 338 #  define uneqr_d(r0, r1, r2)           dcr(SPARC_FBUE, r0, r1, r2)
 339 #  define uneqi_d(r0, r1, i0)           dcw(SPARC_FBUE, r0, r1, i0)
 340 #  define unger_d(r0, r1, r2)           dcr(SPARC_FBUGE, r0, r1, r2)
 341 #  define ungei_d(r0, r1, i0)           dcw(SPARC_FBUGE, r0, r1, i0)
 342 #  define ungtr_d(r0, r1, r2)           dcr(SPARC_FBUG, r0, r1, r2)
 343 #  define ungti_d(r0, r1, i0)           dcw(SPARC_FBUG, r0, r1, i0)
 344 #  define ltgtr_d(r0, r1, r2)           dcr(SPARC_FBLG, r0, r1, r2)
 345 #  define ltgti_d(r0, r1, i0)           dcw(SPARC_FBLG, r0, r1, i0)
 346 #  define ordr_d(r0, r1, r2)            dcr(SPARC_FBO, r0, r1, r2)
 347 #  define ordi_d(r0, r1, i0)            dcw(SPARC_FBO, r0, r1, i0)
 348 #  define unordr_d(r0, r1, r2)          dcr(SPARC_FBU, r0, r1, r2)
 349 #  define unordi_d(r0, r1, i0)          dcw(SPARC_FBU, r0, r1, i0)
 350 #  if __WORDSIZE == 32
 351 #    define ldr_f(r0, r1)               LDF(r1, 0, r0)
 352 #  else
 353 #  define ldr_f(r0, r1)                 _ldr_f(_jit, r0, r1)
 354 static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 355 #  endif
 356 #  define ldi_f(r0, i0)                 _ldi_f(_jit, r0, i0)
 357 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 358 #  if __WORDSIZE == 32
 359 #    define ldxr_f(r0, r1, r2)          LDF(r1, r2, r0)
 360 #  else
 361 #  define ldxr_f(r0, r1, r2)            _ldxr_f(_jit, r0, r1, r2)
 362 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 363 #  endif
 364 #  define ldxi_f(r0, r1, i0)            _ldxi_f(_jit, r0, r1, i0)
 365 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 366 #  if __WORDSIZE == 32
 367 #    define str_f(r0, r1)               STF(r1, r0, 0)
 368 #  else
 369 #  define str_f(r0, r1)                 _str_f(_jit, r0, r1)
 370 static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t);
 371 #  endif
 372 #  define sti_f(r0, i0)                 _sti_f(_jit, r0, i0)
 373 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 374 #  if __WORDSIZE == 32
 375 #    define stxr_f(r0, r1, r2)          STF(r2, r1, r0)
 376 #  else
 377 #  define stxr_f(r0, r1, r2)            _stxr_f(_jit, r0, r1, r2)
 378 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 379 #  endif
 380 #  define stxi_f(r0, r1, i0)            _stxi_f(_jit, r0, r1, i0)
 381 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 382 #  define ldr_d(r0, r1)                 LDDF(r1, 0, r0)
 383 #  define ldi_d(r0, i0)                 _ldi_d(_jit, r0, i0)
 384 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 385 #  define ldxr_d(r0, r1, r2)            LDDF(r1, r2, r0)
 386 #  define ldxi_d(r0, r1, i0)            _ldxi_d(_jit, r0, r1, i0)
 387 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 388 #  define str_d(r0, r1)                 STDF(r1, r0, 0)
 389 #  define sti_d(r0, i0)                 _sti_d(_jit, r0, i0)
 390 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 391 #  define stxr_d(r0, r1, r2)            STDF(r2, r1, r0)
 392 #  define stxi_d(r0, r1, i0)            _stxi_d(_jit, r0, r1, i0)
 393 static void _stxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 394 #  define fbr(cc, i0, r0, r1)           _fbr(_jit, cc, i0, r0, r1)
 395 static jit_word_t
 396 _fbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 397 #  define fbw(cc, i0, r0, i1)           _fbw(_jit, cc, i0, r0, i1)
 398 static jit_word_t
 399 _fbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t*);
 400 #  define bltr_f(i0, r0, r1)            fbr(SPARC_FBL, i0, r0, r1)
 401 #  define blti_f(i0, r0, i1)            fbw(SPARC_FBL, i0, r0, i1)
 402 #  define bler_f(i0, r0, r1)            fbr(SPARC_FBLE, i0, r0, r1)
 403 #  define blei_f(i0, r0, i1)            fbw(SPARC_FBLE, i0, r0, i1)
 404 #  define beqr_f(i0, r0, r1)            fbr(SPARC_FBE, i0, r0, r1)
 405 #  define beqi_f(i0, r0, i1)            fbw(SPARC_FBE, i0, r0, i1)
 406 #  define bger_f(i0, r0, r1)            fbr(SPARC_FBGE, i0, r0, r1)
 407 #  define bgei_f(i0, r0, i1)            fbw(SPARC_FBGE, i0, r0, i1)
 408 #  define bgtr_f(i0, r0, r1)            fbr(SPARC_FBG, i0, r0, r1)
 409 #  define bgti_f(i0, r0, i1)            fbw(SPARC_FBG, i0, r0, i1)
 410 #  define bner_f(i0, r0, r1)            fbr(SPARC_FBNE, i0, r0, r1)
 411 #  define bnei_f(i0, r0, i1)            fbw(SPARC_FBNE, i0, r0, i1)
 412 #  define bunltr_f(i0, r0, r1)          fbr(SPARC_FBUL, i0, r0, r1)
 413 #  define bunlti_f(i0, r0, i1)          fbw(SPARC_FBUL, i0, r0, i1)
 414 #  define bunler_f(i0, r0, r1)          fbr(SPARC_FBULE, i0, r0, r1)
 415 #  define bunlei_f(i0, r0, i1)          fbw(SPARC_FBULE, i0, r0, i1)
 416 #  define buneqr_f(i0, r0, r1)          fbr(SPARC_FBUE, i0, r0, r1)
 417 #  define buneqi_f(i0, r0, i1)          fbw(SPARC_FBUE, i0, r0, i1)
 418 #  define bunger_f(i0, r0, r1)          fbr(SPARC_FBUGE, i0, r0, r1)
 419 #  define bungei_f(i0, r0, i1)          fbw(SPARC_FBUGE, i0, r0, i1)
 420 #  define bungtr_f(i0, r0, r1)          fbr(SPARC_FBUG, i0, r0, r1)
 421 #  define bungti_f(i0, r0, i1)          fbw(SPARC_FBUG, i0, r0, i1)
 422 #  define bltgtr_f(i0, r0, r1)          fbr(SPARC_FBLG, i0, r0, r1)
 423 #  define bltgti_f(i0, r0, i1)          fbw(SPARC_FBLG, i0, r0, i1)
 424 #  define bordr_f(i0, r0, r1)           fbr(SPARC_FBO, i0, r0, r1)
 425 #  define bordi_f(i0, r0, i1)           fbw(SPARC_FBO, i0, r0, i1)
 426 #  define bunordr_f(i0, r0, r1)         fbr(SPARC_FBU, i0, r0, r1)
 427 #  define bunordi_f(i0, r0, i1)         fbw(SPARC_FBU, i0, r0, i1)
 428 #  define dbr(cc, i0, r0, r1)           _dbr(_jit, cc, i0, r0, r1)
 429 static jit_word_t
 430 _dbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 431 #  define dbw(cc, i0, r0, i1)           _dbw(_jit, cc, i0, r0, i1)
 432 static jit_word_t
 433 _dbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t*);
 434 #  define bltr_d(i0, r0, r1)            dbr(SPARC_FBL, i0, r0, r1)
 435 #  define blti_d(i0, r0, i1)            dbw(SPARC_FBL, i0, r0, i1)
 436 #  define bler_d(i0, r0, r1)            dbr(SPARC_FBLE, i0, r0, r1)
 437 #  define blei_d(i0, r0, i1)            dbw(SPARC_FBLE, i0, r0, i1)
 438 #  define beqr_d(i0, r0, r1)            dbr(SPARC_FBE, i0, r0, r1)
 439 #  define beqi_d(i0, r0, i1)            dbw(SPARC_FBE, i0, r0, i1)
 440 #  define bger_d(i0, r0, r1)            dbr(SPARC_FBGE, i0, r0, r1)
 441 #  define bgei_d(i0, r0, i1)            dbw(SPARC_FBGE, i0, r0, i1)
 442 #  define bgtr_d(i0, r0, r1)            dbr(SPARC_FBG, i0, r0, r1)
 443 #  define bgti_d(i0, r0, i1)            dbw(SPARC_FBG, i0, r0, i1)
 444 #  define bner_d(i0, r0, r1)            dbr(SPARC_FBNE, i0, r0, r1)
 445 #  define bnei_d(i0, r0, i1)            dbw(SPARC_FBNE, i0, r0, i1)
 446 #  define bunltr_d(i0, r0, r1)          dbr(SPARC_FBUL, i0, r0, r1)
 447 #  define bunlti_d(i0, r0, i1)          dbw(SPARC_FBUL, i0, r0, i1)
 448 #  define bunler_d(i0, r0, r1)          dbr(SPARC_FBULE, i0, r0, r1)
 449 #  define bunlei_d(i0, r0, i1)          dbw(SPARC_FBULE, i0, r0, i1)
 450 #  define buneqr_d(i0, r0, r1)          dbr(SPARC_FBUE, i0, r0, r1)
 451 #  define buneqi_d(i0, r0, i1)          dbw(SPARC_FBUE, i0, r0, i1)
 452 #  define bunger_d(i0, r0, r1)          dbr(SPARC_FBUGE, i0, r0, r1)
 453 #  define bungei_d(i0, r0, i1)          dbw(SPARC_FBUGE, i0, r0, i1)
 454 #  define bungtr_d(i0, r0, r1)          dbr(SPARC_FBUG, i0, r0, r1)
 455 #  define bungti_d(i0, r0, i1)          dbw(SPARC_FBUG, i0, r0, i1)
 456 #  define bltgtr_d(i0, r0, r1)          dbr(SPARC_FBLG, i0, r0, r1)
 457 #  define bltgti_d(i0, r0, i1)          dbw(SPARC_FBLG, i0, r0, i1)
 458 #  define bordr_d(i0, r0, r1)           dbr(SPARC_FBO, i0, r0, r1)
 459 #  define bordi_d(i0, r0, i1)           dbw(SPARC_FBO, i0, r0, i1)
 460 #  define bunordr_d(i0, r0, r1)         dbr(SPARC_FBU, i0, r0, r1)
 461 #  define bunordi_d(i0, r0, i1)         dbw(SPARC_FBU, i0, r0, i1)
 462 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 463 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 464 #endif
 465
 466 #if CODE
 467 static void
 468 _f3f(jit_state_t *_jit, jit_int32_t rd,
 469      jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
 470 {
 471     jit_instr_t         v;
 472 #  if __WORDSIZE == 64
 473     if (rd > 31) {
 474         assert(rd <= 63 && (rd & 1) == 0);
 475         rd -= 31;
 476     }
 477     if (rs1 > 31) {
 478         assert(rs1 <= 63 && (rs1 & 1) == 0);
 479         rs1 -= 31;
 480     }
 481     if (rs2 > 31) {
 482         assert(rs2 <= 63 && (rs2 & 1) == 0);
 483         rs2 -= 31;
 484     }
 485 #  endif
 486     assert(!(rd  & 0xffffffe0));
 487     assert(!(op3 & 0xffffffc0));
 488     assert(!(rs1 & 0xffffffe0));
 489     assert(!(opf & 0xfffffe00));
 490     assert(!(rs2 & 0xffffffe0));
 491     v.op.b    = 2;
 492     v.rd.b    = rd;
 493     v.op3.b   = op3;
 494     v.rs1.b   = rs1;
 495     v.opf.b   = opf;
 496     v.rs2.b   = rs2;
 497     ii(v.v);
 498 }
 499
 500 #  if __WORDSIZE == 64
 501 static void
 502 _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 503 {
 504     jit_int32_t         t0, t1;
 505     if (r0 != r1) {
 506         if (single_precision_p(r0)) {
 507             if (single_precision_p(r1))
 508                 FMOVS(r1, r0);
 509             else {
 510                 t1 = jit_get_reg(CLASS_SNG);
 511                 movr_d(rn(t1), r1);
 512                 FMOVS(rn(t1), r0);
 513                 jit_unget_reg(t1);
 514             }
 515         }
 516         else {
 517             if (single_precision_p(r1)) {
 518                 t0 = jit_get_reg(CLASS_SNG);
 519                 FMOVS(r1, rn(t0));
 520                 movr_d(r0, rn(t0));
 521                 jit_unget_reg(t0);
 522             }
 523             else {
 524                 t1 = jit_get_reg(CLASS_SNG);
 525                 movr_d(rn(t1), r1);
 526                 FMOVS(rn(t1), rn(t1));
 527                 movr_d(r0, rn(t1));
 528                 jit_unget_reg(t1);
 529             }
 530         }
 531     }
 532 }
 533
 534 static void
 535 _negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 536 {
 537     jit_int32_t         t0, t1;
 538     if (single_precision_p(r0)) {
 539         if (single_precision_p(r1))
 540             FNEGS(r1, r0);
 541         else {
 542             t1 = jit_get_reg(CLASS_SNG);
 543             movr_d(rn(t1), r1);
 544             FNEGS(rn(t1), r0);
 545             jit_unget_reg(t1);
 546         }
 547     }
 548     else {
 549         if (single_precision_p(r1)) {
 550             t0 = jit_get_reg(CLASS_SNG);
 551             FNEGS(r1, rn(t0));
 552             movr_d(r0, rn(t0));
 553             jit_unget_reg(t0);
 554         }
 555         else {
 556             t1 = jit_get_reg(CLASS_SNG);
 557             movr_d(rn(t1), r1);
 558             FNEGS(rn(t1), rn(t1));
 559             movr_d(r0, rn(t1));
 560             jit_unget_reg(t1);
 561         }
 562     }
 563 }
 564
 565 static void
 566 _absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 567 {
 568     jit_int32_t         t0, t1;
 569     if (single_precision_p(r0)) {
 570         if (single_precision_p(r1))
 571             FABSS(r1, r0);
 572         else {
 573             t1 = jit_get_reg(CLASS_SNG);
 574             movr_d(rn(t1), r1);
 575             FABSS(rn(t1), r0);
 576             jit_unget_reg(t1);
 577         }
 578     }
 579     else {
 580         if (single_precision_p(r1)) {
 581             t0 = jit_get_reg(CLASS_SNG);
 582             FABSS(r1, rn(t0));
 583             movr_d(r0, rn(t0));
 584             jit_unget_reg(t0);
 585         }
 586         else {
 587             t1 = jit_get_reg(CLASS_SNG);
 588             movr_d(rn(t1), r1);
 589             FABSS(rn(t1), rn(t1));
 590             movr_d(r0, rn(t1));
 591             jit_unget_reg(t1);
 592         }
 593     }
 594 }
 595
 596 static void
 597 _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 598 {
 599     jit_int32_t         t0, t1;
 600     if (single_precision_p(r0)) {
 601         if (single_precision_p(r1))
 602             FSQRTS(r1, r0);
 603         else {
 604             t1 = jit_get_reg(CLASS_SNG);
 605             movr_d(rn(t1), r1);
 606             FSQRTS(rn(t1), r0);
 607             jit_unget_reg(t1);
 608         }
 609     }
 610     else {
 611         if (single_precision_p(r1)) {
 612             t0 = jit_get_reg(CLASS_SNG);
 613             FSQRTS(r1, rn(t0));
 614             movr_d(r0, rn(t0));
 615             jit_unget_reg(t0);
 616         }
 617         else {
 618             t1 = jit_get_reg(CLASS_SNG);
 619             movr_d(rn(t1), r1);
 620             FSQRTS(rn(t1), rn(t1));
 621             movr_d(r0, rn(t1));
 622             jit_unget_reg(t1);
 623         }
 624     }
 625 }
 626 #  endif
 627
 628 #  if __WORDSIZE == 64
 629 static void
 630 _extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 631 {
 632     jit_int32_t         reg;
 633     if (!single_precision_p(r0)) {
 634         reg = jit_get_reg(CLASS_SNG);
 635         movr_d(rn(reg), r0);
 636         FDTOS(r1, rn(reg));
 637         movr_d(r0, rn(reg));
 638         jit_unget_reg(reg);
 639     }
 640     else
 641         FDTOS(r1, r0);
 642 }
 643 #  endif
 644
 645 static void
 646 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
 647 {
 648     union {
 649         jit_int32_t      i;
 650         jit_float32_t    f;
 651     } data;
 652     jit_int32_t          reg;
 653
 654     if (_jitc->no_data) {
 655         data.f = *i0;
 656         reg = jit_get_reg(jit_class_gpr);
 657         movi(rn(reg), data.i & 0xffffffff);
 658         stxi_i(BIAS(-8), _FP_REGNO, rn(reg));
 659         jit_unget_reg(reg);
 660         ldxi_f(r0, _FP_REGNO, BIAS(-8));
 661     }
 662     else
 663         ldi_f(r0, (jit_word_t)i0);
 664 }
 665
 666 #  if __WORDSIZE == 64
 667 static void
 668 _extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 669 {
 670     jit_int32_t         reg;
 671     if (!single_precision_p(r1)) {
 672         reg = jit_get_reg(CLASS_SNG);
 673         movr_d(rn(reg), r1);
 674         FSTOD(rn(reg), r0);
 675         jit_unget_reg(reg);
 676     }
 677     else
 678         FSTOD(r1, r0);
 679 }
 680 #  endif
 681
 682 static void
 683 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
 684 {
 685     union {
 686 #  if __WORDSIZE == 32
 687         jit_int32_t      i[2];
 688 #  else
 689         jit_word_t       w;
 690 #  endif
 691         jit_float64_t    d;
 692     } data;
 693     jit_int32_t          reg;
 694
 695     if (_jitc->no_data) {
 696         data.d = *i0;
 697         reg = jit_get_reg(jit_class_gpr);
 698 # if __WORDSIZE == 32
 699         movi(rn(reg), data.i[0]);
 700 #  else
 701         movi(rn(reg), data.w);
 702 #  endif
 703         stxi(BIAS(-8), _FP_REGNO, rn(reg));
 704 #  if __WORDSIZE == 32
 705         movi(rn(reg), data.i[1]);
 706         stxi_i(BIAS(-4), _FP_REGNO, rn(reg));
 707 #  endif
 708         jit_unget_reg(reg);
 709         ldxi_d(r0, _FP_REGNO, BIAS(-8));
 710     }
 711     else
 712         ldi_d(r0, (jit_word_t)i0);
 713 }
 714
 715 #  if __WORDSIZE == 32
 716 static void
 717 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 718 {
 719     assert(!(r0 & 1));
 720     assert(!(r1 & 1));
 721     if (r0 != r1) {
 722         FMOVS(r1, r0);
 723         FMOVS(r1 + 1, r0 + 1);
 724     }
 725 }
 726
 727 static void
 728 _negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 729 {
 730     assert(!(r0 & 1));
 731     assert(!(r1 & 1));
 732     FNEGS(r1, r0);
 733     if (r0 != r1)
 734         FMOVS(r1 + 1, r0 + 1);
 735 }
 736
 737 static void
 738 _absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 739 {
 740     assert(!(r0 & 1));
 741     assert(!(r1 & 1));
 742     FABSS(r1, r0);
 743     if (r0 != r1)
 744         FMOVS(r1 + 1, r0 + 1);
 745 }
 746 #  endif
 747
 748 #  if __WORDSIZE == 64
 749 #    define single_rrr(NAME, CODE)                                      \
 750 static void                                                             \
 751 NAME(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) \
 752 {                                                                       \
 753     jit_int32_t         x0, t0, x1, t1, x2, t2, mask = 0;               \
 754     if (!single_precision_p(r0)) {                                      \
 755         mask |= 1;                                                      \
 756         t0 = jit_get_reg(CLASS_SNG);                                    \
 757         x0 = rn(t0);                                                    \
 758         if (r0 == r1) {                                                 \
 759             x1 = x0;                                                    \
 760             movr_d(x1, r1);                                             \
 761             if (r0 == r2)                                               \
 762                 x2 = x0;                                                \
 763         }                                                               \
 764         else if (r0 == r2) {                                            \
 765             x2 = x0;                                                    \
 766             movr_d(x2, r2);                                             \
 767         }                                                               \
 768     }                                                                   \
 769     else                                                                \
 770         x0 = r0;                                                        \
 771     if (!single_precision_p(r1)) {                                      \
 772         if (r0 != r1) {                                                 \
 773             mask |= 2;                                                  \
 774             t1 = jit_get_reg(CLASS_SNG);                                \
 775             x1 = rn(t1);                                                \
 776             movr_d(x1, r1);                                             \
 777             if (r1 == r2)                                               \
 778                 x2 = x1;                                                \
 779         }                                                               \
 780     }                                                                   \
 781     else                                                                \
 782         x1 = r1;                                                        \
 783     if (!single_precision_p(r2)) {                                      \
 784         if (r0 != r2 && r1 != r2) {                                     \
 785             mask |= 4;                                                  \
 786             t2 = jit_get_reg(CLASS_SNG);                                \
 787             x2 = rn(t2);                                                \
 788             movr_d(x2, r2);                                             \
 789         }                                                               \
 790     }                                                                   \
 791     else                                                                \
 792         x2 = r2;                                                        \
 793     CODE(x1, x2, x0);                                                   \
 794     if (mask & 1) {                                                     \
 795         movr_d(r0, x0);                                                 \
 796         jit_unget_reg(t0);                                              \
 797     }                                                                   \
 798     if (mask & 2)                                                       \
 799         jit_unget_reg(t1);                                              \
 800     if (mask & 4)                                                       \
 801         jit_unget_reg(t2);                                              \
 802 }
 803
 804 static void
 805 _fop2f(jit_state_t *_jit, jit_int32_t op,
 806        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 807 {
 808     jit_int32_t         x0, t0, x1, t1, x2, t2, mask = 0;
 809     if (!single_precision_p(r0)) {
 810         mask |= 1;
 811         t0 = jit_get_reg(CLASS_SNG);
 812         x0 = rn(t0);
 813         if (r0 == r1) {
 814             x1 = x0;
 815             movr_d(x1, r1);
 816             if (r0 == r2)
 817                 x2 = x0;
 818         }
 819         else if (r0 == r2) {
 820             x2 = x0;
 821             movr_d(x2, r2);
 822         }
 823     }
 824     else
 825         x0 = r0;
 826     if (!single_precision_p(r1)) {
 827         if (r0 != r1) {
 828             mask |= 2;
 829             t1 = jit_get_reg(CLASS_SNG);
 830             x1 = rn(t1);
 831             movr_d(x1, r1);
 832             if (r1 == r2)
 833                 x2 = x1;
 834         }
 835     }
 836     else
 837         x1 = r1;
 838     if (!single_precision_p(r2)) {
 839         if (r0 != r2 && r1 != r2) {
 840             mask |= 4;
 841             t2 = jit_get_reg(CLASS_SNG);
 842             x2 = rn(t2);
 843             movr_d(x2, r2);
 844         }
 845     }
 846     else
 847         x2 = r2;
 848     FPop1(x0, x1,  op, x2);
 849     if (mask & 1) {
 850         movr_d(r0, x0);
 851         jit_unget_reg(t0);
 852     }
 853     if (mask & 2)
 854         jit_unget_reg(t1);
 855     if (mask & 4)
 856         jit_unget_reg(t2);
 857 }
 858 #  endif
 859
 860 static void
 861 _fop1f(jit_state_t *_jit, jit_int32_t op,
 862        jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
 863 {
 864     jit_int32_t         reg;
 865 #  if __WORDSIZE == 64
 866     jit_int32_t         x0, t0, x1, t1, mask = 0;
 867 #  endif
 868     reg = jit_get_reg(CLASS_SNG);
 869     movi_f(rn(reg), i0);
 870 #  if __WORDSIZE == 64
 871     if (!single_precision_p(r0)) {
 872         mask |= 1;
 873         t0 = jit_get_reg(CLASS_SNG);
 874         x0 = rn(t0);
 875         if (r0 == r1) {
 876             x1 = x0;
 877             movr_d(x1, r1);
 878         }
 879     }
 880     else
 881         x0 = r0;
 882     if (!single_precision_p(r1)) {
 883         if (r0 != r1) {
 884             mask |= 2;
 885             t1 = jit_get_reg(CLASS_SNG);
 886             x1 = rn(t1);
 887             movr_d(x1, r1);
 888         }
 889     }
 890     else
 891         x1 = r1;
 892     FPop1(x0, x1, op, rn(reg));
 893     if (mask & 1) {
 894         movr_d(r0, x0);
 895         jit_unget_reg(t0);
 896     }
 897     if (mask & 2)
 898         jit_unget_reg(t1);
 899 #  else
 900     FPop1(r0, r1, op, rn(reg));
 901 #  endif
 902     jit_unget_reg(reg);
 903 }
 904
 905 static void
 906 _rfop1f(jit_state_t *_jit, jit_int32_t op,
 907         jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
 908 {
 909     jit_int32_t         reg;
 910 #  if __WORDSIZE == 64
 911     jit_int32_t         x0, t0, x1, t1, mask = 0;
 912 #  endif
 913     reg = jit_get_reg(CLASS_SNG);
 914     movi_f(rn(reg), i0);
 915 #  if __WORDSIZE == 64
 916     if (!single_precision_p(r0)) {
 917         mask |= 1;
 918         t0 = jit_get_reg(CLASS_SNG);
 919         x0 = rn(t0);
 920         if (r0 == r1) {
 921             x1 = x0;
 922             movr_d(x1, r1);
 923         }
 924     }
 925     else
 926         x0 = r0;
 927     if (!single_precision_p(r1)) {
 928         if (r0 != r1) {
 929             mask |= 2;
 930             t1 = jit_get_reg(CLASS_SNG);
 931             x1 = rn(t1);
 932             movr_d(x1, r1);
 933         }
 934     }
 935     else
 936         x1 = r1;
 937     FPop1(x0, rn(reg), op, x1);
 938     if (mask & 1) {
 939         movr_d(r0, x0);
 940         jit_unget_reg(t0);
 941     }
 942     if (mask & 2)
 943         jit_unget_reg(t1);
 944 #  else
 945     FPop1(r0, rn(reg), op, r1);
 946 #  endif
 947     jit_unget_reg(reg);
 948 }
 949
 950 static void
 951 _fop1d(jit_state_t *_jit, jit_int32_t op,
 952        jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 953 {
 954     jit_int32_t         reg;
 955     reg = jit_get_reg(CLASS_DBL);
 956     movi_d(rn(reg), i0);
 957     FPop1(r0, r1, op, rn(reg));
 958     jit_unget_reg(reg);
 959 }
 960
 961 static void
 962 _rfop1d(jit_state_t *_jit, jit_int32_t op,
 963         jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 964 {
 965     jit_int32_t         reg;
 966     reg = jit_get_reg(CLASS_DBL);
 967     movi_d(rn(reg), i0);
 968     FPop1(r0, rn(reg), op, r1);
 969     jit_unget_reg(reg);
 970 }
 971
 972 static void
 973 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 974 {
 975     stxi(BIAS(-8), _FP_REGNO, r1);
 976 #  if __WORDSIZE == 32
 977     ldxi_f(r0, _FP_REGNO, BIAS(-8));
 978     FITOS(r0, r0);
 979 #  else
 980     ldxi_d(r0, _FP_REGNO, BIAS(-8));
 981     if (!single_precision_p(r0)) {
 982         jit_int32_t     reg;
 983         reg = jit_get_reg(CLASS_SNG);
 984         movr_d(rn(reg), r0);
 985         FXTOS(rn(reg), rn(reg));
 986         movr_d(r0, rn(reg));
 987         jit_unget_reg(reg);
 988     }
 989     else
 990         FXTOS(r0, r0);
 991 #  endif
 992 }
 993
 994 static void
 995 _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 996 {
 997     jit_int32_t         reg;
 998     reg = jit_get_reg(CLASS_SNG);
 999 #  if __WORDSIZE == 64
1000     if (!single_precision_p(r1)) {
1001         movr_d(rn(reg), r1);
1002         FSTOI(rn(reg), rn(reg));
1003     }
1004     else
1005 #  endif
1006         FSTOI(r1, rn(reg));
1007     stxi_f(BIAS(-8), _FP_REGNO, rn(reg));
1008     ldxi_i(r0, _FP_REGNO, BIAS(-8));
1009     jit_unget_reg(reg);
1010 }
1011
1012 #  if __WORDSIZE == 64
1013 static void
1014 _truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1015 {
1016     jit_int32_t         reg;
1017     reg = jit_get_reg(CLASS_SNG);
1018 #  if __WORDSIZE == 64
1019     if (!single_precision_p(r1)) {
1020         movr_d(rn(reg), r1);
1021         FSTOX(rn(reg), rn(reg));
1022     }
1023     else
1024 #  endif
1025         FSTOX(r1, rn(reg));
1026     stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1027     ldxi_l(r0, _FP_REGNO, BIAS(-8));
1028     jit_unget_reg(reg);
1029 }
1030 #  endif
1031
1032 static void
1033 _fcr(jit_state_t *_jit, jit_int32_t cc,
1034      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1035 {
1036 #  if __WORDSIZE == 64
1037     jit_int32_t         x0, t0, x1, t1, mask = 0;
1038     if (!single_precision_p(r1)) {
1039         mask |= 1;
1040         t0 = jit_get_reg(CLASS_SNG);
1041         x0 = rn(t0);
1042         movr_d(x0, r1);
1043     }
1044     else
1045         x0 = r1;
1046     if (r1 == r2)
1047         x1 = x0;
1048     else if (!single_precision_p(r2)) {
1049         mask |= 2;
1050         t1 = jit_get_reg(CLASS_SNG);
1051         x1 = rn(t1);
1052         movr_d(x1, r2);
1053     }
1054     else
1055         x1 = r2;
1056     FCMPS(x0, x1);
1057     if (mask & 1)
1058         jit_unget_reg(t0);
1059     if (mask & 2)
1060         jit_unget_reg(t1);
1061 #  else
1062     FCMPS(r1, r2);
1063 #  endif
1064     FBa(cc, 3);
1065     movi(r0, 1);
1066     movi(r0, 0);
1067 }
1068
1069 static void
1070 _fcw(jit_state_t *_jit, jit_int32_t cc,
1071      jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
1072 {
1073     jit_int32_t         reg;
1074 #  if __WORDSIZE == 64
1075     jit_int32_t         x0, t0, mask = 0;
1076     if (!single_precision_p(r1)) {
1077         mask |= 1;
1078         t0 = jit_get_reg(CLASS_SNG);
1079         x0 = rn(t0);
1080         movr_d(x0, r1);
1081     }
1082     else
1083         x0 = r1;
1084 #  endif
1085     reg = jit_get_reg(CLASS_SNG);
1086     movi_f(rn(reg), i0);
1087 #  if __WORDSIZE == 64
1088     FCMPS(x0, rn(reg));
1089     if (mask & 1)
1090         jit_unget_reg(t0);
1091 #  else
1092     FCMPS(r1, rn(reg));
1093 #  endif
1094     jit_unget_reg(reg);
1095     FBa(cc, 3);
1096     movi(r0, 1);
1097     movi(r0, 0);
1098 }
1099
1100 static void
1101 _dcr(jit_state_t *_jit, jit_int32_t cc,
1102      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1103 {
1104     FCMPD(r1, r2);
1105     FBa(cc, 3);
1106     movi(r0, 1);
1107     movi(r0, 0);
1108 }
1109
1110 static void
1111 _dcw(jit_state_t *_jit, jit_int32_t cc,
1112      jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1113 {
1114     jit_int32_t         reg;
1115     reg = jit_get_reg(CLASS_DBL);
1116     movi_d(rn(reg), i0);
1117     FCMPD(r1, rn(reg));
1118     jit_unget_reg(reg);
1119     FBa(cc, 3);
1120     movi(r0, 1);
1121     movi(r0, 0);
1122 }
1123
1124 #  if __WORDSIZE == 64
1125 static void
1126 _ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1127 {
1128     jit_int32_t         reg;
1129     if (!single_precision_p(r0)) {
1130         reg = jit_get_reg(CLASS_SNG);
1131         LDF(r1, 0, rn(reg));
1132         movr_d(r0, rn(reg));
1133         jit_unget_reg(reg);
1134     }
1135     else
1136         LDF(r1, 0, r0);
1137 }
1138 #  endif
1139
1140 static void
1141 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1142 {
1143     jit_int32_t         reg;
1144     if (s13_p(i0)) {
1145 #  if __WORDSIZE == 64
1146         if (!single_precision_p(r0)) {
1147             reg = jit_get_reg(CLASS_SNG);
1148             LDFI(0, i0, rn(reg));
1149             movr_d(r0, rn(reg));
1150             jit_unget_reg(reg);
1151         }
1152         else
1153 #  endif
1154             LDFI(0, i0, r0);
1155     }
1156     else {
1157         reg = jit_get_reg(jit_class_gpr);
1158         movi(rn(reg), i0);
1159         ldr_f(r0, rn(reg));
1160         jit_unget_reg(reg);
1161     }
1162 }
1163
1164 #  if __WORDSIZE == 64
1165 static void
1166 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1167 {
1168     jit_int32_t         reg;
1169     if (!single_precision_p(r0)) {
1170         reg = jit_get_reg(CLASS_SNG);
1171         LDF(r1, r2, rn(reg));
1172         movr_d(r0, rn(reg));
1173         jit_unget_reg(reg);
1174     }
1175     else
1176         LDF(r1, r2, r0);
1177 }
1178 #  endif
1179
1180 static void
1181 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1182 {
1183     jit_int32_t         reg;
1184     if (s13_p(i0)) {
1185 #  if __WORDSIZE == 64
1186         if (!single_precision_p(r0)) {
1187             reg = jit_get_reg(CLASS_SNG);
1188             LDFI(r1, i0, rn(reg));
1189             movr_d(r0, rn(reg));
1190             jit_unget_reg(reg);
1191         }
1192         else
1193 #  endif
1194             LDFI(r1, i0, r0);
1195     }
1196     else {
1197         reg = jit_get_reg(jit_class_gpr);
1198         movi(rn(reg), i0);
1199         ldxr_f(r0, r1, rn(reg));
1200         jit_unget_reg(reg);
1201     }
1202 }
1203
1204 #  if __WORDSIZE == 64
1205 static void
1206 _str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1207 {
1208     jit_int32_t         reg;
1209     if (!single_precision_p(r1)) {
1210         reg = jit_get_reg(CLASS_SNG);
1211         movr_d(rn(reg), r1);
1212         STF(rn(reg), r0, 0);
1213         jit_unget_reg(reg);
1214     }
1215     else
1216         STF(r1, r0, 0);
1217 }
1218 # endif
1219
1220 static void
1221 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1222 {
1223     jit_int32_t         reg;
1224     if (s13_p(i0)) {
1225 #  if __WORDSIZE == 64
1226         if (!single_precision_p(r0)) {
1227             reg = jit_get_reg(CLASS_SNG);
1228             movr_d(rn(reg), r0);
1229             STFI(rn(reg), 0, i0);
1230             jit_unget_reg(reg);
1231         }
1232         else
1233 #  endif
1234             STFI(r0, 0, i0);
1235     }
1236     else {
1237         reg = jit_get_reg(jit_class_gpr);
1238         movi(rn(reg), i0);
1239         str_f(rn(reg), r0);
1240         jit_unget_reg(reg);
1241     }
1242 }
1243
1244 #  if __WORDSIZE == 64
1245 static void
1246 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1247 {
1248     jit_int32_t         reg;
1249     if (!single_precision_p(r2)) {
1250         reg = jit_get_reg(CLASS_SNG);
1251         movr_d(rn(reg), r2);
1252         STF(rn(reg), r1, r0);
1253         jit_unget_reg(reg);
1254     }
1255     else
1256         STF(r2, r1, r0);
1257 }
1258 # endif
1259
1260 static void
1261 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1262 {
1263     jit_int32_t         reg;
1264     if (s13_p(i0)) {
1265 #  if __WORDSIZE == 64
1266         if (!single_precision_p(r1)) {
1267             reg = jit_get_reg(CLASS_SNG);
1268             movr_d(rn(reg), r1);
1269             STFI(rn(reg), r0, i0);
1270             jit_unget_reg(reg);
1271         }
1272         else
1273 #  endif
1274             STFI(r1, r0, i0);
1275     }
1276     else {
1277         reg = jit_get_reg(jit_class_gpr);
1278         movi(rn(reg), i0);
1279         stxr_f(rn(reg), r0, r1);
1280         jit_unget_reg(reg);
1281     }
1282 }
1283
1284 static void
1285 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1286 {
1287     stxi(BIAS(-8), _FP_REGNO, r1);
1288 #  if __WORDSIZE == 32
1289     stxi(BIAS(-4), _FP_REGNO, 0);
1290 #  endif
1291     ldxi_d(r0, _FP_REGNO, BIAS(-8));
1292 #  if __WORDSIZE == 32
1293     FITOD(r0, r0);
1294 #  else
1295     FXTOD(r0, r0);
1296 #  endif
1297 }
1298
1299 static void
1300 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1301 {
1302     jit_int32_t         reg;
1303     reg = jit_get_reg(CLASS_SNG);
1304 #  if __WORDSIZE == 64
1305     if (!single_precision_p(r1)) {
1306         movr_d(rn(reg), r1);
1307         FDTOI(rn(reg), rn(reg));
1308     }
1309     else
1310 #  endif
1311         FDTOI(r1, rn(reg));
1312     stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1313     ldxi_i(r0, _FP_REGNO, BIAS(-8));
1314     jit_unget_reg(reg);
1315 }
1316
1317 #  if __WORDSIZE == 64
1318 static void
1319 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1320 {
1321     jit_int32_t         reg;
1322     reg = jit_get_reg(CLASS_DBL);
1323     FDTOX(r1, rn(reg));
1324     stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1325     ldxi_l(r0, _FP_REGNO, BIAS(-8));
1326     jit_unget_reg(reg);
1327 }
1328 #  endif
1329
1330 static void
1331 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1332 {
1333     jit_int32_t         reg;
1334     if (s13_p(i0))
1335         LDDFI(0, i0, r0);
1336     else {
1337         reg = jit_get_reg(jit_class_gpr);
1338         movi(rn(reg), i0);
1339         ldr_d(r0, rn(reg));
1340         jit_unget_reg(reg);
1341     }
1342 }
1343
1344 static void
1345 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t i0)
1346 {
1347     jit_int32_t         reg;
1348     if (s13_p(i0))
1349         LDDFI(r1, i0, r0);
1350     else {
1351         reg = jit_get_reg(jit_class_gpr);
1352         movi(rn(reg), i0);
1353         ldxr_d(r0, r1, rn(reg));
1354         jit_unget_reg(reg);
1355     }
1356 }
1357
1358 static void
1359 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1360 {
1361     jit_int32_t         reg;
1362     if (s13_p(i0))
1363         STDFI(r0, 0, i0);
1364     else {
1365         reg = jit_get_reg(jit_class_gpr);
1366         movi(rn(reg), i0);
1367         str_d(rn(reg), r0);
1368         jit_unget_reg(reg);
1369     }
1370 }
1371
1372 static void
1373 _stxi_d(jit_state_t *_jit, jit_int32_t i0, jit_int32_t r0, jit_int32_t r1)
1374 {
1375     jit_int32_t         reg;
1376     if (s13_p(i0))
1377         STDFI(r1, r0, i0);
1378     else {
1379         reg = jit_get_reg(jit_class_gpr);
1380         movi(rn(reg), i0);
1381         stxr_d(rn(reg), r0, r1);
1382         jit_unget_reg(reg);
1383     }
1384 }
1385
1386 static jit_word_t
1387 _fbr(jit_state_t *_jit, jit_int32_t cc,
1388      jit_word_t i0, jit_int32_t r0,jit_int32_t r1)
1389 {
1390 #  if __WORDSIZE == 64
1391     jit_int32_t         x0, t0, x1, t1, mask = 0;
1392 #  endif
1393     jit_word_t          w;
1394 #  if __WORDSIZE == 64
1395     if (!single_precision_p(r0)) {
1396         mask |= 1;
1397         t0 = jit_get_reg(CLASS_SNG);
1398         x0 = rn(t0);
1399         movr_d(x0, r0);
1400     }
1401     else
1402         x0 = r0;
1403     if (r0 == r1)
1404         x1 = x0;
1405     else if (!single_precision_p(r1)) {
1406         mask |= 2;
1407         t1 = jit_get_reg(CLASS_SNG);
1408         x1 = rn(t1);
1409         movr_d(x1, r1);
1410     }
1411     else
1412         x1 = r1;
1413     FCMPS(x0, x1);
1414     if (mask & 1)
1415         jit_unget_reg(t0);
1416     if (mask & 2)
1417         jit_unget_reg(t1);
1418 #  else
1419     FCMPS(r0, r1);
1420 #  endif
1421     w = _jit->pc.w;
1422     FB(cc, (i0 - w) >> 2);
1423     NOP();
1424     return (w);
1425 }
1426
1427 static jit_word_t
1428 _fbw(jit_state_t *_jit, jit_int32_t cc,
1429      jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
1430 {
1431     jit_word_t          w;
1432     jit_int32_t         reg;
1433 #  if __WORDSIZE == 64
1434     jit_int32_t         x0, t0, mask = 0;
1435     if (!single_precision_p(r0)) {
1436         mask |= 1;
1437         t0 = jit_get_reg(CLASS_SNG);
1438         x0 = rn(t0);
1439         movr_d(x0, r0);
1440     }
1441     else
1442         x0 = r0;
1443 #  endif
1444     reg = jit_get_reg(CLASS_SNG);
1445     movi_f(rn(reg), i1);
1446 #  if __WORDSIZE == 64
1447     FCMPS(x0, rn(reg));
1448     if (mask & 1)
1449         jit_unget_reg(t0);
1450 #  else
1451     FCMPS(r0, rn(reg));
1452 #  endif
1453     jit_unget_reg(reg);
1454     w = _jit->pc.w;
1455     FB(cc, (i0 - w) >> 2);
1456     NOP();
1457     return (w);
1458 }
1459
1460 static jit_word_t
1461 _dbr(jit_state_t *_jit, jit_int32_t cc,
1462      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1463 {
1464     jit_word_t          w;
1465     FCMPD(r0, r1);
1466     w = _jit->pc.w;
1467     FB(cc, (i0 - w) >> 2);
1468     NOP();
1469     return (w);
1470 }
1471
1472 static jit_word_t
1473 _dbw(jit_state_t *_jit, jit_int32_t cc,
1474      jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
1475 {
1476     jit_word_t          w;
1477     jit_int32_t         reg;
1478     reg = jit_get_reg(CLASS_DBL);
1479     movi_d(rn(reg), i1);
1480     FCMPD(r0, rn(reg));
1481     jit_unget_reg(reg);
1482     w = _jit->pc.w;
1483     FB(cc, (i0 - w) >> 2);
1484     NOP();
1485     return (w);
1486 }
1487
1488 static void
1489 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1490 {
1491     assert(_jitc->function->self.call & jit_call_varargs);
1492
1493     /* Load argument. */
1494     ldr_d(r0, r1);
1495
1496     /* Update vararg stack pointer. */
1497     addi(r1, r1, 8);
1498 }
1499 #endif