deps/lightning/lib/jit_ia64-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 #define SF_S0                           0
  22 #define SF_S1                           1
  23 #define SF_S2                           2
  24 #define SF_S3                           3
  25
  26 #define TSTFREG1(r0)                                                    \
  27     do {                                                                \
  28         if (jit_regset_tstbit(&_jitc->regs, r0 + 128))                  \
  29             stop();                                                     \
  30     } while (0)
  31 #define TSTFREG2(r0, r1)                                                \
  32     do {                                                                \
  33         if (jit_regset_tstbit(&_jitc->regs, r0 + 128) ||                \
  34             jit_regset_tstbit(&_jitc->regs, r1 + 128))                  \
  35             stop();                                                     \
  36     } while (0)
  37 #define TSTFREG3(r0, r1, r2)                                            \
  38     do {                                                                \
  39         if (jit_regset_tstbit(&_jitc->regs, r0 + 128) ||                \
  40             jit_regset_tstbit(&_jitc->regs, r1 + 128) ||                \
  41             jit_regset_tstbit(&_jitc->regs, r2 + 128))                  \
  42             stop();                                                     \
  43     } while (0)
  44 #define SETFREG(r0)             jit_regset_setbit(&_jitc->regs, r0 + 128)
  45
  46 /* libm */
  47 extern float sqrtf(float);
  48 extern double sqrt(double);
  49 #define M7(x6,ht,r3,r2,f1)              _M7(_jit,0,x6,ht,r3,r2,f1)
  50 static void _M7(jit_state_t*,jit_word_t,
  51                 jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t)
  52     maybe_unused;
  53 #define M8(x6,ht,r3,im,f1)              _M8(_jit,0,x6,ht,r3,im,f1)
  54 static void _M8(jit_state_t*,jit_word_t,
  55                 jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t)
  56     maybe_unused;
  57 #define M9(x6,ht,r3,f1)                 _M9(_jit,0,x6,ht,r3,f1)
  58 static void _M9(jit_state_t*,jit_word_t,
  59                 jit_word_t,jit_word_t,jit_word_t,jit_word_t);
  60 #define M10(x6,ht,r3,r2,im)             _M10(_jit,0,x6,ht,r3,r2,im)
  61 static void _M10(jit_state_t*,jit_word_t,
  62                  jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t)
  63     maybe_unused;
  64 #define M11(x6,ht,r3,f2,f1)             _M11(_jit,0,x6,ht,r3,f2,f1)
  65 static void _M11(jit_state_t*,jit_word_t,
  66                  jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t)
  67     maybe_unused;
  68 #define M12(x6,ht,r3,f2,f1)             _M12(_jit,0,x6,ht,r3,f2,f1)
  69 static void _M12(jit_state_t*,jit_word_t,
  70                  jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t)
  71     maybe_unused;
  72 #define M18(x6,r2,f1)                   _M18(_jit,0,x6,r2,f1)
  73 static void _M18(jit_state_t*,jit_word_t,
  74                  jit_word_t,jit_word_t,jit_word_t);
  75 #define M19(x6,f2,r1)                   _M19(_jit,0,x6,f2,r1)
  76 static void _M19(jit_state_t*,jit_word_t,
  77                  jit_word_t,jit_word_t,jit_word_t);
  78 #define M21(f2,im)                      M20x(0x3,f2,im)
  79 #define M23(x3,im,f1)                   M22x(x3,im,f1)
  80 #define M27(f1)                         M26x(3,f1)
  81 #define F1(op,x,sf,f4,f3,f2,f1)         F1_(_jit,0,op,x,sf,f4,f3,f2,f1)
  82 #define F2(x2,f4,f3,f2,f1)              F1(0xe,1,x2,f4,f3,f2,f1)
  83 #define F3(f4,f3,f2,f1)                 F1(0xe,0,0,f4,f3,f2,f1)
  84 static void F1_(jit_state_t*,jit_word_t,
  85                 jit_word_t,jit_word_t,jit_word_t,
  86                 jit_word_t,jit_word_t,jit_word_t,jit_word_t);
  87 #define F4(rb,sf,ra,p2,f3,f2,ta,p1)     F4_(_jit,0,rb,sf,ra,p2,f3,f2,ta,p1)
  88 static void F4_(jit_state_t*,jit_word_t,
  89                 jit_word_t,jit_word_t,jit_word_t,jit_word_t,
  90                 jit_word_t,jit_word_t,jit_word_t,jit_word_t);
  91 #define F5(p2,fc,f2,ta,p1)              F5_(_jit,0,p2,fc,f2,ta,p1)
  92 static void F5_(jit_state_t*,jit_word_t,
  93                 jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t)
  94     maybe_unused;
  95 #define F6x(op,q,sf,p2,f3,f2,f1)        F6x_(_jit,0,op,q,sf,p2,f3,f2,f1)
  96 #define F6(op,sf,p2,f3,f2,f1)           F6x(op,0,sf,p2,f3,f2,f1)
  97 #define F7(op,sf,p2,f3,f1)              F6x(op,1,sf,p2,f3,0,f1)
  98 static void F6x_(jit_state_t*,jit_word_t,
  99                  jit_word_t,jit_word_t,jit_word_t,
 100                  jit_word_t,jit_word_t,jit_word_t,jit_word_t);
 101 #define F8(op,sf,x6,f3,f2,f1)           F8_(_jit,0,op,sf,x6,f3,f2,f1)
 102 #define F9(op,x6,f3,f2,f1)              F8(op,0,x6,f3,f2,f1)
 103 #define F10(op,sf,x6,f2,f1)             F8(op,sf,x6,0,f2,f1)
 104 #define F11(x6,f2,f1)                   F8(0,0,x6,0,f2,f1)
 105 static void F8_(jit_state_t*,jit_word_t,
 106                 jit_word_t,jit_word_t,jit_word_t,
 107                 jit_word_t,jit_word_t,jit_word_t);
 108 #define F12(sf,x6,omsk,amsk)            F12_(_jit,0,sf,x6,omsk,amsk)
 109 #define F13(sf,x6)                      F12(sf,x6,0,0)
 110 static void F12_(jit_state_t*,jit_word_t,
 111                  jit_word_t,jit_word_t,jit_word_t,jit_word_t)
 112     maybe_unused;
 113 #define F14x(sf,x,x6,im)                F14x_(_jit,0,sf,x,x6,im)
 114 #define F14(sf,im)                      F14x(sf,0,8,im)
 115 #define F15(im)                         F14x(0,0,0,im)
 116 static void F14x_(jit_state_t*,jit_word_t,
 117                   jit_word_t,jit_word_t,jit_word_t,jit_word_t)
 118     maybe_unused;
 119 #define F16(y,im)                       F16_(_jit,0,y,im)
 120 static void F16_(jit_state_t*,jit_word_t,
 121                  jit_word_t,jit_word_t)maybe_unused;
 122
 123 /* break */
 124 #define BREAK_F(im)                     F15(im)
 125 /* chk */
 126 #define CHK_S(f2,im)                    M21(f2,im)
 127 #define CHKF_A_NC(f1,im)                M23(0x6,im,f1)
 128 #define CHKF_A_CLR(f1,im)               M23(0x7,im,f1)
 129 /* fabs */
 130 #define FABS(f1,f3)                     FMERGE_S(f1,0,f3)
 131 /* fadd */
 132 #define FADD(f1,f3,f2)                  FMA(f1,f3,1,f2)
 133 #define FADD_S(f1,f3,f2)                FMA_S(f1,f3,1,f2)
 134 #define FADD_D(f1,f3,f2)                FMA_D(f1,f3,1,f2)
 135 /* famax */
 136 #define FAMAX(f1,f2,f3)                 F8(0,SF_S0,0x17,f3,f2,f1)
 137 /* famin */
 138 #define FAMIN(f1,f2,f3)                 F8(0,SF_S0,0x16,f3,f2,f1)
 139 /* fand */
 140 #define FAND(f1,f2,f3)                  F9(0,0x2c,f3,f2,f1)
 141 /* fandcm */
 142 #define FANDCM(f1,f2,f3)                F9(0,0x2d,f3,f2,f1)
 143 /* fchkf */
 144 #define FCHKF(im)                       F14(SF_S0,im)
 145 /* fclass */
 146 #define FCLASS_M(p1,p2,f2,fc)           F5(p2,fc,f2,0,p1)
 147 #define FCLASS_M_UNC(p1,p2,f2,fc)       F5(p2,fc,f2,1,p1)
 148 /* fclrf */
 149 #define FCLRF()                         F13(SF_S0,5)
 150 /* fcmp */
 151 #define FCMP_EQ(p1,p2,f2,f3)            F4(0,SF_S0,0,p2,f3,f2,0,p1)
 152 #define FCMP_LT(p1,p2,f2,f3)            F4(1,SF_S0,0,p2,f3,f2,0,p1)
 153 #define FCMP_LE(p1,p2,f2,f3)            F4(0,SF_S0,1,p2,f3,f2,0,p1)
 154 #define FCMP_UNORD(p1,p2,f2,f3)         F4(1,SF_S0,1,p2,f3,f2,0,p1)
 155 #define FCMP_EQ_UNC(p1,p2,f2,f3)        F4(0,SF_S0,0,p2,f3,f2,1,p1)
 156 #define FCMP_LT_UNC(p1,p2,f2,f3)        F4(1,SF_S0,0,p2,f3,f2,1,p1)
 157 #define FCMP_LE_UNC(p1,p2,f2,f3)        F4(0,SF_S0,1,p2,f3,f2,1,p1)
 158 #define FCMP_UNORD_UNC(p1,p2,f2,f3)     F4(1,SF_S0,1,p2,f3,f2,1,p1)
 159 /* fcvt.fx */
 160 #define FCVT_FX(f1,f2)                  F10(0,SF_S0,0x18,f2,f1)
 161 #define FCVT_FXU(f1,f2)                 F10(0,SF_S0,0x19,f2,f1)
 162 #define FCVT_FX_TRUNC(f1,f2)            F10(0,SF_S0,0x1a,f2,f1)
 163 #define FCVT_FXU_TRUNC(f1,f2)           F10(0,SF_S0,0x1b,f2,f1)
 164 /* fcvt.xf */
 165 #define FCVT_XF(f1,f2)                  F11(0x1c,f2,f1)
 166 /* fcvt.fxuf */
 167 #define FCVT_XUF(f1,f3)                 FMA(f1,f3,1,0)
 168 /* fma */
 169 #define FMA(f1,f3,f4,f2)                F1(0x8,0,SF_S0,f4,f3,f2,f1)
 170 #define FMA_p(f1,f3,f4,f2,sf,_p)        F1_(_jit,_p,0x8,0,sf,f4,f3,f2,f1)
 171 #define FMA_S(f1,f3,f4,f2)              F1(0x8,1,SF_S0,f4,f3,f2,f1)
 172 #define FMA_S_p(f1,f3,f4,f2,sf,_p)      F1_(_jit,_p,0x8,1,sf,f4,f3,f2,f1)
 173 #define FMA_D(f1,f3,f4,f2)              F1(0x9,0,SF_S0,f4,f3,f2,f1)
 174 #define FMA_D_p(f1,f3,f4,f2,sf,_p)      F1_(_jit,_p,0x9,0,sf,f4,f3,f2,f1)
 175 /* fmax */
 176 #define FMAX(f1,f2,f3)                  F8(0,SF_S0,0x15,f3,f2,f1)
 177 /* fmerge */
 178 #define FMERGE_S(f1,f2,f3)              F9(0,0x10,f3,f2,f1)
 179 #define FMERGE_NS(f1,f2,f3)             F9(0,0x11,f3,f2,f1)
 180 #define FMERGE_SE(f1,f2,f3)             F9(0,0x12,f3,f2,f1)
 181 /* fmin */
 182 #define FMIN(f1,f2,f3)                  F8(0,SF_S0,0x14,f3,f2,f1)
 183 /* fmix */
 184 #define FMIX_LR(f1,f2,f3)               F9(0,0x39,f3,f2,f1)
 185 #define FMIX_R(f1,f2,f3)                F9(0,0x3a,f3,f2,f1)
 186 #define FMIX_L(f1,f2,f3)                F9(0,0x3b,f3,f2,f1)
 187 /* fmpy */
 188 #define FMPY(f1,f3,f4)                  FMA(f1,f3,f4,0)
 189 #define FMPY_p(f1,f3,f4,sf,_p)          FMA_p(f1,f3,f4,0,sf,_p)
 190 #define FMPY_S(f1,f3,f4)                FMA_S(f1,f3,f4,0)
 191 #define FMPY_S_p(f1,f3,f4,sf,_p)        FMA_S_p(f1,f3,f4,0,sf,_p)
 192 #define FMPY_D(f1,f3,f4)                FMA_D(f1,f3,f4,0)
 193 #define FMPY_D_p(f1,f3,f4,sf,_p)        FMA_D_p(f1,f3,f4,0,sf,_p)
 194 /* fms */
 195 #define FMS(f1,f3,f4,f2)                F1(0xa,0,SF_S0,f4,f3,f2,f1)
 196 #define FMS_S(f1,f3,f4,f2)              F1(0xa,1,SF_S0,f4,f3,f2,f1)
 197 #define FMS_D(f1,f3,f4,f2)              F1(0xb,0,SF_S0,f4,f3,f2,f1)
 198 /* fneg */
 199 #define FNEG(f1,f3)                     FMERGE_NS(f1,f3,f3)
 200 /* fnegabs */
 201 #define FNEGABS(f1,f3)                  FMERGE_NS(f1,0,f3)
 202 /* fnma */
 203 #define FNMA(f1,f3,f4,f2)               F1(0xc,0,SF_S0,f4,f3,f2,f1)
 204 #define FNMA_p(f1,f3,f4,f2,sf,_p)       F1_(_jit,_p,0xc,0,sf,f4,f3,f2,f1)
 205 #define FNMA_S(f1,f3,f4,f2)             F1(0xc,1,SF_S0,f4,f3,f2,f1)
 206 #define FNMA_D(f1,f3,f4,f2)             F1(0xd,0,SF_S0,f4,f3,f2,f1)
 207 /* fnmpy */
 208 #define FNMPY(f1,f3,f4)                 FNMA(f1,f3,f4,0)
 209 /* fnorm */
 210 #define FNORM(f1,f3)                    FMA(f1,f3,1,0)
 211 #define FNORM_S(f1,f3)                  FMA_S(f1,f3,1,0)
 212 #define FNORM_D(f1,f3)                  FMA_D(f1,f3,1,0)
 213 /* for */
 214 #define FOR(f1,f2,f3)                   F9(0,0x2e,f3,f2,f1)
 215 /* fpabs */
 216 #define FPABS(f1,f3)                    FPMERGE_S(f1,0,f3)
 217 /* fpack */
 218 #define FPACK(f1,f2,f3)                 F9(0,0x28,f3,f2,f1)
 219 /* fpamax */
 220 #define FPAMAX(f1,f2,f3)                F8(1,SF_S0,0x17,f3,f2,f1)
 221 /* fpamin */
 222 #define FPAMIN(f1,f2,f3)                F8(1,SF_S0,0x16,f3,f2,f1)
 223 /* fpcmp */
 224 #define FPCMP_EQ(f1,f2,f3)              F8(1,SF_S0,0x30,f3,f2,f1)
 225 #define FPCMP_LT(f1,f2,f3)              F8(1,SF_S0,0x31,f3,f2,f1)
 226 #define FPCMP_LE(f1,f2,f3)              F8(1,SF_S0,0x32,f3,f2,f1)
 227 #define FPCMP_UNORD(f1,f2,f3)           F8(1,SF_S0,0x33,f3,f2,f1)
 228 #define FPCMP_NEQ(f1,f2,f3)             F8(1,SF_S0,0x34,f3,f2,f1)
 229 #define FPCMP_NLT(f1,f2,f3)             F8(1,SF_S0,0x35,f3,f2,f1)
 230 #define FPCMP_NLE(f1,f2,f3)             F8(1,SF_S0,0x36,f3,f2,f1)
 231 #define FPCMP_ORD(f1,f2,f3)             F8(1,SF_S0,0x37,f3,f2,f1)
 232 /* fpcvt.fx */
 233 #define FPCVT_FX(f1,f2)                 F10(1,SF_S0,0x18,f2,f1)
 234 #define FPCVT_FXU(f1,f2)                F10(1,SF_S0,0x19,f2,f1)
 235 #define FPCVT_FX_TRUNC(f1,f2)           F10(1,SF_S0,0x1a,f2,f1)
 236 #define FPCVT_FXU_TRUNC(f1,f2)          F10(1,SF_S0,0x1b,f2,f1)
 237 /* fpma */
 238 #define FPMA(f1,f3,f4,f2)               F1(0x9,1,SF_S0,f4,f3,f3,f1)
 239 /* fpmax */
 240 #define FPMAX(f1,f2,f3)                 F8(1,SF_S0,0x15,f3,f2,f1)
 241 /* fpmerge */
 242 #define FPMERGE_S(f1,f2,f3)             F9(1,0x10,f3,f2,f1)
 243 #define FPMERGE_NS(f1,f2,f3)            F9(1,0x11,f3,f2,f1)
 244 #define FPMERGE_SE(f1,f2,f3)            F9(1,0x12,f3,f2,f1)
 245 /* fpmin */
 246 #define FPMIN(f1,f2,f3)                 F8(1,SF_S0,0x14,f3,f2,f1)
 247 /* fpmpy */
 248 #define FPMPY(f1,f3,f4)                 FPMA(f1,f3,f4,0)
 249 /* fpms */
 250 #define FPMS(f1,f3,f4,f2)               F1(0xb,1,SF_S0,f4,f3,f3,f1)
 251 /* fpneg */
 252 #define FPNEG(f1,f3)                    FPMERGE_NS(f1,f3,f3)
 253 /* fpnegabs */
 254 #define FPNEGABS(f1,f3)                 FPMERGE_NS(f1,0,f3)
 255 /* fpnma */
 256 #define FPNMA(f1,f3,f4,f2)              F1(0xd,1,SF_S0,f4,f3,f3,f1)
 257 /* fpnmpy */
 258 #define FPNMPY(f1,f3,f4)                FPNMA(f1,f3,f4,0)
 259 /* fprcpa */
 260 #define FPRCPA(f1,p2,f2,f3)             F6(1,SF_S0,p2,f3,f2,f1)
 261 /* fprsqrta */
 262 #define FPRSQRTA(f1,p2,f3)              F7(1,SF_S0,p2,f3,f1)
 263 /* frcpa */
 264 #define FRCPA(f1,p2,f2,f3)              F6(0,SF_S0,p2,f3,f2,f1)
 265 /* frsqrta */
 266 #define FRSQRTA(f1,p2,f3)               F7(0,SF_S0,p2,f3,f1)
 267 /* fselect */
 268 #define FSELECT(f1,f3,f4,f2)            F3(f4,f3,f2,f1)
 269 #define FSETC(amsk,omsk)                F12(SF_S0,4,omsk,amsk)
 270 /* fsub */
 271 #define FSUB(f1,f3,f2)                  FMS(f1,f3,1,f2)
 272 #define FSUB_S(f1,f3,f2)                FMS_S(f1,f3,1,f2)
 273 #define FSUB_D(f1,f3,f2)                FMS_D(f1,f3,1,f2)
 274 /* fswap */
 275 #define FSWAP(f1,f2,f3)                 F9(0,0x34,f3,f2,f1)
 276 #define FSWAP_NL(f1,f2,f3)              F9(0,0x35,f3,f2,f1)
 277 #define FSWAP_NR(f1,f2,f3)              F9(0,0x36,f3,f2,f1)
 278 /* fsxt */
 279 #define FSXT_R(f1,f2,f3)                F9(0,0x3c,f3,f2,f1)
 280 #define FSXT_L(f1,f2,f3)                F9(0,0x3d,f3,f2,f1)
 281 /* fxor */
 282 #define FXOR(f1,f2,f3)                  F9(0,0x2f,f3,f2,f1)
 283 /* getf */
 284 #define GETF_S(r1,f2)                   M19(0x1e,f2,r1)
 285 #define GETF_D(r1,f2)                   M19(0x1f,f2,r1)
 286 #define GETF_EXP(r1,f2)                 M19(0x1d,f2,r1)
 287 #define GETF_SIG(r1,f2)                 M19(0x1c,f2,r1)
 288 /* hint */
 289 #define HINT_F(im)                      F16(1,im)
 290 /* invala */
 291 #define INVALAF_E(f1)                   M27(f1)
 292 /* ldf */
 293 #define LDFS(f1,r3)                     M9(0x02,LD_NONE,r3,f1)
 294 #define LDFD(f1,r3)                     M9(0x03,LD_NONE,r3,f1)
 295 #define LDF8(f1,r3)                     M9(0x01,LD_NONE,r3,f1)
 296 #define LDFE(f1,r3)                     M9(0x00,LD_NONE,r3,f1)
 297 #define LDFS_S(f1,r3)                   M9(0x06,LD_NONE,r3,f1)
 298 #define LDFD_S(f1,r3)                   M9(0x07,LD_NONE,r3,f1)
 299 #define LDF8_S(f1,r3)                   M9(0x05,LD_NONE,r3,f1)
 300 #define LDFE_S(f1,r3)                   M9(0x04,LD_NONE,r3,f1)
 301 #define LDFS_A(f1,r3)                   M9(0x0a,LD_NONE,r3,f1)
 302 #define LDFD_A(f1,r3)                   M9(0x0b,LD_NONE,r3,f1)
 303 #define LDF8_A(f1,r3)                   M9(0x09,LD_NONE,r3,f1)
 304 #define LDFE_A(f1,r3)                   M9(0x08,LD_NONE,r3,f1)
 305 #define LDFS_SA(f1,r3)                  M9(0x0e,LD_NONE,r3,f1)
 306 #define LDFD_SA(f1,r3)                  M9(0x0f,LD_NONE,r3,f1)
 307 #define LDF8_SA(f1,r3)                  M9(0x0d,LD_NONE,r3,f1)
 308 #define LDFE_SA(f1,r3)                  M9(0x0c,LD_NONE,r3,f1)
 309 #define LDF_FILL(f1,r3)                 M9(0x1b,LD_NONE,r3,f1)
 310 #define LDFS_C_CLR(f1,r3)               M9(0x22,LD_NONE,r3,f1)
 311 #define LDFD_C_CLR(f1,r3)               M9(0x23,LD_NONE,r3,f1)
 312 #define LDF8_C_CLR(f1,r3)               M9(0x21,LD_NONE,r3,f1)
 313 #define LDFE_C_CLR(f1,r3)               M9(0x20,LD_NONE,r3,f1)
 314 #define LDFS_C_NC(f1,r3)                M9(0x26,LD_NONE,r3,f1)
 315 #define LDFD_C_NC(f1,r3)                M9(0x27,LD_NONE,r3,f1)
 316 #define LDF8_C_NC(f1,r3)                M9(0x25,LD_NONE,r3,f1)
 317 #define LDFE_C_NC(f1,r3)                M9(0x24,LD_NONE,r3,f1)
 318 #define LDFS_inc(f1,r3,r2)              M7(0x02,LD_NONE,r3,r2,f1)
 319 #define LDFD_inc(f1,r3,r2)              M7(0x03,LD_NONE,r3,r2,f1)
 320 #define LDF8_inc(f1,r3,r2)              M7(0x01,LD_NONE,r3,r2,f1)
 321 #define LDFE_inc(f1,r3,r2)              M7(0x00,LD_NONE,r3,r2,f1)
 322 #define LDFS_S_inc(f1,r3,r2)            M7(0x06,LD_NONE,r3,r2,f1)
 323 #define LDFD_S_inc(f1,r3,r2)            M7(0x07,LD_NONE,r3,r2,f1)
 324 #define LDF8_S_inc(f1,r3,r2)            M7(0x05,LD_NONE,r3,r2,f1)
 325 #define LDFE_S_inc(f1,r3,r2)            M7(0x04,LD_NONE,r3,r2,f1)
 326 #define LDFS_A_inc(f1,r3,r2)            M7(0x0a,LD_NONE,r3,r2,f1)
 327 #define LDXFD_A_inc(f1,r3,r2)           M7(0x0b,LD_NONE,r3,r2,f1)
 328 #define LDXF8_A_inc(f1,r3,r2)           M7(0x09,LD_NONE,r3,r2,f1)
 329 #define LDXFE_A_inc(f1,r3,r2)           M7(0x08,LD_NONE,r3,r2,f1)
 330 #define LDXFS_SA_inc(f1,r3,r2)          M7(0x0e,LD_NONE,r3,r2,f1)
 331 #define LDXFD_SA_inc(f1,r3,r2)          M7(0x0f,LD_NONE,r3,r2,f1)
 332 #define LDXF8_SA_inc(f1,r3,r2)          M7(0x0d,LD_NONE,r3,r2,f1)
 333 #define LDXFE_SA_inc(f1,r3,r2)          M7(0x0c,LD_NONE,r3,r2,f1)
 334 #define LDXFS_FILL_inc(f1,r3,r2)        M7(0x1b,LD_NONE,r3,r2,f1)
 335 #define LDXFS_C_CLR_inc(f1,r3,r2)       M7(0x22,LD_NONE,r3,r2,f1)
 336 #define LDXFD_C_CLR_inc(f1,r3,r2)       M7(0x23,LD_NONE,r3,r2,f1)
 337 #define LDXF8_C_CLR_inc(f1,r3,r2)       M7(0x21,LD_NONE,r3,r2,f1)
 338 #define LDXFE_C_CLR_inc(f1,r3,r2)       M7(0x20,LD_NONE,r3,r2,f1)
 339 #define LDXFS_C_NC_inc(f1,r3,r2)        M7(0x26,LD_NONE,r3,r2,f1)
 340 #define LDXFD_C_NC_inc(f1,r3,r2)        M7(0x27,LD_NONE,r3,r2,f1)
 341 #define LDXF8_C_NC_inc(f1,r3,r2)        M7(0x25,LD_NONE,r3,r2,f1)
 342 #define LDXFE_C_NC_inc(f1,r3,r2)        M7(0x24,LD_NONE,r3,r2,f1)
 343 #define LDIFS_inc(f1,f3,im)             M8(0x02,LD_NONE,f3,im,f1)
 344 #define LDIFD_inc(f1,f3,im)             M8(0x03,LD_NONE,f3,im,f1)
 345 #define LDIF8_inc(f1,f3,im)             M8(0x01,LD_NONE,f3,im,f1)
 346 #define LDIFE_inc(f1,f3,im)             M8(0x00,LD_NONE,f3,im,f1)
 347 #define LDIFS_S_inc(f1,f3,im)           M8(0x06,LD_NONE,f3,im,f1)
 348 #define LDIFD_S_inc(f1,f3,im)           M8(0x07,LD_NONE,f3,im,f1)
 349 #define LDIF8_S_inc(f1,f3,im)           M8(0x05,LD_NONE,f3,im,f1)
 350 #define LDIFE_S_inc(f1,f3,im)           M8(0x04,LD_NONE,f3,im,f1)
 351 #define LDIFS_A_inc(f1,f3,im)           M8(0x0a,LD_NONE,f3,im,f1)
 352 #define LDIFD_A_inc(f1,f3,im)           M8(0x0b,LD_NONE,f3,im,f1)
 353 #define LDIF8_A_inc(f1,f3,im)           M8(0x09,LD_NONE,f3,im,f1)
 354 #define LDIFE_A_inc(f1,f3,im)           M8(0x08,LD_NONE,f3,im,f1)
 355 #define LDIF_FILL_inc(f1,f3,im)         M8(0x1b,LD_NONE,f3,im,f1)
 356 #define LDIFS_C_CLR_inc(f1,f3,im)       M8(0x22,LD_NONE,f3,im,f1)
 357 #define LDIFD_C_CLR_inc(f1,f3,im)       M8(0x23,LD_NONE,f3,im,f1)
 358 #define LDIF8_C_CLR_inc(f1,f3,im)       M8(0x21,LD_NONE,f3,im,f1)
 359 #define LDIFE_C_CLR_inc(f1,f3,im)       M8(0x20,LD_NONE,f3,im,f1)
 360 #define LDIFS_C_NC_inc(f1,f3,im)        M8(0x26,LD_NONE,f3,im,f1)
 361 #define LDIFD_C_NC_inc(f1,f3,im)        M8(0x27,LD_NONE,f3,im,f1)
 362 #define LDIF8_C_NC_inc(f1,f3,im)        M8(0x25,LD_NONE,f3,im,f1)
 363 #define LDIFE_C_NC_inc(f1,f3,im)        M8(0x24,LD_NONE,f3,im,f1)
 364 /* ldpf */
 365 #define LDFPS(f1,f2,r3)                 M11(0x02,LD_NONE,r3,f2,f1)
 366 #define LDFPD(f1,f2,r3)                 M11(0x03,LD_NONE,r3,f2,f1)
 367 #define LDFP8(f1,f2,r3)                 M11(0x01,LD_NONE,r3,f2,f1)
 368 #define LDFPS_S(f1,f2,r3)               M11(0x06,LD_NONE,r3,f2,f1)
 369 #define LDFPD_S(f1,f2,r3)               M11(0x07,LD_NONE,r3,f2,f1)
 370 #define LDFP8_S(f1,f2,r3)               M11(0x05,LD_NONE,r3,f2,f1)
 371 #define LDFPS_A(f1,f2,r3)               M11(0x0a,LD_NONE,r3,f2,f1)
 372 #define LDFPD_A(f1,f2,r3)               M11(0x0b,LD_NONE,r3,f2,f1)
 373 #define LDFP8_A(f1,f2,r3)               M11(0x09,LD_NONE,r3,f2,f1)
 374 #define LDFPS_SA(f1,f2,r3)              M11(0x0e,LD_NONE,r3,f2,f1)
 375 #define LDFPD_SA(f1,f2,r3)              M11(0x0f,LD_NONE,r3,f2,f1)
 376 #define LDFP8_SA(f1,f2,r3)              M11(0x0d,LD_NONE,r3,f2,f1)
 377 #define LDFPS_C_CLR(f1,f2,r3)           M11(0x22,LD_NONE,r3,f2,f1)
 378 #define LDFPD_C_CLR(f1,f2,r3)           M11(0x23,LD_NONE,r3,f2,f1)
 379 #define LDFP8_C_CLR(f1,f2,r3)           M11(0x21,LD_NONE,r3,f2,f1)
 380 #define LDFPS_C_NC(f1,f2,r3)            M11(0x26,LD_NONE,r3,f2,f1)
 381 #define LDFPD_C_NC(f1,f2,r3)            M11(0x27,LD_NONE,r3,f2,f1)
 382 #define LDFP8_C_NC(f1,f2,r3)            M11(0x25,LD_NONE,r3,f2,f1)
 383 #define LDIFPS(f1,f2,r3)                M12(0x02,LD_NONE,r3,f2,f1)
 384 #define LDIFPD(f1,f2,r3)                M12(0x03,LD_NONE,r3,f2,f1)
 385 #define LDIFP8(f1,f2,r3)                M12(0x01,LD_NONE,r3,f2,f1)
 386 #define LDIFPS_S(f1,f2,r3)              M12(0x06,LD_NONE,r3,f2,f1)
 387 #define LDIFPD_S(f1,f2,r3)              M12(0x07,LD_NONE,r3,f2,f1)
 388 #define LDIFP8_S(f1,f2,r3)              M12(0x05,LD_NONE,r3,f2,f1)
 389 #define LDIFPS_A(f1,f2,r3)              M12(0x0a,LD_NONE,r3,f2,f1)
 390 #define LDIFPD_A(f1,f2,r3)              M12(0x0b,LD_NONE,r3,f2,f1)
 391 #define LDIFP8_A(f1,f2,r3)              M12(0x09,LD_NONE,r3,f2,f1)
 392 #define LDIFPS_SA(f1,f2,r3)             M12(0x0e,LD_NONE,r3,f2,f1)
 393 #define LDIFPD_SA(f1,f2,r3)             M12(0x0f,LD_NONE,r3,f2,f1)
 394 #define LDIFP8_SA(f1,f2,r3)             M12(0x0d,LD_NONE,r3,f2,f1)
 395 #define LDIFPS_C_CLR(f1,f2,r3)          M12(0x22,LD_NONE,r3,f2,f1)
 396 #define LDIFPD_C_CLR(f1,f2,r3)          M12(0x23,LD_NONE,r3,f2,f1)
 397 #define LDIFP8_C_CLR(f1,f2,r3)          M12(0x21,LD_NONE,r3,f2,f1)
 398 #define LDIFPS_C_NC(f1,f2,r3)           M12(0x26,LD_NONE,r3,f2,f1)
 399 #define LDIFPD_C_NC(f1,f2,r3)           M12(0x27,LD_NONE,r3,f2,f1)
 400 #define LDIFP8_C_NC(f1,f2,r3)           M12(0x25,LD_NONE,r3,f2,f1)
 401 /* mov - Move Floating-point Register */
 402 #define MOVF(f1,f3)                     FMERGE_S(f1,f3,f3)
 403 /* nop */
 404 #define NOP_F(im)                       F16(0,im)
 405 /* setf */
 406 #define SETF_S(f1,r2)                   M18(0x1e,r2,f1)
 407 #define SETF_D(f1,r2)                   M18(0x1f,r2,f1)
 408 #define SETF_EXP(f1,r2)                 M18(0x1d,r2,f1)
 409 #define SETF_SIG(f1,r2)                 M18(0x1c,r2,f1)
 410 /* stf */
 411 #define STFS(r3,f2)                     M13(0x32,ST_NONE,r3,f2)
 412 #define STFD(r3,f2)                     M13(0x33,ST_NONE,r3,f2)
 413 #define STF8(r3,f2)                     M13(0x31,ST_NONE,r3,f2)
 414 #define STFE(r3,f2)                     M13(0x30,ST_NONE,r3,f2)
 415 #define STF_SPILL(r3,f2)                M13(0x3b,ST_NONE,r3,f2)
 416 #define STFS_inc(r3,f2,im)              M10(0x32,ST_NONE,r3,f2,im)
 417 #define STFD_inc(r3,f2,im)              M10(0x33,ST_NONE,r3,f2,im)
 418 #define STF8_inc(r3,f2,im)              M10(0x31,ST_NONE,r3,f2,im)
 419 #define STFE_inc(r3,f2,im)              M10(0x30,ST_NONE,r3,f2,im)
 420 #define STF_SPILL_inc(r3,f2,im)         M10(0x3b,ST_NONE,r3,f2,im)
 421 /* xma */
 422 #define XMA_L(f1,f3,f4,f2)              F2(0,f4,f3,f2,f1)
 423 #define XMA_LU(f1,f3,f4,f2)             XMA_L(f1,f3,f4,f2)
 424 #define XMA_H(f1,f3,f4,f2)              F2(3,f4,f3,f2,f1)
 425 #define XMA_HU(f1,f3,f4,f2)             F2(2,f4,f3,f2,f1)
 426 /* xmpy */
 427 #define XMPY_L(f1,f3,f4)                XMA_L(f1,f3,f4,0)
 428 #define XMPY_LU(f1,f3,f4)               XMA_L(f1,f3,f4,0)
 429 #define XMPY_H(f1,f3,f4)                XMA_H(f1,f3,f4,0)
 430 #define XMPY_HU(f1,f3,f4)               XMA_HU(f1,f3,f4,0)
 431
 432 #define movr_f(r0,r1)                   movr_d(r0,r1)
 433 #define movr_d(r0,r1)                   MOVF(r0,r1)
 434 #define movi_f(r0,i0)                   _movi_f(_jit,r0,i0)
 435 static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
 436 #define movi_d(r0,i0)                   _movi_d(_jit,r0,i0)
 437 static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
 438 #define movr_w_f(r0,r1)                 _movr_w_f(_jit,r0,r1)
 439 static void _movr_w_f(jit_state_t*,jit_int32_t,jit_int32_t);
 440 #define movr_f_w(r0,r1)                 _movr_f_w(_jit,r0,r1)
 441 static void _movr_f_w(jit_state_t*,jit_int32_t,jit_int32_t);
 442 #define movr_w_d(r0,r1)                 _movr_w_d(_jit,r0,r1)
 443 static void _movr_w_d(jit_state_t*,jit_int32_t,jit_int32_t);
 444 #define movr_d_w(r0,r1)                 _movr_d_w(_jit,r0,r1)
 445 static void _movr_d_w(jit_state_t*,jit_int32_t,jit_int32_t);
 446 #define movi_f_w(r0,i0)                 _movi_f_w(_jit,r0,i0)
 447 static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*);
 448 #define movi_d_w(r0,i0)                 _movi_d_w(_jit,r0,i0)
 449 static void _movi_d_w(jit_state_t*,jit_int32_t,jit_float64_t*);
 450 #define absr_f(r0,r1)                   absr_d(r0,r1)
 451 #define absr_d(r0,r1)                   FABS(r0,r1)
 452 #define negr_f(r0,r1)                   negr_d(r0,r1)
 453 #define negr_d(r0,r1)                   FNEG(r0,r1)
 454 #define sqrtr_f(r0,r1)                  _sqrtr_f(_jit,r0,r1)
 455 static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 456 #define sqrtr_d(r0,r1)                  _sqrtr_d(_jit,r0,r1)
 457 static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 458 #define extr_f_d(r0,r1)                 FNORM_D(r0,r1)
 459 #define extr_d_f(r0,r1)                 FNORM_S(r0,r1)
 460 #define extr_f(r0,r1)                   _extr_f(_jit,r0,r1)
 461 static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 462 #define extr_d(r0,r1)                   _extr_d(_jit,r0,r1)
 463 static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 464 #define truncr_f_i(r0,r1)               truncr_d_l(r0,r1)
 465 #define truncr_d_i(r0,r1)               truncr_d_l(r0,r1)
 466 #define truncr_f_l(r0,r1)               truncr_d_l(r0,r1)
 467 #define truncr_d_l(r0,r1)               _truncr_d_l(_jit,r0,r1)
 468 static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
 469 #define addr_f(r0,r1,r2)                FADD_S(r0,r1,r2)
 470 #define addi_f(r0,r1,i0)                _addi_f(_jit,r0,r1,i0)
 471 static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 472 #define addr_d(r0,r1,r2)                FADD_D(r0,r1,r2)
 473 #define addi_d(r0,r1,i0)                _addi_d(_jit,r0,r1,i0)
 474 static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 475 #define subr_f(r0,r1,r2)                FSUB_S(r0,r1,r2)
 476 #define subi_f(r0,r1,i0)                _subi_f(_jit,r0,r1,i0)
 477 static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 478 #define subr_d(r0,r1,r2)                FSUB_D(r0,r1,r2)
 479 #define subi_d(r0,r1,i0)                _subi_d(_jit,r0,r1,i0)
 480 static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 481 #define rsbr_f(r0,r1,r2)                subr_f(r0,r2,r1)
 482 #define rsbi_f(r0,r1,i0)                _rsbi_f(_jit,r0,r1,i0)
 483 static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 484 #define rsbr_d(r0,r1,r2)                subr_d(r0,r2,r1)
 485 #define rsbi_d(r0,r1,i0)                _rsbi_d(_jit,r0,r1,i0)
 486 static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 487 #define mulr_f(r0,r1,r2)                FMPY_S(r0,r1,r2)
 488 #define muli_f(r0,r1,i0)                _muli_f(_jit,r0,r1,i0)
 489 static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 490 #define mulr_d(r0,r1,r2)                FMPY_D(r0,r1,r2)
 491 #define muli_d(r0,r1,i0)                _muli_d(_jit,r0,r1,i0)
 492 static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 493 #define divr_f(r0,r1,r2)                _divr_f(_jit,r0,r1,r2)
 494 static void _divr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 495 #define divi_f(r0,r1,i0)                _divi_f(_jit,r0,r1,i0)
 496 static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 497 #define divr_d(r0,r1,r2)                _divr_d(_jit,r0,r1,r2)
 498 static void _divr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 499 #define divi_d(r0,r1,i0)                _divi_d(_jit,r0,r1,i0)
 500 static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 501 #define ltr_f(r0,r1,r2)                 ltr_d(r0,r1,r2)
 502 #define ltr_d(r0,r1,r2)                 _ltr_d(_jit,r0,r1,r2)
 503 static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 504 #define lti_f(r0,r1,i0)                 _lti_f(_jit,r0,r1,i0)
 505 static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 506 #define lti_d(r0,r1,i0)                 _lti_d(_jit,r0,r1,i0)
 507 static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 508 #define ler_f(r0,r1,r2)                 ler_d(r0,r1,r2)
 509 #define ler_d(r0,r1,r2)                 _ler_d(_jit,r0,r1,r2)
 510 static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 511 #define lei_f(r0,r1,i0)                 _lei_f(_jit,r0,r1,i0)
 512 static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 513 #define lei_d(r0,r1,i0)                 _lei_d(_jit,r0,r1,i0)
 514 static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 515 #define eqr_f(r0,r1,r2)                 eqr_d(r0,r1,r2)
 516 #define eqr_d(r0,r1,r2)                 _eqr_d(_jit,r0,r1,r2)
 517 static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 518 #define eqi_f(r0,r1,i0)                 _eqi_f(_jit,r0,r1,i0)
 519 static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 520 #define eqi_d(r0,r1,i0)                 _eqi_d(_jit,r0,r1,i0)
 521 static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 522 #define ger_f(r0,r1,r2)                 ger_d(r0,r1,r2)
 523 #define ger_d(r0,r1,r2)                 _ger_d(_jit,r0,r1,r2)
 524 static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 525 #define gei_f(r0,r1,i0)                 _gei_f(_jit,r0,r1,i0)
 526 static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 527 #define gei_d(r0,r1,i0)                 _gei_d(_jit,r0,r1,i0)
 528 static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 529 #define gtr_f(r0,r1,r2)                 gtr_d(r0,r1,r2)
 530 #define gtr_d(r0,r1,r2)                 _gtr_d(_jit,r0,r1,r2)
 531 static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 532 #define gti_f(r0,r1,i0)                 _gti_f(_jit,r0,r1,i0)
 533 static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 534 #define gti_d(r0,r1,i0)                 _gti_d(_jit,r0,r1,i0)
 535 static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 536 #define ner_f(r0,r1,r2)                 ner_d(r0,r1,r2)
 537 #define ner_d(r0,r1,r2)                 _ner_d(_jit,r0,r1,r2)
 538 static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 539 #define nei_f(r0,r1,i0)                 _nei_f(_jit,r0,r1,i0)
 540 static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 541 #define nei_d(r0,r1,i0)                 _nei_d(_jit,r0,r1,i0)
 542 static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 543 #define unltr_f(r0,r1,r2)               unltr_d(r0,r1,r2)
 544 #define unltr_d(r0,r1,r2)               _unltr_d(_jit,r0,r1,r2)
 545 static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 546 #define unlti_f(r0,r1,i0)               _unlti_f(_jit,r0,r1,i0)
 547 static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 548 #define unlti_d(r0,r1,i0)               _unlti_d(_jit,r0,r1,i0)
 549 static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 550 #define unler_f(r0,r1,r2)               unler_d(r0,r1,r2)
 551 #define unler_d(r0,r1,r2)               _unler_d(_jit,r0,r1,r2)
 552 static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 553 #define unlei_f(r0,r1,i0)               _unlei_f(_jit,r0,r1,i0)
 554 static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 555 #define unlei_d(r0,r1,i0)               _unlei_d(_jit,r0,r1,i0)
 556 static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 557 #define uneqr_f(r0,r1,r2)               uneqr_d(r0,r1,r2)
 558 #define uneqr_d(r0,r1,r2)               _uneqr_d(_jit,r0,r1,r2)
 559 static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 560 #define uneqi_f(r0,r1,i0)               _uneqi_f(_jit,r0,r1,i0)
 561 static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 562 #define uneqi_d(r0,r1,i0)               _uneqi_d(_jit,r0,r1,i0)
 563 static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 564 #define unger_f(r0,r1,r2)               unger_d(r0,r1,r2)
 565 #define unger_d(r0,r1,r2)               _unger_d(_jit,r0,r1,r2)
 566 static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 567 #define ungei_f(r0,r1,i0)               _ungei_f(_jit,r0,r1,i0)
 568 static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 569 #define ungei_d(r0,r1,i0)               _ungei_d(_jit,r0,r1,i0)
 570 static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 571 #define ungtr_f(r0,r1,r2)               ungtr_d(r0,r1,r2)
 572 #define ungtr_d(r0,r1,r2)               _ungtr_d(_jit,r0,r1,r2)
 573 static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 574 #define ungti_f(r0,r1,i0)               _ungti_f(_jit,r0,r1,i0)
 575 static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 576 #define ungti_d(r0,r1,i0)               _ungti_d(_jit,r0,r1,i0)
 577 static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 578 #define ltgtr_f(r0,r1,r2)               ltgtr_d(r0,r1,r2)
 579 #define ltgtr_d(r0,r1,r2)               _ltgtr_d(_jit,r0,r1,r2)
 580 static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 581 #define ltgti_f(r0,r1,i0)               _ltgti_f(_jit,r0,r1,i0)
 582 static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 583 #define ltgti_d(r0,r1,i0)               _ltgti_d(_jit,r0,r1,i0)
 584 static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 585 #define ordr_f(r0,r1,r2)                ordr_d(r0,r1,r2)
 586 #define ordr_d(r0,r1,r2)                _ordr_d(_jit,r0,r1,r2)
 587 static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 588 #define ordi_f(r0,r1,i0)                _ordi_f(_jit,r0,r1,i0)
 589 static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 590 #define ordi_d(r0,r1,i0)                _ordi_d(_jit,r0,r1,i0)
 591 static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 592 #define unordr_f(r0,r1,r2)              unordr_d(r0,r1,r2)
 593 #define unordr_d(r0,r1,r2)              _unordr_d(_jit,r0,r1,r2)
 594 static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 595 #define unordi_f(r0,r1,i0)              _unordi_f(_jit,r0,r1,i0)
 596 static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 597 #define unordi_d(r0,r1,i0)              _unordi_d(_jit,r0,r1,i0)
 598 static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 599 #define ldr_f(r0,r1)                    LDFS(r0,r1)
 600 #define ldi_f(r0,i0)                    _ldi_f(_jit,r0,i0)
 601 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 602 #define ldxr_f(r0,r1,r2)                _ldxr_f(_jit,r0,r1,r2)
 603 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 604 #define ldxi_f(r0,r1,i0)                _ldxi_f(_jit,r0,r1,i0)
 605 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 606 #define ldr_d(r0,r1)                    LDFD(r0,r1)
 607 #define ldi_d(r0,i0)                    _ldi_d(_jit,r0,i0)
 608 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 609 #define ldxr_d(r0,r1,r2)                _ldxr_d(_jit,r0,r1,r2)
 610 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 611 #define ldxi_d(r0,r1,i0)                _ldxi_d(_jit,r0,r1,i0)
 612 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 613 #define str_f(r0,r1)                    STFS(r0,r1)
 614 #define sti_f(i0,r0)                    _sti_f(_jit,i0,r0)
 615 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 616 #define stxr_f(r0,r1,r2)                _stxr_f(_jit,r0,r1,r2)
 617 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 618 #define stxi_f(i0,r0,r1)                _stxi_f(_jit,i0,r0,r1)
 619 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 620 #define str_d(r0,r1)                    STFD(r0,r1)
 621 #define sti_d(i0,r0)                    _sti_d(_jit,i0,r0)
 622 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 623 #define stxr_d(r0,r1,r2)                _stxr_d(_jit,r0,r1,r2)
 624 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 625 #define stxi_d(i0,r0,r1)                _stxi_d(_jit,i0,r0,r1)
 626 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 627 #define bltr_f(i0,r0,r1)                bltr_d(i0,r0,r1)
 628 #define bltr_d(i0,r0,r1)                _bltr_d(_jit,i0,r0,r1)
 629 static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 630 #define blti_f(i0,r0,i1)                _blti_f(_jit,i0,r0,i1)
 631 static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 632 #define blti_d(i0,r0,i1)                _blti_d(_jit,i0,r0,i1)
 633 static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 634 #define bler_f(i0,r0,r1)                bler_d(i0,r0,r1)
 635 #define bler_d(i0,r0,r1)                _bler_d(_jit,i0,r0,r1)
 636 static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 637 #define blei_f(i0,r0,i1)                _blei_f(_jit,i0,r0,i1)
 638 static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 639 #define blei_d(i0,r0,i1)                _blei_d(_jit,i0,r0,i1)
 640 static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 641 #define beqr_f(i0,r0,r1)                beqr_d(i0,r0,r1)
 642 #define beqr_d(i0,r0,r1)                _beqr_d(_jit,i0,r0,r1)
 643 static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 644 #define beqi_f(i0,r0,i1)                _beqi_f(_jit,i0,r0,i1)
 645 static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 646 #define beqi_d(i0,r0,i1)                _beqi_d(_jit,i0,r0,i1)
 647 static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 648 #define bger_f(i0,r0,r1)                bger_d(i0,r0,r1)
 649 #define bger_d(i0,r0,r1)                _bger_d(_jit,i0,r0,r1)
 650 static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 651 #define bgei_f(i0,r0,i1)                _bgei_f(_jit,i0,r0,i1)
 652 static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 653 #define bgei_d(i0,r0,i1)                _bgei_d(_jit,i0,r0,i1)
 654 static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 655 #define bgtr_f(i0,r0,r1)                bgtr_d(i0,r0,r1)
 656 #define bgtr_d(i0,r0,r1)                _bgtr_d(_jit,i0,r0,r1)
 657 static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 658 #define bgti_f(i0,r0,i1)                _bgti_f(_jit,i0,r0,i1)
 659 static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 660 #define bgti_d(i0,r0,i1)                _bgti_d(_jit,i0,r0,i1)
 661 static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 662 #define bner_f(i0,r0,r1)                bner_d(i0,r0,r1)
 663 #define bner_d(i0,r0,r1)                _bner_d(_jit,i0,r0,r1)
 664 static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 665 #define bnei_f(i0,r0,i1)                _bnei_f(_jit,i0,r0,i1)
 666 static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 667 #define bnei_d(i0,r0,i1)                _bnei_d(_jit,i0,r0,i1)
 668 static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 669 #define bunltr_f(i0,r0,r1)              bunltr_d(i0,r0,r1)
 670 #define bunltr_d(i0,r0,r1)              _bunltr_d(_jit,i0,r0,r1)
 671 static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 672 #define bunlti_f(i0,r0,i1)              _bunlti_f(_jit,i0,r0,i1)
 673 static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 674 #define bunlti_d(i0,r0,i1)              _bunlti_d(_jit,i0,r0,i1)
 675 static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 676 #define bunler_f(i0,r0,r1)              bunler_d(i0,r0,r1)
 677 #define bunler_d(i0,r0,r1)              _bunler_d(_jit,i0,r0,r1)
 678 static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 679 #define bunlei_f(i0,r0,i1)              _bunlei_f(_jit,i0,r0,i1)
 680 static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 681 #define bunlei_d(i0,r0,i1)              _bunlei_d(_jit,i0,r0,i1)
 682 static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 683 #define buneqr_f(i0,r0,r1)              buneqr_d(i0,r0,r1)
 684 #define buneqr_d(i0,r0,r1)              _buneqr_d(_jit,i0,r0,r1)
 685 static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 686 #define buneqi_f(i0,r0,i1)              _buneqi_f(_jit,i0,r0,i1)
 687 static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 688 #define buneqi_d(i0,r0,i1)              _buneqi_d(_jit,i0,r0,i1)
 689 static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 690 #define bunger_f(i0,r0,r1)              bunger_d(i0,r0,r1)
 691 #define bunger_d(i0,r0,r1)              _bunger_d(_jit,i0,r0,r1)
 692 static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 693 #define bungei_f(i0,r0,i1)              _bungei_f(_jit,i0,r0,i1)
 694 static jit_word_t _bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 695 #define bungei_d(i0,r0,i1)              _bungei_d(_jit,i0,r0,i1)
 696 static jit_word_t _bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 697 #define bungtr_f(i0,r0,r1)              bungtr_d(i0,r0,r1)
 698 #define bungtr_d(i0,r0,r1)              _bungtr_d(_jit,i0,r0,r1)
 699 static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 700 #define bungti_f(i0,r0,i1)              _bungti_f(_jit,i0,r0,i1)
 701 static jit_word_t _bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 702 #define bungti_d(i0,r0,i1)              _bungti_d(_jit,i0,r0,i1)
 703 static jit_word_t _bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 704 #define bltgtr_f(i0,r0,r1)              bltgtr_d(i0,r0,r1)
 705 #define bltgtr_d(i0,r0,r1)              _bltgtr_d(_jit,i0,r0,r1)
 706 static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 707 #define bltgti_f(i0,r0,i1)              _bltgti_f(_jit,i0,r0,i1)
 708 static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 709 #define bltgti_d(i0,r0,i1)              _bltgti_d(_jit,i0,r0,i1)
 710 static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 711 #define bordr_f(i0,r0,r1)               bordr_d(i0,r0,r1)
 712 #define bordr_d(i0,r0,r1)               _bordr_d(_jit,i0,r0,r1)
 713 static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 714 #define bordi_f(i0,r0,i1)               _bordi_f(_jit,i0,r0,i1)
 715 static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 716 #define bordi_d(i0,r0,i1)               _bordi_d(_jit,i0,r0,i1)
 717 static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 718 #define bunordr_f(i0,r0,r1)             bunordr_d(i0,r0,r1)
 719 #define bunordr_d(i0,r0,r1)             _bunordr_d(_jit,i0,r0,r1)
 720 static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 721 #define bunordi_f(i0,r0,i1)             _bunordi_f(_jit,i0,r0,i1)
 722 static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 723 #define bunordi_d(i0,r0,i1)             _bunordi_d(_jit,i0,r0,i1)
 724 static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 725 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 726 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 727 #endif
 728
 729 #if CODE
 730 static void
 731 _M7(jit_state_t *_jit, jit_word_t _p,
 732     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2, jit_word_t f1)
 733 {
 734     assert(!(_p & ~0x3fL));
 735     assert(!(x6 & ~0x3fL));
 736     assert(!(ht &  ~0x3L));
 737     assert(!(r3 & ~0x7fL));
 738     assert(!(r2 & ~0x7fL));
 739     assert(!(f1 & ~0x7fL));
 740     TSTREG2(r2, r3);
 741     TSTPRED(_p);
 742     TSTFREG1(f1);
 743     inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)|
 744          (r3<<20)|(r2<<13)|(f1<<6)|_p, INST_M);
 745     SETFREG(f1);
 746     SETREG(r3);
 747 }
 748
 749 static void
 750 _M8(jit_state_t *_jit, jit_word_t _p,
 751     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im, jit_word_t f1)
 752 {
 753     assert(!(_p &  ~0x3fL));
 754     assert(!(x6 &  ~0x3fL));
 755     assert(!(ht &   ~0x3L));
 756     assert(!(r3 &  ~0x7fL));
 757     assert(im > -256 && im <= 255);
 758     assert(!(f1 &  ~0x7fL));
 759     TSTREG1(r3);
 760     TSTPRED(_p);
 761     TSTFREG1(f1);
 762     inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)|
 763          (((im>>8)&1L)<<27)|(r3<<20)|((im&0x7fLL)<<13)|(f1<<6)|_p, INST_M);
 764     SETFREG(f1);
 765     SETREG(r3);
 766 }
 767
 768 static void
 769 _M9(jit_state_t *_jit, jit_word_t _p,
 770     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f1)
 771 {
 772     assert(!(_p & ~0x3fL));
 773     assert(!(x6 & ~0x3fL));
 774     assert(!(ht &  ~0x3L));
 775     assert(!(r3 & ~0x7fL));
 776     assert(!(f1 & ~0x7fL));
 777     TSTREG1(r3);
 778     TSTPRED(_p);
 779     TSTFREG1(f1);
 780     inst((6L<<37)|(x6<<30)|(ht<<28)|(r3<<20)|(f1<<6)|_p, INST_M);
 781     SETFREG(f1);
 782 }
 783
 784 static void
 785 _M10(jit_state_t *_jit, jit_word_t _p,
 786      jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t im)
 787 {
 788     assert(!(_p &  ~0x3fL));
 789     assert(!(x6 &  ~0x3fL));
 790     assert(!(ht &   ~0x3L));
 791     assert(!(r3 &  ~0x7fL));
 792     assert(!(f2 &  ~0x7fL));
 793     assert(im > -256 && im <= 255);
 794     TSTREG1(r3);
 795     TSTFREG1(f2);
 796     TSTPRED(_p);
 797     inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)|
 798          (((im>>8)&1L)<<27)|(r3<<20)|(f2<<13)|((im&0x7fL)<<6)|_p, INST_M);
 799     SETREG(r3);
 800 }
 801
 802 static void
 803 _M11(jit_state_t *_jit, jit_word_t _p,
 804      jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t f1)
 805 {
 806     assert(!(_p & ~0x3fL));
 807     assert(!(x6 & ~0x3fL));
 808     assert(!(ht &  ~0x3L));
 809     assert(!(r3 & ~0x7fL));
 810     assert(!(f2 & ~0x7fL));
 811     assert(!(f1 & ~0x7fL));
 812     TSTREG1(r3);
 813     TSTPRED(_p);
 814     TSTFREG2(f1, f2);
 815     inst((6L<<37)|(x6<<30)|(ht<<28)|(1L<<27)|
 816          (r3<<20)|(f2<<13)|(f1<<6)|_p, INST_M);
 817     SETFREG(f1);
 818     SETFREG(f2);
 819 }
 820
 821 static void
 822 _M12(jit_state_t *_jit, jit_word_t _p,
 823      jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t f1)
 824 {
 825     assert(!(_p & ~0x3fL));
 826     assert(!(x6 & ~0x3fL));
 827     assert(!(ht &  ~0x3L));
 828     assert(!(r3 & ~0x7fL));
 829     assert(!(f2 & ~0x7fL));
 830     assert(!(f1 & ~0x7fL));
 831     TSTREG1(r3);
 832     TSTPRED(_p);
 833     TSTFREG2(f1, f2);
 834     inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)|
 835          (1L<<27)|(r3<<20)|(f2<<13)|(f1<<6)|_p, INST_M);
 836     SETFREG(f1);
 837     SETFREG(f2);
 838     SETREG(r3);
 839 }
 840
 841 static void
 842 _M18(jit_state_t *_jit, jit_word_t _p,
 843      jit_word_t x6, jit_word_t r2, jit_word_t f1)
 844 {
 845     assert(!(_p & ~0x3fL));
 846     assert(!(x6 & ~0x3fL));
 847     assert(!(r2 & ~0x7fL));
 848     assert(!(f1 & ~0x7fL));
 849     TSTREG1(r2);
 850     TSTPRED(_p);
 851     TSTFREG1(f1);
 852     inst((6L<<37)|(x6<<30)|(1L<<27)|(r2<<13)|(f1<<6)|_p, INST_M);
 853     SETFREG(f1);
 854 }
 855
 856 static void
 857 _M19(jit_state_t *_jit, jit_word_t _p,
 858      jit_word_t x6, jit_word_t f2, jit_word_t r1)
 859 {
 860     assert(!(_p & ~0x3fL));
 861     assert(!(x6 & ~0x3fL));
 862     assert(!(f2 & ~0x7fL));
 863     assert(!(r1 & ~0x7fL));
 864     TSTFREG1(f2);
 865     TSTPRED(_p);
 866     TSTREG1(r1);
 867     inst((4L<<37)|(x6<<30)|(1L<<27)|(f2<<13)|(r1<<6)|_p, INST_M);
 868     SETREG(r1);
 869 }
 870
 871 static void
 872 F1_(jit_state_t *_jit, jit_word_t _p,
 873     jit_word_t op, jit_word_t x, jit_word_t sf,
 874     jit_word_t f4, jit_word_t f3, jit_word_t f2, jit_word_t f1)
 875 {
 876     assert(!(_p & ~0x3fL));
 877     assert(!(op &  ~0xfL));
 878     assert(!(x  &  ~0x1L));
 879     assert(!(sf &  ~0x3L));
 880     assert(!(f4 & ~0x7fL));
 881     assert(!(f3 & ~0x7fL));
 882     assert(!(f2 & ~0x7fL));
 883     assert(!(f1 & ~0x7fL));
 884     TSTFREG3(f2, f3, f4);
 885     TSTPRED(_p);
 886     TSTFREG1(f1);
 887     inst((op<<37)|(x<<36)|(sf<<34)|(f4<<27)|
 888          (f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F);
 889     SETFREG(f1);
 890 }
 891
 892 static void
 893 F4_(jit_state_t *_jit, jit_word_t _p,
 894     jit_word_t rb, jit_word_t sf, jit_word_t ra, jit_word_t p2,
 895     jit_word_t f3, jit_word_t f2, jit_word_t ta, jit_word_t p1)
 896 {
 897     assert(!(_p & ~0x3fL));
 898     assert(!(rb &  ~0x1L));
 899     assert(!(sf &  ~0x3L));
 900     assert(!(ra &  ~0x1L));
 901     assert(!(p2 & ~0x3fL));
 902     assert(!(f3 & ~0x7fL));
 903     assert(!(f2 & ~0x7fL));
 904     assert(!(ta &  ~0x1L));
 905     assert(!(p1 & ~0x3fL));
 906     TSTFREG2(f2, f3);
 907     TSTPRED(_p);
 908     inst((4L<<37)|(rb<<36)|(sf<<34)|(ra<<33)|(p2<<27)|
 909          (f3<<20)|(f2<<13)|(ta<<12)|(p1<<6)|_p, INST_F);
 910     if (p1)
 911         _jitc->pred |= 1 << p1;
 912     if (p2)
 913         _jitc->pred |= 1 << p2;
 914 }
 915
 916 static void
 917 F5_(jit_state_t *_jit, jit_word_t _p,
 918     jit_word_t p2, jit_word_t fc, jit_word_t f2, jit_word_t ta, jit_word_t p1)
 919 {
 920     assert(!(_p &  ~0x3fL));
 921     assert(!(p2 &  ~0x3fL));
 922     assert(!(fc & ~0x1ffL));
 923     assert(!(f2 &  ~0x7fL));
 924     assert(!(ta &   ~0x1L));
 925     assert(!(p1 &  ~0x3fL));
 926     TSTFREG1(f2);
 927     TSTPRED(_p);
 928     inst((5L<<37)|(((fc>>7)&3L)<<33)|(p2<<27)|
 929          ((fc&0x7fL)<<20)|(f2<<13)|(ta<<12)|(p1<<6)|_p, INST_F);
 930     if (p1)
 931         _jitc->pred |= 1 << p1;
 932     if (p2)
 933         _jitc->pred |= 1 << p2;
 934 }
 935
 936 static void
 937 F6x_(jit_state_t *_jit, jit_word_t _p,
 938      jit_word_t op, jit_word_t q, jit_word_t sf,
 939      jit_word_t p2,  jit_word_t f3, jit_word_t f2, jit_word_t f1)
 940 {
 941     assert(!(_p & ~0x3fL));
 942     assert(!(op &  ~0xfL));
 943     assert(!(q  &  ~0x1L));
 944     assert(!(sf &  ~0x3L));
 945     assert(!(p2 & ~0x3fL));
 946     assert(!(f3 & ~0x7fL));
 947     assert(!(f2 & ~0x7fL));
 948     assert(!(f1 & ~0x7fL));
 949     TSTFREG2(f2, f3);
 950     TSTPRED(_p);
 951     TSTFREG1(f1);
 952     inst((op<<37)|(q<<36)|(sf<<34)|(1L<<33)|
 953          (p2<<27)|(f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F);
 954     SETFREG(f1);
 955     if (p2)
 956         _jitc->pred |= 1 << p2;
 957 }
 958
 959 static void
 960 F8_(jit_state_t *_jit, jit_word_t _p,
 961     jit_word_t op, jit_word_t sf, jit_word_t x6,
 962     jit_word_t f3, jit_word_t f2, jit_word_t f1)
 963 {
 964     assert(!(_p & ~0x3fL));
 965     assert(!(op &  ~0xfL));
 966     assert(!(sf &  ~0x3L));
 967     assert(!(x6 & ~0x3fL));
 968     assert(!(f3 & ~0x7fL));
 969     assert(!(f2 & ~0x7fL));
 970     assert(!(f1 & ~0x7fL));
 971     TSTFREG2(f2, f3);
 972     TSTPRED(_p);
 973     TSTFREG1(f1);
 974     inst((op<<37)|(sf<<34)|(x6<<27)|(f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F);
 975     SETFREG(f1);
 976 }
 977
 978 static void
 979 F12_(jit_state_t *_jit, jit_word_t _p,
 980      jit_word_t sf, jit_word_t x6, jit_word_t omsk, jit_word_t amsk)
 981 {
 982     assert(!(_p   & ~0x3fL));
 983     assert(!(sf   &  ~0x3L));
 984     assert(!(x6   & ~0x3fL));
 985     assert(!(omsk & ~0x7fL));
 986     assert(!(amsk & ~0x7fL));
 987     TSTPRED(_p);
 988     inst((sf<<34)|(x6<<27)|(omsk<<20)|(amsk<<13), INST_F);
 989 }
 990
 991 static void
 992 F14x_(jit_state_t* _jit, jit_word_t _p,
 993       jit_word_t sf,  jit_word_t x, jit_word_t x6, jit_word_t im)
 994 {
 995     assert(!(_p &    ~0x3fL));
 996     assert(!(sf &     ~0x3L));
 997     assert(!(x  &     ~0x1L));
 998     assert(!(x6 &    ~0x3fL));
 999     assert(!(im & ~0x1ffffL));
1000     TSTPRED(_p);
1001     inst((((im>>20)&1L)<<36)|(sf<<34)|(x<<33)|
1002          (x6<<27)|((im&0xffffL)<<6)|_p, INST_F);
1003 }
1004
1005 static void
1006 F16_(jit_state_t* _jit, jit_word_t _p,
1007      jit_word_t y, jit_word_t im)
1008 {
1009     assert(!(_p &    ~0x3fL));
1010     assert(!(y  &     ~0x1L));
1011     assert(!(im & ~0x1ffffL));
1012     TSTPRED(_p);
1013     inst((((im>>20)&1L)<<36)|(y<<27)|(1L<<26)|((im&0xffffL)<<6)|_p, INST_F);
1014 }
1015
1016 static void
1017 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
1018 {
1019     union {
1020         jit_int32_t      i;
1021         jit_float32_t    f;
1022     } data;
1023     jit_int32_t          reg;
1024
1025     if (_jitc->no_data) {
1026         data.f = *i0;
1027         reg = jit_get_reg(jit_class_gpr);
1028         movi(rn(reg), data.i & 0xffffffff);
1029         SETF_S(r0, rn(reg));
1030         jit_unget_reg(reg);
1031     }
1032     else
1033         ldi_f(r0, (jit_word_t)i0);
1034 }
1035
1036 static void
1037 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
1038 {
1039     union {
1040         jit_word_t       w;
1041         jit_float64_t    d;
1042     } data;
1043     jit_int32_t          reg;
1044
1045     if (_jitc->no_data) {
1046         data.d = *i0;
1047         reg = jit_get_reg(jit_class_gpr);
1048         movi(rn(reg), data.w);
1049         SETF_D(r0, rn(reg));
1050         jit_unget_reg(reg);
1051     }
1052     else
1053         ldi_d(r0, (jit_word_t)i0);
1054 }
1055
1056 static void
1057 _movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1058 {
1059     /* Should be used only in this case (with out0 == 120) */
1060     if (r1 >= 120)
1061         r1 = _jitc->rout + (r1 - 120);
1062     SETF_S(r0, r1);
1063 }
1064
1065 static void
1066 _movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1067 {
1068     /* Should actually be used only in this case (with out0 == 120) */
1069     if (r0 >= 120)
1070         r0 = _jitc->rout + (r0 - 120);
1071     GETF_S(r0, r1);
1072 }
1073
1074 static void
1075 _movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
1076 {
1077     jit_data_t          data;
1078
1079     /* Should be used only in this case (with out0 == 120) */
1080     if (r0 >= 120)
1081         r0 = _jitc->rout + (r0 - 120);
1082     if (_jitc->no_data) {
1083         data.f = *i0;
1084         movi(r0, data.q.l);
1085     }
1086     else
1087         ldi_i(r0, (jit_word_t)i0);
1088 }
1089
1090 static void
1091 _movr_w_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1092 {
1093     /* Should be used only in this case (with out0 == 120) */
1094     if (r1 >= 120)
1095         r1 = _jitc->rout + (r1 - 120);
1096     SETF_D(r0, r1);
1097 }
1098
1099 static void
1100 _movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1101 {
1102     /* Should be used only in this case (with out0 == 120) */
1103     if (r0 >= 120)
1104         r0 = _jitc->rout + (r0 - 120);
1105     GETF_D(r0, r1);
1106 }
1107
1108 static void
1109 _movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
1110 {
1111     union {
1112         jit_word_t       w;
1113         jit_float64_t    d;
1114     } data;
1115
1116     /* Should be used only in this case (with out0 == 120) */
1117     if (r0 >= 120)
1118         r0 = _jitc->rout + (r0 - 120);
1119     if (_jitc->no_data) {
1120         data.d = *i0;
1121         movi(r0, data.w);
1122     }
1123     else
1124         ldi_l(r0, (jit_word_t)i0);
1125 }
1126
1127 #define fpr_opi(name, type, size)                                       \
1128 static void                                                             \
1129 _##name##i_##type(jit_state_t *_jit,                                    \
1130                   jit_int32_t r0, jit_int32_t r1,                       \
1131                   jit_float##size##_t *i0)                              \
1132 {                                                                       \
1133     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
1134     movi_##type(rn(reg), i0);                                           \
1135     name##r_##type(r0, r1, rn(reg));                                    \
1136     jit_unget_reg(reg);                                                 \
1137 }
1138 #define fpr_bopi(name, type, size)                                      \
1139 static jit_word_t                                                       \
1140 _b##name##i_##type(jit_state_t *_jit,                                   \
1141                   jit_word_t i0, jit_int32_t r0,                        \
1142                   jit_float##size##_t *i1)                              \
1143 {                                                                       \
1144     jit_word_t          word;                                           \
1145     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
1146                                           jit_class_nospill);           \
1147     movi_##type(rn(reg), i1);                                           \
1148     word = b##name##r_##type(i0, r0, rn(reg));                          \
1149     jit_unget_reg(reg);                                                 \
1150     return (word);                                                      \
1151 }
1152 #define fopi(name)                      fpr_opi(name, f, 32)
1153 #define fbopi(name)                     fpr_bopi(name, f, 32)
1154 #define dopi(name)                      fpr_opi(name, d, 64)
1155 #define dbopi(name)                     fpr_bopi(name, d, 64)
1156
1157 fopi(add)
1158 fopi(sub)
1159 fopi(rsb)
1160 fopi(mul)
1161 fopi(div)
1162 dopi(add)
1163 dopi(sub)
1164 dopi(rsb)
1165 dopi(mul)
1166 dopi(div)
1167
1168 /* translation from gcc -O0 */
1169 static void
1170 _divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1171 {
1172     jit_int32_t         t0, t1, t2;
1173     t0 = jit_get_reg(jit_class_fpr);
1174     t1 = jit_get_reg(jit_class_fpr);
1175     t2 = jit_get_reg(jit_class_fpr);
1176     FRCPA(rn(t0), PR_6, r1, r2);
1177     FNMA_p(rn(t1), r2, rn(t0), GR_1, SF_S1, PR_6);
1178     FMA_p(rn(t2), rn(t0), rn(t1), rn(t0), SF_S1, PR_6);
1179     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1180     FMA_p(rn(t2), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1181     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1182     FMA_p(rn(t1), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1183     FMPY_S_p(rn(t2), r1, rn(t1), SF_S1, PR_6);
1184     FNMA_p(rn(t0), r2, rn(t2), r1, SF_S1, PR_6);
1185     FMA_S_p(r0, rn(t0), rn(t1), rn(t2), SF_S0, PR_6);
1186     jit_unget_reg(t2);
1187     jit_unget_reg(t1);
1188     jit_unget_reg(t0);
1189 }
1190
1191 static void
1192 _divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1193 {
1194     jit_int32_t         t0, t1, t2;
1195     t0 = jit_get_reg(jit_class_fpr);
1196     t1 = jit_get_reg(jit_class_fpr);
1197     t2 = jit_get_reg(jit_class_fpr);
1198     FRCPA(rn(t0), PR_6, r1, r2);
1199     FNMA_p(rn(t1), r2, rn(t0), GR_1, SF_S1, PR_6);
1200     FMA_p(rn(t2), rn(t0), rn(t1), rn(t0), SF_S1, PR_6);
1201     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1202     FMA_p(rn(t2), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1203     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1204     FMA_p(rn(t1), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1205     FMPY_D_p(rn(t2), r1, rn(t1), SF_S1, PR_6);
1206     FNMA_p(rn(t0), r2, rn(t2), r1, SF_S1, PR_6);
1207     FMA_D_p(r0, rn(t0), rn(t1), rn(t2), SF_S0, PR_6);
1208     jit_unget_reg(t2);
1209     jit_unget_reg(t1);
1210     jit_unget_reg(t0);
1211 }
1212
1213 static void
1214 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1215 {
1216     jit_int32_t         reg;
1217     reg = jit_get_reg(jit_class_fpr);
1218     SETF_SIG(rn(reg), r1);
1219     FCVT_XF(r0, rn(reg));
1220     FNORM_S(r0, r0);
1221     jit_unget_reg(reg);
1222 }
1223
1224 static void
1225 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1226 {
1227     jit_int32_t         reg;
1228     reg = jit_get_reg(jit_class_fpr);
1229     SETF_SIG(rn(reg), r1);
1230     FCVT_XF(r0, rn(reg));
1231     FNORM_D(r0, r0);
1232     jit_unget_reg(reg);
1233 }
1234
1235 static void
1236 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1237 {
1238     jit_int32_t         reg;
1239     reg = jit_get_reg(jit_class_fpr);
1240     FCVT_FX_TRUNC(rn(reg), r1);
1241     GETF_SIG(r0, rn(reg));
1242     FNORM(r0, r0);
1243     jit_unget_reg(reg);
1244 }
1245
1246 static void
1247 _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1248 {
1249     FCMP_LT(PR_6, PR_7, r1, r2);
1250     MOVI_p(r0, 1, PR_6);
1251     MOV_p(r0, GR_0, PR_7);
1252 }
1253 fopi(lt)
1254 dopi(lt)
1255
1256 static void
1257 _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1258 {
1259     FCMP_LE(PR_6, PR_7, r1, r2);
1260     MOVI_p(r0, 1, PR_6);
1261     MOV_p(r0, GR_0, PR_7);
1262 }
1263 fopi(le)
1264 dopi(le)
1265
1266 static void
1267 _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1268 {
1269     FCMP_EQ(PR_6, PR_7, r1, r2);
1270     MOVI_p(r0, 1, PR_6);
1271     MOV_p(r0, GR_0, PR_7);
1272 }
1273 fopi(eq)
1274 dopi(eq)
1275
1276 static void
1277 _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1278 {
1279     FCMP_LE(PR_6, PR_7, r2, r1);
1280     MOVI_p(r0, 1, PR_6);
1281     MOV_p(r0, GR_0, PR_7);
1282 }
1283 fopi(ge)
1284 dopi(ge)
1285
1286 static void
1287 _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1288 {
1289     FCMP_LT(PR_6, PR_7, r2, r1);
1290     MOVI_p(r0, 1, PR_6);
1291     MOV_p(r0, GR_0, PR_7);
1292 }
1293 fopi(gt)
1294 dopi(gt)
1295
1296 static void
1297 _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1298 {
1299     FCMP_EQ(PR_6, PR_7, r1, r2);
1300     MOV_p(r0, GR_0, PR_6);
1301     MOVI_p(r0, 1, PR_7);
1302 }
1303 fopi(ne)
1304 dopi(ne)
1305
1306 static void
1307 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1308 {
1309     FCMP_LE(PR_6, PR_7, r2, r1);
1310     MOV_p(r0, GR_0, PR_6);
1311     MOVI_p(r0, 1, PR_7);
1312 }
1313 fopi(unlt)
1314 dopi(unlt)
1315
1316 static void
1317 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1318 {
1319     FCMP_LT(PR_6, PR_7, r2, r1);
1320     MOV_p(r0, GR_0, PR_6);
1321     MOVI_p(r0, 1, PR_7);
1322 }
1323 fopi(unle)
1324 dopi(unle)
1325
1326 static void
1327 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1328 {
1329     MOVI(r0, 1);
1330     FCMP_LT(PR_8, PR_9, r1, r2);
1331     FCMP_LT(PR_6, PR_7, r2, r1);
1332     MOV_p(r0, GR_0, PR_8);              /* !(r1 < r2) && !(r2 < r1) */
1333     MOV_p(r0, GR_0, PR_6);
1334 }
1335 fopi(uneq)
1336 dopi(uneq)
1337
1338 static void
1339 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1340 {
1341     FCMP_LT(PR_6, PR_7, r1, r2);
1342     MOV_p(r0, GR_0, PR_6);
1343     MOVI_p(r0, 1, PR_7);
1344 }
1345 fopi(unge)
1346 dopi(unge)
1347
1348 static void
1349 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1350 {
1351     FCMP_LE(PR_6, PR_7, r1, r2);
1352     MOV_p(r0, GR_0, PR_6);
1353     MOVI_p(r0, 1, PR_7);
1354 }
1355 fopi(ungt)
1356 dopi(ungt)
1357
1358 static void
1359 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1360 {
1361     MOVI(r0, 1);
1362     FCMP_EQ(PR_8, PR_9, r1, r2);
1363     FCMP_UNORD(PR_6, PR_7, r1, r2);
1364     MOV_p(r0, GR_0, PR_8);
1365     MOV_p(r0, GR_0, PR_6);
1366 }
1367 fopi(ltgt)
1368 dopi(ltgt)
1369
1370 static void
1371 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1372 {
1373     FCMP_UNORD(PR_6, PR_7, r1, r2);
1374     MOV_p(r0, GR_0, PR_6);
1375     MOVI_p(r0, 1, PR_7);
1376 }
1377 fopi(ord)
1378 dopi(ord)
1379
1380 static void
1381 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1382 {
1383     FCMP_UNORD(PR_6, PR_7, r1, r2);
1384     MOVI_p(r0, 1, PR_6);
1385     MOV_p(r0, GR_0, PR_7);
1386 }
1387 fopi(unord)
1388 dopi(unord)
1389
1390 static void
1391 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1392 {
1393     jit_int32_t         reg;
1394     reg = jit_get_reg(jit_class_gpr);
1395     movi(rn(reg), i0);
1396     ldr_f(r0, rn(reg));
1397     jit_unget_reg(reg);
1398 }
1399
1400 static void
1401 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1402 {
1403     jit_int32_t         reg;
1404     reg = jit_get_reg(jit_class_gpr);
1405     addr(rn(reg), r1, r2);
1406     ldr_f(r0, rn(reg));
1407     jit_unget_reg(reg);
1408 }
1409
1410 static void
1411 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1412 {
1413     jit_int32_t         reg;
1414     if (r0) {
1415         reg = jit_get_reg(jit_class_gpr);
1416         addi(rn(reg), r1, i0);
1417         ldr_f(r0, rn(reg));
1418         jit_unget_reg(reg);
1419     }
1420     else
1421         ldr_f(r0, r1);
1422 }
1423
1424 static void
1425 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1426 {
1427     jit_int32_t         reg;
1428     reg = jit_get_reg(jit_class_gpr);
1429     movi(rn(reg), i0);
1430     ldr_d(r0, rn(reg));
1431     jit_unget_reg(reg);
1432 }
1433
1434 static void
1435 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1436 {
1437     jit_int32_t         reg;
1438     reg = jit_get_reg(jit_class_gpr);
1439     addr(rn(reg), r1, r2);
1440     ldr_d(r0, rn(reg));
1441     jit_unget_reg(reg);
1442 }
1443
1444 static void
1445 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1446 {
1447     jit_int32_t         reg;
1448     if (r0) {
1449         reg = jit_get_reg(jit_class_gpr);
1450         addi(rn(reg), r1, i0);
1451         ldr_d(r0, rn(reg));
1452         jit_unget_reg(reg);
1453     }
1454     else
1455         ldr_d(r0, r1);
1456 }
1457
1458 static void
1459 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1460 {
1461     jit_int32_t         reg;
1462     reg = jit_get_reg(jit_class_gpr);
1463     movi(rn(reg), i0);
1464     str_f(rn(reg), r0);
1465     jit_unget_reg(reg);
1466 }
1467
1468 static void
1469 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1470 {
1471     jit_int32_t         reg;
1472     reg = jit_get_reg(jit_class_gpr);
1473     addr(rn(reg), r0, r1);
1474     str_f(rn(reg), r2);
1475     jit_unget_reg(reg);
1476 }
1477
1478 static void
1479 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1480 {
1481     jit_int32_t         reg;
1482     if (i0) {
1483         reg = jit_get_reg(jit_class_gpr);
1484         addi(rn(reg), r0, i0);
1485         str_f(rn(reg), r1);
1486         jit_unget_reg(reg);
1487     }
1488     else
1489         str_f(r0, r1);
1490 }
1491
1492 static void
1493 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1494 {
1495     jit_int32_t         reg;
1496     reg = jit_get_reg(jit_class_gpr);
1497     movi(rn(reg), i0);
1498     str_d(rn(reg), r0);
1499     jit_unget_reg(reg);
1500 }
1501
1502 static void
1503 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1504 {
1505     jit_int32_t         reg;
1506     reg = jit_get_reg(jit_class_gpr);
1507     addr(rn(reg), r0, r1);
1508     str_d(rn(reg), r2);
1509     jit_unget_reg(reg);
1510 }
1511
1512 static void
1513 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1514 {
1515     jit_int32_t         reg;
1516     if (i0) {
1517         reg = jit_get_reg(jit_class_gpr);
1518         addi(rn(reg), r0, i0);
1519         str_d(rn(reg), r1);
1520         jit_unget_reg(reg);
1521     }
1522     else
1523         str_d(r0, r1);
1524 }
1525
1526 static void
1527 _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1528 {
1529     movr_f(GR_8, r1);
1530     calli((jit_word_t)sqrtf);
1531     MOVF(r0, GR_8);
1532 }
1533
1534 static void
1535 _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1536 {
1537     movr_d(GR_8, r1);
1538     calli((jit_word_t)sqrt);
1539     MOVF(r0, GR_8);
1540 }
1541
1542 static jit_word_t
1543 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1544 {
1545     jit_word_t          w;
1546     FCMP_LT(PR_6, PR_7, r0, r1);
1547     sync();
1548     w = _jit->pc.w;
1549     BRI_COND((i0 - w) >> 4, PR_6);
1550     return (w);
1551 }
1552 fbopi(lt)
1553 dbopi(lt)
1554
1555 static jit_word_t
1556 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1557 {
1558     jit_word_t          w;
1559     FCMP_LE(PR_6, PR_7, r0, r1);
1560     sync();
1561     w = _jit->pc.w;
1562     BRI_COND((i0 - w) >> 4, PR_6);
1563     return (w);
1564 }
1565 fbopi(le)
1566 dbopi(le)
1567
1568 static jit_word_t
1569 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1570 {
1571     jit_word_t          w;
1572     FCMP_EQ(PR_6, PR_7, r0, r1);
1573     sync();
1574     w = _jit->pc.w;
1575     BRI_COND((i0 - w) >> 4, PR_6);
1576     return (w);
1577 }
1578 fbopi(eq)
1579 dbopi(eq)
1580
1581 static jit_word_t
1582 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1583 {
1584     jit_word_t          w;
1585     FCMP_LE(PR_6, PR_7, r1, r0);
1586     sync();
1587     w = _jit->pc.w;
1588     BRI_COND((i0 - w) >> 4, PR_6);
1589     return (w);
1590 }
1591 fbopi(ge)
1592 dbopi(ge)
1593
1594 static jit_word_t
1595 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1596 {
1597     jit_word_t          w;
1598     FCMP_LT(PR_6, PR_7, r1, r0);
1599     sync();
1600     w = _jit->pc.w;
1601     BRI_COND((i0 - w) >> 4, PR_6);
1602     return (w);
1603 }
1604 fbopi(gt)
1605 dbopi(gt)
1606
1607 static jit_word_t
1608 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1609 {
1610     jit_word_t          w;
1611     FCMP_EQ(PR_6, PR_7, r0, r1);
1612     sync();
1613     w = _jit->pc.w;
1614     BRI_COND((i0 - w) >> 4, PR_7);
1615     return (w);
1616 }
1617 fbopi(ne)
1618 dbopi(ne)
1619
1620 static jit_word_t
1621 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1622 {
1623     jit_word_t          w;
1624     FCMP_LE(PR_6, PR_7, r1, r0);
1625     sync();
1626     w = _jit->pc.w;
1627     BRI_COND((i0 - w) >> 4, PR_7);
1628     return (w);
1629 }
1630 fbopi(unlt)
1631 dbopi(unlt)
1632
1633 static jit_word_t
1634 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1635 {
1636     jit_word_t          w;
1637     FCMP_LT(PR_6, PR_7, r1, r0);
1638     sync();
1639     w = _jit->pc.w;
1640     BRI_COND((i0 - w) >> 4, PR_7);
1641     return (w);
1642 }
1643 fbopi(unle)
1644 dbopi(unle)
1645
1646 static jit_word_t
1647 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1648 {
1649     jit_word_t          w;
1650     jit_word_t          junord, jne;
1651     FCMP_UNORD(PR_8, PR_9, r0, r1);
1652     sync();
1653     /* junord L1 */
1654     junord = _jit->pc.w;
1655     BRI_COND(3, PR_8);
1656     FCMP_EQ(PR_6, PR_7, r0, r1);
1657     sync();
1658     /* jne L2 */
1659     jne = _jit->pc.w;
1660     BRI_COND(2, PR_7);
1661     sync();
1662     w = _jit->pc.w;
1663     /* L1: */
1664     patch_at(jit_code_bunordr_d, junord, _jit->pc.w);
1665     BRI((i0 - w) >> 4);         /* unconditional jump to patch */
1666     sync();
1667     /* L2: */
1668     patch_at(jit_code_bner_d, jne, _jit->pc.w);
1669     return (w);
1670 }
1671 fbopi(uneq)
1672 dbopi(uneq)
1673
1674 static jit_word_t
1675 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1676 {
1677     jit_word_t          w;
1678     FCMP_LT(PR_6, PR_7, r0, r1);
1679     sync();
1680     w = _jit->pc.w;
1681     BRI_COND((i0 - w) >> 4, PR_7);
1682     return (w);
1683 }
1684 fbopi(unge)
1685 dbopi(unge)
1686
1687 static jit_word_t
1688 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1689 {
1690     jit_word_t          w;
1691     FCMP_LE(PR_6, PR_7, r0, r1);
1692     sync();
1693     w = _jit->pc.w;
1694     BRI_COND((i0 - w) >> 4, PR_7);
1695     return (w);
1696 }
1697 fbopi(ungt)
1698 dbopi(ungt)
1699
1700 static jit_word_t
1701 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1702 {
1703     jit_word_t          w;
1704     jit_word_t          jeq, junord;
1705     FCMP_EQ(PR_8, PR_9, r0, r1);
1706     /* jeq L1 */
1707     sync();
1708     jeq = _jit->pc.w;
1709     BRI_COND(4, PR_8);
1710     FCMP_UNORD(PR_6, PR_7, r0, r1);
1711     /* junord L1 */
1712     sync();
1713     junord = _jit->pc.w;
1714     BRI_COND(2, PR_6);
1715     sync();
1716     w = _jit->pc.w;
1717     BRI((i0 - w) >> 4);         /* unconditional jump to patch */
1718     /* L1 */
1719     sync();
1720     patch_at(jit_code_beqr_d, jeq, _jit->pc.w);
1721     patch_at(jit_code_bordr_d, junord, _jit->pc.w);
1722     return (w);
1723 }
1724 fbopi(ltgt)
1725 dbopi(ltgt)
1726
1727 static jit_word_t
1728 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1729 {
1730     jit_word_t          w;
1731     FCMP_UNORD(PR_6, PR_7, r0, r1);
1732     sync();
1733     w = _jit->pc.w;
1734     BRI_COND((i0 - w) >> 4, PR_7);
1735     return (w);
1736 }
1737 fbopi(ord)
1738 dbopi(ord)
1739
1740 static jit_word_t
1741 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1742 {
1743     jit_word_t          w;
1744     FCMP_UNORD(PR_6, PR_7, r0, r1);
1745     sync();
1746     w = _jit->pc.w;
1747     BRI_COND((i0 - w) >> 4, PR_6);
1748     return (w);
1749 }
1750 fbopi(unord)
1751 dbopi(unord)
1752
1753 static void
1754 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1755 {
1756     assert(_jitc->function->self.call & jit_call_varargs);
1757     /* Load argument. */
1758     ldr_d(r0, r1);
1759     /* Update va_list. */
1760     addi(r1, r1, 8);
1761 }
1762 #endif