deps/lightning/lib/jit_ia64-fpu.c

   1 /*
   2  * Copyright (C) 2013-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 #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 movi_w_f(r0, i0)                _movi_w_f(_jit, r0, i0)
 443 static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t);
 444 #define movr_w_d(r0,r1)                 _movr_w_d(_jit,r0,r1)
 445 static void _movr_w_d(jit_state_t*,jit_int32_t,jit_int32_t);
 446 #define movr_d_w(r0,r1)                 _movr_d_w(_jit,r0,r1)
 447 static void _movr_d_w(jit_state_t*,jit_int32_t,jit_int32_t);
 448 #define movi_w_d(r0, i0)                _movi_w_d(_jit, r0, i0)
 449 static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_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 fmar_f(r0,r1,r2,r3)             FMA_S(r0,r1,r2,r3)
 457 #define fmsr_f(r0,r1,r2,r3)             FMS_S(r0,r1,r2,r3)
 458 #define fnmsr_f(r0,r1,r2,r3)            FNMA_S(r0,r1,r2,r3)
 459 #define fnmar_f(r0,r1,r2,r3)            _fnmar_f(_jit,r0,r1,r2,r3)
 460 static void _fnmar_f(jit_state_t*,
 461                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 462 #define sqrtr_d(r0,r1)                  _sqrtr_d(_jit,r0,r1)
 463 static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 464 #define fmar_d(r0,r1,r2,r3)             FMA_D(r0,r1,r2,r3)
 465 #define fmsr_d(r0,r1,r2,r3)             FMS_D(r0,r1,r2,r3)
 466 #define fnmsr_d(r0,r1,r2,r3)            FNMA_D(r0,r1,r2,r3)
 467 #define fnmar_d(r0,r1,r2,r3)            _fnmar_d(_jit,r0,r1,r2,r3)
 468 static void _fnmar_d(jit_state_t*,
 469                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 470 #define extr_f_d(r0,r1)                 FNORM_D(r0,r1)
 471 #define extr_d_f(r0,r1)                 FNORM_S(r0,r1)
 472 #define extr_f(r0,r1)                   _extr_f(_jit,r0,r1)
 473 static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 474 #define extr_d(r0,r1)                   _extr_d(_jit,r0,r1)
 475 static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 476 #define truncr_f_i(r0,r1)               truncr_d_l(r0,r1)
 477 #define truncr_d_i(r0,r1)               truncr_d_l(r0,r1)
 478 #define truncr_f_l(r0,r1)               truncr_d_l(r0,r1)
 479 #define truncr_d_l(r0,r1)               _truncr_d_l(_jit,r0,r1)
 480 static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
 481 #define addr_f(r0,r1,r2)                FADD_S(r0,r1,r2)
 482 #define addi_f(r0,r1,i0)                _addi_f(_jit,r0,r1,i0)
 483 static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 484 #define addr_d(r0,r1,r2)                FADD_D(r0,r1,r2)
 485 #define addi_d(r0,r1,i0)                _addi_d(_jit,r0,r1,i0)
 486 static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 487 #define subr_f(r0,r1,r2)                FSUB_S(r0,r1,r2)
 488 #define subi_f(r0,r1,i0)                _subi_f(_jit,r0,r1,i0)
 489 static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 490 #define subr_d(r0,r1,r2)                FSUB_D(r0,r1,r2)
 491 #define subi_d(r0,r1,i0)                _subi_d(_jit,r0,r1,i0)
 492 static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 493 #define rsbr_f(r0,r1,r2)                subr_f(r0,r2,r1)
 494 #define rsbi_f(r0,r1,i0)                _rsbi_f(_jit,r0,r1,i0)
 495 static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 496 #define rsbr_d(r0,r1,r2)                subr_d(r0,r2,r1)
 497 #define rsbi_d(r0,r1,i0)                _rsbi_d(_jit,r0,r1,i0)
 498 static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 499 #define mulr_f(r0,r1,r2)                FMPY_S(r0,r1,r2)
 500 #define muli_f(r0,r1,i0)                _muli_f(_jit,r0,r1,i0)
 501 static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 502 #define mulr_d(r0,r1,r2)                FMPY_D(r0,r1,r2)
 503 #define muli_d(r0,r1,i0)                _muli_d(_jit,r0,r1,i0)
 504 static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 505 #define divr_f(r0,r1,r2)                _divr_f(_jit,r0,r1,r2)
 506 static void _divr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 507 #define divi_f(r0,r1,i0)                _divi_f(_jit,r0,r1,i0)
 508 static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 509 #define divr_d(r0,r1,r2)                _divr_d(_jit,r0,r1,r2)
 510 static void _divr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 511 #define divi_d(r0,r1,i0)                _divi_d(_jit,r0,r1,i0)
 512 static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 513 #define ltr_f(r0,r1,r2)                 ltr_d(r0,r1,r2)
 514 #define ltr_d(r0,r1,r2)                 _ltr_d(_jit,r0,r1,r2)
 515 static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 516 #define lti_f(r0,r1,i0)                 _lti_f(_jit,r0,r1,i0)
 517 static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 518 #define lti_d(r0,r1,i0)                 _lti_d(_jit,r0,r1,i0)
 519 static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 520 #define ler_f(r0,r1,r2)                 ler_d(r0,r1,r2)
 521 #define ler_d(r0,r1,r2)                 _ler_d(_jit,r0,r1,r2)
 522 static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 523 #define lei_f(r0,r1,i0)                 _lei_f(_jit,r0,r1,i0)
 524 static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 525 #define lei_d(r0,r1,i0)                 _lei_d(_jit,r0,r1,i0)
 526 static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 527 #define eqr_f(r0,r1,r2)                 eqr_d(r0,r1,r2)
 528 #define eqr_d(r0,r1,r2)                 _eqr_d(_jit,r0,r1,r2)
 529 static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 530 #define eqi_f(r0,r1,i0)                 _eqi_f(_jit,r0,r1,i0)
 531 static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 532 #define eqi_d(r0,r1,i0)                 _eqi_d(_jit,r0,r1,i0)
 533 static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 534 #define ger_f(r0,r1,r2)                 ger_d(r0,r1,r2)
 535 #define ger_d(r0,r1,r2)                 _ger_d(_jit,r0,r1,r2)
 536 static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 537 #define gei_f(r0,r1,i0)                 _gei_f(_jit,r0,r1,i0)
 538 static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 539 #define gei_d(r0,r1,i0)                 _gei_d(_jit,r0,r1,i0)
 540 static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 541 #define gtr_f(r0,r1,r2)                 gtr_d(r0,r1,r2)
 542 #define gtr_d(r0,r1,r2)                 _gtr_d(_jit,r0,r1,r2)
 543 static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 544 #define gti_f(r0,r1,i0)                 _gti_f(_jit,r0,r1,i0)
 545 static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 546 #define gti_d(r0,r1,i0)                 _gti_d(_jit,r0,r1,i0)
 547 static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 548 #define ner_f(r0,r1,r2)                 ner_d(r0,r1,r2)
 549 #define ner_d(r0,r1,r2)                 _ner_d(_jit,r0,r1,r2)
 550 static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 551 #define nei_f(r0,r1,i0)                 _nei_f(_jit,r0,r1,i0)
 552 static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 553 #define nei_d(r0,r1,i0)                 _nei_d(_jit,r0,r1,i0)
 554 static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 555 #define unltr_f(r0,r1,r2)               unltr_d(r0,r1,r2)
 556 #define unltr_d(r0,r1,r2)               _unltr_d(_jit,r0,r1,r2)
 557 static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 558 #define unlti_f(r0,r1,i0)               _unlti_f(_jit,r0,r1,i0)
 559 static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 560 #define unlti_d(r0,r1,i0)               _unlti_d(_jit,r0,r1,i0)
 561 static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 562 #define unler_f(r0,r1,r2)               unler_d(r0,r1,r2)
 563 #define unler_d(r0,r1,r2)               _unler_d(_jit,r0,r1,r2)
 564 static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 565 #define unlei_f(r0,r1,i0)               _unlei_f(_jit,r0,r1,i0)
 566 static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 567 #define unlei_d(r0,r1,i0)               _unlei_d(_jit,r0,r1,i0)
 568 static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 569 #define uneqr_f(r0,r1,r2)               uneqr_d(r0,r1,r2)
 570 #define uneqr_d(r0,r1,r2)               _uneqr_d(_jit,r0,r1,r2)
 571 static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 572 #define uneqi_f(r0,r1,i0)               _uneqi_f(_jit,r0,r1,i0)
 573 static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 574 #define uneqi_d(r0,r1,i0)               _uneqi_d(_jit,r0,r1,i0)
 575 static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 576 #define unger_f(r0,r1,r2)               unger_d(r0,r1,r2)
 577 #define unger_d(r0,r1,r2)               _unger_d(_jit,r0,r1,r2)
 578 static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 579 #define ungei_f(r0,r1,i0)               _ungei_f(_jit,r0,r1,i0)
 580 static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 581 #define ungei_d(r0,r1,i0)               _ungei_d(_jit,r0,r1,i0)
 582 static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 583 #define ungtr_f(r0,r1,r2)               ungtr_d(r0,r1,r2)
 584 #define ungtr_d(r0,r1,r2)               _ungtr_d(_jit,r0,r1,r2)
 585 static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 586 #define ungti_f(r0,r1,i0)               _ungti_f(_jit,r0,r1,i0)
 587 static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 588 #define ungti_d(r0,r1,i0)               _ungti_d(_jit,r0,r1,i0)
 589 static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 590 #define ltgtr_f(r0,r1,r2)               ltgtr_d(r0,r1,r2)
 591 #define ltgtr_d(r0,r1,r2)               _ltgtr_d(_jit,r0,r1,r2)
 592 static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 593 #define ltgti_f(r0,r1,i0)               _ltgti_f(_jit,r0,r1,i0)
 594 static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 595 #define ltgti_d(r0,r1,i0)               _ltgti_d(_jit,r0,r1,i0)
 596 static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 597 #define ordr_f(r0,r1,r2)                ordr_d(r0,r1,r2)
 598 #define ordr_d(r0,r1,r2)                _ordr_d(_jit,r0,r1,r2)
 599 static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 600 #define ordi_f(r0,r1,i0)                _ordi_f(_jit,r0,r1,i0)
 601 static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 602 #define ordi_d(r0,r1,i0)                _ordi_d(_jit,r0,r1,i0)
 603 static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 604 #define unordr_f(r0,r1,r2)              unordr_d(r0,r1,r2)
 605 #define unordr_d(r0,r1,r2)              _unordr_d(_jit,r0,r1,r2)
 606 static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 607 #define unordi_f(r0,r1,i0)              _unordi_f(_jit,r0,r1,i0)
 608 static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 609 #define unordi_d(r0,r1,i0)              _unordi_d(_jit,r0,r1,i0)
 610 static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 611 #define ldr_f(r0,r1)                    LDFS(r0,r1)
 612 #define ldi_f(r0,i0)                    _ldi_f(_jit,r0,i0)
 613 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 614 #define ldxr_f(r0,r1,r2)                _ldxr_f(_jit,r0,r1,r2)
 615 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 616 #define ldxi_f(r0,r1,i0)                _ldxi_f(_jit,r0,r1,i0)
 617 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 618 #  define unldr_x(r0, r1, i0)           _unldr_x(_jit, r0, r1, i0)
 619 static void _unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 620 #  define unldi_x(r0, i0, i1)           _unldi_x(_jit, r0, i0, i1)
 621 static void _unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 622 #define ldr_d(r0,r1)                    LDFD(r0,r1)
 623 #define ldi_d(r0,i0)                    _ldi_d(_jit,r0,i0)
 624 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 625 #define ldxr_d(r0,r1,r2)                _ldxr_d(_jit,r0,r1,r2)
 626 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 627 #define ldxi_d(r0,r1,i0)                _ldxi_d(_jit,r0,r1,i0)
 628 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 629 #define str_f(r0,r1)                    STFS(r0,r1)
 630 #define sti_f(i0,r0)                    _sti_f(_jit,i0,r0)
 631 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 632 #define stxr_f(r0,r1,r2)                _stxr_f(_jit,r0,r1,r2)
 633 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 634 #define stxi_f(i0,r0,r1)                _stxi_f(_jit,i0,r0,r1)
 635 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 636 #define unstr_x(r0, r1, i0)             _unstr_x(_jit, r0, r1, i0)
 637 static void _unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 638 #define unsti_x(i0, r0, i1)             _unsti_x(_jit, i0, r0, i1)
 639 static void _unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 640 #define str_d(r0,r1)                    STFD(r0,r1)
 641 #define sti_d(i0,r0)                    _sti_d(_jit,i0,r0)
 642 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 643 #define stxr_d(r0,r1,r2)                _stxr_d(_jit,r0,r1,r2)
 644 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 645 #define stxi_d(i0,r0,r1)                _stxi_d(_jit,i0,r0,r1)
 646 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 647 #define bltr_f(i0,r0,r1)                bltr_d(i0,r0,r1)
 648 #define bltr_d(i0,r0,r1)                _bltr_d(_jit,i0,r0,r1)
 649 static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 650 #define blti_f(i0,r0,i1)                _blti_f(_jit,i0,r0,i1)
 651 static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 652 #define blti_d(i0,r0,i1)                _blti_d(_jit,i0,r0,i1)
 653 static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 654 #define bler_f(i0,r0,r1)                bler_d(i0,r0,r1)
 655 #define bler_d(i0,r0,r1)                _bler_d(_jit,i0,r0,r1)
 656 static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 657 #define blei_f(i0,r0,i1)                _blei_f(_jit,i0,r0,i1)
 658 static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 659 #define blei_d(i0,r0,i1)                _blei_d(_jit,i0,r0,i1)
 660 static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 661 #define beqr_f(i0,r0,r1)                beqr_d(i0,r0,r1)
 662 #define beqr_d(i0,r0,r1)                _beqr_d(_jit,i0,r0,r1)
 663 static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 664 #define beqi_f(i0,r0,i1)                _beqi_f(_jit,i0,r0,i1)
 665 static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 666 #define beqi_d(i0,r0,i1)                _beqi_d(_jit,i0,r0,i1)
 667 static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 668 #define bger_f(i0,r0,r1)                bger_d(i0,r0,r1)
 669 #define bger_d(i0,r0,r1)                _bger_d(_jit,i0,r0,r1)
 670 static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 671 #define bgei_f(i0,r0,i1)                _bgei_f(_jit,i0,r0,i1)
 672 static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 673 #define bgei_d(i0,r0,i1)                _bgei_d(_jit,i0,r0,i1)
 674 static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 675 #define bgtr_f(i0,r0,r1)                bgtr_d(i0,r0,r1)
 676 #define bgtr_d(i0,r0,r1)                _bgtr_d(_jit,i0,r0,r1)
 677 static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 678 #define bgti_f(i0,r0,i1)                _bgti_f(_jit,i0,r0,i1)
 679 static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 680 #define bgti_d(i0,r0,i1)                _bgti_d(_jit,i0,r0,i1)
 681 static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 682 #define bner_f(i0,r0,r1)                bner_d(i0,r0,r1)
 683 #define bner_d(i0,r0,r1)                _bner_d(_jit,i0,r0,r1)
 684 static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 685 #define bnei_f(i0,r0,i1)                _bnei_f(_jit,i0,r0,i1)
 686 static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 687 #define bnei_d(i0,r0,i1)                _bnei_d(_jit,i0,r0,i1)
 688 static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 689 #define bunltr_f(i0,r0,r1)              bunltr_d(i0,r0,r1)
 690 #define bunltr_d(i0,r0,r1)              _bunltr_d(_jit,i0,r0,r1)
 691 static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 692 #define bunlti_f(i0,r0,i1)              _bunlti_f(_jit,i0,r0,i1)
 693 static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 694 #define bunlti_d(i0,r0,i1)              _bunlti_d(_jit,i0,r0,i1)
 695 static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 696 #define bunler_f(i0,r0,r1)              bunler_d(i0,r0,r1)
 697 #define bunler_d(i0,r0,r1)              _bunler_d(_jit,i0,r0,r1)
 698 static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 699 #define bunlei_f(i0,r0,i1)              _bunlei_f(_jit,i0,r0,i1)
 700 static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 701 #define bunlei_d(i0,r0,i1)              _bunlei_d(_jit,i0,r0,i1)
 702 static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 703 #define buneqr_f(i0,r0,r1)              buneqr_d(i0,r0,r1)
 704 #define buneqr_d(i0,r0,r1)              _buneqr_d(_jit,i0,r0,r1)
 705 static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 706 #define buneqi_f(i0,r0,i1)              _buneqi_f(_jit,i0,r0,i1)
 707 static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 708 #define buneqi_d(i0,r0,i1)              _buneqi_d(_jit,i0,r0,i1)
 709 static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 710 #define bunger_f(i0,r0,r1)              bunger_d(i0,r0,r1)
 711 #define bunger_d(i0,r0,r1)              _bunger_d(_jit,i0,r0,r1)
 712 static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 713 #define bungei_f(i0,r0,i1)              _bungei_f(_jit,i0,r0,i1)
 714 static jit_word_t _bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 715 #define bungei_d(i0,r0,i1)              _bungei_d(_jit,i0,r0,i1)
 716 static jit_word_t _bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 717 #define bungtr_f(i0,r0,r1)              bungtr_d(i0,r0,r1)
 718 #define bungtr_d(i0,r0,r1)              _bungtr_d(_jit,i0,r0,r1)
 719 static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 720 #define bungti_f(i0,r0,i1)              _bungti_f(_jit,i0,r0,i1)
 721 static jit_word_t _bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 722 #define bungti_d(i0,r0,i1)              _bungti_d(_jit,i0,r0,i1)
 723 static jit_word_t _bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 724 #define bltgtr_f(i0,r0,r1)              bltgtr_d(i0,r0,r1)
 725 #define bltgtr_d(i0,r0,r1)              _bltgtr_d(_jit,i0,r0,r1)
 726 static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 727 #define bltgti_f(i0,r0,i1)              _bltgti_f(_jit,i0,r0,i1)
 728 static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 729 #define bltgti_d(i0,r0,i1)              _bltgti_d(_jit,i0,r0,i1)
 730 static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 731 #define bordr_f(i0,r0,r1)               bordr_d(i0,r0,r1)
 732 #define bordr_d(i0,r0,r1)               _bordr_d(_jit,i0,r0,r1)
 733 static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 734 #define bordi_f(i0,r0,i1)               _bordi_f(_jit,i0,r0,i1)
 735 static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 736 #define bordi_d(i0,r0,i1)               _bordi_d(_jit,i0,r0,i1)
 737 static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 738 #define bunordr_f(i0,r0,r1)             bunordr_d(i0,r0,r1)
 739 #define bunordr_d(i0,r0,r1)             _bunordr_d(_jit,i0,r0,r1)
 740 static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 741 #define bunordi_f(i0,r0,i1)             _bunordi_f(_jit,i0,r0,i1)
 742 static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 743 #define bunordi_d(i0,r0,i1)             _bunordi_d(_jit,i0,r0,i1)
 744 static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 745 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 746 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 747 #endif
 748
 749 #if CODE
 750 static void
 751 _M7(jit_state_t *_jit, jit_word_t _p,
 752     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t r2, jit_word_t f1)
 753 {
 754     assert(!(_p & ~0x3fL));
 755     assert(!(x6 & ~0x3fL));
 756     assert(!(ht &  ~0x3L));
 757     assert(!(r3 & ~0x7fL));
 758     assert(!(r2 & ~0x7fL));
 759     assert(!(f1 & ~0x7fL));
 760     TSTREG2(r2, r3);
 761     TSTPRED(_p);
 762     TSTFREG1(f1);
 763     inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)|
 764          (r3<<20)|(r2<<13)|(f1<<6)|_p, INST_M);
 765     SETFREG(f1);
 766     SETREG(r3);
 767 }
 768
 769 static void
 770 _M8(jit_state_t *_jit, jit_word_t _p,
 771     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im, jit_word_t f1)
 772 {
 773     assert(!(_p &  ~0x3fL));
 774     assert(!(x6 &  ~0x3fL));
 775     assert(!(ht &   ~0x3L));
 776     assert(!(r3 &  ~0x7fL));
 777     assert(im > -256 && im <= 255);
 778     assert(!(f1 &  ~0x7fL));
 779     TSTREG1(r3);
 780     TSTPRED(_p);
 781     TSTFREG1(f1);
 782     inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)|
 783          (((im>>8)&1L)<<27)|(r3<<20)|((im&0x7fLL)<<13)|(f1<<6)|_p, INST_M);
 784     SETFREG(f1);
 785     SETREG(r3);
 786 }
 787
 788 static void
 789 _M9(jit_state_t *_jit, jit_word_t _p,
 790     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f1)
 791 {
 792     assert(!(_p & ~0x3fL));
 793     assert(!(x6 & ~0x3fL));
 794     assert(!(ht &  ~0x3L));
 795     assert(!(r3 & ~0x7fL));
 796     assert(!(f1 & ~0x7fL));
 797     TSTREG1(r3);
 798     TSTPRED(_p);
 799     TSTFREG1(f1);
 800     inst((6L<<37)|(x6<<30)|(ht<<28)|(r3<<20)|(f1<<6)|_p, INST_M);
 801     SETFREG(f1);
 802 }
 803
 804 static void
 805 _M10(jit_state_t *_jit, jit_word_t _p,
 806      jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t im)
 807 {
 808     assert(!(_p &  ~0x3fL));
 809     assert(!(x6 &  ~0x3fL));
 810     assert(!(ht &   ~0x3L));
 811     assert(!(r3 &  ~0x7fL));
 812     assert(!(f2 &  ~0x7fL));
 813     assert(im > -256 && im <= 255);
 814     TSTREG1(r3);
 815     TSTFREG1(f2);
 816     TSTPRED(_p);
 817     inst((7L<<37)|(((im>>8)&1L)<<36)|(x6<<30)|(ht<<28)|
 818          (((im>>8)&1L)<<27)|(r3<<20)|(f2<<13)|((im&0x7fL)<<6)|_p, INST_M);
 819     SETREG(r3);
 820 }
 821
 822 static void
 823 _M11(jit_state_t *_jit, jit_word_t _p,
 824      jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t f1)
 825 {
 826     assert(!(_p & ~0x3fL));
 827     assert(!(x6 & ~0x3fL));
 828     assert(!(ht &  ~0x3L));
 829     assert(!(r3 & ~0x7fL));
 830     assert(!(f2 & ~0x7fL));
 831     assert(!(f1 & ~0x7fL));
 832     TSTREG1(r3);
 833     TSTPRED(_p);
 834     TSTFREG2(f1, f2);
 835     inst((6L<<37)|(x6<<30)|(ht<<28)|(1L<<27)|
 836          (r3<<20)|(f2<<13)|(f1<<6)|_p, INST_M);
 837     SETFREG(f1);
 838     SETFREG(f2);
 839 }
 840
 841 static void
 842 _M12(jit_state_t *_jit, jit_word_t _p,
 843      jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t f2, jit_word_t f1)
 844 {
 845     assert(!(_p & ~0x3fL));
 846     assert(!(x6 & ~0x3fL));
 847     assert(!(ht &  ~0x3L));
 848     assert(!(r3 & ~0x7fL));
 849     assert(!(f2 & ~0x7fL));
 850     assert(!(f1 & ~0x7fL));
 851     TSTREG1(r3);
 852     TSTPRED(_p);
 853     TSTFREG2(f1, f2);
 854     inst((6L<<37)|(1L<<36)|(x6<<30)|(ht<<28)|
 855          (1L<<27)|(r3<<20)|(f2<<13)|(f1<<6)|_p, INST_M);
 856     SETFREG(f1);
 857     SETFREG(f2);
 858     SETREG(r3);
 859 }
 860
 861 static void
 862 _M18(jit_state_t *_jit, jit_word_t _p,
 863      jit_word_t x6, jit_word_t r2, jit_word_t f1)
 864 {
 865     assert(!(_p & ~0x3fL));
 866     assert(!(x6 & ~0x3fL));
 867     assert(!(r2 & ~0x7fL));
 868     assert(!(f1 & ~0x7fL));
 869     TSTREG1(r2);
 870     TSTPRED(_p);
 871     TSTFREG1(f1);
 872     inst((6L<<37)|(x6<<30)|(1L<<27)|(r2<<13)|(f1<<6)|_p, INST_M);
 873     SETFREG(f1);
 874 }
 875
 876 static void
 877 _M19(jit_state_t *_jit, jit_word_t _p,
 878      jit_word_t x6, jit_word_t f2, jit_word_t r1)
 879 {
 880     assert(!(_p & ~0x3fL));
 881     assert(!(x6 & ~0x3fL));
 882     assert(!(f2 & ~0x7fL));
 883     assert(!(r1 & ~0x7fL));
 884     TSTFREG1(f2);
 885     TSTPRED(_p);
 886     TSTREG1(r1);
 887     inst((4L<<37)|(x6<<30)|(1L<<27)|(f2<<13)|(r1<<6)|_p, INST_M);
 888     SETREG(r1);
 889 }
 890
 891 static void
 892 F1_(jit_state_t *_jit, jit_word_t _p,
 893     jit_word_t op, jit_word_t x, jit_word_t sf,
 894     jit_word_t f4, jit_word_t f3, jit_word_t f2, jit_word_t f1)
 895 {
 896     assert(!(_p & ~0x3fL));
 897     assert(!(op &  ~0xfL));
 898     assert(!(x  &  ~0x1L));
 899     assert(!(sf &  ~0x3L));
 900     assert(!(f4 & ~0x7fL));
 901     assert(!(f3 & ~0x7fL));
 902     assert(!(f2 & ~0x7fL));
 903     assert(!(f1 & ~0x7fL));
 904     TSTFREG3(f2, f3, f4);
 905     TSTPRED(_p);
 906     TSTFREG1(f1);
 907     inst((op<<37)|(x<<36)|(sf<<34)|(f4<<27)|
 908          (f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F);
 909     SETFREG(f1);
 910 }
 911
 912 static void
 913 F4_(jit_state_t *_jit, jit_word_t _p,
 914     jit_word_t rb, jit_word_t sf, jit_word_t ra, jit_word_t p2,
 915     jit_word_t f3, jit_word_t f2, jit_word_t ta, jit_word_t p1)
 916 {
 917     assert(!(_p & ~0x3fL));
 918     assert(!(rb &  ~0x1L));
 919     assert(!(sf &  ~0x3L));
 920     assert(!(ra &  ~0x1L));
 921     assert(!(p2 & ~0x3fL));
 922     assert(!(f3 & ~0x7fL));
 923     assert(!(f2 & ~0x7fL));
 924     assert(!(ta &  ~0x1L));
 925     assert(!(p1 & ~0x3fL));
 926     TSTFREG2(f2, f3);
 927     TSTPRED(_p);
 928     inst((4L<<37)|(rb<<36)|(sf<<34)|(ra<<33)|(p2<<27)|
 929          (f3<<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 F5_(jit_state_t *_jit, jit_word_t _p,
 938     jit_word_t p2, jit_word_t fc, jit_word_t f2, jit_word_t ta, jit_word_t p1)
 939 {
 940     assert(!(_p &  ~0x3fL));
 941     assert(!(p2 &  ~0x3fL));
 942     assert(!(fc & ~0x1ffL));
 943     assert(!(f2 &  ~0x7fL));
 944     assert(!(ta &   ~0x1L));
 945     assert(!(p1 &  ~0x3fL));
 946     TSTFREG1(f2);
 947     TSTPRED(_p);
 948     inst((5L<<37)|(((fc>>7)&3L)<<33)|(p2<<27)|
 949          ((fc&0x7fL)<<20)|(f2<<13)|(ta<<12)|(p1<<6)|_p, INST_F);
 950     if (p1)
 951         _jitc->pred |= 1 << p1;
 952     if (p2)
 953         _jitc->pred |= 1 << p2;
 954 }
 955
 956 static void
 957 F6x_(jit_state_t *_jit, jit_word_t _p,
 958      jit_word_t op, jit_word_t q, jit_word_t sf,
 959      jit_word_t p2,  jit_word_t f3, jit_word_t f2, jit_word_t f1)
 960 {
 961     assert(!(_p & ~0x3fL));
 962     assert(!(op &  ~0xfL));
 963     assert(!(q  &  ~0x1L));
 964     assert(!(sf &  ~0x3L));
 965     assert(!(p2 & ~0x3fL));
 966     assert(!(f3 & ~0x7fL));
 967     assert(!(f2 & ~0x7fL));
 968     assert(!(f1 & ~0x7fL));
 969     TSTFREG2(f2, f3);
 970     TSTPRED(_p);
 971     TSTFREG1(f1);
 972     inst((op<<37)|(q<<36)|(sf<<34)|(1L<<33)|
 973          (p2<<27)|(f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F);
 974     SETFREG(f1);
 975     if (p2)
 976         _jitc->pred |= 1 << p2;
 977 }
 978
 979 static void
 980 F8_(jit_state_t *_jit, jit_word_t _p,
 981     jit_word_t op, jit_word_t sf, jit_word_t x6,
 982     jit_word_t f3, jit_word_t f2, jit_word_t f1)
 983 {
 984     assert(!(_p & ~0x3fL));
 985     assert(!(op &  ~0xfL));
 986     assert(!(sf &  ~0x3L));
 987     assert(!(x6 & ~0x3fL));
 988     assert(!(f3 & ~0x7fL));
 989     assert(!(f2 & ~0x7fL));
 990     assert(!(f1 & ~0x7fL));
 991     TSTFREG2(f2, f3);
 992     TSTPRED(_p);
 993     TSTFREG1(f1);
 994     inst((op<<37)|(sf<<34)|(x6<<27)|(f3<<20)|(f2<<13)|(f1<<6)|_p, INST_F);
 995     SETFREG(f1);
 996 }
 997
 998 static void
 999 F12_(jit_state_t *_jit, jit_word_t _p,
1000      jit_word_t sf, jit_word_t x6, jit_word_t omsk, jit_word_t amsk)
1001 {
1002     assert(!(_p   & ~0x3fL));
1003     assert(!(sf   &  ~0x3L));
1004     assert(!(x6   & ~0x3fL));
1005     assert(!(omsk & ~0x7fL));
1006     assert(!(amsk & ~0x7fL));
1007     TSTPRED(_p);
1008     inst((sf<<34)|(x6<<27)|(omsk<<20)|(amsk<<13), INST_F);
1009 }
1010
1011 static void
1012 F14x_(jit_state_t* _jit, jit_word_t _p,
1013       jit_word_t sf,  jit_word_t x, jit_word_t x6, jit_word_t im)
1014 {
1015     assert(!(_p &    ~0x3fL));
1016     assert(!(sf &     ~0x3L));
1017     assert(!(x  &     ~0x1L));
1018     assert(!(x6 &    ~0x3fL));
1019     assert(!(im & ~0x1ffffL));
1020     TSTPRED(_p);
1021     inst((((im>>20)&1L)<<36)|(sf<<34)|(x<<33)|
1022          (x6<<27)|((im&0xffffL)<<6)|_p, INST_F);
1023 }
1024
1025 static void
1026 F16_(jit_state_t* _jit, jit_word_t _p,
1027      jit_word_t y, jit_word_t im)
1028 {
1029     assert(!(_p &    ~0x3fL));
1030     assert(!(y  &     ~0x1L));
1031     assert(!(im & ~0x1ffffL));
1032     TSTPRED(_p);
1033     inst((((im>>20)&1L)<<36)|(y<<27)|(1L<<26)|((im&0xffffL)<<6)|_p, INST_F);
1034 }
1035
1036 static void
1037 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
1038 {
1039     union {
1040         jit_int32_t      i;
1041         jit_float32_t    f;
1042     } data;
1043     jit_int32_t          reg;
1044
1045     if (_jitc->no_data) {
1046         data.f = *i0;
1047         reg = jit_get_reg(jit_class_gpr);
1048         movi(rn(reg), data.i & 0xffffffff);
1049         SETF_S(r0, rn(reg));
1050         jit_unget_reg(reg);
1051     }
1052     else
1053         ldi_f(r0, (jit_word_t)i0);
1054 }
1055
1056 static void
1057 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
1058 {
1059     union {
1060         jit_word_t       w;
1061         jit_float64_t    d;
1062     } data;
1063     jit_int32_t          reg;
1064
1065     if (_jitc->no_data) {
1066         data.d = *i0;
1067         reg = jit_get_reg(jit_class_gpr);
1068         movi(rn(reg), data.w);
1069         SETF_D(r0, rn(reg));
1070         jit_unget_reg(reg);
1071     }
1072     else
1073         ldi_d(r0, (jit_word_t)i0);
1074 }
1075
1076 static void
1077 _movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1078 {
1079     /* Should be used only in this case (with out0 == 120) */
1080     if (r1 >= 120)
1081         r1 = _jitc->rout + (r1 - 120);
1082     SETF_S(r0, r1);
1083 }
1084
1085 static void
1086 _movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1087 {
1088     /* Should actually be used only in this case (with out0 == 120) */
1089     if (r0 >= 120)
1090         r0 = _jitc->rout + (r0 - 120);
1091     GETF_S(r0, r1);
1092 }
1093
1094 static void
1095 _movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1096 {
1097     jit_int32_t         reg;
1098     reg = jit_get_reg(jit_class_gpr);
1099     movi(rn(reg), i0);
1100     movr_w_f(r0, rn(reg));
1101     jit_unget_reg(reg);
1102 }
1103
1104 static void
1105 _movr_w_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1106 {
1107     /* Should be used only in this case (with out0 == 120) */
1108     if (r1 >= 120)
1109         r1 = _jitc->rout + (r1 - 120);
1110     SETF_D(r0, r1);
1111 }
1112
1113 static void
1114 _movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1115 {
1116     /* Should be used only in this case (with out0 == 120) */
1117     if (r0 >= 120)
1118         r0 = _jitc->rout + (r0 - 120);
1119     GETF_D(r0, r1);
1120 }
1121
1122 static void
1123 _movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1124 {
1125     jit_int32_t         reg;
1126     reg = jit_get_reg(jit_class_gpr);
1127     movi(rn(reg), i0);
1128     movr_w_d(r0, rn(reg));
1129     jit_unget_reg(reg);
1130 }
1131
1132 #define fpr_opi(name, type, size)                                       \
1133 static void                                                             \
1134 _##name##i_##type(jit_state_t *_jit,                                    \
1135                   jit_int32_t r0, jit_int32_t r1,                       \
1136                   jit_float##size##_t *i0)                              \
1137 {                                                                       \
1138     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
1139     movi_##type(rn(reg), i0);                                           \
1140     name##r_##type(r0, r1, rn(reg));                                    \
1141     jit_unget_reg(reg);                                                 \
1142 }
1143 #define fpr_bopi(name, type, size)                                      \
1144 static jit_word_t                                                       \
1145 _b##name##i_##type(jit_state_t *_jit,                                   \
1146                   jit_word_t i0, jit_int32_t r0,                        \
1147                   jit_float##size##_t *i1)                              \
1148 {                                                                       \
1149     jit_word_t          word;                                           \
1150     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
1151                                           jit_class_nospill);           \
1152     movi_##type(rn(reg), i1);                                           \
1153     word = b##name##r_##type(i0, r0, rn(reg));                          \
1154     jit_unget_reg(reg);                                                 \
1155     return (word);                                                      \
1156 }
1157 #define fopi(name)                      fpr_opi(name, f, 32)
1158 #define fbopi(name)                     fpr_bopi(name, f, 32)
1159 #define dopi(name)                      fpr_opi(name, d, 64)
1160 #define dbopi(name)                     fpr_bopi(name, d, 64)
1161
1162 fopi(add)
1163 fopi(sub)
1164 fopi(rsb)
1165 fopi(mul)
1166 fopi(div)
1167 dopi(add)
1168 dopi(sub)
1169 dopi(rsb)
1170 dopi(mul)
1171 dopi(div)
1172
1173 /* translation from gcc -O0 */
1174 static void
1175 _divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1176 {
1177     jit_int32_t         t0, t1, t2;
1178     t0 = jit_get_reg(jit_class_fpr);
1179     t1 = jit_get_reg(jit_class_fpr);
1180     t2 = jit_get_reg(jit_class_fpr);
1181     FRCPA(rn(t0), PR_6, r1, r2);
1182     FNMA_p(rn(t1), r2, rn(t0), GR_1, SF_S1, PR_6);
1183     FMA_p(rn(t2), rn(t0), rn(t1), rn(t0), SF_S1, PR_6);
1184     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1185     FMA_p(rn(t2), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1186     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1187     FMA_p(rn(t1), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1188     FMPY_S_p(rn(t2), r1, rn(t1), SF_S1, PR_6);
1189     FNMA_p(rn(t0), r2, rn(t2), r1, SF_S1, PR_6);
1190     FMA_S_p(r0, rn(t0), rn(t1), rn(t2), SF_S0, PR_6);
1191     jit_unget_reg(t2);
1192     jit_unget_reg(t1);
1193     jit_unget_reg(t0);
1194 }
1195
1196 static void
1197 _divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1198 {
1199     jit_int32_t         t0, t1, t2;
1200     t0 = jit_get_reg(jit_class_fpr);
1201     t1 = jit_get_reg(jit_class_fpr);
1202     t2 = jit_get_reg(jit_class_fpr);
1203     FRCPA(rn(t0), PR_6, r1, r2);
1204     FNMA_p(rn(t1), r2, rn(t0), GR_1, SF_S1, PR_6);
1205     FMA_p(rn(t2), rn(t0), rn(t1), rn(t0), SF_S1, PR_6);
1206     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1207     FMA_p(rn(t2), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1208     FMPY_p(rn(t1), rn(t1), rn(t1), SF_S1, PR_6);
1209     FMA_p(rn(t1), rn(t2), rn(t1), rn(t2), SF_S1, PR_6);
1210     FMPY_D_p(rn(t2), r1, rn(t1), SF_S1, PR_6);
1211     FNMA_p(rn(t0), r2, rn(t2), r1, SF_S1, PR_6);
1212     FMA_D_p(r0, rn(t0), rn(t1), rn(t2), SF_S0, PR_6);
1213     jit_unget_reg(t2);
1214     jit_unget_reg(t1);
1215     jit_unget_reg(t0);
1216 }
1217
1218 static void
1219 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1220 {
1221     jit_int32_t         reg;
1222     reg = jit_get_reg(jit_class_fpr);
1223     SETF_SIG(rn(reg), r1);
1224     FCVT_XF(r0, rn(reg));
1225     FNORM_S(r0, r0);
1226     jit_unget_reg(reg);
1227 }
1228
1229 static void
1230 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1231 {
1232     jit_int32_t         reg;
1233     reg = jit_get_reg(jit_class_fpr);
1234     SETF_SIG(rn(reg), r1);
1235     FCVT_XF(r0, rn(reg));
1236     FNORM_D(r0, r0);
1237     jit_unget_reg(reg);
1238 }
1239
1240 static void
1241 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1242 {
1243     jit_int32_t         reg;
1244     reg = jit_get_reg(jit_class_fpr);
1245     FCVT_FX_TRUNC(rn(reg), r1);
1246     GETF_SIG(r0, rn(reg));
1247     FNORM(r0, r0);
1248     jit_unget_reg(reg);
1249 }
1250
1251 static void
1252 _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1253 {
1254     FCMP_LT(PR_6, PR_7, r1, r2);
1255     MOVI_p(r0, 1, PR_6);
1256     MOV_p(r0, GR_0, PR_7);
1257 }
1258 fopi(lt)
1259 dopi(lt)
1260
1261 static void
1262 _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1263 {
1264     FCMP_LE(PR_6, PR_7, r1, r2);
1265     MOVI_p(r0, 1, PR_6);
1266     MOV_p(r0, GR_0, PR_7);
1267 }
1268 fopi(le)
1269 dopi(le)
1270
1271 static void
1272 _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1273 {
1274     FCMP_EQ(PR_6, PR_7, r1, r2);
1275     MOVI_p(r0, 1, PR_6);
1276     MOV_p(r0, GR_0, PR_7);
1277 }
1278 fopi(eq)
1279 dopi(eq)
1280
1281 static void
1282 _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1283 {
1284     FCMP_LE(PR_6, PR_7, r2, r1);
1285     MOVI_p(r0, 1, PR_6);
1286     MOV_p(r0, GR_0, PR_7);
1287 }
1288 fopi(ge)
1289 dopi(ge)
1290
1291 static void
1292 _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1293 {
1294     FCMP_LT(PR_6, PR_7, r2, r1);
1295     MOVI_p(r0, 1, PR_6);
1296     MOV_p(r0, GR_0, PR_7);
1297 }
1298 fopi(gt)
1299 dopi(gt)
1300
1301 static void
1302 _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1303 {
1304     FCMP_EQ(PR_6, PR_7, r1, r2);
1305     MOV_p(r0, GR_0, PR_6);
1306     MOVI_p(r0, 1, PR_7);
1307 }
1308 fopi(ne)
1309 dopi(ne)
1310
1311 static void
1312 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1313 {
1314     FCMP_LE(PR_6, PR_7, r2, r1);
1315     MOV_p(r0, GR_0, PR_6);
1316     MOVI_p(r0, 1, PR_7);
1317 }
1318 fopi(unlt)
1319 dopi(unlt)
1320
1321 static void
1322 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1323 {
1324     FCMP_LT(PR_6, PR_7, r2, r1);
1325     MOV_p(r0, GR_0, PR_6);
1326     MOVI_p(r0, 1, PR_7);
1327 }
1328 fopi(unle)
1329 dopi(unle)
1330
1331 static void
1332 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1333 {
1334     MOVI(r0, 1);
1335     FCMP_LT(PR_8, PR_9, r1, r2);
1336     FCMP_LT(PR_6, PR_7, r2, r1);
1337     MOV_p(r0, GR_0, PR_8);              /* !(r1 < r2) && !(r2 < r1) */
1338     MOV_p(r0, GR_0, PR_6);
1339 }
1340 fopi(uneq)
1341 dopi(uneq)
1342
1343 static void
1344 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1345 {
1346     FCMP_LT(PR_6, PR_7, r1, r2);
1347     MOV_p(r0, GR_0, PR_6);
1348     MOVI_p(r0, 1, PR_7);
1349 }
1350 fopi(unge)
1351 dopi(unge)
1352
1353 static void
1354 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1355 {
1356     FCMP_LE(PR_6, PR_7, r1, r2);
1357     MOV_p(r0, GR_0, PR_6);
1358     MOVI_p(r0, 1, PR_7);
1359 }
1360 fopi(ungt)
1361 dopi(ungt)
1362
1363 static void
1364 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1365 {
1366     MOVI(r0, 1);
1367     FCMP_EQ(PR_8, PR_9, r1, r2);
1368     FCMP_UNORD(PR_6, PR_7, r1, r2);
1369     MOV_p(r0, GR_0, PR_8);
1370     MOV_p(r0, GR_0, PR_6);
1371 }
1372 fopi(ltgt)
1373 dopi(ltgt)
1374
1375 static void
1376 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1377 {
1378     FCMP_UNORD(PR_6, PR_7, r1, r2);
1379     MOV_p(r0, GR_0, PR_6);
1380     MOVI_p(r0, 1, PR_7);
1381 }
1382 fopi(ord)
1383 dopi(ord)
1384
1385 static void
1386 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1387 {
1388     FCMP_UNORD(PR_6, PR_7, r1, r2);
1389     MOVI_p(r0, 1, PR_6);
1390     MOV_p(r0, GR_0, PR_7);
1391 }
1392 fopi(unord)
1393 dopi(unord)
1394
1395 static void
1396 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1397 {
1398     jit_int32_t         reg;
1399     reg = jit_get_reg(jit_class_gpr);
1400     movi(rn(reg), i0);
1401     ldr_f(r0, rn(reg));
1402     jit_unget_reg(reg);
1403 }
1404
1405 static void
1406 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1407 {
1408     jit_int32_t         reg;
1409     reg = jit_get_reg(jit_class_gpr);
1410     addr(rn(reg), r1, r2);
1411     ldr_f(r0, rn(reg));
1412     jit_unget_reg(reg);
1413 }
1414
1415 static void
1416 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1417 {
1418     jit_int32_t         reg;
1419     if (r0) {
1420         reg = jit_get_reg(jit_class_gpr);
1421         addi(rn(reg), r1, i0);
1422         ldr_f(r0, rn(reg));
1423         jit_unget_reg(reg);
1424     }
1425     else
1426         ldr_f(r0, r1);
1427 }
1428
1429 static void
1430 _unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1431 {
1432     if (jit_unaligned_p())
1433         fallback_unldr_x(r0, r1, i0);
1434     else
1435         generic_unldr_x(r0, r1, i0);
1436 }
1437
1438 static void
1439 _unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
1440 {
1441     if (jit_unaligned_p())
1442         fallback_unldi_x(r0, i0, i1);
1443     else
1444         generic_unldi_x(r0, i0, i1);
1445 }
1446
1447 static void
1448 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1449 {
1450     jit_int32_t         reg;
1451     reg = jit_get_reg(jit_class_gpr);
1452     movi(rn(reg), i0);
1453     ldr_d(r0, rn(reg));
1454     jit_unget_reg(reg);
1455 }
1456
1457 static void
1458 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1459 {
1460     jit_int32_t         reg;
1461     reg = jit_get_reg(jit_class_gpr);
1462     addr(rn(reg), r1, r2);
1463     ldr_d(r0, rn(reg));
1464     jit_unget_reg(reg);
1465 }
1466
1467 static void
1468 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1469 {
1470     jit_int32_t         reg;
1471     if (r0) {
1472         reg = jit_get_reg(jit_class_gpr);
1473         addi(rn(reg), r1, i0);
1474         ldr_d(r0, rn(reg));
1475         jit_unget_reg(reg);
1476     }
1477     else
1478         ldr_d(r0, r1);
1479 }
1480
1481 static void
1482 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1483 {
1484     jit_int32_t         reg;
1485     reg = jit_get_reg(jit_class_gpr);
1486     movi(rn(reg), i0);
1487     str_f(rn(reg), r0);
1488     jit_unget_reg(reg);
1489 }
1490
1491 static void
1492 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1493 {
1494     jit_int32_t         reg;
1495     reg = jit_get_reg(jit_class_gpr);
1496     addr(rn(reg), r0, r1);
1497     str_f(rn(reg), r2);
1498     jit_unget_reg(reg);
1499 }
1500
1501 static void
1502 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1503 {
1504     jit_int32_t         reg;
1505     if (i0) {
1506         reg = jit_get_reg(jit_class_gpr);
1507         addi(rn(reg), r0, i0);
1508         str_f(rn(reg), r1);
1509         jit_unget_reg(reg);
1510     }
1511     else
1512         str_f(r0, r1);
1513 }
1514
1515 static void
1516 _unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1517 {
1518     if (jit_unaligned_p())
1519         fallback_unstr_x(r0, r1, i0);
1520     else
1521         generic_unstr_x(r0, r1, i0);
1522 }
1523
1524 static void
1525 _unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1526 {
1527     if (jit_unaligned_p())
1528         fallback_unsti_x(i0, r0, i1);
1529     else
1530         fallback_unsti_x(i0, r0, i1);
1531 }
1532
1533 static void
1534 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1535 {
1536     jit_int32_t         reg;
1537     reg = jit_get_reg(jit_class_gpr);
1538     movi(rn(reg), i0);
1539     str_d(rn(reg), r0);
1540     jit_unget_reg(reg);
1541 }
1542
1543 static void
1544 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1545 {
1546     jit_int32_t         reg;
1547     reg = jit_get_reg(jit_class_gpr);
1548     addr(rn(reg), r0, r1);
1549     str_d(rn(reg), r2);
1550     jit_unget_reg(reg);
1551 }
1552
1553 static void
1554 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1555 {
1556     jit_int32_t         reg;
1557     if (i0) {
1558         reg = jit_get_reg(jit_class_gpr);
1559         addi(rn(reg), r0, i0);
1560         str_d(rn(reg), r1);
1561         jit_unget_reg(reg);
1562     }
1563     else
1564         str_d(r0, r1);
1565 }
1566
1567 static void
1568 _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1569 {
1570     movr_f(GR_8, r1);
1571     calli((jit_word_t)sqrtf);
1572     MOVF(r0, GR_8);
1573 }
1574
1575 static void
1576 _fnmar_f(jit_state_t *_jit,
1577          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1578 {
1579     fmar_f(r0, r1, r2, r3);
1580     negr_f(r0, r0);
1581 }
1582
1583 static void
1584 _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1585 {
1586     movr_d(GR_8, r1);
1587     calli((jit_word_t)sqrt);
1588     MOVF(r0, GR_8);
1589 }
1590
1591 static void
1592 _fnmar_d(jit_state_t *_jit,
1593          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1594 {
1595     fmar_d(r0, r1, r2, r3);
1596     negr_d(r0, r0);
1597 }
1598
1599 static jit_word_t
1600 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1601 {
1602     jit_word_t          w;
1603     FCMP_LT(PR_6, PR_7, r0, r1);
1604     sync();
1605     w = _jit->pc.w;
1606     BRI_COND((i0 - w) >> 4, PR_6);
1607     return (w);
1608 }
1609 fbopi(lt)
1610 dbopi(lt)
1611
1612 static jit_word_t
1613 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1614 {
1615     jit_word_t          w;
1616     FCMP_LE(PR_6, PR_7, r0, r1);
1617     sync();
1618     w = _jit->pc.w;
1619     BRI_COND((i0 - w) >> 4, PR_6);
1620     return (w);
1621 }
1622 fbopi(le)
1623 dbopi(le)
1624
1625 static jit_word_t
1626 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1627 {
1628     jit_word_t          w;
1629     FCMP_EQ(PR_6, PR_7, r0, r1);
1630     sync();
1631     w = _jit->pc.w;
1632     BRI_COND((i0 - w) >> 4, PR_6);
1633     return (w);
1634 }
1635 fbopi(eq)
1636 dbopi(eq)
1637
1638 static jit_word_t
1639 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1640 {
1641     jit_word_t          w;
1642     FCMP_LE(PR_6, PR_7, r1, r0);
1643     sync();
1644     w = _jit->pc.w;
1645     BRI_COND((i0 - w) >> 4, PR_6);
1646     return (w);
1647 }
1648 fbopi(ge)
1649 dbopi(ge)
1650
1651 static jit_word_t
1652 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1653 {
1654     jit_word_t          w;
1655     FCMP_LT(PR_6, PR_7, r1, r0);
1656     sync();
1657     w = _jit->pc.w;
1658     BRI_COND((i0 - w) >> 4, PR_6);
1659     return (w);
1660 }
1661 fbopi(gt)
1662 dbopi(gt)
1663
1664 static jit_word_t
1665 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1666 {
1667     jit_word_t          w;
1668     FCMP_EQ(PR_6, PR_7, r0, r1);
1669     sync();
1670     w = _jit->pc.w;
1671     BRI_COND((i0 - w) >> 4, PR_7);
1672     return (w);
1673 }
1674 fbopi(ne)
1675 dbopi(ne)
1676
1677 static jit_word_t
1678 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1679 {
1680     jit_word_t          w;
1681     FCMP_LE(PR_6, PR_7, r1, r0);
1682     sync();
1683     w = _jit->pc.w;
1684     BRI_COND((i0 - w) >> 4, PR_7);
1685     return (w);
1686 }
1687 fbopi(unlt)
1688 dbopi(unlt)
1689
1690 static jit_word_t
1691 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1692 {
1693     jit_word_t          w;
1694     FCMP_LT(PR_6, PR_7, r1, r0);
1695     sync();
1696     w = _jit->pc.w;
1697     BRI_COND((i0 - w) >> 4, PR_7);
1698     return (w);
1699 }
1700 fbopi(unle)
1701 dbopi(unle)
1702
1703 static jit_word_t
1704 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1705 {
1706     jit_word_t          w;
1707     jit_word_t          junord, jne;
1708     FCMP_UNORD(PR_8, PR_9, r0, r1);
1709     sync();
1710     /* junord L1 */
1711     junord = _jit->pc.w;
1712     BRI_COND(3, PR_8);
1713     FCMP_EQ(PR_6, PR_7, r0, r1);
1714     sync();
1715     /* jne L2 */
1716     jne = _jit->pc.w;
1717     BRI_COND(2, PR_7);
1718     sync();
1719     w = _jit->pc.w;
1720     /* L1: */
1721     patch_at(jit_code_bunordr_d, junord, _jit->pc.w);
1722     BRI((i0 - w) >> 4);         /* unconditional jump to patch */
1723     sync();
1724     /* L2: */
1725     patch_at(jit_code_bner_d, jne, _jit->pc.w);
1726     return (w);
1727 }
1728 fbopi(uneq)
1729 dbopi(uneq)
1730
1731 static jit_word_t
1732 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1733 {
1734     jit_word_t          w;
1735     FCMP_LT(PR_6, PR_7, r0, r1);
1736     sync();
1737     w = _jit->pc.w;
1738     BRI_COND((i0 - w) >> 4, PR_7);
1739     return (w);
1740 }
1741 fbopi(unge)
1742 dbopi(unge)
1743
1744 static jit_word_t
1745 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1746 {
1747     jit_word_t          w;
1748     FCMP_LE(PR_6, PR_7, r0, r1);
1749     sync();
1750     w = _jit->pc.w;
1751     BRI_COND((i0 - w) >> 4, PR_7);
1752     return (w);
1753 }
1754 fbopi(ungt)
1755 dbopi(ungt)
1756
1757 static jit_word_t
1758 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1759 {
1760     jit_word_t          w;
1761     jit_word_t          jeq, junord;
1762     FCMP_EQ(PR_8, PR_9, r0, r1);
1763     /* jeq L1 */
1764     sync();
1765     jeq = _jit->pc.w;
1766     BRI_COND(4, PR_8);
1767     FCMP_UNORD(PR_6, PR_7, r0, r1);
1768     /* junord L1 */
1769     sync();
1770     junord = _jit->pc.w;
1771     BRI_COND(2, PR_6);
1772     sync();
1773     w = _jit->pc.w;
1774     BRI((i0 - w) >> 4);         /* unconditional jump to patch */
1775     /* L1 */
1776     sync();
1777     patch_at(jit_code_beqr_d, jeq, _jit->pc.w);
1778     patch_at(jit_code_bordr_d, junord, _jit->pc.w);
1779     return (w);
1780 }
1781 fbopi(ltgt)
1782 dbopi(ltgt)
1783
1784 static jit_word_t
1785 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1786 {
1787     jit_word_t          w;
1788     FCMP_UNORD(PR_6, PR_7, r0, r1);
1789     sync();
1790     w = _jit->pc.w;
1791     BRI_COND((i0 - w) >> 4, PR_7);
1792     return (w);
1793 }
1794 fbopi(ord)
1795 dbopi(ord)
1796
1797 static jit_word_t
1798 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1799 {
1800     jit_word_t          w;
1801     FCMP_UNORD(PR_6, PR_7, r0, r1);
1802     sync();
1803     w = _jit->pc.w;
1804     BRI_COND((i0 - w) >> 4, PR_6);
1805     return (w);
1806 }
1807 fbopi(unord)
1808 dbopi(unord)
1809
1810 static void
1811 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1812 {
1813     assert(_jitc->function->self.call & jit_call_varargs);
1814     /* Load argument. */
1815     ldr_d(r0, r1);
1816     /* Update va_list. */
1817     addi(r1, r1, 8);
1818 }
1819 #endif