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