deps/lightning/lib/jit_mips-fpu.c

   1 /*
   2  * Copyright (C) 2012-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 BE_P                          (__BYTE_ORDER == __BIG_ENDIAN)
  22 #  define LE_P                          (__BYTE_ORDER == __LITTLE_ENDIAN)
  23 #  define MIPS_fmt_S                    0x10            /* float32 */
  24 #  define MIPS_fmt_D                    0x11            /* float64 */
  25 #  define MIPS_fmt_W                    0x14            /* int32 */
  26 #  define MIPS_fmt_L                    0x15            /* int64 */
  27 #  define MIPS_fmt_PS                   0x16            /* 2 x float32 */
  28 #  define MIPS_fmt_S_PU                 0x20
  29 #  define MIPS_fmt_S_PL                 0x26
  30 #  define MIPS_condn_S                  0x14            /* release 6 */
  31 #  define MIPS_condn_D                  0x15            /* release 6 */
  32 #  define MIPS_ADD_fmt                  0x00
  33 #  define MIPS_LWXC1                    0x00
  34 #  define MIPS_SUB_fmt                  0x01
  35 #  define MIPS_LDXC1                    0x01
  36 #  define MIPS_MUL_fmt                  0x02
  37 #  define MIPS_DIV_fmt                  0x03
  38 #  define MIPS_SQRT_fmt                 0x04
  39 #  define MIPS_ABS_fmt                  0x05
  40 #  define MIPS_LUXC1                    0x05
  41 #  define MIPS_MOV_fmt                  0x06
  42 #  define MIPS_NEG_fmt                  0x07
  43 #  define MIPS_SWXC1                    0x08
  44 #  define MIPS_ROUND_fmt_L              0x08
  45 #  define MIPS_TRUNC_fmt_L              0x09
  46 #  define MIPS_SDXC1                    0x09
  47 #  define MIPS_CEIL_fmt_L               0x0a
  48 #  define MIPS_FLOOR_fmt_L              0x0b
  49 #  define MIPS_ROUND_fmt_W              0x0c
  50 #  define MIPS_TRUNC_fmt_W              0x0d
  51 #  define MIPS_SUXC1                    0x0d
  52 #  define MIPS_CEIL_fmt_W               0x0e
  53 #  define MIPS_FLOOR_fmt_W              0x0f
  54 #  define MIPS_RECIP                    0x15
  55 #  define MIPS_RSQRT                    0x16
  56 #  define MIPS_MADDF                    0x18
  57 #  define MIPS_MSUBF                    0x19
  58 #  define MIPS_ALNV_PS                  0x1e
  59 #  define MIPS_CVT_fmt_S                0x20
  60 #  define MIPS_CVT_fmt_D                0x21
  61 #  define MIPS_CVT_fmt_W                0x24
  62 #  define MIPS_CVT_fmt_L                0x25
  63 #  define MIPS_PLL                      0x2c
  64 #  define MIPS_PLU                      0x2d
  65 #  define MIPS_PUL                      0x2e
  66 #  define MIPS_PUU                      0x2f
  67 #  define MIPS_MADD_fmt_S               0x20
  68 #  define MIPS_MADD_fmt_D               0x21
  69 #  define MIPS_MADD_fmt_PS              0x22
  70 #  define MIPS_MSUB_fmt_S               0x28
  71 #  define MIPS_MSUB_fmt_D               0x29
  72 #  define MIPS_MSUB_fmt_PS              0x2a
  73 #  define MIPS_NMADD_fmt_S              0x30
  74 #  define MIPS_NMADD_fmt_D              0x31
  75 #  define MIPS_NMADD_fmt_PS             0x32
  76 #  define MIPS_NMSUB_fmt_S              0x38
  77 #  define MIPS_NMSUB_fmt_D              0x39
  78 #  define MIPS_NMSUB_fmt_PS             0x3a
  79 #  define MIPS_cond_F                   0x30
  80 #  define MIPS_cond_UN                  0x31
  81 #  define MIPS_cond_EQ                  0x32
  82 #  define MIPS_cond_UEQ                 0x33
  83 #  define MIPS_cond_OLT                 0x34
  84 #  define MIPS_cond_ULT                 0x35
  85 #  define MIPS_cond_OLE                 0x36
  86 #  define MIPS_cond_ULE                 0x37
  87 #  define MIPS_cond_SF                  0x38
  88 #  define MIPS_cond_NGLE                0x39
  89 #  define MIPS_cond_SEQ                 0x3a
  90 #  define MIPS_cond_NGL                 0x3b
  91 #  define MIPS_cond_LT                  0x3c
  92 #  define MIPS_cond_NGE                 0x3d
  93 #  define MIPS_cond_LE                  0x3e
  94 #  define MIPS_cond_UGT                 0x3f
  95 /* Mips release 6 */
  96 #  define MIPS_cmp_AF                   0x00
  97 #  define MIPS_cmp_UN                   0x01
  98 #  define MIPS_cmp_EQ                   0x02
  99 #  define MIPS_cmp_UEQ                  0x03
 100 #  define MIPS_cmp_LT                   0x04
 101 #  define MIPS_cmp_ULT                  0x05
 102 #  define MIPS_cmp_LE                   0x06
 103 #  define MIPS_cmp_ULE                  0x07
 104 #  define MIPS_cmp_SAF                  0x08
 105 #  define MIPS_cmp_SUN                  0x09
 106 #  define MIPS_cmp_SEQ                  0x0a
 107 #  define MIPS_cmp_SUEQ                 0x0b
 108 #  define MIPS_cmp_SLT                  0x0c
 109 #  define MIPS_cmp_SULT                 0x0d
 110 #  define MIPS_cmp_SLE                  0x0e
 111 #  define MIPS_cmp_SULE                 0x0f
 112 #  define ADD_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_ADD_fmt)
 113 #  define ADD_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_ADD_fmt)
 114 #  define SUB_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_SUB_fmt)
 115 #  define SUB_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_SUB_fmt)
 116 #  define MUL_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_MUL_fmt)
 117 #  define MUL_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_MUL_fmt)
 118 #  define DIV_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_DIV_fmt)
 119 #  define DIV_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_DIV_fmt)
 120 #  define ABS_S(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_ABS_fmt)
 121 #  define ABS_D(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_ABS_fmt)
 122 #  define NEG_S(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_NEG_fmt)
 123 #  define NEG_D(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_NEG_fmt)
 124 #  define SQRT_S(fd,fs)                 hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_SQRT_fmt)
 125 #  define SQRT_D(fd,fs)                 hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_SQRT_fmt)
 126 #  define MFC1(rt, fs)                  hrrrit(MIPS_COP1,MIPS_MF,rt,fs,0,0)
 127 #  define MFHC1(rt, fs)                 hrrrit(MIPS_COP1,MIPS_MFH,rt,fs,0,0)
 128 #  define MTC1(rt, fs)                  hrrrit(MIPS_COP1,MIPS_MT,rt,fs,0,0)
 129 #  define MTHC1(rt, fs)                 hrrrit(MIPS_COP1,MIPS_MTH,rt,fs,0,0)
 130 #  define DMFC1(rt, fs)                 hrrrit(MIPS_COP1,MIPS_DMF,rt,fs,0,0)
 131 #  define DMTC1(rt, fs)                 hrrrit(MIPS_COP1,MIPS_DMT,rt,fs,0,0)
 132 #  define CVT_D_S(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_D)
 133 #  define CVT_D_W(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_W,0,fs,fd,MIPS_CVT_fmt_D)
 134 #  define CVT_D_L(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_L,0,fs,fd,MIPS_CVT_fmt_D)
 135 #  define CVT_L_S(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_L)
 136 #  define CVT_L_D(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_CVT_fmt_L)
 137 #  define CVT_PS_S(fd,fs)               hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_PS)
 138 #  define CVT_S_D(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_CVT_fmt_S)
 139 #  define CVT_S_W(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_W,0,fs,fd,MIPS_CVT_fmt_S)
 140 #  define CVT_S_L(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_L,0,fs,fd,MIPS_CVT_fmt_S)
 141 #  define CVT_S_PL(fd,fs)               hrrrit(MIPS_COP1,MIPS_fmt_PS,0,fs,fd,MIPS_CVT_fmt_S_PL)
 142 #  define CVT_S_PU(fd,fs)               hrrrit(MIPS_COP1,MIPS_fmt_PS,0,fs,fd,MIPS_CVT_fmt_S_PU)
 143 #  define CVT_W_S(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_W)
 144 #  define CVT_W_D(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_CVT_fmt_W)
 145 #  define TRUNC_L_S(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_TRUNC_fmt_L)
 146 #  define TRUNC_L_D(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_TRUNC_fmt_L)
 147 #  define TRUNC_W_S(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_TRUNC_fmt_W)
 148 #  define TRUNC_W_D(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_TRUNC_fmt_W)
 149 #  define MADD_S(fd,fr,fs,ft)           hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MADD_fmt_S)
 150 #  define MADD_D(fd,fr,fs,ft)           hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MADD_fmt_D)
 151 #  define MSUB_S(fd,fr,fs,ft)           hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MSUB_fmt_S)
 152 #  define MSUB_D(fd,fr,fs,ft)           hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MSUB_fmt_D)
 153 #  define NMADD_S(fd,fr,fs,ft)          hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMADD_fmt_S)
 154 #  define NMADD_D(fd,fr,fs,ft)          hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMADD_fmt_D)
 155 #  define NMSUB_S(fd,fr,fs,ft)          hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMSUB_fmt_S)
 156 #  define NMSUB_D(fd,fr,fs,ft)          hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMSUB_fmt_D)
 157 /* fd = fd + (fs * ft) */
 158 #  define MADDF_S(fd,fs,ft)             hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_MADDF)
 159 #  define MADDF_D(fd,fs,ft)             hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_MADDF)
 160 /* fd = fd - (fs * ft) */
 161 #  define MSUBF_S(fd,fs,ft)             hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_MSUBF)
 162 #  define MSUBF_D(fd,fs,ft)             hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_MSUBF)
 163 #  define LWC1(rt, of, rb)              hrri(MIPS_LWC1, rb, rt, of)
 164 #  define SWC1(rt, of, rb)              hrri(MIPS_SWC1, rb, rt, of)
 165 #  define LDC1(rt, of, rb)              hrri(MIPS_LDC1, rb, rt, of)
 166 #  define SDC1(rt, of, rb)              hrri(MIPS_SDC1, rb, rt, of)
 167 #  define MOV_S(fd, fs)                 hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_MOV_fmt)
 168 #  define MOV_D(fd, fs)                 hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_MOV_fmt)
 169 #  define BC1F(im)                      hrri(MIPS_COP1,MIPS_BC,MIPS_BCF,im)
 170 #  define BC1EQZ(ft,im)                 hrri(MIPS_COP1,MIPS_BC1EQZ,ft,im)
 171 #  define BC1T(im)                      hrri(MIPS_COP1,MIPS_BC,MIPS_BCT,im)
 172 #  define BC1NEZ(ft,im)                 hrri(MIPS_COP1,MIPS_BC1NEZ,ft,im)
 173 #  define C_F_S(fs,ft)                  c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_F)
 174 #  define C_F_D(fs,ft)                  c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_F)
 175 #  define C_F_PS(fs,ft)                 c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_F)
 176 #  define C_UN_S(fs,ft)                 c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_UN)
 177 #  define C_UN_D(fs,ft)                 c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_UN)
 178 #  define C_UN_PS(fs,ft)                c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UN)
 179 #  define C_EQ_S(fs,ft)                 c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_EQ)
 180 #  define C_EQ_D(fs,ft)                 c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_EQ)
 181 #  define C_EQ_PS(fs,ft)                c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_EQ)
 182 #  define C_UEQ_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_UEQ)
 183 #  define C_UEQ_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_UEQ)
 184 #  define C_UEQ_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UEQ)
 185 #  define C_OLT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_OLT)
 186 #  define C_OLT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_OLT)
 187 #  define C_OLT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_OLT)
 188 #  define C_ULT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_ULT)
 189 #  define C_ULT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_ULT)
 190 #  define C_ULT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_ULT)
 191 #  define C_OLE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_OLE)
 192 #  define C_OLE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_OLE)
 193 #  define C_OLE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_OLE)
 194 #  define C_ULE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_ULE)
 195 #  define C_ULE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_ULE)
 196 #  define C_ULE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_ULE)
 197 #  define C_SF_S(fs,ft)                 c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_SF)
 198 #  define C_SF_D(fs,ft)                 c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_SF)
 199 #  define C_SF_PS(fs,ft)                c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_SF)
 200 #  define C_NGLE_S(fs,ft)               c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NGLE)
 201 #  define C_NGLE_D(fs,ft)               c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NGLE)
 202 #  define C_NGLE_PS(fs,ft)              c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NGLE)
 203 #  define C_SEQ_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_SEQ)
 204 #  define C_SEQ_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_SEQ)
 205 #  define C_SEQ_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_SEQ)
 206 #  define C_NGL_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NGL)
 207 #  define C_NGL_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NGL)
 208 #  define C_NGL_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NGL)
 209 #  define C_NLT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NLT)
 210 #  define C_NLT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NLT)
 211 #  define C_NLT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NLT)
 212 #  define C_NGE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NGE)
 213 #  define C_NGE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NGE)
 214 #  define C_NGE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NGE)
 215 #  define C_NLE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NLE)
 216 #  define C_NLE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NLE)
 217 #  define C_NLE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NLE)
 218 #  define C_UGT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_UGT)
 219 #  define C_UGT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_UGT)
 220 #  define C_UGT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UGT)
 221 #  define c_cond_fmt(fm,ft,fs,cc)       _c_cond_fmt(_jit,fm,ft,fs,cc)
 222 static void
 223 _c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
 224             jit_int32_t ft, jit_int32_t fs, jit_int32_t cc);
 225 #  define CMP_AF_S(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_AF)
 226 #  define CMP_AF_D(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_AF)
 227 #  define CMP_UN_S(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_UN)
 228 #  define CMP_UN_D(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_UN)
 229 #  define CMP_EQ_S(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_EQ)
 230 #  define CMP_EQ_D(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_EQ)
 231 #  define CMP_UEQ_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_UEQ)
 232 #  define CMP_UEQ_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_UEQ)
 233 #  define CMP_LT_S(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_LT)
 234 #  define CMP_LT_D(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_LT)
 235 #  define CMP_ULT_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_ULT)
 236 #  define CMP_ULT_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_ULT)
 237 #  define CMP_LE_S(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_LE)
 238 #  define CMP_LE_D(fd,fs,ft)            cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_LE)
 239 #  define CMP_ULE_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_ULE)
 240 #  define CMP_ULE_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_ULE)
 241 #  define CMP_SAF_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SAF)
 242 #  define CMP_SAF_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SAF)
 243 #  define CMP_SUN_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SUN)
 244 #  define CMP_SUN_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SUN)
 245 #  define CMP_SEQ_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SEQ)
 246 #  define CMP_SEQ_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SEQ)
 247 #  define CMP_SUEQ_S(fd,fs,ft)          cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SUEQ)
 248 #  define CMP_SUEQ_D(fd,fs,ft)          cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SUEQ)
 249 #  define CMP_SLT_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SLT)
 250 #  define CMP_SLT_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SLT)
 251 #  define CMP_SULT_S(fd,fs,ft)          cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SULT)
 252 #  define CMP_SULT_D(fd,fs,ft)          cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SULT)
 253 #  define CMP_SLE_S(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SLE)
 254 #  define CMP_SLE_D(fd,fs,ft)           cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SLE)
 255 #  define CMP_SULE_S(fd,fs,ft)          cmp_cond_fmt(MIPS_condn_S,fd,ft,fs,MIPS_cmp_SULE)
 256 #  define CMP_SULE_D(fd,fs,ft)          cmp_cond_fmt(MIPS_condn_D,fd,ft,fs,MIPS_cmp_SULE)
 257 #  define cmp_cond_fmt(fm,fd,ft,fs,cn)  _cmp_cond_fmt(_jit,fm,fd,ft,fs,cn)
 258 static void
 259 _cmp_cond_fmt(jit_state_t *_jit, jit_int32_t fm, jit_int32_t fd,
 260               jit_int32_t ft, jit_int32_t fs, jit_int32_t cn);
 261 #  define addr_f(r0,r1,r2)              ADD_S(r0,r1,r2)
 262 #  define addi_f(r0,r1,i0)              _addi_f(_jit,r0,r1,i0)
 263 static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 264 #  define addr_d(r0,r1,r2)              ADD_D(r0,r1,r2)
 265 #  define addi_d(r0,r1,i0)              _addi_d(_jit,r0,r1,i0)
 266 static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 267 #  define subr_f(r0,r1,r2)              SUB_S(r0,r1,r2)
 268 #  define subi_f(r0,r1,i0)              _subi_f(_jit,r0,r1,i0)
 269 static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 270 #  define subr_d(r0,r1,r2)              SUB_D(r0,r1,r2)
 271 #  define subi_d(r0,r1,i0)              _subi_d(_jit,r0,r1,i0)
 272 static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 273 #  define rsbr_f(r0,r1,r2)              subr_f(r0,r2,r1)
 274 #  define rsbi_f(r0,r1,i0)              _rsbi_f(_jit,r0,r1,i0)
 275 static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 276 #  define rsbr_d(r0,r1,r2)              subr_d(r0,r2,r1)
 277 #  define rsbi_d(r0,r1,i0)              _rsbi_d(_jit,r0,r1,i0)
 278 static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 279 #  define mulr_f(r0,r1,r2)              MUL_S(r0,r1,r2)
 280 #  define muli_f(r0,r1,i0)              _muli_f(_jit,r0,r1,i0)
 281 static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 282 #  define mulr_d(r0,r1,r2)              MUL_D(r0,r1,r2)
 283 #  define muli_d(r0,r1,i0)              _muli_d(_jit,r0,r1,i0)
 284 static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 285 #  define divr_f(r0,r1,r2)              DIV_S(r0,r1,r2)
 286 #  define divi_f(r0,r1,i0)              _divi_f(_jit,r0,r1,i0)
 287 static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 288 #  define divr_d(r0,r1,r2)              DIV_D(r0,r1,r2)
 289 #  define divi_d(r0,r1,i0)              _divi_d(_jit,r0,r1,i0)
 290 static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 291 #  define absr_f(r0,r1)                 ABS_S(r0,r1)
 292 #  define absr_d(r0,r1)                 ABS_D(r0,r1)
 293 #  define negr_f(r0,r1)                 NEG_S(r0,r1)
 294 #  define negr_d(r0,r1)                 NEG_D(r0,r1)
 295 #  define sqrtr_f(r0,r1)                SQRT_S(r0,r1)
 296 #  define sqrtr_d(r0,r1)                SQRT_D(r0,r1)
 297 #  define movr_w_f(r0, r1)              MTC1(r1, r0)
 298 #  define movr_f_w(r0, r1)              MFC1(r0, r1)
 299 # define movi_w_f(r0, i0)               _movi_w_f(_jit, r0, i0)
 300 static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t);
 301 #  define extr_f(r0, r1)                _extr_f(_jit, r0, r1)
 302 static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 303 #  define truncr_f_i(r0, r1)            _truncr_f_i(_jit, r0, r1)
 304 static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
 305 #  if __WORDSIZE == 64
 306 #    define truncr_f_l(r0, r1)          _truncr_f_l(_jit, r0, r1)
 307 static void _truncr_f_l(jit_state_t*,jit_int32_t,jit_int32_t);
 308 #  endif
 309 #  define extr_d_f(r0, r1)              CVT_S_D(r0, r1)
 310 #  define ldr_f(r0, r1)                 LWC1(r0, 0, r1)
 311 #  define ldi_f(r0, i0)                 _ldi_f(_jit, r0, i0)
 312 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 313 #  define ldxr_f(r0, r1, r2)            _ldxr_f(_jit, r0, r1, r2)
 314 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 315 #  define ldxi_f(r0, r1, i0)            _ldxi_f(_jit, r0, r1, i0)
 316 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 317 #  define unldr_x(r0, r1, i0)           _unldr_x(_jit, r0, r1, i0)
 318 static void _unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 319 #  define unldi_x(r0, i0, i1)           _unldi_x(_jit, r0, i0, i1)
 320 static void _unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 321 #  define str_f(r0, r1)                 SWC1(r1, 0, r0)
 322 #  define sti_f(i0, r0)                 _sti_f(_jit, i0, r0)
 323 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 324 #  define stxr_f(r0, r1, r2)            _stxr_f(_jit, r0, r1, r2)
 325 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 326 #  define stxi_f(i0, r0, r1)            _stxi_f(_jit, i0, r0, r1)
 327 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 328 #  define unstr_x(r0, r1, i0)           _unstr_x(_jit, r0, r1, i0)
 329 static void _unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 330 #  define unsti_x(i0, r0, i1)           _unsti_x(_jit, i0, r0, i1)
 331 static void _unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 332 #  define fmar_f(r0, r1, r2, r3)        _fmar_f(_jit, r0, r1, r2, r3)
 333 static void _fmar_f(jit_state_t*,
 334                     jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 335 #  define fmsr_f(r0, r1, r2, r3)        _fmsr_f(_jit, r0, r1, r2, r3)
 336 static void _fmsr_f(jit_state_t*,
 337                     jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 338 #  define fnmar_f(r0, r1, r2, r3)       _fnmar_f(_jit, r0, r1, r2, r3)
 339 static void _fnmar_f(jit_state_t*,
 340                      jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 341 #  define fnmsr_f(r0, r1, r2, r3)       _fnmsr_f(_jit, r0, r1, r2, r3)
 342 static void _fnmsr_f(jit_state_t*,
 343                      jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 344 #  define movr_f(r0, r1)                _movr_f(_jit, r0, r1)
 345 static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 346 #  define movi_f(r0, i0)                _movi_f(_jit, r0, i0)
 347 static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
 348 #  if NEW_ABI && __WORDSIZE == 32
 349 #    define movi64(r0, i0)              _movi64(_jit, r0, i0)
 350 static void _movi64(jit_state_t*,jit_int32_t,jit_int64_t);
 351 #    define movi_d_w(r0, i0)            _movi_d_w(_jit, r0, i0)
 352 static void _movi_d_w(jit_state_t*,jit_int32_t,jit_int64_t);
 353 #  elif __WORDSIZE == 64
 354 #    define movi64(r0, i0)              movi(r0, i0)
 355 #  endif
 356 #  if __WORDSIZE == 64 || NEW_ABI
 357 #    define movr_w_d(r0, r1)            DMTC1(r1, r0)
 358 #    define movr_d_w(r0, r1)            DMFC1(r0, r1)
 359 #    define movi_w_d(r0, i0)            _movi_w_d(_jit, r0, i0)
 360 static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t);
 361 #  endif
 362 #  if __WORDSIZE == 32
 363 #    define movr_ww_d(r0, r1, r2)       _movr_ww_d(_jit, r0, r1, r2)
 364 static void _movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 365 #    define movr_d_ww(r0, r1, r2)       _movr_d_ww(_jit, r0, r1, r2)
 366 static void _movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 367 #    define movi_ww_d(r0, i0, i1)       _movi_ww_d(_jit, r0, i0, i1)
 368 static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 369 #  endif
 370 #  define extr_d(r0, r1)                _extr_d(_jit, r0, r1)
 371 static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 372 #  define truncr_d_i(r0, r1)            _truncr_d_i(_jit, r0, r1)
 373 static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
 374 #  if __WORDSIZE == 64
 375 #    define truncr_d_l(r0, r1)          _truncr_d_l(_jit, r0, r1)
 376 static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
 377 #  endif
 378 #  define ldr_d(r0, r1)                 _ldr_d(_jit, r0, r1)
 379 static void _ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 380 #  define ldi_d(r0, i0)                 _ldi_d(_jit, r0, i0)
 381 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 382 #  define ldxr_d(r0, r1, r2)            _ldxr_d(_jit, r0, r1, r2)
 383 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 384 #  define ldxi_d(r0, r1, i0)            _ldxi_d(_jit, r0, r1, i0)
 385 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 386 #  define str_d(r0, r1)                 _str_d(_jit, r0, r1)
 387 static void _str_d(jit_state_t*,jit_int32_t,jit_int32_t);
 388 #  define sti_d(i0, r0)                 _sti_d(_jit, i0, r0)
 389 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 390 #  define stxr_d(r0, r1, r2)            _stxr_d(_jit, r0, r1, r2)
 391 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 392 #  define stxi_d(i0, r0, r1)            _stxi_d(_jit, i0, r0, r1)
 393 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 394 #  define fmar_d(r0, r1, r2, r3)        _fmar_d(_jit, r0, r1, r2, r3)
 395 static void _fmar_d(jit_state_t*,
 396                     jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 397 #  define fmsr_d(r0, r1, r2, r3)        _fmsr_d(_jit, r0, r1, r2, r3)
 398 static void _fmsr_d(jit_state_t*,
 399                     jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 400 #  define fnmar_d(r0, r1, r2, r3)       _fnmar_d(_jit, r0, r1, r2, r3)
 401 static void _fnmar_d(jit_state_t*,
 402                      jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 403 #  define fnmsr_d(r0, r1, r2, r3)       _fnmsr_d(_jit, r0, r1, r2, r3)
 404 static void _fnmsr_d(jit_state_t*,
 405                      jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 406 #  define movr_d(r0, r1)                _movr_d(_jit, r0, r1)
 407 static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 408 #  define movi_d(r0, i0)                _movi_d(_jit, r0, i0)
 409 static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
 410 #  define ltr_f(r0, r1, r2)             _ltr_f(_jit, r0, r1, r2)
 411 static void _ltr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 412 #  define lti_f(r0, r1, i2)             _lti_f(_jit, r0, r1, i2)
 413 static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 414 #  define ler_f(r0, r1, r2)             _ler_f(_jit, r0, r1, r2)
 415 static void _ler_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 416 #  define lei_f(r0, r1, i2)             _lei_f(_jit, r0, r1, i2)
 417 static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 418 #  define eqr_f(r0, r1, r2)             _eqr_f(_jit, r0, r1, r2)
 419 static void _eqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 420 #  define eqi_f(r0, r1, i2)             _eqi_f(_jit, r0, r1, i2)
 421 static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 422 #  define ger_f(r0, r1, r2)             _ger_f(_jit, r0, r1, r2)
 423 static void _ger_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 424 #  define gei_f(r0, r1, i2)             _gei_f(_jit, r0, r1, i2)
 425 static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 426 #  define gtr_f(r0, r1, r2)             _gtr_f(_jit, r0, r1, r2)
 427 static void _gtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 428 #  define gti_f(r0, r1, i2)             _gti_f(_jit, r0, r1, i2)
 429 static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 430 #  define ner_f(r0, r1, r2)             _ner_f(_jit, r0, r1, r2)
 431 static void _ner_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 432 #  define nei_f(r0, r1, i2)             _nei_f(_jit, r0, r1, i2)
 433 static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 434 #  define unltr_f(r0, r1, r2)           _unltr_f(_jit, r0, r1, r2)
 435 static void _unltr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 436 #  define unlti_f(r0, r1, i2)           _unlti_f(_jit, r0, r1, i2)
 437 static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 438 #  define unler_f(r0, r1, r2)           _unler_f(_jit, r0, r1, r2)
 439 static void _unler_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 440 #  define unlei_f(r0, r1, i2)           _unlei_f(_jit, r0, r1, i2)
 441 static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 442 #  define uneqr_f(r0, r1, r2)           _uneqr_f(_jit, r0, r1, r2)
 443 static void _uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 444 #  define uneqi_f(r0, r1, i2)           _uneqi_f(_jit, r0, r1, i2)
 445 static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 446 #  define unger_f(r0, r1, r2)           _unger_f(_jit, r0, r1, r2)
 447 static void _unger_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 448 #  define ungei_f(r0, r1, i2)           _ungei_f(_jit, r0, r1, i2)
 449 static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 450 #  define ungtr_f(r0, r1, r2)           _ungtr_f(_jit, r0, r1, r2)
 451 static void _ungtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 452 #  define ungti_f(r0, r1, i2)           _ungti_f(_jit, r0, r1, i2)
 453 static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 454 #  define ltgtr_f(r0, r1, r2)           _ltgtr_f(_jit, r0, r1, r2)
 455 static void _ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 456 #  define ltgti_f(r0, r1, i2)           _ltgti_f(_jit, r0, r1, i2)
 457 static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 458 #  define ordr_f(r0, r1, r2)            _ordr_f(_jit, r0, r1, r2)
 459 static void _ordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 460 #  define ordi_f(r0, r1, i2)            _ordi_f(_jit, r0, r1, i2)
 461 static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 462 #  define unordr_f(r0, r1, r2)          _unordr_f(_jit, r0, r1, r2)
 463 static void _unordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 464 #  define unordi_f(r0, r1, i2)          _unordi_f(_jit, r0, r1, i2)
 465 static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 466 #  define bltr_f(i0, r0, r1)            _bltr_f(_jit, i0, r0, r1)
 467 static jit_word_t _bltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 468 #  define blti_f(i0, r0, i1)            _blti_f(_jit, i0, r0, i1)
 469 static jit_word_t
 470 _blti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 471 #  define bler_f(i0, r0, r1)            _bler_f(_jit, i0, r0, r1)
 472 static jit_word_t _bler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 473 #  define blei_f(i0, r0, i1)            _blei_f(_jit, i0, r0, i1)
 474 static jit_word_t
 475 _blei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 476 #  define beqr_f(i0, r0, r1)            _beqr_f(_jit, i0, r0, r1)
 477 static jit_word_t _beqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 478 #  define beqi_f(i0, r0, i1)            _beqi_f(_jit, i0, r0, i1)
 479 static jit_word_t
 480 _beqi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 481 #  define bger_f(i0, r0, r1)            _bger_f(_jit, i0, r0, r1)
 482 static jit_word_t _bger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 483 #  define bgei_f(i0, r0, i1)            _bgei_f(_jit, i0, r0, i1)
 484 static jit_word_t
 485 _bgei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 486 #  define bgtr_f(i0, r0, r1)            _bgtr_f(_jit, i0, r0, r1)
 487 static jit_word_t _bgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 488 #  define bgti_f(i0, r0, i1)            _bgti_f(_jit, i0, r0, i1)
 489 static jit_word_t
 490 _bgti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 491 #  define bner_f(i0, r0, r1)            _bner_f(_jit, i0, r0, r1)
 492 static jit_word_t _bner_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 493 #  define bnei_f(i0, r0, i1)            _bnei_f(_jit, i0, r0, i1)
 494 static jit_word_t
 495 _bnei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 496 #  define bunltr_f(i0, r0, r1)          _bunltr_f(_jit, i0, r0, r1)
 497 static jit_word_t _bunltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 498 #  define bunlti_f(i0, r0, i1)          _bunlti_f(_jit, i0, r0, i1)
 499 static jit_word_t
 500 _bunlti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 501 #  define bunler_f(i0, r0, r1)          _bunler_f(_jit, i0, r0, r1)
 502 static jit_word_t _bunler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 503 #  define bunlei_f(i0, r0, i1)          _bunlei_f(_jit, i0, r0, i1)
 504 static jit_word_t
 505 _bunlei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 506 #  define buneqr_f(i0, r0, r1)          _buneqr_f(_jit, i0, r0, r1)
 507 static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 508 #  define buneqi_f(i0, r0, i1)          _buneqi_f(_jit, i0, r0, i1)
 509 static jit_word_t
 510 _buneqi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 511 #  define bunger_f(i0, r0, r1)          _bunger_f(_jit, i0, r0, r1)
 512 static jit_word_t _bunger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 513 #  define bungei_f(i0, r0, i1)          _bungei_f(_jit, i0, r0, i1)
 514 static jit_word_t
 515 _bungei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 516 #  define bungtr_f(i0, r0, r1)          _bungtr_f(_jit, i0, r0, r1)
 517 static jit_word_t _bungtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 518 #  define bungti_f(i0, r0, i1)          _bungti_f(_jit, i0, r0, i1)
 519 static jit_word_t
 520 _bungti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 521 #  define bltgtr_f(i0, r0, r1)          _bltgtr_f(_jit, i0, r0, r1)
 522 static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 523 #  define bltgti_f(i0, r0, i1)          _bltgti_f(_jit, i0, r0, i1)
 524 static jit_word_t
 525 _bltgti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 526 #  define bordr_f(i0, r0, r1)           _bordr_f(_jit, i0, r0, r1)
 527 static jit_word_t _bordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 528 #  define bordi_f(i0, r0, i1)           _bordi_f(_jit, i0, r0, i1)
 529 static jit_word_t
 530 _bordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 531 #  define bunordr_f(i0, r0, r1)         _bunordr_f(_jit, i0, r0, r1)
 532 static jit_word_t _bunordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 533 #  define bunordi_f(i0, r0, i1)         _bunordi_f(_jit, i0, r0, i1)
 534 static jit_word_t
 535 _bunordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 536 #  define extr_f_d(r0, r1)              CVT_D_S(r0, r1)
 537 #  define ltr_d(r0, r1, r2)             _ltr_d(_jit, r0, r1, r2)
 538 static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 539 #  define lti_d(r0, r1, i2)             _lti_d(_jit, r0, r1, i2)
 540 static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 541 #  define ler_d(r0, r1, r2)             _ler_d(_jit, r0, r1, r2)
 542 static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 543 #  define lei_d(r0, r1, i2)             _lei_d(_jit, r0, r1, i2)
 544 static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 545 #  define eqr_d(r0, r1, r2)             _eqr_d(_jit, r0, r1, r2)
 546 static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 547 #  define eqi_d(r0, r1, i2)             _eqi_d(_jit, r0, r1, i2)
 548 static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 549 #  define ger_d(r0, r1, r2)             _ger_d(_jit, r0, r1, r2)
 550 static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 551 #  define gei_d(r0, r1, i2)             _gei_d(_jit, r0, r1, i2)
 552 static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 553 #  define gtr_d(r0, r1, r2)             _gtr_d(_jit, r0, r1, r2)
 554 static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 555 #  define gti_d(r0, r1, i2)             _gti_d(_jit, r0, r1, i2)
 556 static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 557 #  define ner_d(r0, r1, r2)             _ner_d(_jit, r0, r1, r2)
 558 static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 559 #  define nei_d(r0, r1, i2)             _nei_d(_jit, r0, r1, i2)
 560 static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 561 #  define unltr_d(r0, r1, r2)           _unltr_d(_jit, r0, r1, r2)
 562 static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 563 #  define unlti_d(r0, r1, i2)           _unlti_d(_jit, r0, r1, i2)
 564 static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 565 #  define unler_d(r0, r1, r2)           _unler_d(_jit, r0, r1, r2)
 566 static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 567 #  define unlei_d(r0, r1, i2)           _unlei_d(_jit, r0, r1, i2)
 568 static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 569 #  define uneqr_d(r0, r1, r2)           _uneqr_d(_jit, r0, r1, r2)
 570 static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 571 #  define uneqi_d(r0, r1, i2)           _uneqi_d(_jit, r0, r1, i2)
 572 static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 573 #  define unger_d(r0, r1, r2)           _unger_d(_jit, r0, r1, r2)
 574 static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 575 #  define ungei_d(r0, r1, i2)           _ungei_d(_jit, r0, r1, i2)
 576 static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 577 #  define ungtr_d(r0, r1, r2)           _ungtr_d(_jit, r0, r1, r2)
 578 static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 579 #  define ungti_d(r0, r1, i2)           _ungti_d(_jit, r0, r1, i2)
 580 static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 581 #  define ltgtr_d(r0, r1, r2)           _ltgtr_d(_jit, r0, r1, r2)
 582 static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 583 #  define ltgti_d(r0, r1, i2)           _ltgti_d(_jit, r0, r1, i2)
 584 static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 585 #  define ordr_d(r0, r1, r2)            _ordr_d(_jit, r0, r1, r2)
 586 static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 587 #  define ordi_d(r0, r1, i2)            _ordi_d(_jit, r0, r1, i2)
 588 static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 589 #  define unordr_d(r0, r1, r2)          _unordr_d(_jit, r0, r1, r2)
 590 static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 591 #  define unordi_d(r0, r1, i2)          _unordi_d(_jit, r0, r1, i2)
 592 static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 593 #  define bltr_d(i0, r0, r1)            _bltr_d(_jit, i0, r0, r1)
 594 static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 595 #  define blti_d(i0, r0, i1)            _blti_d(_jit, i0, r0, i1)
 596 static jit_word_t
 597 _blti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 598 #  define bler_d(i0, r0, r1)            _bler_d(_jit, i0, r0, r1)
 599 static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 600 #  define blei_d(i0, r0, i1)            _blei_d(_jit, i0, r0, i1)
 601 static jit_word_t
 602 _blei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 603 #  define beqr_d(i0, r0, r1)            _beqr_d(_jit, i0, r0, r1)
 604 static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 605 #  define beqi_d(i0, r0, i1)            _beqi_d(_jit, i0, r0, i1)
 606 static jit_word_t
 607 _beqi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 608 #  define bger_d(i0, r0, r1)            _bger_d(_jit, i0, r0, r1)
 609 static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 610 #  define bgei_d(i0, r0, i1)            _bgei_d(_jit, i0, r0, i1)
 611 static jit_word_t
 612 _bgei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 613 #  define bgtr_d(i0, r0, r1)            _bgtr_d(_jit, i0, r0, r1)
 614 static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 615 #  define bgti_d(i0, r0, i1)            _bgti_d(_jit, i0, r0, i1)
 616 static jit_word_t
 617 _bgti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 618 #  define bner_d(i0, r0, r1)            _bner_d(_jit, i0, r0, r1)
 619 static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 620 #  define bnei_d(i0, r0, i1)            _bnei_d(_jit, i0, r0, i1)
 621 static jit_word_t
 622 _bnei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 623 #  define bunltr_d(i0, r0, r1)          _bunltr_d(_jit, i0, r0, r1)
 624 static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 625 #  define bunlti_d(i0, r0, i1)          _bunlti_d(_jit, i0, r0, i1)
 626 static jit_word_t
 627 _bunlti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 628 #  define bunler_d(i0, r0, r1)          _bunler_d(_jit, i0, r0, r1)
 629 static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 630 #  define bunlei_d(i0, r0, i1)          _bunlei_d(_jit, i0, r0, i1)
 631 static jit_word_t
 632 _bunlei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 633 #  define buneqr_d(i0, r0, r1)          _buneqr_d(_jit, i0, r0, r1)
 634 static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 635 #  define buneqi_d(i0, r0, i1)          _buneqi_d(_jit, i0, r0, i1)
 636 static jit_word_t
 637 _buneqi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 638 #  define bunger_d(i0, r0, r1)          _bunger_d(_jit, i0, r0, r1)
 639 static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 640 #  define bungei_d(i0, r0, i1)          _bungei_d(_jit, i0, r0, i1)
 641 static jit_word_t
 642 _bungei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 643 #  define bungtr_d(i0, r0, r1)          _bungtr_d(_jit, i0, r0, r1)
 644 static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 645 #  define bungti_d(i0, r0, i1)          _bungti_d(_jit, i0, r0, i1)
 646 static jit_word_t
 647 _bungti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 648 #  define bltgtr_d(i0, r0, r1)          _bltgtr_d(_jit, i0, r0, r1)
 649 static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 650 #  define bltgti_d(i0, r0, i1)          _bltgti_d(_jit, i0, r0, i1)
 651 static jit_word_t
 652 _bltgti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 653 #  define bordr_d(i0, r0, r1)           _bordr_d(_jit, i0, r0, r1)
 654 static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 655 #  define bordi_d(i0, r0, i1)           _bordi_d(_jit, i0, r0, i1)
 656 static jit_word_t
 657 _bordi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 658 #  define bunordr_d(i0, r0, r1)         _bunordr_d(_jit, i0, r0, r1)
 659 static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 660 #  define bunordi_d(i0, r0, i1)         _bunordi_d(_jit, i0, r0, i1)
 661 static jit_word_t
 662 _bunordi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 663 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 664 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 665 #endif
 666
 667 #if CODE
 668 static void
 669 _c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
 670             jit_int32_t ft, jit_int32_t fs, jit_int32_t cc)
 671 {
 672     jit_instr_t         i;
 673     i.cc.b = cc;
 674     i.fs.b = fs;
 675     i.ft.b = ft;
 676     i.fm.b = fm;
 677     i.hc.b = MIPS_COP1;
 678     instr(i.op);
 679 }
 680
 681 static void
 682 _cmp_cond_fmt(jit_state_t *_jit, jit_int32_t fm, jit_int32_t fd,
 683               jit_int32_t ft, jit_int32_t fs, jit_int32_t cn)
 684 {
 685     jit_instr_t         i;
 686     i.op = 0;           /* must have bit 6 zero ed */
 687     i.cn.b = cn;
 688     i.ft.b = ft;
 689     i.fs.b = fs;
 690     i.fd.b = fd;
 691     i.fm.b = fm;
 692     i.hc.b = MIPS_COP1;
 693     instr(i.op);
 694 }
 695
 696 #  define fpr_opi(name, type, size)                                     \
 697 static void                                                             \
 698 _##name##i_##type(jit_state_t *_jit,                                    \
 699                   jit_int32_t r0, jit_int32_t r1,                       \
 700                   jit_float##size##_t *i0)                              \
 701 {                                                                       \
 702     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
 703     movi_##type(rn(reg), i0);                                           \
 704     name##r_##type(r0, r1, rn(reg));                                    \
 705     jit_unget_reg(reg);                                                 \
 706 }
 707 #  define fpr_bopi(name, type, size)                                    \
 708 static jit_word_t                                                       \
 709 _b##name##i_##type(jit_state_t *_jit,                                   \
 710                   jit_word_t i0, jit_int32_t r0,                        \
 711                   jit_float##size##_t *i1)                              \
 712 {                                                                       \
 713     jit_word_t          word;                                           \
 714     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
 715                                           jit_class_nospill);           \
 716     movi_##type(rn(reg), i1);                                           \
 717     word = b##name##r_##type(i0, r0, rn(reg));                          \
 718     jit_unget_reg(reg);                                                 \
 719     return (word);                                                      \
 720 }
 721 #  define fopi(name)                    fpr_opi(name, f, 32)
 722 #  define fbopi(name)                   fpr_bopi(name, f, 32)
 723 #  define dopi(name)                    fpr_opi(name, d, 64)
 724 #  define dbopi(name)                   fpr_bopi(name, d, 64)
 725
 726 fopi(add)
 727 fopi(sub)
 728 fopi(rsb)
 729 fopi(mul)
 730 fopi(div)
 731
 732 static void
 733 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 734 {
 735     jit_int32_t         t0;
 736     t0 = jit_get_reg(jit_class_fpr);
 737 #  if __WORDSIZE == 32
 738     MTC1(r1, rn(t0));
 739     CVT_S_W(r0, rn(t0));
 740 #  else
 741     DMTC1(r1, rn(t0));
 742     CVT_S_L(r0, rn(t0));
 743 #  endif
 744     jit_unget_reg(t0);
 745 }
 746
 747 static void
 748 _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 749 {
 750     jit_int32_t         t0;
 751     t0 = jit_get_reg(jit_class_fpr);
 752     TRUNC_W_S(rn(t0), r1);
 753     MFC1(r0, rn(t0));
 754     jit_unget_reg(t0);
 755 }
 756
 757 #  if __WORDSIZE == 64
 758 static void
 759 _truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 760 {
 761     jit_int32_t         t0;
 762     t0 = jit_get_reg(jit_class_fpr);
 763     TRUNC_L_S(rn(t0), r1);
 764     DMFC1(r0, rn(t0));
 765     jit_unget_reg(t0);
 766 }
 767 #  endif
 768
 769 static void
 770 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 771 {
 772     jit_int32_t         reg;
 773     if (can_sign_extend_short_p(i0))
 774         LWC1(r0, i0, _ZERO_REGNO);
 775     else {
 776         reg = jit_get_reg(jit_class_gpr);
 777         movi(rn(reg), i0);
 778         ldr_f(r0, rn(reg));
 779         jit_unget_reg(reg);
 780     }
 781 }
 782
 783 static void
 784 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 785 {
 786     jit_int32_t         reg;
 787     reg = jit_get_reg(jit_class_gpr);
 788     addr(rn(reg), r1, r2);
 789     ldr_f(r0, rn(reg));
 790     jit_unget_reg(reg);
 791 }
 792
 793 static void
 794 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 795 {
 796     jit_int32_t         reg;
 797     if (can_sign_extend_short_p(i0))
 798         LWC1(r0, i0, r1);
 799     else {
 800         reg = jit_get_reg(jit_class_gpr);
 801         addi(rn(reg), r1, i0);
 802         ldr_f(r0, rn(reg));
 803         jit_unget_reg(reg);
 804     }
 805 }
 806
 807 static void
 808 _unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 809 {
 810     jit_int32_t         t0, r2;
 811 #  if __WORDSIZE == 32
 812     jit_int32_t         t1, r3;
 813 #  endif
 814     if (jit_unaligned_p()) {
 815         assert(i0 == 4 || i0 == 8);
 816         t0 = jit_get_reg(jit_class_gpr);
 817         r2 = rn(t0);
 818         if (i0 == 4) {
 819             unldr(r2, r1, 4);
 820             movr_w_f(r0, r2);
 821         }
 822         else {
 823 #  if __WORDSIZE == 32
 824             t1 = jit_get_reg(jit_class_gpr);
 825             r3 = rn(t1);
 826 #    if __BYTE_ORDER == __LITTLE_ENDIAN
 827             unldr(r2, r1, 4);
 828             addi(r3, r1, 4);
 829             unldr(r3, r3, 4);
 830 #    else
 831             unldr(r3, r1, 4);
 832             addi(r2, r1, 4);
 833             unldr(r2, r2, 4);
 834 #    endif
 835             movr_ww_d(r0, r2, r3);
 836             jit_unget_reg(t1);
 837 #  else
 838             unldr(r2, r1, 8);
 839             movr_w_d(r0, r2);
 840 #  endif
 841         }
 842         jit_unget_reg(t0);
 843     }
 844     else
 845         generic_unldr_x(r0, r1, i0);
 846 }
 847
 848 static void
 849 _unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
 850 {
 851     jit_int32_t         t0, r2;
 852 #  if __WORDSIZE == 32
 853     jit_int32_t         t1, r3;
 854 #  endif
 855     if (jit_unaligned_p()) {
 856         assert(i1 == 4 || i1 == 8);
 857         t0 = jit_get_reg(jit_class_gpr);
 858         r2 = rn(t0);
 859         if (i1 == 4) {
 860             unldi(r2, i0, 4);
 861             movr_w_f(r0, r2);
 862         }
 863         else {
 864 #  if __WORDSIZE == 32
 865             t1 = jit_get_reg(jit_class_gpr);
 866             r3 = rn(t1);
 867 #    if __BYTE_ORDER == __LITTLE_ENDIAN
 868             unldi(r2, i0, 4);
 869             unldi(r3, i0 + 4, 4);
 870 #    else
 871             unldi(r3, i0, 4);
 872             unldi(r2, i0 + 4, 4);
 873 #    endif
 874             movr_ww_d(r0, r3, r2);
 875             jit_unget_reg(t1);
 876 #  else
 877             unldi(r2, i0, 8);
 878             movr_w_d(r0, r2);
 879 #  endif
 880         }
 881         jit_unget_reg(t0);
 882     }
 883     else
 884         generic_unldi_x(r0, i0, i1);
 885 }
 886
 887 static void
 888 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 889 {
 890     jit_int32_t         reg;
 891     if (can_sign_extend_short_p(i0))
 892         SWC1(r0, i0, _ZERO_REGNO);
 893     else {
 894         reg = jit_get_reg(jit_class_gpr);
 895         movi(rn(reg), i0);
 896         str_f(rn(reg), r0);
 897         jit_unget_reg(reg);
 898     }
 899 }
 900
 901 static void
 902 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 903 {
 904     jit_int32_t         reg;
 905     reg = jit_get_reg(jit_class_gpr);
 906     addr(rn(reg), r0, r1);
 907     str_f(rn(reg), r2);
 908     jit_unget_reg(reg);
 909 }
 910
 911 static void
 912 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 913 {
 914     jit_int32_t         reg;
 915     if (can_sign_extend_short_p(i0))
 916         SWC1(r1, i0, r0);
 917     else {
 918         reg = jit_get_reg(jit_class_gpr);
 919         addi(rn(reg), r0, i0);
 920         str_f(rn(reg), r1);
 921         jit_unget_reg(reg);
 922     }
 923 }
 924
 925 static void
 926 _unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 927 {
 928     if (jit_unaligned_p())
 929         fallback_unstr_x(r0, r1, i0);
 930     else
 931         generic_unstr_x(r0, r1, i0);
 932 }
 933
 934 static void
 935 _unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
 936 {
 937     if (jit_unaligned_p())
 938         fallback_unsti_x(i0, r0, i1);
 939     else
 940         fallback_unsti_x(i0, r0, i1);
 941 }
 942
 943
 944 static void
 945 _fmar_f(jit_state_t *_jit,
 946         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 947 {
 948     jit_int32_t         t0;
 949     if (jit_mips2_p()) {
 950         if (jit_mips6_p()) {
 951             if (r0 == r3)
 952                 MADDF_S(r0, r2, r1);
 953             else {
 954                 t0 = jit_get_reg(jit_class_fpr);
 955                 movr_f(rn(t0), r3);
 956                 MADDF_S(rn(t0), r2, r1);
 957                 movr_f(r0, rn(t0));
 958                 jit_unget_reg(t0);
 959             }
 960         }
 961         else
 962             MADD_S(r0, r3, r2, r1);
 963     }
 964     else {
 965         if (r0 != r3) {
 966             mulr_f(r0, r1, r2);
 967             addr_f(r0, r0, r3);
 968         }
 969         else {
 970             t0 = jit_get_reg(jit_class_fpr);
 971             mulr_f(rn(t0), r1, r2);
 972             addr_f(r0, rn(t0), r3);
 973             jit_unget_reg(t0);
 974         }
 975     }
 976 }
 977
 978 static void
 979 _fmsr_f(jit_state_t *_jit,
 980         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 981 {
 982     jit_int32_t         t0;
 983     if (jit_mips2_p()) {
 984         if (jit_mips6_p()) {
 985             if (r0 == r3)
 986                 MSUBF_S(r0, r2, r1);
 987             else {
 988                 t0 = jit_get_reg(jit_class_fpr);
 989                 movr_f(rn(t0), r3);
 990                 MSUBF_S(rn(t0), r2, r1);
 991                 movr_f(r0, rn(t0));
 992                 jit_unget_reg(t0);
 993             }
 994             negr_f(r0, r0);
 995         }
 996         else
 997             MSUB_S(r0, r3, r2, r1);
 998     }
 999     else {
1000         if (r0 != r3) {
1001             mulr_f(r0, r1, r2);
1002             subr_f(r0, r0, r3);
1003         }
1004         else {
1005             t0 = jit_get_reg(jit_class_fpr);
1006             mulr_f(rn(t0), r1, r2);
1007             subr_f(r0, rn(t0), r3);
1008             jit_unget_reg(t0);
1009         }
1010     }
1011 }
1012
1013 static void
1014 _fnmar_f(jit_state_t *_jit,
1015          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1016 {
1017     jit_int32_t         t0;
1018     if (jit_mips2_p()) {
1019         if (jit_mips6_p()) {
1020             if (r0 == r3)
1021                 MADDF_S(r0, r2, r1);
1022             else {
1023                 t0 = jit_get_reg(jit_class_fpr);
1024                 movr_f(rn(t0), r3);
1025                 MADDF_S(rn(t0), r2, r1);
1026                 movr_f(r0, rn(t0));
1027                 jit_unget_reg(t0);
1028             }
1029             negr_f(r0, r0);
1030         }
1031         else
1032             NMADD_S(r0, r3, r2, r1);
1033     }
1034     else {
1035         t0 = jit_get_reg(jit_class_fpr);
1036         negr_f(rn(t0), r1);
1037         mulr_f(rn(t0), rn(t0), r2);
1038         subr_f(r0, rn(t0), r3);
1039         jit_unget_reg(t0);
1040     }
1041 }
1042
1043 static void
1044 _fnmsr_f(jit_state_t *_jit,
1045          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1046 {
1047     jit_int32_t         t0;
1048     if (jit_mips2_p()) {
1049         if (jit_mips6_p()) {
1050             if (r0 == r3)
1051                 MSUBF_S(r0, r2, r1);
1052             else {
1053                 t0 = jit_get_reg(jit_class_fpr);
1054                 movr_f(rn(t0), r3);
1055                 MSUBF_S(rn(t0), r2, r1);
1056                 movr_f(r0, rn(t0));
1057                 jit_unget_reg(t0);
1058             }
1059         }
1060         else
1061             NMSUB_S(r0, r3, r2, r1);
1062     }
1063     else {
1064         t0 = jit_get_reg(jit_class_fpr);
1065         negr_f(rn(t0), r1);
1066         mulr_f(rn(t0), rn(t0), r2);
1067         addr_f(r0, rn(t0), r3);
1068         jit_unget_reg(t0);
1069     }
1070 }
1071
1072 static void
1073 _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1074 {
1075     if (r0 != r1)
1076         MOV_S(r0, r1);
1077 }
1078
1079 static void
1080 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
1081 {
1082     union {
1083         jit_int32_t     i;
1084         jit_float32_t   f;
1085     } data;
1086     jit_int32_t         reg;
1087
1088     data.f = *i0;
1089     if (data.i) {
1090         if (_jitc->no_data) {
1091             reg = jit_get_reg(jit_class_gpr);
1092             movi(rn(reg), data.i);
1093             MTC1(rn(reg), r0);
1094             jit_unget_reg(reg);
1095         }
1096         else
1097             ldi_f(r0, (jit_word_t)i0);
1098     }
1099     else
1100         MTC1(_ZERO_REGNO, r0);
1101 }
1102
1103 static void
1104 _movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1105 {
1106     jit_int32_t         reg;
1107     reg = jit_get_reg(jit_class_gpr);
1108     movi(rn(reg), i0);
1109     movr_w_f(r0, rn(reg));
1110     jit_unget_reg(reg);
1111 }
1112
1113 dopi(add)
1114 dopi(sub)
1115 dopi(rsb)
1116 dopi(mul)
1117 dopi(div)
1118
1119 #if NEW_ABI && __WORDSIZE == 32
1120 /* n32 abi requires 64 bit cpu */
1121 static void
1122 _movi64(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0)
1123 {
1124     if (i0 == 0)
1125         OR(r0, _ZERO_REGNO, _ZERO_REGNO);
1126     else if (i0 >= -32678 && i0 <= 32767)
1127         DADDIU(r0, _ZERO_REGNO, i0);
1128     else if (i0 >= 0 && i0 <= 65535)
1129         ORI(r0, _ZERO_REGNO, i0);
1130     else {
1131         if (i0 >= 0 && i0 <= 0x7fffffffLL)
1132             LUI(r0, i0 >> 16);
1133         else if (i0 >= 0 && i0 <= 0xffffffffLL) {
1134             if (i0 & 0xffff0000LL) {
1135                 ORI(r0, _ZERO_REGNO, (jit_word_t)(i0 >> 16));
1136                 DSLL(r0, r0, 16);
1137             }
1138         }
1139         else {
1140             movi(r0, (jit_word_t)(i0 >> 32));
1141             if (i0 & 0xffff0000LL) {
1142                 DSLL(r0, r0, 16);
1143                 ORI(r0, r0, (jit_word_t)(i0 >> 16));
1144                 DSLL(r0, r0, 16);
1145             }
1146             else
1147                 DSLL32(r0, r0, 0);
1148         }
1149         if ((jit_word_t)i0 & 0xffff)
1150             ORI(r0, r0, (jit_word_t)i0 & 0xffff);
1151     }
1152 }
1153
1154 static void
1155 _movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0)
1156 {
1157     union {
1158         jit_int64_t     l;
1159         jit_float64_t   d;
1160     } data;
1161     data.d = i0;
1162     movi64(r0, data.l);
1163 }
1164 #endif
1165
1166 #if __WORDSIZE == 64 || NEW_ABI
1167 static void
1168 _movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1169 {
1170     jit_int32_t         reg;
1171     reg = jit_get_reg(jit_class_gpr);
1172     movi64(rn(reg), i0);
1173     movr_w_d(r0, rn(reg));
1174     jit_unget_reg(reg);
1175 }
1176 #endif
1177
1178 #if __WORDSIZE == 32
1179 static void
1180 _movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1181 {
1182     if (jit_mips6_p()) {
1183         MTC1(r1, r0);
1184         MTHC1(r2, r0);
1185     }
1186     else {
1187         MTC1(r1, r0 + BE_P);
1188         MTC1(r2, r0 + LE_P);
1189     }
1190 }
1191
1192 static void
1193 _movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1194 {
1195     if (jit_mips6_p()) {
1196         MFC1(r0, r2);
1197         MFHC1(r1, r2);
1198     }
1199     else {
1200         MFC1(r0, r2 + BE_P);
1201         MFC1(r1, r2 + LE_P);
1202     }
1203 }
1204
1205 static void
1206 _movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
1207 {
1208     jit_int32_t         t0, t1;
1209     t0 = jit_get_reg(jit_class_gpr);
1210     t1 = jit_get_reg(jit_class_gpr);
1211     movi(rn(t0), i0);
1212     movi(rn(t1), i1);
1213     MTC1(rn(t0), r0);
1214     MTC1(rn(t1), r0 + 1);
1215     jit_unget_reg(t1);
1216     jit_unget_reg(t0);
1217 }
1218 #endif
1219
1220 static void
1221 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1222 {
1223     jit_int32_t         t0;
1224     t0 = jit_get_reg(jit_class_fpr);
1225 #  if __WORDSIZE == 32
1226     MTC1(r1, rn(t0));
1227     CVT_D_W(r0, rn(t0));
1228 #  else
1229     DMTC1(r1, rn(t0));
1230     CVT_D_L(r0, rn(t0));
1231 #  endif
1232     jit_unget_reg(t0);
1233 }
1234
1235 static void
1236 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1237 {
1238     jit_int32_t         t0;
1239     t0 = jit_get_reg(jit_class_fpr);
1240     TRUNC_W_D(rn(t0), r1);
1241     MFC1(r0, rn(t0));
1242     jit_unget_reg(t0);
1243 }
1244
1245 #  if __WORDSIZE == 64
1246 static void
1247 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1248 {
1249     jit_int32_t         t0;
1250     t0 = jit_get_reg(jit_class_fpr);
1251     TRUNC_L_D(rn(t0), r1);
1252     DMFC1(r0, rn(t0));
1253     jit_unget_reg(t0);
1254 }
1255 #  endif
1256
1257 static void
1258 _ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1259 {
1260     if (jit_mips6_p() || __WORDSIZE == 64 || NEW_ABI)
1261         LDC1(r0, 0, r1);
1262     else {
1263         LWC1(r0 + BE_P, 0, r1);
1264         LWC1(r0 + LE_P, 4, r1);
1265     }
1266 }
1267
1268 static void
1269 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1270 {
1271     jit_int32_t         reg;
1272     if (jit_mips6_p() || __WORDSIZE == 64 || NEW_ABI) {
1273         if (can_sign_extend_short_p(i0))
1274             LDC1(r0, i0, _ZERO_REGNO);
1275         else {
1276             reg = jit_get_reg(jit_class_gpr);
1277             movi(rn(reg), i0);
1278             LDC1(r0, 0, rn(reg));
1279             jit_unget_reg(reg);
1280         }
1281     }
1282     else {
1283         if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
1284             LWC1(r0 + BE_P, i0, _ZERO_REGNO);
1285             LWC1(r0 + LE_P, i0 + 4, _ZERO_REGNO);
1286         }
1287         else {
1288             reg = jit_get_reg(jit_class_gpr);
1289             movi(rn(reg), i0);
1290             ldr_d(r0, rn(reg));
1291             jit_unget_reg(reg);
1292         }
1293     }
1294 }
1295
1296 static void
1297 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1298 {
1299     jit_int32_t         reg;
1300     reg = jit_get_reg(jit_class_gpr);
1301     addr(rn(reg), r1, r2);
1302     ldr_d(r0, rn(reg));
1303     jit_unget_reg(reg);
1304 }
1305
1306 static void
1307 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1308 {
1309     jit_int32_t         reg;
1310     if (jit_mips6_p() || __WORDSIZE == 64 || NEW_ABI) {
1311         if (can_sign_extend_short_p(i0))
1312             LDC1(r0, i0, r1);
1313         else
1314             goto fallback;
1315     }
1316     else {
1317         if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
1318             LWC1(r0 + BE_P, i0, r1);
1319             LWC1(r0 + LE_P, i0 + 4, r1);
1320         }
1321         else {
1322         fallback:
1323             reg = jit_get_reg(jit_class_gpr);
1324             addi(rn(reg), r1, i0);
1325             ldr_d(r0, rn(reg));
1326             jit_unget_reg(reg);
1327         }
1328     }
1329 }
1330
1331 static void
1332 _str_d(jit_state_t *_jit,jit_int32_t r0, jit_int32_t r1)
1333 {
1334     if (jit_mips6_p() || __WORDSIZE == 64 || NEW_ABI)
1335         SDC1(r1, 0, r0);
1336     else {
1337         SWC1(r1 + BE_P, 0, r0);
1338         SWC1(r1 + LE_P, 4, r0);
1339     }
1340 }
1341
1342 static void
1343 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1344 {
1345     jit_int32_t         reg;
1346     if (jit_mips6_p() ||  __WORDSIZE == 64 || NEW_ABI) {
1347         if (can_sign_extend_short_p(i0))
1348             SDC1(r0, i0, _ZERO_REGNO);
1349         else
1350             goto fallback;
1351     }
1352     else {
1353         if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
1354             SWC1(r0 + BE_P, i0, _ZERO_REGNO);
1355             SWC1(r0 + LE_P, i0 + 4, _ZERO_REGNO);
1356         }
1357         else {
1358         fallback:
1359             reg = jit_get_reg(jit_class_gpr);
1360             movi(rn(reg), i0);
1361             str_d(rn(reg), r0);
1362             jit_unget_reg(reg);
1363         }
1364     }
1365 }
1366
1367 static void
1368 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1369 {
1370     jit_int32_t         reg;
1371     reg = jit_get_reg(jit_class_gpr);
1372     addr(rn(reg), r0, r1);
1373     str_d(rn(reg), r2);
1374     jit_unget_reg(reg);
1375 }
1376
1377 static void
1378 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1379 {
1380     jit_int32_t         reg;
1381     if (jit_mips6_p() || __WORDSIZE == 64 || NEW_ABI) {
1382         if (can_sign_extend_short_p(i0))
1383             SDC1(r1, i0, r0);
1384         else
1385             goto fallback;
1386     }
1387     else {
1388         if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
1389             SWC1(r1 + BE_P, i0, r0);
1390             SWC1(r1 + LE_P, i0 + 4, r0);
1391         }
1392         else {
1393         fallback:
1394             reg = jit_get_reg(jit_class_gpr);
1395             addi(rn(reg), r0, i0);
1396             str_d(rn(reg), r1);
1397             jit_unget_reg(reg);
1398         }
1399     }
1400 }
1401
1402 static void
1403 _fmar_d(jit_state_t *_jit,
1404         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1405 {
1406     jit_int32_t         t0;
1407     if (jit_mips2_p()) {
1408         if (jit_mips6_p()) {
1409             if (r0 == r3)
1410                 MADDF_D(r0, r2, r1);
1411             else {
1412                 t0 = jit_get_reg(jit_class_fpr);
1413                 movr_d(rn(t0), r3);
1414                 MADDF_D(rn(t0), r2, r1);
1415                 movr_d(r0, rn(t0));
1416                 jit_unget_reg(t0);
1417             }
1418         }
1419         else
1420             MADD_D(r0, r3, r2, r1);
1421     }
1422     else {
1423         if (r0 != r3) {
1424             mulr_d(r0, r1, r2);
1425             addr_d(r0, r0, r3);
1426         }
1427         else {
1428             t0 = jit_get_reg(jit_class_fpr);
1429             mulr_d(rn(t0), r1, r2);
1430             addr_d(r0, rn(t0), r3);
1431             jit_unget_reg(t0);
1432         }
1433     }
1434 }
1435
1436 static void
1437 _fmsr_d(jit_state_t *_jit,
1438         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1439 {
1440     jit_int32_t         t0;
1441     if (jit_mips2_p()) {
1442         if (jit_mips6_p()) {
1443             if (r0 == r3)
1444                 MSUBF_D(r0, r2, r1);
1445             else {
1446                 t0 = jit_get_reg(jit_class_fpr);
1447                 movr_d(rn(t0), r3);
1448                 MSUBF_D(rn(t0), r2, r1);
1449                 movr_d(r0, rn(t0));
1450                 jit_unget_reg(t0);
1451             }
1452             negr_d(r0, r0);
1453         }
1454         else
1455             MSUB_D(r0, r3, r2, r1);
1456     }
1457     else {
1458         if (r0 != r3) {
1459             mulr_d(r0, r1, r2);
1460             subr_d(r0, r0, r3);
1461         }
1462         else {
1463             t0 = jit_get_reg(jit_class_fpr);
1464             mulr_d(rn(t0), r1, r2);
1465             subr_d(r0, rn(t0), r3);
1466             jit_unget_reg(t0);
1467         }
1468     }
1469 }
1470
1471 static void
1472 _fnmar_d(jit_state_t *_jit,
1473          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1474 {
1475     jit_int32_t         t0;
1476     if (jit_mips2_p()) {
1477         if (jit_mips6_p()) {
1478             if (r0 == r3)
1479                 MADDF_D(r0, r2, r1);
1480             else {
1481                 t0 = jit_get_reg(jit_class_fpr);
1482                 movr_d(rn(t0), r3);
1483                 MADDF_D(rn(t0), r2, r1);
1484                 movr_d(r0, rn(t0));
1485                 jit_unget_reg(t0);
1486             }
1487             negr_d(r0, r0);
1488         }
1489         else
1490             NMADD_D(r0, r3, r2, r1);
1491     }
1492     else {
1493         t0 = jit_get_reg(jit_class_fpr);
1494         negr_d(rn(t0), r1);
1495         mulr_d(rn(t0), rn(t0), r2);
1496         subr_d(r0, rn(t0), r3);
1497         jit_unget_reg(t0);
1498     }
1499 }
1500
1501 static void
1502 _fnmsr_d(jit_state_t *_jit,
1503          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1504 {
1505     jit_int32_t         t0;
1506     if (jit_mips2_p()) {
1507         if (jit_mips6_p()) {
1508             if (r0 == r3)
1509                 MSUBF_D(r0, r2, r1);
1510             else {
1511                 t0 = jit_get_reg(jit_class_fpr);
1512                 movr_d(rn(t0), r3);
1513                 MSUBF_D(rn(t0), r2, r1);
1514                 movr_d(r0, rn(t0));
1515                 jit_unget_reg(t0);
1516             }
1517         }
1518         else
1519             NMSUB_D(r0, r3, r2, r1);
1520     }
1521     else {
1522         t0 = jit_get_reg(jit_class_fpr);
1523         negr_d(rn(t0), r1);
1524         mulr_d(rn(t0), rn(t0), r2);
1525         addr_d(r0, rn(t0), r3);
1526         jit_unget_reg(t0);
1527     }
1528 }
1529
1530 static void
1531 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1532 {
1533     if (r0 != r1)
1534         MOV_D(r0, r1);
1535 }
1536
1537 static void
1538 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
1539 {
1540     union {
1541         jit_int32_t     i[2];
1542         jit_int64_t     l;
1543         jit_float64_t   d;
1544     } data;
1545     jit_int32_t         reg;
1546
1547     data.d = *i0;
1548 #  if __WORDSIZE == 64 || NEW_ABI
1549     if (data.l) {
1550         if (_jitc->no_data) {
1551             reg = jit_get_reg(jit_class_gpr);
1552             movi64(rn(reg), data.l);
1553             DMTC1(rn(reg), r0);
1554             jit_unget_reg(reg);
1555         }
1556         else
1557             ldi_d(r0, (jit_word_t)i0);
1558     }
1559     else
1560         DMTC1(_ZERO_REGNO, r0);
1561 #  else
1562     if (jit_mips6_p()) {
1563         if (_jitc->no_data) {
1564             reg = jit_get_reg(jit_class_gpr);
1565 #  if __WORDSIZE == 64
1566             movi(rn(reg), data.l);
1567             DMTC1(rn(reg), r0);
1568 #  else
1569             movi(rn(reg), data.i[0 + BE_P]);
1570             MTC1(rn(reg), r0);
1571             movi(rn(reg), data.i[0 + LE_P]);
1572             MTHC1(rn(reg), r0);
1573 #  endif
1574             jit_unget_reg(reg);
1575         }
1576         else
1577             ldi_d(r0, (jit_word_t)i0);
1578     }
1579     else {
1580         if (_jitc->no_data)
1581             reg = jit_get_reg(jit_class_gpr);
1582         if (data.i[0]) {
1583             if (_jitc->no_data) {
1584                 movi(rn(reg), data.i[0]);
1585                 MTC1(rn(reg), r0 + BE_P);
1586             }
1587             else
1588                 ldi_f(r0 + BE_P, (jit_word_t)i0);
1589         }
1590         else
1591             MTC1(_ZERO_REGNO, r0 + BE_P);
1592         if (data.i[1]) {
1593             if (_jitc->no_data) {
1594                 movi(rn(reg), data.i[1]);
1595                 MTC1(rn(reg), r0 + LE_P);
1596             }
1597             else
1598                 ldi_f(r0 + LE_P, ((jit_word_t)i0) + 4);
1599         }
1600         else
1601             MTC1(_ZERO_REGNO, r0 + LE_P);
1602         if (_jitc->no_data)
1603             jit_unget_reg(reg);
1604     }
1605 #  endif
1606 }
1607
1608 static void
1609 _ltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1610 {
1611     jit_word_t          w;
1612     jit_int32_t         reg;
1613     if (jit_mips6_p()) {
1614         reg = jit_get_reg(jit_class_fpr);
1615         CMP_LT_S(rn(reg), r1, r2);
1616         MFC1(r0, rn(reg));
1617         jit_unget_reg(reg);
1618         andi(r0, r0, 1);
1619     }
1620     else {
1621         C_OLT_S(r1, r2);
1622         /* cannot optimize delay slot */
1623         flush();
1624         w = _jit->pc.w;
1625         BC1T(0);
1626         /* delay slot */
1627         movi(r0, 1);
1628         movi(r0, 0);
1629         flush();
1630         patch_at(w, _jit->pc.w);
1631     }
1632 }
1633 fopi(lt)
1634
1635 static void
1636 _ler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1637 {
1638     jit_word_t          w;
1639     jit_int32_t         reg;
1640     if (jit_mips6_p()) {
1641         reg = jit_get_reg(jit_class_fpr);
1642         CMP_LE_S(rn(reg), r1, r2);
1643         MFC1(r0, rn(reg));
1644         jit_unget_reg(reg);
1645         andi(r0, r0, 1);
1646     }
1647     else {
1648         C_OLE_S(r1, r2);
1649         /* cannot optimize delay slot */
1650         flush();
1651         w = _jit->pc.w;
1652         BC1T(0);
1653         /* delay slot */
1654         movi(r0, 1);
1655         movi(r0, 0);
1656         flush();
1657         patch_at(w, _jit->pc.w);
1658     }
1659 }
1660 fopi(le)
1661
1662 static void
1663 _eqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1664 {
1665     jit_word_t          w;
1666     jit_int32_t         reg;
1667     if (jit_mips6_p()) {
1668         reg = jit_get_reg(jit_class_fpr);
1669         CMP_EQ_S(rn(reg), r1, r2);
1670         MFC1(r0, rn(reg));
1671         jit_unget_reg(reg);
1672         andi(r0, r0, 1);
1673     }
1674     else {
1675         C_EQ_S(r1, r2);
1676         /* cannot optimize delay slot */
1677         flush();
1678         w = _jit->pc.w;
1679         BC1T(0);
1680         /* delay slot */
1681         movi(r0, 1);
1682         movi(r0, 0);
1683         flush();
1684         patch_at(w, _jit->pc.w);
1685     }
1686 }
1687 fopi(eq)
1688
1689 static void
1690 _ger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1691 {
1692     jit_word_t          w;
1693     jit_int32_t         reg;
1694     if (jit_mips6_p()) {
1695         reg = jit_get_reg(jit_class_fpr);
1696         CMP_ULT_S(rn(reg), r1, r2);
1697         MFC1(r0, rn(reg));
1698         jit_unget_reg(reg);
1699         addi(r0, r0, 1);
1700     }
1701     else {
1702         C_ULT_S(r1, r2);
1703         /* cannot optimize delay slot */
1704         flush();
1705         w = _jit->pc.w;
1706         BC1F(0);
1707         /* delay slot */
1708         movi(r0, 1);
1709         movi(r0, 0);
1710         flush();
1711         patch_at(w, _jit->pc.w);
1712     }
1713 }
1714 fopi(ge)
1715
1716 static void
1717 _gtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1718 {
1719     jit_word_t          w;
1720     jit_int32_t         reg;
1721     if (jit_mips6_p()) {
1722         reg = jit_get_reg(jit_class_fpr);
1723         CMP_ULE_S(rn(reg), r1, r2);
1724         MFC1(r0, rn(reg));
1725         jit_unget_reg(reg);
1726         addi(r0, r0, 1);
1727     }
1728     else {
1729         C_ULE_S(r1, r2);
1730         /* cannot optimize delay slot */
1731         flush();
1732         w = _jit->pc.w;
1733         BC1F(0);
1734         /* delay slot */
1735         movi(r0, 1);
1736         movi(r0, 0);
1737         flush();
1738         patch_at(w, _jit->pc.w);
1739     }
1740 }
1741 fopi(gt)
1742
1743 static void
1744 _ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1745 {
1746     jit_word_t          w;
1747     jit_int32_t         reg;
1748     if (jit_mips6_p()) {
1749         reg = jit_get_reg(jit_class_fpr);
1750         CMP_EQ_S(rn(reg), r1, r2);
1751         MFC1(r0, rn(reg));
1752         jit_unget_reg(reg);
1753         addi(r0, r0, 1);
1754     }
1755     else {
1756         C_EQ_S(r1, r2);
1757         /* cannot optimize delay slot */
1758         flush();
1759         w = _jit->pc.w;
1760         BC1F(0);
1761         /* delay slot */
1762         movi(r0, 1);
1763         movi(r0, 0);
1764         flush();
1765         patch_at(w, _jit->pc.w);
1766     }
1767 }
1768 fopi(ne)
1769
1770 static void
1771 _unltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1772 {
1773     jit_word_t          w;
1774     jit_int32_t         reg;
1775     if (jit_mips6_p()) {
1776         reg = jit_get_reg(jit_class_fpr);
1777         CMP_ULT_S(rn(reg), r1, r2);
1778         MFC1(r0, rn(reg));
1779         jit_unget_reg(reg);
1780         andi(r0, r0, 1);
1781     }
1782     else {
1783         C_ULT_S(r1, r2);
1784         /* cannot optimize delay slot */
1785         flush();
1786         w = _jit->pc.w;
1787         BC1T(0);
1788         /* delay slot */
1789         movi(r0, 1);
1790         movi(r0, 0);
1791         flush();
1792         patch_at(w, _jit->pc.w);
1793     }
1794 }
1795 fopi(unlt)
1796
1797 static void
1798 _unler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1799 {
1800     jit_word_t          w;
1801     jit_int32_t         reg;
1802     if (jit_mips6_p()) {
1803         reg = jit_get_reg(jit_class_fpr);
1804         CMP_ULE_S(rn(reg), r1, r2);
1805         MFC1(r0, rn(reg));
1806         jit_unget_reg(reg);
1807         andi(r0, r0, 1);
1808     }
1809     else {
1810         C_ULE_S(r1, r2);
1811         /* cannot optimize delay slot */
1812         flush();
1813         w = _jit->pc.w;
1814         BC1T(0);
1815         /* delay slot */
1816         movi(r0, 1);
1817         movi(r0, 0);
1818         flush();
1819         patch_at(w, _jit->pc.w);
1820     }
1821 }
1822 fopi(unle)
1823
1824 static void
1825 _uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1826 {
1827     jit_word_t          w;
1828     jit_int32_t         reg;
1829     if (jit_mips6_p()) {
1830         reg = jit_get_reg(jit_class_fpr);
1831         CMP_UEQ_S(rn(reg), r1, r2);
1832         MFC1(r0, rn(reg));
1833         jit_unget_reg(reg);
1834         andi(r0, r0, 1);
1835     }
1836     else {
1837         C_UEQ_S(r1, r2);
1838         /* cannot optimize delay slot */
1839         flush();
1840         w = _jit->pc.w;
1841         BC1T(0);
1842         /* delay slot */
1843         movi(r0, 1);
1844         movi(r0, 0);
1845         flush();
1846         patch_at(w, _jit->pc.w);
1847     }
1848 }
1849 fopi(uneq)
1850
1851 static void
1852 _unger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1853 {
1854     jit_word_t          w;
1855     jit_int32_t         reg;
1856     if (jit_mips6_p()) {
1857         reg = jit_get_reg(jit_class_fpr);
1858         CMP_LT_S(rn(reg), r1, r2);
1859         MFC1(r0, rn(reg));
1860         jit_unget_reg(reg);
1861         addi(r0, r0, 1);
1862     }
1863     else {
1864         C_OLT_S(r1, r2);
1865         /* cannot optimize delay slot */
1866         flush();
1867         w = _jit->pc.w;
1868         BC1F(0);
1869         /* delay slot */
1870         movi(r0, 1);
1871         movi(r0, 0);
1872         flush();
1873         patch_at(w, _jit->pc.w);
1874     }
1875 }
1876 fopi(unge)
1877
1878 static void
1879 _ungtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1880 {
1881     jit_word_t          w;
1882     jit_int32_t         reg;
1883     if (jit_mips6_p()) {
1884         reg = jit_get_reg(jit_class_fpr);
1885         CMP_LE_S(rn(reg), r1, r2);
1886         MFC1(r0, rn(reg));
1887         jit_unget_reg(reg);
1888         addi(r0, r0, 1);
1889     }
1890     else {
1891         C_OLE_S(r1, r2);
1892         /* cannot optimize delay slot */
1893         flush();
1894         w = _jit->pc.w;
1895         BC1F(0);
1896         /* delay slot */
1897         movi(r0, 1);
1898         movi(r0, 0);
1899         flush();
1900         patch_at(w, _jit->pc.w);
1901     }
1902 }
1903 fopi(ungt)
1904
1905 static void
1906 _ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1907 {
1908     jit_word_t          w;
1909     jit_int32_t         reg;
1910     if (jit_mips6_p()) {
1911         reg = jit_get_reg(jit_class_fpr);
1912         CMP_UEQ_S(rn(reg), r1, r2);
1913         MFC1(r0, rn(reg));
1914         jit_unget_reg(reg);
1915         addi(r0, r0, 1);
1916     }
1917     else {
1918         C_UEQ_S(r1, r2);
1919         /* cannot optimize delay slot */
1920         flush();
1921         w = _jit->pc.w;
1922         BC1F(0);
1923         /* delay slot */
1924         movi(r0, 1);
1925         movi(r0, 0);
1926         flush();
1927         patch_at(w, _jit->pc.w);
1928     }
1929 }
1930 fopi(ltgt)
1931
1932 static void
1933 _ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1934 {
1935     jit_word_t          w;
1936     jit_int32_t         reg;
1937     if (jit_mips6_p()) {
1938         reg = jit_get_reg(jit_class_fpr);
1939         CMP_UN_S(rn(reg), r1, r2);
1940         MFC1(r0, rn(reg));
1941         jit_unget_reg(reg);
1942         addi(r0, r0, 1);
1943     }
1944     else {
1945         C_UN_S(r1, r2);
1946         flush();
1947         /* cannot optimize delay slot */
1948         w = _jit->pc.w;
1949         BC1F(0);
1950         /* delay slot */
1951         movi(r0, 1);
1952         movi(r0, 0);
1953         flush();
1954         patch_at(w, _jit->pc.w);
1955     }
1956 }
1957 fopi(ord)
1958
1959 static void
1960 _unordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1961 {
1962     jit_word_t          w;
1963     jit_int32_t         reg;
1964     if (jit_mips6_p()) {
1965         reg = jit_get_reg(jit_class_fpr);
1966         CMP_UN_S(rn(reg), r1, r2);
1967         MFC1(r0, rn(reg));
1968         jit_unget_reg(reg);
1969         andi(r0, r0, 1);
1970     }
1971     else {
1972         C_UN_S(r1, r2);
1973         /* cannot optimize delay slot */
1974         flush();
1975         w = _jit->pc.w;
1976         BC1T(0);
1977         /* delay slot */
1978         movi(r0, 1);
1979         movi(r0, 0);
1980         flush();
1981         patch_at(w, _jit->pc.w);
1982     }
1983 }
1984 fopi(unord)
1985
1986 static jit_word_t
1987 _bltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1988 {
1989     jit_word_t          w;
1990     jit_int32_t         op, reg;
1991     if (jit_mips6_p()) {
1992         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
1993         op = pending();
1994         CMP_LT_S(rn(reg), r1, r2);
1995         flush();
1996         w = _jit->pc.w;
1997         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
1998     }
1999     else {
2000         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2001         op = pending();
2002         C_OLT_S(r1, r2);
2003         flush();
2004         w = _jit->pc.w;
2005         BC1T(((i0 - w) >> 2) - 1);
2006     }
2007     delay(op);
2008     jit_unget_reg(reg);
2009     return (w);
2010 }
2011 fbopi(lt)
2012
2013 static jit_word_t
2014 _bler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2015 {
2016     jit_word_t          w;
2017     jit_int32_t         op, reg;
2018     if (jit_mips6_p()) {
2019         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2020         op = pending();
2021         CMP_LE_S(rn(reg), r1, r2);
2022         flush();
2023         w = _jit->pc.w;
2024         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2025     }
2026     else {
2027         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2028         op = pending();
2029         C_OLE_S(r1, r2);
2030         flush();
2031         w = _jit->pc.w;
2032         BC1T(((i0 - w) >> 2) - 1);
2033     }
2034     delay(op);
2035     jit_unget_reg(reg);
2036     return (w);
2037 }
2038 fbopi(le)
2039
2040 static jit_word_t
2041 _beqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2042 {
2043     jit_word_t          w;
2044     jit_int32_t         op, reg;
2045     if (jit_mips6_p()) {
2046         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2047         op = pending();
2048         CMP_EQ_S(rn(reg), r1, r2);
2049         flush();
2050         w = _jit->pc.w;
2051         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2052     }
2053     else {
2054         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2055         op = pending();
2056         C_EQ_S(r1, r2);
2057         flush();
2058         w = _jit->pc.w;
2059         BC1T(((i0 - w) >> 2) - 1);
2060     }
2061     delay(op);
2062     jit_unget_reg(reg);
2063     return (w);
2064 }
2065 fbopi(eq)
2066
2067 static jit_word_t
2068 _bger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2069 {
2070     jit_word_t          w;
2071     jit_int32_t         op, reg;
2072     if (jit_mips6_p()) {
2073         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2074         op = pending();
2075         CMP_ULT_S(rn(reg), r1, r2);
2076         flush();
2077         w = _jit->pc.w;
2078         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2079     }
2080     else {
2081         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2082         op = pending();
2083         C_ULT_S(r1, r2);
2084         flush();
2085         w = _jit->pc.w;
2086         BC1F(((i0 - w) >> 2) - 1);
2087     }
2088     delay(op);
2089     jit_unget_reg(reg);
2090     return (w);
2091 }
2092 fbopi(ge)
2093
2094 static jit_word_t
2095 _bgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2096 {
2097     jit_word_t          w;
2098     jit_int32_t         op, reg;
2099     if (jit_mips6_p()) {
2100         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2101         op = pending();
2102         CMP_ULE_S(rn(reg), r1, r2);
2103         flush();
2104         w = _jit->pc.w;
2105         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2106     }
2107     else {
2108         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2109         op = pending();
2110         C_ULE_S(r1, r2);
2111         flush();
2112         w = _jit->pc.w;
2113         BC1F(((i0 - w) >> 2) - 1);
2114     }
2115     delay(op);
2116     jit_unget_reg(reg);
2117     return (w);
2118 }
2119 fbopi(gt)
2120
2121 static jit_word_t
2122 _bner_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2123 {
2124     jit_word_t          w;
2125     jit_int32_t         op, reg;
2126     if (jit_mips6_p()) {
2127         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2128         op = pending();
2129         CMP_EQ_S(rn(reg), r1, r2);
2130         flush();
2131         w = _jit->pc.w;
2132         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2133     }
2134     else {
2135         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2136         op = pending();
2137         C_EQ_S(r1, r2);
2138         flush();
2139         w = _jit->pc.w;
2140         BC1F(((i0 - w) >> 2) - 1);
2141     }
2142     delay(op);
2143     jit_unget_reg(reg);
2144     return (w);
2145 }
2146 fbopi(ne)
2147
2148 static jit_word_t
2149 _bunltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2150 {
2151     jit_word_t          w;
2152     jit_int32_t         op, reg;
2153     if (jit_mips6_p()) {
2154         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2155         op = pending();
2156         CMP_ULT_S(rn(reg), r1, r2);
2157         flush();
2158         w = _jit->pc.w;
2159         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2160     }
2161     else {
2162         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2163         op = pending();
2164         C_ULT_S(r1, r2);
2165         flush();
2166         w = _jit->pc.w;
2167         BC1T(((i0 - w) >> 2) - 1);
2168     }
2169     delay(op);
2170     jit_unget_reg(reg);
2171     return (w);
2172 }
2173 fbopi(unlt)
2174
2175 static jit_word_t
2176 _bunler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2177 {
2178     jit_word_t          w;
2179     jit_int32_t         op, reg;
2180     if (jit_mips6_p()) {
2181         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2182         op = pending();
2183         CMP_ULE_S(rn(reg), r1, r2);
2184         flush();
2185         w = _jit->pc.w;
2186         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2187     }
2188     else {
2189         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2190         op = pending();
2191         C_ULE_S(r1, r2);
2192         flush();
2193         w = _jit->pc.w;
2194         BC1T(((i0 - w) >> 2) - 1);
2195     }
2196     delay(op);
2197     jit_unget_reg(reg);
2198     return (w);
2199 }
2200 fbopi(unle)
2201
2202 static jit_word_t
2203 _buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2204 {
2205     jit_word_t          w;
2206     jit_int32_t         op, reg;
2207     if (jit_mips6_p()) {
2208         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2209         op = pending();
2210         CMP_UEQ_S(rn(reg), r1, r2);
2211         flush();
2212         w = _jit->pc.w;
2213         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2214     }
2215     else {
2216         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2217         op = pending();
2218         C_UEQ_S(r1, r2);
2219         flush();
2220         w = _jit->pc.w;
2221         BC1T(((i0 - w) >> 2) - 1);
2222     }
2223     delay(op);
2224     jit_unget_reg(reg);
2225     return (w);
2226 }
2227 fbopi(uneq)
2228
2229 static jit_word_t
2230 _bunger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2231 {
2232     jit_word_t          w;
2233     jit_int32_t         op, reg;
2234     if (jit_mips6_p()) {
2235         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2236         op = pending();
2237         CMP_LT_S(rn(reg), r1, r2);
2238         flush();
2239         w = _jit->pc.w;
2240         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2241     }
2242     else {
2243         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2244         op = pending();
2245         C_OLT_S(r1, r2);
2246         flush();
2247         w = _jit->pc.w;
2248         BC1F(((i0 - w) >> 2) - 1);
2249     }
2250     delay(op);
2251     jit_unget_reg(reg);
2252     return (w);
2253 }
2254 fbopi(unge)
2255
2256 static jit_word_t
2257 _bungtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2258 {
2259     jit_word_t          w;
2260     jit_int32_t         op, reg;
2261     if (jit_mips6_p()) {
2262         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2263         op = pending();
2264         CMP_LE_S(rn(reg), r1, r2);
2265         flush();
2266         w = _jit->pc.w;
2267         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2268     }
2269     else {
2270         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2271         op = pending();
2272         C_OLE_S(r1, r2);
2273         flush();
2274         w = _jit->pc.w;
2275         BC1F(((i0 - w) >> 2) - 1);
2276     }
2277     delay(op);
2278     jit_unget_reg(reg);
2279     return (w);
2280 }
2281 fbopi(ungt)
2282
2283 static jit_word_t
2284 _bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2285 {
2286     jit_word_t          w;
2287     jit_int32_t         op, reg;
2288     if (jit_mips6_p()) {
2289         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2290         op = pending();
2291         CMP_UEQ_S(rn(reg), r1, r2);
2292         flush();
2293         w = _jit->pc.w;
2294         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2295     }
2296     else {
2297         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2298         op = pending();
2299         C_UEQ_S(r1, r2);
2300         flush();
2301         w = _jit->pc.w;
2302         BC1F(((i0 - w) >> 2) - 1);
2303     }
2304     delay(op);
2305     jit_unget_reg(reg);
2306     return (w);
2307 }
2308 fbopi(ltgt)
2309
2310 static jit_word_t
2311 _bordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2312 {
2313     jit_word_t          w;
2314     jit_int32_t         op, reg;
2315     if (jit_mips6_p()) {
2316         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2317         op = pending();
2318         CMP_UN_S(rn(reg), r1, r2);
2319         flush();
2320         w = _jit->pc.w;
2321         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2322     }
2323     else {
2324         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2325         op = pending();
2326         C_UN_S(r1, r2);
2327         flush();
2328         w = _jit->pc.w;
2329         BC1F(((i0 - w) >> 2) - 1);
2330     }
2331     delay(op);
2332     jit_unget_reg(reg);
2333     return (w);
2334 }
2335 fbopi(ord)
2336
2337 static jit_word_t
2338 _bunordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2339 {
2340     jit_word_t          w;
2341     jit_int32_t         op, reg;
2342     if (jit_mips6_p()) {
2343         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2344         op = pending();
2345         CMP_UN_S(rn(reg), r1, r2);
2346         flush();
2347         w = _jit->pc.w;
2348         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2349     }
2350     else {
2351         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2352         op = pending();
2353         C_UN_S(r1, r2);
2354         flush();
2355         w = _jit->pc.w;
2356         BC1T(((i0 - w) >> 2) - 1);
2357     }
2358     delay(op);
2359     jit_unget_reg(reg);
2360     return (w);
2361 }
2362 fbopi(unord)
2363
2364 static void
2365 _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2366 {
2367     jit_word_t          w;
2368     jit_int32_t         reg;
2369     if (jit_mips6_p()) {
2370         reg = jit_get_reg(jit_class_fpr);
2371         CMP_LT_D(rn(reg), r1, r2);
2372         MFC1(r0, rn(reg));
2373         jit_unget_reg(reg);
2374         andi(r0, r0, 1);
2375     }
2376     else {
2377         C_OLT_D(r1, r2);
2378         /* cannot optimize delay slot */
2379         flush();
2380         w = _jit->pc.w;
2381         BC1T(0);
2382         /* delay slot */
2383         movi(r0, 1);
2384         movi(r0, 0);
2385         flush();
2386         patch_at(w, _jit->pc.w);
2387     }
2388 }
2389 dopi(lt)
2390
2391 static void
2392 _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2393 {
2394     jit_word_t          w;
2395     jit_int32_t         reg;
2396     if (jit_mips6_p()) {
2397         reg = jit_get_reg(jit_class_fpr);
2398         CMP_LE_D(rn(reg), r1, r2);
2399         MFC1(r0, rn(reg));
2400         jit_unget_reg(reg);
2401         andi(r0, r0, 1);
2402     }
2403     else {
2404         C_OLE_D(r1, r2);
2405         /* cannot optimize delay slot */
2406         flush();
2407         w = _jit->pc.w;
2408         BC1T(0);
2409         /* delay slot */
2410         movi(r0, 1);
2411         movi(r0, 0);
2412         flush();
2413         patch_at(w, _jit->pc.w);
2414     }
2415 }
2416 dopi(le)
2417
2418 static void
2419 _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2420 {
2421     jit_word_t          w;
2422     jit_int32_t         reg;
2423     if (jit_mips6_p()) {
2424         reg = jit_get_reg(jit_class_fpr);
2425         CMP_EQ_D(rn(reg), r1, r2);
2426         MFC1(r0, rn(reg));
2427         jit_unget_reg(reg);
2428         andi(r0, r0, 1);
2429     }
2430     else {
2431         C_EQ_D(r1, r2);
2432         /* cannot optimize delay slot */
2433         flush();
2434         w = _jit->pc.w;
2435         BC1T(0);
2436         /* delay slot */
2437         movi(r0, 1);
2438         movi(r0, 0);
2439         flush();
2440         patch_at(w, _jit->pc.w);
2441     }
2442 }
2443 dopi(eq)
2444
2445 static void
2446 _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2447 {
2448     jit_word_t          w;
2449     jit_int32_t         reg;
2450     if (jit_mips6_p()) {
2451         reg = jit_get_reg(jit_class_fpr);
2452         CMP_ULT_D(rn(reg), r1, r2);
2453         MFC1(r0, rn(reg));
2454         jit_unget_reg(reg);
2455         addi(r0, r0, 1);
2456     }
2457     else {
2458         C_ULT_D(r1, r2);
2459         /* cannot optimize delay slot */
2460         flush();
2461         w = _jit->pc.w;
2462         BC1F(0);
2463         /* delay slot */
2464         movi(r0, 1);
2465         movi(r0, 0);
2466         flush();
2467         patch_at(w, _jit->pc.w);
2468     }
2469 }
2470 dopi(ge)
2471
2472 static void
2473 _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2474 {
2475     jit_word_t          w;
2476     jit_int32_t         reg;
2477     if (jit_mips6_p()) {
2478         reg = jit_get_reg(jit_class_fpr);
2479         CMP_ULE_D(rn(reg), r1, r2);
2480         MFC1(r0, rn(reg));
2481         jit_unget_reg(reg);
2482         addi(r0, r0, 1);
2483     }
2484     else {
2485         C_ULE_D(r1, r2);
2486         /* cannot optimize delay slot */
2487         flush();
2488         w = _jit->pc.w;
2489         BC1F(0);
2490         /* delay slot */
2491         movi(r0, 1);
2492         movi(r0, 0);
2493         flush();
2494         patch_at(w, _jit->pc.w);
2495     }
2496 }
2497 dopi(gt)
2498
2499 static void
2500 _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2501 {
2502     jit_word_t          w;
2503     jit_int32_t         reg;
2504     if (jit_mips6_p()) {
2505         reg = jit_get_reg(jit_class_fpr);
2506         CMP_EQ_D(rn(reg), r1, r2);
2507         MFC1(r0, rn(reg));
2508         jit_unget_reg(reg);
2509         addi(r0, r0, 1);
2510     }
2511     else {
2512         C_EQ_D(r1, r2);
2513         /* cannot optimize delay slot */
2514         flush();
2515         w = _jit->pc.w;
2516         BC1F(0);
2517         /* delay slot */
2518         movi(r0, 1);
2519         movi(r0, 0);
2520         flush();
2521         patch_at(w, _jit->pc.w);
2522     }
2523 }
2524 dopi(ne)
2525
2526 static void
2527 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2528 {
2529     jit_word_t          w;
2530     jit_int32_t         reg;
2531     if (jit_mips6_p()) {
2532         reg = jit_get_reg(jit_class_fpr);
2533         CMP_ULT_D(rn(reg), r1, r2);
2534         MFC1(r0, rn(reg));
2535         jit_unget_reg(reg);
2536         andi(r0, r0, 1);
2537     }
2538     else {
2539         C_ULT_D(r1, r2);
2540         /* cannot optimize delay slot */
2541         flush();
2542         w = _jit->pc.w;
2543         BC1T(0);
2544         /* delay slot */
2545         movi(r0, 1);
2546         movi(r0, 0);
2547         flush();
2548         patch_at(w, _jit->pc.w);
2549     }
2550 }
2551 dopi(unlt)
2552
2553 static void
2554 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2555 {
2556     jit_word_t          w;
2557     jit_int32_t         reg;
2558     if (jit_mips6_p()) {
2559         reg = jit_get_reg(jit_class_fpr);
2560         CMP_ULE_D(rn(reg), r1, r2);
2561         MFC1(r0, rn(reg));
2562         jit_unget_reg(reg);
2563         andi(r0, r0, 1);
2564     }
2565     else {
2566         C_ULE_D(r1, r2);
2567         /* cannot optimize delay slot */
2568         flush();
2569         w = _jit->pc.w;
2570         BC1T(0);
2571         /* delay slot */
2572         movi(r0, 1);
2573         movi(r0, 0);
2574         flush();
2575         patch_at(w, _jit->pc.w);
2576     }
2577 }
2578 dopi(unle)
2579
2580 static void
2581 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2582 {
2583     jit_word_t          w;
2584     jit_int32_t         reg;
2585     if (jit_mips6_p()) {
2586         reg = jit_get_reg(jit_class_fpr);
2587         CMP_UEQ_D(rn(reg), r1, r2);
2588         MFC1(r0, rn(reg));
2589         jit_unget_reg(reg);
2590         andi(r0, r0, 1);
2591     }
2592     else {
2593         C_UEQ_D(r1, r2);
2594         /* cannot optimize delay slot */
2595         flush();
2596         w = _jit->pc.w;
2597         BC1T(0);
2598         /* delay slot */
2599         movi(r0, 1);
2600         movi(r0, 0);
2601         flush();
2602         patch_at(w, _jit->pc.w);
2603     }
2604 }
2605 dopi(uneq)
2606
2607 static void
2608 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2609 {
2610     jit_word_t          w;
2611     jit_int32_t         reg;
2612     if (jit_mips6_p()) {
2613         reg = jit_get_reg(jit_class_fpr);
2614         CMP_LT_D(rn(reg), r1, r2);
2615         MFC1(r0, rn(reg));
2616         jit_unget_reg(reg);
2617         addi(r0, r0, 1);
2618     }
2619     else {
2620         C_OLT_D(r1, r2);
2621         /* cannot optimize delay slot */
2622         flush();
2623         w = _jit->pc.w;
2624         BC1F(0);
2625         /* delay slot */
2626         movi(r0, 1);
2627         movi(r0, 0);
2628         flush();
2629         patch_at(w, _jit->pc.w);
2630     }
2631 }
2632 dopi(unge)
2633
2634 static void
2635 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2636 {
2637     jit_word_t          w;
2638     jit_int32_t         reg;
2639     if (jit_mips6_p()) {
2640         reg = jit_get_reg(jit_class_fpr);
2641         CMP_LE_D(rn(reg), r1, r2);
2642         MFC1(r0, rn(reg));
2643         jit_unget_reg(reg);
2644         addi(r0, r0, 1);
2645     }
2646     else {
2647         C_OLE_D(r1, r2);
2648         /* cannot optimize delay slot */
2649         flush();
2650         w = _jit->pc.w;
2651         BC1F(0);
2652         /* delay slot */
2653         movi(r0, 1);
2654         movi(r0, 0);
2655         flush();
2656         patch_at(w, _jit->pc.w);
2657     }
2658 }
2659 dopi(ungt)
2660
2661 static void
2662 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2663 {
2664     jit_word_t          w;
2665     jit_int32_t         reg;
2666     if (jit_mips6_p()) {
2667         reg = jit_get_reg(jit_class_fpr);
2668         CMP_UEQ_D(rn(reg), r1, r2);
2669         MFC1(r0, rn(reg));
2670         jit_unget_reg(reg);
2671         addi(r0, r0, 1);
2672     }
2673     else {
2674         C_UEQ_D(r1, r2);
2675         /* cannot optimize delay slot */
2676         flush();
2677         w = _jit->pc.w;
2678         BC1F(0);
2679         /* delay slot */
2680         movi(r0, 1);
2681         movi(r0, 0);
2682         flush();
2683         patch_at(w, _jit->pc.w);
2684     }
2685 }
2686 dopi(ltgt)
2687
2688 static void
2689 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2690 {
2691     jit_word_t          w;
2692     jit_int32_t         reg;
2693     if (jit_mips6_p()) {
2694         reg = jit_get_reg(jit_class_fpr);
2695         CMP_UN_D(rn(reg), r1, r2);
2696         MFC1(r0, rn(reg));
2697         jit_unget_reg(reg);
2698         addi(r0, r0, 1);
2699     }
2700     else {
2701         C_UN_D(r1, r2);
2702         /* cannot optimize delay slot */
2703         flush();
2704         w = _jit->pc.w;
2705         BC1F(0);
2706         /* delay slot */
2707         movi(r0, 1);
2708         movi(r0, 0);
2709         flush();
2710         patch_at(w, _jit->pc.w);
2711     }
2712 }
2713 dopi(ord)
2714
2715 static void
2716 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2717 {
2718     jit_word_t          w;
2719     jit_int32_t         reg;
2720     if (jit_mips6_p()) {
2721         reg = jit_get_reg(jit_class_fpr);
2722         CMP_UN_D(rn(reg), r1, r2);
2723         MFC1(r0, rn(reg));
2724         jit_unget_reg(reg);
2725         andi(r0, r0, 1);
2726     }
2727     else {
2728         C_UN_D(r1, r2);
2729         /* cannot optimize delay slot */
2730         flush();
2731         w = _jit->pc.w;
2732         BC1T(0);
2733         /* delay slot */
2734         movi(r0, 1);
2735         movi(r0, 0);
2736         flush();
2737         patch_at(w, _jit->pc.w);
2738     }
2739 }
2740 dopi(unord)
2741
2742 static jit_word_t
2743 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2744 {
2745     jit_word_t          w;
2746     jit_int32_t         op, reg;
2747     if (jit_mips6_p()) {
2748         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2749         op = pending();
2750         CMP_LT_D(rn(reg), r1, r2);
2751         flush();
2752         w = _jit->pc.w;
2753         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2754     }
2755     else {
2756         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2757         op = pending();
2758         C_OLT_D(r1, r2);
2759         flush();
2760         w = _jit->pc.w;
2761         BC1T(((i0 - w) >> 2) - 1);
2762     }
2763     delay(op);
2764     jit_unget_reg(reg);
2765     return (w);
2766 }
2767 dbopi(lt)
2768
2769 static jit_word_t
2770 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2771 {
2772     jit_word_t          w;
2773     jit_int32_t         op, reg;
2774     if (jit_mips6_p()) {
2775         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2776         op = pending();
2777         CMP_LE_D(rn(reg), r1, r2);
2778         flush();
2779         w = _jit->pc.w;
2780         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2781     }
2782     else {
2783         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2784         op = pending();
2785         C_OLE_D(r1, r2);
2786         flush();
2787         w = _jit->pc.w;
2788         BC1T(((i0 - w) >> 2) - 1);
2789     }
2790     delay(op);
2791     jit_unget_reg(reg);
2792     return (w);
2793 }
2794 dbopi(le)
2795
2796 static jit_word_t
2797 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2798 {
2799     jit_word_t          w;
2800     jit_int32_t         op, reg;
2801     if (jit_mips6_p()) {
2802         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2803         op = pending();
2804         CMP_EQ_D(rn(reg), r1, r2);
2805         flush();
2806         w = _jit->pc.w;
2807         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2808     }
2809     else {
2810         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2811         op = pending();
2812         C_EQ_D(r1, r2);
2813         flush();
2814         w = _jit->pc.w;
2815         BC1T(((i0 - w) >> 2) - 1);
2816     }
2817     delay(op);
2818     jit_unget_reg(reg);
2819     return (w);
2820 }
2821 dbopi(eq)
2822
2823 static jit_word_t
2824 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2825 {
2826     jit_word_t          w;
2827     jit_int32_t         op, reg;
2828     if (jit_mips6_p()) {
2829         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2830         op = pending();
2831         CMP_ULT_D(rn(reg), r1, r2);
2832         flush();
2833         w = _jit->pc.w;
2834         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2835     }
2836     else {
2837         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2838         op = pending();
2839         C_ULT_D(r1, r2);
2840         flush();
2841         w = _jit->pc.w;
2842         BC1F(((i0 - w) >> 2) - 1);
2843     }
2844     delay(op);
2845     jit_unget_reg(reg);
2846     return (w);
2847 }
2848 dbopi(ge)
2849
2850 static jit_word_t
2851 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2852 {
2853     jit_word_t          w;
2854     jit_int32_t         op, reg;
2855     if (jit_mips6_p()) {
2856         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2857         op = pending();
2858         CMP_ULE_D(rn(reg), r1, r2);
2859         flush();
2860         w = _jit->pc.w;
2861         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2862     }
2863     else {
2864         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2865         op = pending();
2866         C_ULE_D(r1, r2);
2867         flush();
2868         w = _jit->pc.w;
2869         BC1F(((i0 - w) >> 2) - 1);
2870     }
2871     delay(op);
2872     jit_unget_reg(reg);
2873     return (w);
2874 }
2875 dbopi(gt)
2876
2877 static jit_word_t
2878 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2879 {
2880     jit_word_t          w;
2881     jit_int32_t         op, reg;
2882     if (jit_mips6_p()) {
2883         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2884         op = pending();
2885         CMP_EQ_D(rn(reg), r1, r2);
2886         flush();
2887         w = _jit->pc.w;
2888         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2889     }
2890     else {
2891         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2892         op = pending();
2893         C_EQ_D(r1, r2);
2894         flush();
2895         w = _jit->pc.w;
2896         BC1F(((i0 - w) >> 2) - 1);
2897     }
2898     delay(op);
2899     jit_unget_reg(reg);
2900     return (w);
2901 }
2902 dbopi(ne)
2903
2904 static jit_word_t
2905 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2906 {
2907     jit_word_t          w;
2908     jit_int32_t         op, reg;
2909     if (jit_mips6_p()) {
2910         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2911         op = pending();
2912         CMP_ULT_D(rn(reg), r1, r2);
2913         flush();
2914         w = _jit->pc.w;
2915         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2916     }
2917     else {
2918         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2919         op = pending();
2920         C_ULT_D(r1, r2);
2921         flush();
2922         w = _jit->pc.w;
2923         BC1T(((i0 - w) >> 2) - 1);
2924     }
2925     delay(op);
2926     jit_unget_reg(reg);
2927     return (w);
2928 }
2929 dbopi(unlt)
2930
2931 static jit_word_t
2932 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2933 {
2934     jit_word_t          w;
2935     jit_int32_t         op, reg;
2936     if (jit_mips6_p()) {
2937         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2938         op = pending();
2939         CMP_ULE_D(rn(reg), r1, r2);
2940         flush();
2941         w = _jit->pc.w;
2942         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2943     }
2944     else {
2945         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2946         op = pending();
2947         C_ULE_D(r1, r2);
2948         flush();
2949         w = _jit->pc.w;
2950         BC1T(((i0 - w) >> 2) - 1);
2951     }
2952     delay(op);
2953     jit_unget_reg(reg);
2954     return (w);
2955 }
2956 dbopi(unle)
2957
2958 static jit_word_t
2959 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2960 {
2961     jit_word_t          w;
2962     jit_int32_t         op, reg;
2963     if (jit_mips6_p()) {
2964         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2965         op = pending();
2966         CMP_UEQ_D(rn(reg), r1, r2);
2967         flush();
2968         w = _jit->pc.w;
2969         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
2970     }
2971     else {
2972         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
2973         op = pending();
2974         C_UEQ_D(r1, r2);
2975         flush();
2976         w = _jit->pc.w;
2977         BC1T(((i0 - w) >> 2) - 1);
2978     }
2979     delay(op);
2980     jit_unget_reg(reg);
2981     return (w);
2982 }
2983 dbopi(uneq)
2984
2985 static jit_word_t
2986 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
2987 {
2988     jit_word_t          w;
2989     jit_int32_t         op, reg;
2990     if (jit_mips6_p()) {
2991         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
2992         op = pending();
2993         CMP_LT_D(rn(reg), r1, r2);
2994         flush();
2995         w = _jit->pc.w;
2996         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
2997     }
2998     else {
2999         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
3000         op = pending();
3001         C_OLT_D(r1, r2);
3002         flush();
3003         w = _jit->pc.w;
3004         BC1F(((i0 - w) >> 2) - 1);
3005     }
3006     delay(op);
3007     jit_unget_reg(reg);
3008     return (w);
3009 }
3010 dbopi(unge)
3011
3012 static jit_word_t
3013 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
3014 {
3015     jit_word_t          w;
3016     jit_int32_t         op, reg;
3017     if (jit_mips6_p()) {
3018         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
3019         op = pending();
3020         CMP_LE_D(rn(reg), r1, r2);
3021         flush();
3022         w = _jit->pc.w;
3023         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
3024     }
3025     else {
3026         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
3027         op = pending();
3028         C_OLE_D(r1, r2);
3029         flush();
3030         w = _jit->pc.w;
3031         BC1F(((i0 - w) >> 2) - 1);
3032     }
3033     delay(op);
3034     jit_unget_reg(reg);
3035     return (w);
3036 }
3037 dbopi(ungt)
3038
3039 static jit_word_t
3040 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
3041 {
3042     jit_word_t          w;
3043     jit_int32_t         op, reg;
3044     if (jit_mips6_p()) {
3045         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
3046         op = pending();
3047         CMP_UEQ_D(rn(reg), r1, r2);
3048         flush();
3049         w = _jit->pc.w;
3050         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
3051     }
3052     else {
3053         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
3054         op = pending();
3055         C_UEQ_D(r1, r2);
3056         flush();
3057         w = _jit->pc.w;
3058         BC1F(((i0 - w) >> 2) - 1);
3059     }
3060     delay(op);
3061     jit_unget_reg(reg);
3062     return (w);
3063 }
3064 dbopi(ltgt)
3065
3066 static jit_word_t
3067 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
3068 {
3069     jit_word_t          w;
3070     jit_int32_t         op, reg;
3071     if (jit_mips6_p()) {
3072         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
3073         op = pending();
3074         CMP_UN_D(rn(reg), r1, r2);
3075         flush();
3076         w = _jit->pc.w;
3077         BC1EQZ(rn(reg), ((i0 - w) >> 2) - 1);
3078     }
3079     else {
3080         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
3081         op = pending();
3082         C_UN_D(r1, r2);
3083         flush();
3084         w = _jit->pc.w;
3085         BC1F(((i0 - w) >> 2) - 1);
3086     }
3087     delay(op);
3088     jit_unget_reg(reg);
3089     return (w);
3090 }
3091 dbopi(ord)
3092
3093 static jit_word_t
3094 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
3095 {
3096     jit_word_t          w;
3097     jit_int32_t         op, reg;
3098     if (jit_mips6_p()) {
3099         reg = jit_get_reg_for_delay_slot(jit_class_fpr, r1, r2);
3100         op = pending();
3101         CMP_UN_D(rn(reg), r1, r2);
3102         flush();
3103         w = _jit->pc.w;
3104         BC1NEZ(rn(reg), ((i0 - w) >> 2) - 1);
3105     }
3106     else {
3107         reg = jit_get_reg_for_delay_slot(jit_class_fpr|jit_class_chk, r1, r2);
3108         op = pending();
3109         C_UN_D(r1, r2);
3110         flush();
3111         w = _jit->pc.w;
3112         BC1T(((i0 - w) >> 2) - 1);
3113     }
3114     delay(op);
3115     jit_unget_reg(reg);
3116     return (w);
3117 }
3118 dbopi(unord)
3119
3120 static void
3121 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3122 {
3123 #if !NEW_ABI
3124     jit_int32_t         reg;
3125 #endif
3126     assert(_jitc->function->self.call & jit_call_varargs);
3127 #if !NEW_ABI
3128     /* Align, if required. */
3129     reg = jit_get_reg(jit_class_gpr);
3130     andi(rn(reg), r1, 7);
3131     addr(r1, r1, rn(reg));
3132     jit_unget_reg(reg);
3133 #endif
3134
3135     /* Load argument. */
3136     ldr_d(r0, r1);
3137
3138     /* Update va_list. */
3139     addi(r1, r1, sizeof(jit_float64_t));
3140 }
3141
3142 #  undef fopi
3143 #  undef fbopi
3144 #  undef dopi
3145 #  undef dbopi
3146 #  undef fpr_bopi
3147 #  undef fpr_opi
3148 #endif