deps/lightning/lib/jit_mips-fpu.c

   1 /*
   2  * Copyright (C) 2012-2022  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_ADD_fmt                  0x00
  31 #  define MIPS_LWXC1                    0x00
  32 #  define MIPS_SUB_fmt                  0x01
  33 #  define MIPS_LDXC1                    0x01
  34 #  define MIPS_MUL_fmt                  0x02
  35 #  define MIPS_DIV_fmt                  0x03
  36 #  define MIPS_SQRT_fmt                 0x04
  37 #  define MIPS_ABS_fmt                  0x05
  38 #  define MIPS_LUXC1                    0x05
  39 #  define MIPS_MOV_fmt                  0x06
  40 #  define MIPS_NEG_fmt                  0x07
  41 #  define MIPS_SWXC1                    0x08
  42 #  define MIPS_ROUND_fmt_L              0x08
  43 #  define MIPS_TRUNC_fmt_L              0x09
  44 #  define MIPS_SDXC1                    0x09
  45 #  define MIPS_CEIL_fmt_L               0x0a
  46 #  define MIPS_FLOOR_fmt_L              0x0b
  47 #  define MIPS_ROUND_fmt_W              0x0c
  48 #  define MIPS_TRUNC_fmt_W              0x0d
  49 #  define MIPS_SUXC1                    0x0d
  50 #  define MIPS_CEIL_fmt_W               0x0e
  51 #  define MIPS_FLOOR_fmt_W              0x0f
  52 #  define MIPS_RECIP                    0x15
  53 #  define MIPS_RSQRT                    0x16
  54 #  define MIPS_ALNV_PS                  0x1e
  55 #  define MIPS_CVT_fmt_S                0x20
  56 #  define MIPS_CVT_fmt_D                0x21
  57 #  define MIPS_CVT_fmt_W                0x24
  58 #  define MIPS_CVT_fmt_L                0x25
  59 #  define MIPS_PLL                      0x2c
  60 #  define MIPS_PLU                      0x2d
  61 #  define MIPS_PUL                      0x2e
  62 #  define MIPS_PUU                      0x2f
  63 #  define MIPS_MADD_fmt_S               (0x20 | MIPS_fmt_S)
  64 #  define MIPS_MADD_fmt_D               (0x20 | MIPS_fmt_D)
  65 #  define MIPS_MADD_fmt_PS              (0x20 | MIPS_fmt_PS)
  66 #  define MIPS_MSUB_fmt_S               (0x28 | MIPS_fmt_S)
  67 #  define MIPS_MSUB_fmt_D               (0x28 | MIPS_fmt_D)
  68 #  define MIPS_MSUB_fmt_PS              (0x28 | MIPS_fmt_PS)
  69 #  define MIPS_NMADD_fmt_S              (0x30 | MIPS_fmt_S)
  70 #  define MIPS_NMADD_fmt_D              (0x30 | MIPS_fmt_D)
  71 #  define MIPS_NMADD_fmt_PS             (0x30 | MIPS_fmt_PS)
  72 #  define MIPS_NMSUB_fmt_S              (0x38 | MIPS_fmt_S)
  73 #  define MIPS_NMSUB_fmt_D              (0x38 | MIPS_fmt_D)
  74 #  define MIPS_NMSUB_fmt_PS             (0x38 | MIPS_fmt_PS)
  75 #  define MIPS_cond_F                   0x30
  76 #  define MIPS_cond_UN                  0x31
  77 #  define MIPS_cond_EQ                  0x32
  78 #  define MIPS_cond_UEQ                 0x33
  79 #  define MIPS_cond_OLT                 0x34
  80 #  define MIPS_cond_ULT                 0x35
  81 #  define MIPS_cond_OLE                 0x36
  82 #  define MIPS_cond_ULE                 0x37
  83 #  define MIPS_cond_SF                  0x38
  84 #  define MIPS_cond_NGLE                0x39
  85 #  define MIPS_cond_SEQ                 0x3a
  86 #  define MIPS_cond_NGL                 0x3b
  87 #  define MIPS_cond_LT                  0x3c
  88 #  define MIPS_cond_NGE                 0x3d
  89 #  define MIPS_cond_LE                  0x3e
  90 #  define MIPS_cond_UGT                 0x3f
  91 #  define ADD_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_ADD_fmt)
  92 #  define ADD_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_ADD_fmt)
  93 #  define SUB_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_SUB_fmt)
  94 #  define SUB_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_SUB_fmt)
  95 #  define MUL_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_MUL_fmt)
  96 #  define MUL_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_MUL_fmt)
  97 #  define DIV_S(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_DIV_fmt)
  98 #  define DIV_D(fd,fs,ft)               hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_DIV_fmt)
  99 #  define ABS_S(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_ABS_fmt)
 100 #  define ABS_D(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_ABS_fmt)
 101 #  define NEG_S(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_NEG_fmt)
 102 #  define NEG_D(fd,fs)                  hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_NEG_fmt)
 103 #  define SQRT_S(fd,fs)                 hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_SQRT_fmt)
 104 #  define SQRT_D(fd,fs)                 hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_SQRT_fmt)
 105 #  define MFC1(rt, fs)                  hrrrit(MIPS_COP1,MIPS_MF,rt,fs,0,0)
 106 #  define MTC1(rt, fs)                  hrrrit(MIPS_COP1,MIPS_MT,rt,fs,0,0)
 107 #  define DMFC1(rt, fs)                 hrrrit(MIPS_COP1,MIPS_DMF,rt,fs,0,0)
 108 #  define DMTC1(rt, fs)                 hrrrit(MIPS_COP1,MIPS_DMT,rt,fs,0,0)
 109 #  define CVT_D_S(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_D)
 110 #  define CVT_D_W(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_W,0,fs,fd,MIPS_CVT_fmt_D)
 111 #  define CVT_D_L(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_L,0,fs,fd,MIPS_CVT_fmt_D)
 112 #  define CVT_L_S(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_L)
 113 #  define CVT_L_D(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_CVT_fmt_L)
 114 #  define CVT_PS_S(fd,fs)               hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_PS)
 115 #  define CVT_S_D(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_CVT_fmt_S)
 116 #  define CVT_S_W(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_W,0,fs,fd,MIPS_CVT_fmt_S)
 117 #  define CVT_S_L(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_L,0,fs,fd,MIPS_CVT_fmt_S)
 118 #  define CVT_S_PL(fd,fs)               hrrrit(MIPS_COP1,MIPS_fmt_PS,0,fs,fd,MIPS_CVT_fmt_S_PL)
 119 #  define CVT_S_PU(fd,fs)               hrrrit(MIPS_COP1,MIPS_fmt_PS,0,fs,fd,MIPS_CVT_fmt_S_PU)
 120 #  define CVT_W_S(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_CVT_fmt_W)
 121 #  define CVT_W_D(fd,fs)                hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_CVT_fmt_W)
 122 #  define TRUNC_L_S(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_TRUNC_fmt_L)
 123 #  define TRUNC_L_D(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_TRUNC_fmt_L)
 124 #  define TRUNC_W_S(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_TRUNC_fmt_W)
 125 #  define TRUNC_W_D(fd,fs)              hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_TRUNC_fmt_W)
 126 #  define LWC1(rt, of, rb)              hrri(MIPS_LWC1, rb, rt, of)
 127 #  define SWC1(rt, of, rb)              hrri(MIPS_SWC1, rb, rt, of)
 128 #  define LDC1(rt, of, rb)              hrri(MIPS_LDC1, rb, rt, of)
 129 #  define SDC1(rt, of, rb)              hrri(MIPS_SDC1, rb, rt, of)
 130 #  define MOV_S(fd, fs)                 hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_MOV_fmt)
 131 #  define MOV_D(fd, fs)                 hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_MOV_fmt)
 132 #  define BC1F(im)                      hrri(MIPS_COP1,MIPS_BC,MIPS_BCF,im)
 133 #  define BC1T(im)                      hrri(MIPS_COP1,MIPS_BC,MIPS_BCT,im)
 134 #  define C_F_S(fs,ft)                  c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_F)
 135 #  define C_F_D(fs,ft)                  c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_F)
 136 #  define C_F_PS(fs,ft)                 c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_F)
 137 #  define C_UN_S(fs,ft)                 c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_UN)
 138 #  define C_UN_D(fs,ft)                 c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_UN)
 139 #  define C_UN_PS(fs,ft)                c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UN)
 140 #  define C_EQ_S(fs,ft)                 c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_EQ)
 141 #  define C_EQ_D(fs,ft)                 c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_EQ)
 142 #  define C_EQ_PS(fs,ft)                c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_EQ)
 143 #  define C_UEQ_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_UEQ)
 144 #  define C_UEQ_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_UEQ)
 145 #  define C_UEQ_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UEQ)
 146 #  define C_OLT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_OLT)
 147 #  define C_OLT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_OLT)
 148 #  define C_OLT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_OLT)
 149 #  define C_ULT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_ULT)
 150 #  define C_ULT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_ULT)
 151 #  define C_ULT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_ULT)
 152 #  define C_OLE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_OLE)
 153 #  define C_OLE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_OLE)
 154 #  define C_OLE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_OLE)
 155 #  define C_ULE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_ULE)
 156 #  define C_ULE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_ULE)
 157 #  define C_ULE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_ULE)
 158 #  define C_SF_S(fs,ft)                 c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_SF)
 159 #  define C_SF_D(fs,ft)                 c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_SF)
 160 #  define C_SF_PS(fs,ft)                c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_SF)
 161 #  define C_NGLE_S(fs,ft)               c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NGLE)
 162 #  define C_NGLE_D(fs,ft)               c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NGLE)
 163 #  define C_NGLE_PS(fs,ft)              c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NGLE)
 164 #  define C_SEQ_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_SEQ)
 165 #  define C_SEQ_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_SEQ)
 166 #  define C_SEQ_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_SEQ)
 167 #  define C_NGL_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NGL)
 168 #  define C_NGL_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NGL)
 169 #  define C_NGL_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NGL)
 170 #  define C_NLT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NLT)
 171 #  define C_NLT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NLT)
 172 #  define C_NLT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NLT)
 173 #  define C_NGE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NGE)
 174 #  define C_NGE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NGE)
 175 #  define C_NGE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NGE)
 176 #  define C_NLE_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_NLE)
 177 #  define C_NLE_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_NLE)
 178 #  define C_NLE_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_NLE)
 179 #  define C_UGT_S(fs,ft)                c_cond_fmt(MIPS_fmt_S,ft,fs,MIPS_cond_UGT)
 180 #  define C_UGT_D(fs,ft)                c_cond_fmt(MIPS_fmt_D,ft,fs,MIPS_cond_UGT)
 181 #  define C_UGT_PS(fs,ft)               c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UGT)
 182 #  define c_cond_fmt(fm,ft,fs,cc)       _c_cond_fmt(_jit,fm,ft,fs,cc)
 183 static void
 184 _c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
 185             jit_int32_t ft, jit_int32_t fs, jit_int32_t cc);
 186 #  define addr_f(r0,r1,r2)              ADD_S(r0,r1,r2)
 187 #  define addi_f(r0,r1,i0)              _addi_f(_jit,r0,r1,i0)
 188 static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 189 #  define addr_d(r0,r1,r2)              ADD_D(r0,r1,r2)
 190 #  define addi_d(r0,r1,i0)              _addi_d(_jit,r0,r1,i0)
 191 static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 192 #  define subr_f(r0,r1,r2)              SUB_S(r0,r1,r2)
 193 #  define subi_f(r0,r1,i0)              _subi_f(_jit,r0,r1,i0)
 194 static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 195 #  define subr_d(r0,r1,r2)              SUB_D(r0,r1,r2)
 196 #  define subi_d(r0,r1,i0)              _subi_d(_jit,r0,r1,i0)
 197 static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 198 #  define rsbr_f(r0,r1,r2)              subr_f(r0,r2,r1)
 199 #  define rsbi_f(r0,r1,i0)              _rsbi_f(_jit,r0,r1,i0)
 200 static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 201 #  define rsbr_d(r0,r1,r2)              subr_d(r0,r2,r1)
 202 #  define rsbi_d(r0,r1,i0)              _rsbi_d(_jit,r0,r1,i0)
 203 static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 204 #  define mulr_f(r0,r1,r2)              MUL_S(r0,r1,r2)
 205 #  define muli_f(r0,r1,i0)              _muli_f(_jit,r0,r1,i0)
 206 static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 207 #  define mulr_d(r0,r1,r2)              MUL_D(r0,r1,r2)
 208 #  define muli_d(r0,r1,i0)              _muli_d(_jit,r0,r1,i0)
 209 static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 210 #  define divr_f(r0,r1,r2)              DIV_S(r0,r1,r2)
 211 #  define divi_f(r0,r1,i0)              _divi_f(_jit,r0,r1,i0)
 212 static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 213 #  define divr_d(r0,r1,r2)              DIV_D(r0,r1,r2)
 214 #  define divi_d(r0,r1,i0)              _divi_d(_jit,r0,r1,i0)
 215 static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 216 #  define absr_f(r0,r1)                 ABS_S(r0,r1)
 217 #  define absr_d(r0,r1)                 ABS_D(r0,r1)
 218 #  define negr_f(r0,r1)                 NEG_S(r0,r1)
 219 #  define negr_d(r0,r1)                 NEG_D(r0,r1)
 220 #  define sqrtr_f(r0,r1)                SQRT_S(r0,r1)
 221 #  define sqrtr_d(r0,r1)                SQRT_D(r0,r1)
 222 #  define movr_w_f(r0, r1)              MTC1(r1, r0)
 223 #  define movr_f_w(r0, r1)              MFC1(r1, r0)
 224 #  define movi_f_w(r0, i0)              _movi_f_w(_jit, r0, i0)
 225 static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*);
 226 #  define extr_f(r0, r1)                _extr_f(_jit, r0, r1)
 227 static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 228 #  define truncr_f_i(r0, r1)            _truncr_f_i(_jit, r0, r1)
 229 static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
 230 #  if __WORDSIZE == 64
 231 #    define truncr_f_l(r0, r1)          _truncr_f_l(_jit, r0, r1)
 232 static void _truncr_f_l(jit_state_t*,jit_int32_t,jit_int32_t);
 233 #  endif
 234 #  define extr_d_f(r0, r1)              CVT_S_D(r0, r1)
 235 #  define ldr_f(r0, r1)                 LWC1(r0, 0, r1)
 236 #  define ldi_f(r0, i0)                 _ldi_f(_jit, r0, i0)
 237 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 238 #  define ldxr_f(r0, r1, r2)            _ldxr_f(_jit, r0, r1, r2)
 239 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 240 #  define ldxi_f(r0, r1, i0)            _ldxi_f(_jit, r0, r1, i0)
 241 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 242 #  define str_f(r0, r1)                 SWC1(r1, 0, r0)
 243 #  define sti_f(i0, r0)                 _sti_f(_jit, i0, r0)
 244 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 245 #  define stxr_f(r0, r1, r2)            _stxr_f(_jit, r0, r1, r2)
 246 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 247 #  define stxi_f(i0, r0, r1)            _stxi_f(_jit, i0, r0, r1)
 248 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 249 #  define movr_f(r0, r1)                _movr_f(_jit, r0, r1)
 250 static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 251 #  define movi_f(r0, i0)                _movi_f(_jit, r0, i0)
 252 static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
 253 #  if NEW_ABI
 254 #    if __WORDSIZE == 32
 255 #      define movi64(r0, i0)            _movi64(_jit, r0, i0)
 256 static void _movi64(jit_state_t*,jit_int32_t,jit_int64_t);
 257 #    else
 258 #      define movi64(r0, i0)            movi(r0, i0)
 259 #    endif
 260 #    define movr_w_d(r0, r1)            DMTC1(r1, r0)
 261 #    define movr_d_w(r0, r1)            DMFC1(r0, r1)
 262 #    define movi_d_w(r0, i0)            _movi_d_w(_jit,r0,i0)
 263 static void _movi_d_w(jit_state_t*,jit_int32_t,jit_float64_t*);
 264 #  else
 265 #    define movr_ww_d(r0, r1, r2)       _movr_ww_d(_jit, r0, r1, r2)
 266 static void _movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 267 #    define movr_d_ww(r0, r1, r2)       _movr_d_ww(_jit, r0, r1, r2)
 268 static void _movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 269 #    define movi_d_ww(r0, r1, i0)       _movi_d_ww(_jit, r0, r1, i0)
 270 static void _movi_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 271 #  endif
 272 #  define extr_d(r0, r1)                _extr_d(_jit, r0, r1)
 273 static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 274 #  define truncr_d_i(r0, r1)            _truncr_d_i(_jit, r0, r1)
 275 static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
 276 #  if __WORDSIZE == 64
 277 #    define truncr_d_l(r0, r1)          _truncr_d_l(_jit, r0, r1)
 278 static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
 279 #  endif
 280 #  define ldr_d(r0, r1)                 _ldr_d(_jit, r0, r1)
 281 static void _ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 282 #  define ldi_d(r0, i0)                 _ldi_d(_jit, r0, i0)
 283 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 284 #  define ldxr_d(r0, r1, r2)            _ldxr_d(_jit, r0, r1, r2)
 285 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 286 #  define ldxi_d(r0, r1, i0)            _ldxi_d(_jit, r0, r1, i0)
 287 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 288 #  define str_d(r0, r1)                 _str_d(_jit, r0, r1)
 289 static void _str_d(jit_state_t*,jit_int32_t,jit_int32_t);
 290 #  define sti_d(i0, r0)                 _sti_d(_jit, i0, r0)
 291 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 292 #  define stxr_d(r0, r1, r2)            _stxr_d(_jit, r0, r1, r2)
 293 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 294 #  define stxi_d(i0, r0, r1)            _stxi_d(_jit, i0, r0, r1)
 295 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 296 #  define movr_d(r0, r1)                _movr_d(_jit, r0, r1)
 297 static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 298 #  define movi_d(r0, i0)                _movi_d(_jit, r0, i0)
 299 static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
 300 #  define ltr_f(r0, r1, r2)             _ltr_f(_jit, r0, r1, r2)
 301 static void _ltr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 302 #  define lti_f(r0, r1, i2)             _lti_f(_jit, r0, r1, i2)
 303 static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 304 #  define ler_f(r0, r1, r2)             _ler_f(_jit, r0, r1, r2)
 305 static void _ler_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 306 #  define lei_f(r0, r1, i2)             _lei_f(_jit, r0, r1, i2)
 307 static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 308 #  define eqr_f(r0, r1, r2)             _eqr_f(_jit, r0, r1, r2)
 309 static void _eqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 310 #  define eqi_f(r0, r1, i2)             _eqi_f(_jit, r0, r1, i2)
 311 static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 312 #  define ger_f(r0, r1, r2)             _ger_f(_jit, r0, r1, r2)
 313 static void _ger_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 314 #  define gei_f(r0, r1, i2)             _gei_f(_jit, r0, r1, i2)
 315 static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 316 #  define gtr_f(r0, r1, r2)             _gtr_f(_jit, r0, r1, r2)
 317 static void _gtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 318 #  define gti_f(r0, r1, i2)             _gti_f(_jit, r0, r1, i2)
 319 static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 320 #  define ner_f(r0, r1, r2)             _ner_f(_jit, r0, r1, r2)
 321 static void _ner_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 322 #  define nei_f(r0, r1, i2)             _nei_f(_jit, r0, r1, i2)
 323 static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 324 #  define unltr_f(r0, r1, r2)           _unltr_f(_jit, r0, r1, r2)
 325 static void _unltr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 326 #  define unlti_f(r0, r1, i2)           _unlti_f(_jit, r0, r1, i2)
 327 static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 328 #  define unler_f(r0, r1, r2)           _unler_f(_jit, r0, r1, r2)
 329 static void _unler_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 330 #  define unlei_f(r0, r1, i2)           _unlei_f(_jit, r0, r1, i2)
 331 static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 332 #  define uneqr_f(r0, r1, r2)           _uneqr_f(_jit, r0, r1, r2)
 333 static void _uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 334 #  define uneqi_f(r0, r1, i2)           _uneqi_f(_jit, r0, r1, i2)
 335 static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 336 #  define unger_f(r0, r1, r2)           _unger_f(_jit, r0, r1, r2)
 337 static void _unger_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 338 #  define ungei_f(r0, r1, i2)           _ungei_f(_jit, r0, r1, i2)
 339 static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 340 #  define ungtr_f(r0, r1, r2)           _ungtr_f(_jit, r0, r1, r2)
 341 static void _ungtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 342 #  define ungti_f(r0, r1, i2)           _ungti_f(_jit, r0, r1, i2)
 343 static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 344 #  define ltgtr_f(r0, r1, r2)           _ltgtr_f(_jit, r0, r1, r2)
 345 static void _ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 346 #  define ltgti_f(r0, r1, i2)           _ltgti_f(_jit, r0, r1, i2)
 347 static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 348 #  define ordr_f(r0, r1, r2)            _ordr_f(_jit, r0, r1, r2)
 349 static void _ordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 350 #  define ordi_f(r0, r1, i2)            _ordi_f(_jit, r0, r1, i2)
 351 static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 352 #  define unordr_f(r0, r1, r2)          _unordr_f(_jit, r0, r1, r2)
 353 static void _unordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 354 #  define unordi_f(r0, r1, i2)          _unordi_f(_jit, r0, r1, i2)
 355 static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 356 #  define bltr_f(i0, r0, r1)            _bltr_f(_jit, i0, r0, r1)
 357 static jit_word_t _bltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 358 #  define blti_f(i0, r0, i1)            _blti_f(_jit, i0, r0, i1)
 359 static jit_word_t
 360 _blti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 361 #  define bler_f(i0, r0, r1)            _bler_f(_jit, i0, r0, r1)
 362 static jit_word_t _bler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 363 #  define blei_f(i0, r0, i1)            _blei_f(_jit, i0, r0, i1)
 364 static jit_word_t
 365 _blei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 366 #  define beqr_f(i0, r0, r1)            _beqr_f(_jit, i0, r0, r1)
 367 static jit_word_t _beqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 368 #  define beqi_f(i0, r0, i1)            _beqi_f(_jit, i0, r0, i1)
 369 static jit_word_t
 370 _beqi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 371 #  define bger_f(i0, r0, r1)            _bger_f(_jit, i0, r0, r1)
 372 static jit_word_t _bger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 373 #  define bgei_f(i0, r0, i1)            _bgei_f(_jit, i0, r0, i1)
 374 static jit_word_t
 375 _bgei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 376 #  define bgtr_f(i0, r0, r1)            _bgtr_f(_jit, i0, r0, r1)
 377 static jit_word_t _bgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 378 #  define bgti_f(i0, r0, i1)            _bgti_f(_jit, i0, r0, i1)
 379 static jit_word_t
 380 _bgti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 381 #  define bner_f(i0, r0, r1)            _bner_f(_jit, i0, r0, r1)
 382 static jit_word_t _bner_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 383 #  define bnei_f(i0, r0, i1)            _bnei_f(_jit, i0, r0, i1)
 384 static jit_word_t
 385 _bnei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 386 #  define bunltr_f(i0, r0, r1)          _bunltr_f(_jit, i0, r0, r1)
 387 static jit_word_t _bunltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 388 #  define bunlti_f(i0, r0, i1)          _bunlti_f(_jit, i0, r0, i1)
 389 static jit_word_t
 390 _bunlti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 391 #  define bunler_f(i0, r0, r1)          _bunler_f(_jit, i0, r0, r1)
 392 static jit_word_t _bunler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 393 #  define bunlei_f(i0, r0, i1)          _bunlei_f(_jit, i0, r0, i1)
 394 static jit_word_t
 395 _bunlei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 396 #  define buneqr_f(i0, r0, r1)          _buneqr_f(_jit, i0, r0, r1)
 397 static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 398 #  define buneqi_f(i0, r0, i1)          _buneqi_f(_jit, i0, r0, i1)
 399 static jit_word_t
 400 _buneqi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 401 #  define bunger_f(i0, r0, r1)          _bunger_f(_jit, i0, r0, r1)
 402 static jit_word_t _bunger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 403 #  define bungei_f(i0, r0, i1)          _bungei_f(_jit, i0, r0, i1)
 404 static jit_word_t
 405 _bungei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 406 #  define bungtr_f(i0, r0, r1)          _bungtr_f(_jit, i0, r0, r1)
 407 static jit_word_t _bungtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 408 #  define bungti_f(i0, r0, i1)          _bungti_f(_jit, i0, r0, i1)
 409 static jit_word_t
 410 _bungti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 411 #  define bltgtr_f(i0, r0, r1)          _bltgtr_f(_jit, i0, r0, r1)
 412 static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 413 #  define bltgti_f(i0, r0, i1)          _bltgti_f(_jit, i0, r0, i1)
 414 static jit_word_t
 415 _bltgti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 416 #  define bordr_f(i0, r0, r1)           _bordr_f(_jit, i0, r0, r1)
 417 static jit_word_t _bordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 418 #  define bordi_f(i0, r0, i1)           _bordi_f(_jit, i0, r0, i1)
 419 static jit_word_t
 420 _bordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 421 #  define bunordr_f(i0, r0, r1)         _bunordr_f(_jit, i0, r0, r1)
 422 static jit_word_t _bunordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 423 #  define bunordi_f(i0, r0, i1)         _bunordi_f(_jit, i0, r0, i1)
 424 static jit_word_t
 425 _bunordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
 426 #  define extr_f_d(r0, r1)              CVT_D_S(r0, r1)
 427 #  define ltr_d(r0, r1, r2)             _ltr_d(_jit, r0, r1, r2)
 428 static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 429 #  define lti_d(r0, r1, i2)             _lti_d(_jit, r0, r1, i2)
 430 static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 431 #  define ler_d(r0, r1, r2)             _ler_d(_jit, r0, r1, r2)
 432 static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 433 #  define lei_d(r0, r1, i2)             _lei_d(_jit, r0, r1, i2)
 434 static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 435 #  define eqr_d(r0, r1, r2)             _eqr_d(_jit, r0, r1, r2)
 436 static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 437 #  define eqi_d(r0, r1, i2)             _eqi_d(_jit, r0, r1, i2)
 438 static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 439 #  define ger_d(r0, r1, r2)             _ger_d(_jit, r0, r1, r2)
 440 static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 441 #  define gei_d(r0, r1, i2)             _gei_d(_jit, r0, r1, i2)
 442 static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 443 #  define gtr_d(r0, r1, r2)             _gtr_d(_jit, r0, r1, r2)
 444 static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 445 #  define gti_d(r0, r1, i2)             _gti_d(_jit, r0, r1, i2)
 446 static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 447 #  define ner_d(r0, r1, r2)             _ner_d(_jit, r0, r1, r2)
 448 static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 449 #  define nei_d(r0, r1, i2)             _nei_d(_jit, r0, r1, i2)
 450 static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 451 #  define unltr_d(r0, r1, r2)           _unltr_d(_jit, r0, r1, r2)
 452 static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 453 #  define unlti_d(r0, r1, i2)           _unlti_d(_jit, r0, r1, i2)
 454 static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 455 #  define unler_d(r0, r1, r2)           _unler_d(_jit, r0, r1, r2)
 456 static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 457 #  define unlei_d(r0, r1, i2)           _unlei_d(_jit, r0, r1, i2)
 458 static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 459 #  define uneqr_d(r0, r1, r2)           _uneqr_d(_jit, r0, r1, r2)
 460 static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 461 #  define uneqi_d(r0, r1, i2)           _uneqi_d(_jit, r0, r1, i2)
 462 static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 463 #  define unger_d(r0, r1, r2)           _unger_d(_jit, r0, r1, r2)
 464 static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 465 #  define ungei_d(r0, r1, i2)           _ungei_d(_jit, r0, r1, i2)
 466 static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 467 #  define ungtr_d(r0, r1, r2)           _ungtr_d(_jit, r0, r1, r2)
 468 static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 469 #  define ungti_d(r0, r1, i2)           _ungti_d(_jit, r0, r1, i2)
 470 static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 471 #  define ltgtr_d(r0, r1, r2)           _ltgtr_d(_jit, r0, r1, r2)
 472 static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 473 #  define ltgti_d(r0, r1, i2)           _ltgti_d(_jit, r0, r1, i2)
 474 static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 475 #  define ordr_d(r0, r1, r2)            _ordr_d(_jit, r0, r1, r2)
 476 static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 477 #  define ordi_d(r0, r1, i2)            _ordi_d(_jit, r0, r1, i2)
 478 static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 479 #  define unordr_d(r0, r1, r2)          _unordr_d(_jit, r0, r1, r2)
 480 static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 481 #  define unordi_d(r0, r1, i2)          _unordi_d(_jit, r0, r1, i2)
 482 static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 483 #  define bltr_d(i0, r0, r1)            _bltr_d(_jit, i0, r0, r1)
 484 static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 485 #  define blti_d(i0, r0, i1)            _blti_d(_jit, i0, r0, i1)
 486 static jit_word_t
 487 _blti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 488 #  define bler_d(i0, r0, r1)            _bler_d(_jit, i0, r0, r1)
 489 static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 490 #  define blei_d(i0, r0, i1)            _blei_d(_jit, i0, r0, i1)
 491 static jit_word_t
 492 _blei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 493 #  define beqr_d(i0, r0, r1)            _beqr_d(_jit, i0, r0, r1)
 494 static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 495 #  define beqi_d(i0, r0, i1)            _beqi_d(_jit, i0, r0, i1)
 496 static jit_word_t
 497 _beqi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 498 #  define bger_d(i0, r0, r1)            _bger_d(_jit, i0, r0, r1)
 499 static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 500 #  define bgei_d(i0, r0, i1)            _bgei_d(_jit, i0, r0, i1)
 501 static jit_word_t
 502 _bgei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 503 #  define bgtr_d(i0, r0, r1)            _bgtr_d(_jit, i0, r0, r1)
 504 static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 505 #  define bgti_d(i0, r0, i1)            _bgti_d(_jit, i0, r0, i1)
 506 static jit_word_t
 507 _bgti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 508 #  define bner_d(i0, r0, r1)            _bner_d(_jit, i0, r0, r1)
 509 static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 510 #  define bnei_d(i0, r0, i1)            _bnei_d(_jit, i0, r0, i1)
 511 static jit_word_t
 512 _bnei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 513 #  define bunltr_d(i0, r0, r1)          _bunltr_d(_jit, i0, r0, r1)
 514 static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 515 #  define bunlti_d(i0, r0, i1)          _bunlti_d(_jit, i0, r0, i1)
 516 static jit_word_t
 517 _bunlti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 518 #  define bunler_d(i0, r0, r1)          _bunler_d(_jit, i0, r0, r1)
 519 static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 520 #  define bunlei_d(i0, r0, i1)          _bunlei_d(_jit, i0, r0, i1)
 521 static jit_word_t
 522 _bunlei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 523 #  define buneqr_d(i0, r0, r1)          _buneqr_d(_jit, i0, r0, r1)
 524 static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 525 #  define buneqi_d(i0, r0, i1)          _buneqi_d(_jit, i0, r0, i1)
 526 static jit_word_t
 527 _buneqi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 528 #  define bunger_d(i0, r0, r1)          _bunger_d(_jit, i0, r0, r1)
 529 static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 530 #  define bungei_d(i0, r0, i1)          _bungei_d(_jit, i0, r0, i1)
 531 static jit_word_t
 532 _bungei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 533 #  define bungtr_d(i0, r0, r1)          _bungtr_d(_jit, i0, r0, r1)
 534 static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 535 #  define bungti_d(i0, r0, i1)          _bungti_d(_jit, i0, r0, i1)
 536 static jit_word_t
 537 _bungti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 538 #  define bltgtr_d(i0, r0, r1)          _bltgtr_d(_jit, i0, r0, r1)
 539 static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 540 #  define bltgti_d(i0, r0, i1)          _bltgti_d(_jit, i0, r0, i1)
 541 static jit_word_t
 542 _bltgti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 543 #  define bordr_d(i0, r0, r1)           _bordr_d(_jit, i0, r0, r1)
 544 static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 545 #  define bordi_d(i0, r0, i1)           _bordi_d(_jit, i0, r0, i1)
 546 static jit_word_t
 547 _bordi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 548 #  define bunordr_d(i0, r0, r1)         _bunordr_d(_jit, i0, r0, r1)
 549 static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 550 #  define bunordi_d(i0, r0, i1)         _bunordi_d(_jit, i0, r0, i1)
 551 static jit_word_t
 552 _bunordi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
 553 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 554 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 555 #endif
 556
 557 #if CODE
 558 static void
 559 _c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
 560             jit_int32_t ft, jit_int32_t fs, jit_int32_t cc)
 561 {
 562     jit_instr_t         i;
 563     i.cc.b = cc;
 564     i.fs.b = fs;
 565     i.ft.b = ft;
 566     i.fm.b = fm;
 567     i.hc.b = MIPS_COP1;
 568     ii(i.op);
 569 }
 570
 571 #  define fpr_opi(name, type, size)                                     \
 572 static void                                                             \
 573 _##name##i_##type(jit_state_t *_jit,                                    \
 574                   jit_int32_t r0, jit_int32_t r1,                       \
 575                   jit_float##size##_t *i0)                              \
 576 {                                                                       \
 577     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
 578     movi_##type(rn(reg), i0);                                           \
 579     name##r_##type(r0, r1, rn(reg));                                    \
 580     jit_unget_reg(reg);                                                 \
 581 }
 582 #  define fpr_bopi(name, type, size)                                    \
 583 static jit_word_t                                                       \
 584 _b##name##i_##type(jit_state_t *_jit,                                   \
 585                   jit_word_t i0, jit_int32_t r0,                        \
 586                   jit_float##size##_t *i1)                              \
 587 {                                                                       \
 588     jit_word_t          word;                                           \
 589     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
 590                                           jit_class_nospill);           \
 591     movi_##type(rn(reg), i1);                                           \
 592     word = b##name##r_##type(i0, r0, rn(reg));                          \
 593     jit_unget_reg(reg);                                                 \
 594     return (word);                                                      \
 595 }
 596 #  define fopi(name)                    fpr_opi(name, f, 32)
 597 #  define fbopi(name)                   fpr_bopi(name, f, 32)
 598 #  define dopi(name)                    fpr_opi(name, d, 64)
 599 #  define dbopi(name)                   fpr_bopi(name, d, 64)
 600
 601 fopi(add)
 602 fopi(sub)
 603 fopi(rsb)
 604 fopi(mul)
 605 fopi(div)
 606
 607 static void
 608 _movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
 609 {
 610     union {
 611         jit_int32_t     i;
 612         jit_float32_t   f;
 613     } data;
 614
 615     data.f = *i0;
 616     movi(r0, data.i);
 617 }
 618
 619 static void
 620 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 621 {
 622     jit_int32_t         t0;
 623     t0 = jit_get_reg(jit_class_fpr);
 624 #  if __WORDSIZE == 32
 625     MTC1(r1, rn(t0));
 626     CVT_S_W(r0, rn(t0));
 627 #  else
 628     DMTC1(r1, rn(t0));
 629     CVT_S_L(r0, rn(t0));
 630 #  endif
 631     jit_unget_reg(t0);
 632 }
 633
 634 static void
 635 _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 636 {
 637     jit_int32_t         t0;
 638     t0 = jit_get_reg(jit_class_fpr);
 639     TRUNC_W_S(rn(t0), r1);
 640     MFC1(r0, rn(t0));
 641     jit_unget_reg(t0);
 642 }
 643
 644 #  if __WORDSIZE == 64
 645 static void
 646 _truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 647 {
 648     jit_int32_t         t0;
 649     t0 = jit_get_reg(jit_class_fpr);
 650     TRUNC_L_S(rn(t0), r1);
 651     DMFC1(r0, rn(t0));
 652     jit_unget_reg(t0);
 653 }
 654 #  endif
 655
 656 static void
 657 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 658 {
 659     jit_int32_t         reg;
 660     if (can_sign_extend_short_p(i0))
 661         LWC1(r0, i0, _ZERO_REGNO);
 662     else {
 663         reg = jit_get_reg(jit_class_gpr);
 664         movi(rn(reg), i0);
 665         ldr_f(r0, rn(reg));
 666         jit_unget_reg(reg);
 667     }
 668 }
 669
 670 static void
 671 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 672 {
 673     jit_int32_t         reg;
 674     reg = jit_get_reg(jit_class_gpr);
 675     addr(rn(reg), r1, r2);
 676     ldr_f(r0, rn(reg));
 677     jit_unget_reg(reg);
 678 }
 679
 680 static void
 681 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 682 {
 683     jit_int32_t         reg;
 684     if (can_sign_extend_short_p(i0))
 685         LWC1(r0, i0, r1);
 686     else {
 687         reg = jit_get_reg(jit_class_gpr);
 688         addi(rn(reg), r1, i0);
 689         ldr_f(r0, rn(reg));
 690         jit_unget_reg(reg);
 691     }
 692 }
 693
 694 static void
 695 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 696 {
 697     jit_int32_t         reg;
 698     if (can_sign_extend_short_p(i0))
 699         SWC1(r0, i0, _ZERO_REGNO);
 700     else {
 701         reg = jit_get_reg(jit_class_gpr);
 702         movi(rn(reg), i0);
 703         str_f(rn(reg), r0);
 704         jit_unget_reg(reg);
 705     }
 706 }
 707
 708 static void
 709 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 710 {
 711     jit_int32_t         reg;
 712     reg = jit_get_reg(jit_class_gpr);
 713     addr(rn(reg), r0, r1);
 714     str_f(rn(reg), r2);
 715     jit_unget_reg(reg);
 716 }
 717
 718 static void
 719 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 720 {
 721     jit_int32_t         reg;
 722     if (can_sign_extend_short_p(i0))
 723         SWC1(r1, i0, r0);
 724     else {
 725         reg = jit_get_reg(jit_class_gpr);
 726         addi(rn(reg), r0, i0);
 727         str_f(rn(reg), r1);
 728         jit_unget_reg(reg);
 729     }
 730 }
 731
 732 static void
 733 _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 734 {
 735     if (r0 != r1)
 736         MOV_S(r0, r1);
 737 }
 738
 739 static void
 740 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
 741 {
 742     union {
 743         jit_int32_t     i;
 744         jit_float32_t   f;
 745     } data;
 746     jit_int32_t         reg;
 747
 748     data.f = *i0;
 749     if (data.i) {
 750         if (_jitc->no_data) {
 751             reg = jit_get_reg(jit_class_gpr);
 752             movi(rn(reg), data.i);
 753             MTC1(rn(reg), r0);
 754             jit_unget_reg(reg);
 755         }
 756         else
 757             ldi_f(r0, (jit_word_t)i0);
 758     }
 759     else
 760         MTC1(_ZERO_REGNO, r0);
 761 }
 762
 763 dopi(add)
 764 dopi(sub)
 765 dopi(rsb)
 766 dopi(mul)
 767 dopi(div)
 768
 769 #if NEW_ABI
 770 /* n32 abi requires 64 bit cpu */
 771 static void
 772 _movi64(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0)
 773 {
 774     if (i0 == 0)
 775         OR(r0, _ZERO_REGNO, _ZERO_REGNO);
 776     else if (i0 >= -32678 && i0 <= 32767)
 777         DADDIU(r0, _ZERO_REGNO, i0);
 778     else if (i0 >= 0 && i0 <= 65535)
 779         ORI(r0, _ZERO_REGNO, i0);
 780     else {
 781         if (i0 >= 0 && i0 <= 0x7fffffffLL)
 782             LUI(r0, i0 >> 16);
 783         else if (i0 >= 0 && i0 <= 0xffffffffLL) {
 784             if (i0 & 0xffff0000LL) {
 785                 ORI(r0, _ZERO_REGNO, (jit_word_t)(i0 >> 16));
 786                 DSLL(r0, r0, 16);
 787             }
 788         }
 789         else {
 790             movi(r0, (jit_word_t)(i0 >> 32));
 791             if (i0 & 0xffff0000LL) {
 792                 DSLL(r0, r0, 16);
 793                 ORI(r0, r0, (jit_word_t)(i0 >> 16));
 794                 DSLL(r0, r0, 16);
 795             }
 796             else
 797                 DSLL32(r0, r0, 0);
 798         }
 799         if ((jit_word_t)i0 & 0xffff)
 800             ORI(r0, r0, (jit_word_t)i0 & 0xffff);
 801     }
 802 }
 803
 804 static void
 805 _movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
 806 {
 807     jit_word_t          w;
 808     union {
 809         jit_int64_t     l;
 810         jit_float64_t   d;
 811     } data;
 812     if (_jitc->no_data) {
 813         data.d = *i0;
 814         movi64(r0, data.l);
 815     }
 816     else {
 817         w = (jit_word_t)i0;
 818         if (can_sign_extend_short_p(w))
 819             LD(r0, w, _ZERO_REGNO);
 820         else {
 821             movi(r0, w);
 822             LD(r0, 0, r0);
 823         }
 824     }
 825 }
 826
 827 #else
 828 static void
 829 _movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 830 {
 831     assert(r1 == r2 - 1);
 832     MTC1(r1, r0 + BE_P);
 833     MTC1(r2, r0 + LE_P);
 834 }
 835
 836 static void
 837 _movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 838 {
 839     assert(r0 == r1 - 1);
 840     MFC1(r0, r2 + BE_P);
 841     MFC1(r1, r2 + LE_P);
 842 }
 843
 844 static void
 845 _movi_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 846 {
 847     union {
 848         jit_int32_t     i[2];
 849         jit_int64_t     l;
 850         jit_float64_t   d;
 851     } data;
 852
 853     data.d = *i0;
 854     movi(r0, data.i[0]);
 855     movi(r1, data.i[1]);
 856 }
 857 #endif
 858
 859 static void
 860 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 861 {
 862     jit_int32_t         t0;
 863     t0 = jit_get_reg(jit_class_fpr);
 864 #  if __WORDSIZE == 32
 865     MTC1(r1, rn(t0));
 866     CVT_D_W(r0, rn(t0));
 867 #  else
 868     DMTC1(r1, rn(t0));
 869     CVT_D_L(r0, rn(t0));
 870 #  endif
 871     jit_unget_reg(t0);
 872 }
 873
 874 static void
 875 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 876 {
 877     jit_int32_t         t0;
 878     t0 = jit_get_reg(jit_class_fpr);
 879     TRUNC_W_D(rn(t0), r1);
 880     MFC1(r0, rn(t0));
 881     jit_unget_reg(t0);
 882 }
 883
 884 #  if __WORDSIZE == 64
 885 static void
 886 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 887 {
 888     jit_int32_t         t0;
 889     t0 = jit_get_reg(jit_class_fpr);
 890     TRUNC_L_D(rn(t0), r1);
 891     DMFC1(r0, rn(t0));
 892     jit_unget_reg(t0);
 893 }
 894 #  endif
 895
 896 static void
 897 _ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 898 {
 899 #  if __WORDSIZE == 64 || NEW_ABI
 900     LDC1(r0, 0, r1);
 901 #  else
 902     LWC1(r0 + BE_P, 0, r1);
 903     LWC1(r0 + LE_P, 4, r1);
 904 #  endif
 905 }
 906
 907 static void
 908 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 909 {
 910     jit_int32_t         reg;
 911 #  if __WORDSIZE == 64 || NEW_ABI
 912     if (can_sign_extend_short_p(i0))
 913         LDC1(r0, i0, _ZERO_REGNO);
 914     else {
 915         reg = jit_get_reg(jit_class_gpr);
 916         movi(rn(reg), i0);
 917         LDC1(r0, 0, rn(reg));
 918         jit_unget_reg(reg);
 919     }
 920 #  else
 921     if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
 922         LWC1(r0 + BE_P, i0, _ZERO_REGNO);
 923         LWC1(r0 + LE_P, i0 + 4, _ZERO_REGNO);
 924     }
 925     else {
 926         reg = jit_get_reg(jit_class_gpr);
 927         movi(rn(reg), i0);
 928         LWC1(r0 + BE_P, 0, rn(reg));
 929         LWC1(r0 + LE_P, 4, rn(reg));
 930         jit_unget_reg(reg);
 931     }
 932 #  endif
 933 }
 934
 935 static void
 936 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 937 {
 938     jit_int32_t         reg;
 939     reg = jit_get_reg(jit_class_gpr);
 940     addr(rn(reg), r1, r2);
 941     ldr_d(r0, rn(reg));
 942     jit_unget_reg(reg);
 943 }
 944
 945 static void
 946 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 947 {
 948     jit_int32_t         reg;
 949 #  if __WORDSIZE == 64 || NEW_ABI
 950     if (can_sign_extend_short_p(i0))
 951         LDC1(r0, i0, r1);
 952 #  else
 953     if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
 954         LWC1(r0 + BE_P, i0, r1);
 955         LWC1(r0 + LE_P, i0 + 4, r1);
 956     }
 957 #  endif
 958     else {
 959         reg = jit_get_reg(jit_class_gpr);
 960         addi(rn(reg), r1, i0);
 961         ldr_d(r0, rn(reg));
 962         jit_unget_reg(reg);
 963     }
 964 }
 965
 966 static void
 967 _str_d(jit_state_t *_jit,jit_int32_t r0, jit_int32_t r1)
 968 {
 969 #  if __WORDSIZE == 64 || NEW_ABI
 970     SDC1(r1, 0, r0);
 971 #  else
 972     SWC1(r1 + BE_P, 0, r0);
 973     SWC1(r1 + LE_P, 4, r0);
 974 #  endif
 975 }
 976
 977 static void
 978 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 979 {
 980     jit_int32_t         reg;
 981 #  if __WORDSIZE == 64 || NEW_ABI
 982     if (can_sign_extend_short_p(i0))
 983         SDC1(r0, i0, _ZERO_REGNO);
 984 #  else
 985     if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
 986         SWC1(r0 + BE_P, i0, _ZERO_REGNO);
 987         SWC1(r0 + LE_P, i0 + 4, _ZERO_REGNO);
 988     }
 989 #  endif
 990     else {
 991         reg = jit_get_reg(jit_class_gpr);
 992         movi(rn(reg), i0);
 993         str_d(rn(reg), r0);
 994         jit_unget_reg(reg);
 995     }
 996 }
 997
 998 static void
 999 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1000 {
1001     jit_int32_t         reg;
1002     reg = jit_get_reg(jit_class_gpr);
1003     addr(rn(reg), r0, r1);
1004     str_d(rn(reg), r2);
1005     jit_unget_reg(reg);
1006 }
1007
1008 static void
1009 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1010 {
1011     jit_int32_t         reg;
1012 #  if __WORDSIZE == 64 || NEW_ABI
1013     if (can_sign_extend_short_p(i0))
1014         SDC1(r1, i0, r0);
1015 #  else
1016     if (can_sign_extend_short_p(i0) && can_sign_extend_short_p(i0 + 4)) {
1017         SWC1(r1 + BE_P, i0, r0);
1018         SWC1(r1 + LE_P, i0 + 4, r0);
1019     }
1020 #  endif
1021     else {
1022         reg = jit_get_reg(jit_class_gpr);
1023         addi(rn(reg), r0, i0);
1024         str_d(rn(reg), r1);
1025         jit_unget_reg(reg);
1026     }
1027 }
1028
1029 static void
1030 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1031 {
1032     if (r0 != r1)
1033         MOV_D(r0, r1);
1034 }
1035
1036 static void
1037 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
1038 {
1039     union {
1040         jit_int32_t     i[2];
1041         jit_int64_t     l;
1042         jit_float64_t   d;
1043     } data;
1044     jit_int32_t         reg;
1045
1046     data.d = *i0;
1047 #  if __WORDSIZE == 64 || NEW_ABI
1048     if (data.l) {
1049         if (_jitc->no_data) {
1050             reg = jit_get_reg(jit_class_gpr);
1051             movi64(rn(reg), data.l);
1052             DMTC1(rn(reg), r0);
1053             jit_unget_reg(reg);
1054         }
1055         else
1056             ldi_d(r0, (jit_word_t)i0);
1057     }
1058     else
1059         DMTC1(_ZERO_REGNO, r0);
1060 #  else
1061     if (_jitc->no_data)
1062         reg = jit_get_reg(jit_class_gpr);
1063     if (data.i[0]) {
1064         if (_jitc->no_data) {
1065             movi(rn(reg), data.i[0]);
1066             MTC1(rn(reg), r0 + BE_P);
1067         }
1068         else
1069             ldi_f(r0 + BE_P, (jit_word_t)i0);
1070     }
1071     else
1072         MTC1(_ZERO_REGNO, r0 + BE_P);
1073     if (data.i[1]) {
1074         if (_jitc->no_data) {
1075             movi(rn(reg), data.i[1]);
1076             MTC1(rn(reg), r0 + LE_P);
1077         }
1078         else
1079             ldi_f(r0 + LE_P, ((jit_word_t)i0) + 4);
1080     }
1081     else
1082         MTC1(_ZERO_REGNO, r0 + LE_P);
1083     if (_jitc->no_data)
1084         jit_unget_reg(reg);
1085 #  endif
1086 }
1087
1088 static void
1089 _ltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1090 {
1091     jit_word_t          w;
1092     C_OLT_S(r1, r2);
1093     w = _jit->pc.w;
1094     BC1T(0);
1095     /* delay slot */
1096     movi(r0, 1);
1097     movi(r0, 0);
1098     patch_at(w, _jit->pc.w);
1099 }
1100 fopi(lt)
1101
1102 static void
1103 _ler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1104 {
1105     jit_word_t          w;
1106     C_OLE_S(r1, r2);
1107     w = _jit->pc.w;
1108     BC1T(0);
1109     /* delay slot */
1110     movi(r0, 1);
1111     movi(r0, 0);
1112     patch_at(w, _jit->pc.w);
1113 }
1114 fopi(le)
1115
1116 static void
1117 _eqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1118 {
1119     jit_word_t          w;
1120     C_EQ_S(r1, r2);
1121     w = _jit->pc.w;
1122     BC1T(0);
1123     /* delay slot */
1124     movi(r0, 1);
1125     movi(r0, 0);
1126     patch_at(w, _jit->pc.w);
1127 }
1128 fopi(eq)
1129
1130 static void
1131 _ger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1132 {
1133     jit_word_t          w;
1134     C_ULT_S(r1, r2);
1135     w = _jit->pc.w;
1136     BC1F(0);
1137     /* delay slot */
1138     movi(r0, 1);
1139     movi(r0, 0);
1140     patch_at(w, _jit->pc.w);
1141 }
1142 fopi(ge)
1143
1144 static void
1145 _gtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1146 {
1147     jit_word_t          w;
1148     C_ULE_S(r1, r2);
1149     w = _jit->pc.w;
1150     BC1F(0);
1151     /* delay slot */
1152     movi(r0, 1);
1153     movi(r0, 0);
1154     patch_at(w, _jit->pc.w);
1155 }
1156 fopi(gt)
1157
1158 static void
1159 _ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1160 {
1161     jit_word_t          w;
1162     C_EQ_S(r1, r2);
1163     w = _jit->pc.w;
1164     BC1F(0);
1165     /* delay slot */
1166     movi(r0, 1);
1167     movi(r0, 0);
1168     patch_at(w, _jit->pc.w);
1169 }
1170 fopi(ne)
1171
1172 static void
1173 _unltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1174 {
1175     jit_word_t          w;
1176     C_ULT_S(r1, r2);
1177     w = _jit->pc.w;
1178     BC1T(0);
1179     /* delay slot */
1180     movi(r0, 1);
1181     movi(r0, 0);
1182     patch_at(w, _jit->pc.w);
1183 }
1184 fopi(unlt)
1185
1186 static void
1187 _unler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1188 {
1189     jit_word_t          w;
1190     C_ULE_S(r1, r2);
1191     w = _jit->pc.w;
1192     BC1T(0);
1193     /* delay slot */
1194     movi(r0, 1);
1195     movi(r0, 0);
1196     patch_at(w, _jit->pc.w);
1197 }
1198 fopi(unle)
1199
1200 static void
1201 _uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1202 {
1203     jit_word_t          w;
1204     C_UEQ_S(r1, r2);
1205     w = _jit->pc.w;
1206     BC1T(0);
1207     /* delay slot */
1208     movi(r0, 1);
1209     movi(r0, 0);
1210     patch_at(w, _jit->pc.w);
1211 }
1212 fopi(uneq)
1213
1214 static void
1215 _unger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1216 {
1217     jit_word_t          w;
1218     C_OLT_S(r1, r2);
1219     w = _jit->pc.w;
1220     BC1F(0);
1221     /* delay slot */
1222     movi(r0, 1);
1223     movi(r0, 0);
1224     patch_at(w, _jit->pc.w);
1225 }
1226 fopi(unge)
1227
1228 static void
1229 _ungtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1230 {
1231     jit_word_t          w;
1232     C_OLE_S(r1, r2);
1233     w = _jit->pc.w;
1234     BC1F(0);
1235     /* delay slot */
1236     movi(r0, 1);
1237     movi(r0, 0);
1238     patch_at(w, _jit->pc.w);
1239 }
1240 fopi(ungt)
1241
1242 static void
1243 _ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1244 {
1245     jit_word_t          w;
1246     C_UEQ_S(r1, r2);
1247     w = _jit->pc.w;
1248     BC1F(0);
1249     /* delay slot */
1250     movi(r0, 1);
1251     movi(r0, 0);
1252     patch_at(w, _jit->pc.w);
1253 }
1254 fopi(ltgt)
1255
1256 static void
1257 _ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1258 {
1259     jit_word_t          w;
1260     C_UN_S(r1, r2);
1261     w = _jit->pc.w;
1262     BC1F(0);
1263     /* delay slot */
1264     movi(r0, 1);
1265     movi(r0, 0);
1266     patch_at(w, _jit->pc.w);
1267 }
1268 fopi(ord)
1269
1270 static void
1271 _unordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1272 {
1273     jit_word_t          w;
1274     C_UN_S(r1, r2);
1275     w = _jit->pc.w;
1276     BC1T(0);
1277     /* delay slot */
1278     movi(r0, 1);
1279     movi(r0, 0);
1280     patch_at(w, _jit->pc.w);
1281 }
1282 fopi(unord)
1283
1284 static jit_word_t
1285 _bltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1286 {
1287     jit_word_t          w;
1288     C_OLT_S(r1, r2);
1289     w = _jit->pc.w;
1290     BC1T(((i0 - w) >> 2) - 1);
1291     NOP(1);
1292     return (w);
1293 }
1294 fbopi(lt)
1295
1296 static jit_word_t
1297 _bler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1298 {
1299     jit_word_t          w;
1300     C_OLE_S(r1, r2);
1301     w = _jit->pc.w;
1302     BC1T(((i0 - w) >> 2) - 1);
1303     NOP(1);
1304     return (w);
1305 }
1306 fbopi(le)
1307
1308 static jit_word_t
1309 _beqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1310 {
1311     jit_word_t          w;
1312     C_EQ_S(r1, r2);
1313     w = _jit->pc.w;
1314     BC1T(((i0 - w) >> 2) - 1);
1315     NOP(1);
1316     return (w);
1317 }
1318 fbopi(eq)
1319
1320 static jit_word_t
1321 _bger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1322 {
1323     jit_word_t          w;
1324     C_ULT_S(r1, r2);
1325     w = _jit->pc.w;
1326     BC1F(((i0 - w) >> 2) - 1);
1327     NOP(1);
1328     return (w);
1329 }
1330 fbopi(ge)
1331
1332 static jit_word_t
1333 _bgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1334 {
1335     jit_word_t          w;
1336     C_ULE_S(r1, r2);
1337     w = _jit->pc.w;
1338     BC1F(((i0 - w) >> 2) - 1);
1339     NOP(1);
1340     return (w);
1341 }
1342 fbopi(gt)
1343
1344 static jit_word_t
1345 _bner_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1346 {
1347     jit_word_t          w;
1348     C_EQ_S(r1, r2);
1349     w = _jit->pc.w;
1350     BC1F(((i0 - w) >> 2) - 1);
1351     NOP(1);
1352     return (w);
1353 }
1354 fbopi(ne)
1355
1356 static jit_word_t
1357 _bunltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1358 {
1359     jit_word_t          w;
1360     C_ULT_S(r1, r2);
1361     w = _jit->pc.w;
1362     BC1T(((i0 - w) >> 2) - 1);
1363     NOP(1);
1364     return (w);
1365 }
1366 fbopi(unlt)
1367
1368 static jit_word_t
1369 _bunler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1370 {
1371     jit_word_t          w;
1372     C_ULE_S(r1, r2);
1373     w = _jit->pc.w;
1374     BC1T(((i0 - w) >> 2) - 1);
1375     NOP(1);
1376     return (w);
1377 }
1378 fbopi(unle)
1379
1380 static jit_word_t
1381 _buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1382 {
1383     jit_word_t          w;
1384     C_UEQ_S(r1, r2);
1385     w = _jit->pc.w;
1386     BC1T(((i0 - w) >> 2) - 1);
1387     NOP(1);
1388     return (w);
1389 }
1390 fbopi(uneq)
1391
1392 static jit_word_t
1393 _bunger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1394 {
1395     jit_word_t          w;
1396     C_OLT_S(r1, r2);
1397     w = _jit->pc.w;
1398     BC1F(((i0 - w) >> 2) - 1);
1399     NOP(1);
1400     return (w);
1401 }
1402 fbopi(unge)
1403
1404 static jit_word_t
1405 _bungtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1406 {
1407     jit_word_t          w;
1408     C_OLE_S(r1, r2);
1409     w = _jit->pc.w;
1410     BC1F(((i0 - w) >> 2) - 1);
1411     NOP(1);
1412     return (w);
1413 }
1414 fbopi(ungt)
1415
1416 static jit_word_t
1417 _bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1418 {
1419     jit_word_t          w;
1420     C_UEQ_S(r1, r2);
1421     w = _jit->pc.w;
1422     BC1F(((i0 - w) >> 2) - 1);
1423     NOP(1);
1424     return (w);
1425 }
1426 fbopi(ltgt)
1427
1428 static jit_word_t
1429 _bordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1430 {
1431     jit_word_t          w;
1432     C_UN_S(r1, r2);
1433     w = _jit->pc.w;
1434     BC1F(((i0 - w) >> 2) - 1);
1435     NOP(1);
1436     return (w);
1437 }
1438 fbopi(ord)
1439
1440 static jit_word_t
1441 _bunordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1442 {
1443     jit_word_t          w;
1444     C_UN_S(r1, r2);
1445     w = _jit->pc.w;
1446     BC1T(((i0 - w) >> 2) - 1);
1447     NOP(1);
1448     return (w);
1449 }
1450 fbopi(unord)
1451
1452 static void
1453 _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1454 {
1455     jit_word_t          w;
1456     C_OLT_D(r1, r2);
1457     w = _jit->pc.w;
1458     BC1T(0);
1459     /* delay slot */
1460     movi(r0, 1);
1461     movi(r0, 0);
1462     patch_at(w, _jit->pc.w);
1463 }
1464 dopi(lt)
1465
1466 static void
1467 _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1468 {
1469     jit_word_t          w;
1470     C_OLE_D(r1, r2);
1471     w = _jit->pc.w;
1472     BC1T(0);
1473     /* delay slot */
1474     movi(r0, 1);
1475     movi(r0, 0);
1476     patch_at(w, _jit->pc.w);
1477 }
1478 dopi(le)
1479
1480 static void
1481 _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1482 {
1483     jit_word_t          w;
1484     C_EQ_D(r1, r2);
1485     w = _jit->pc.w;
1486     BC1T(0);
1487     /* delay slot */
1488     movi(r0, 1);
1489     movi(r0, 0);
1490     patch_at(w, _jit->pc.w);
1491 }
1492 dopi(eq)
1493
1494 static void
1495 _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1496 {
1497     jit_word_t          w;
1498     C_ULT_D(r1, r2);
1499     w = _jit->pc.w;
1500     BC1F(0);
1501     /* delay slot */
1502     movi(r0, 1);
1503     movi(r0, 0);
1504     patch_at(w, _jit->pc.w);
1505 }
1506 dopi(ge)
1507
1508 static void
1509 _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1510 {
1511     jit_word_t          w;
1512     C_ULE_D(r1, r2);
1513     w = _jit->pc.w;
1514     BC1F(0);
1515     /* delay slot */
1516     movi(r0, 1);
1517     movi(r0, 0);
1518     patch_at(w, _jit->pc.w);
1519 }
1520 dopi(gt)
1521
1522 static void
1523 _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1524 {
1525     jit_word_t          w;
1526     C_EQ_D(r1, r2);
1527     w = _jit->pc.w;
1528     BC1F(0);
1529     /* delay slot */
1530     movi(r0, 1);
1531     movi(r0, 0);
1532     patch_at(w, _jit->pc.w);
1533 }
1534 dopi(ne)
1535
1536 static void
1537 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1538 {
1539     jit_word_t          w;
1540     C_ULT_D(r1, r2);
1541     w = _jit->pc.w;
1542     BC1T(0);
1543     /* delay slot */
1544     movi(r0, 1);
1545     movi(r0, 0);
1546     patch_at(w, _jit->pc.w);
1547 }
1548 dopi(unlt)
1549
1550 static void
1551 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1552 {
1553     jit_word_t          w;
1554     C_ULE_D(r1, r2);
1555     w = _jit->pc.w;
1556     BC1T(0);
1557     /* delay slot */
1558     movi(r0, 1);
1559     movi(r0, 0);
1560     patch_at(w, _jit->pc.w);
1561 }
1562 dopi(unle)
1563
1564 static void
1565 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1566 {
1567     jit_word_t          w;
1568     C_UEQ_D(r1, r2);
1569     w = _jit->pc.w;
1570     BC1T(0);
1571     /* delay slot */
1572     movi(r0, 1);
1573     movi(r0, 0);
1574     patch_at(w, _jit->pc.w);
1575 }
1576 dopi(uneq)
1577
1578 static void
1579 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1580 {
1581     jit_word_t          w;
1582     C_OLT_D(r1, r2);
1583     w = _jit->pc.w;
1584     BC1F(0);
1585     /* delay slot */
1586     movi(r0, 1);
1587     movi(r0, 0);
1588     patch_at(w, _jit->pc.w);
1589 }
1590 dopi(unge)
1591
1592 static void
1593 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1594 {
1595     jit_word_t          w;
1596     C_OLE_D(r1, r2);
1597     w = _jit->pc.w;
1598     BC1F(0);
1599     /* delay slot */
1600     movi(r0, 1);
1601     movi(r0, 0);
1602     patch_at(w, _jit->pc.w);
1603 }
1604 dopi(ungt)
1605
1606 static void
1607 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1608 {
1609     jit_word_t          w;
1610     C_UEQ_D(r1, r2);
1611     w = _jit->pc.w;
1612     BC1F(0);
1613     /* delay slot */
1614     movi(r0, 1);
1615     movi(r0, 0);
1616     patch_at(w, _jit->pc.w);
1617 }
1618 dopi(ltgt)
1619
1620 static void
1621 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1622 {
1623     jit_word_t          w;
1624     C_UN_D(r1, r2);
1625     w = _jit->pc.w;
1626     BC1F(0);
1627     /* delay slot */
1628     movi(r0, 1);
1629     movi(r0, 0);
1630     patch_at(w, _jit->pc.w);
1631 }
1632 dopi(ord)
1633
1634 static void
1635 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1636 {
1637     jit_word_t          w;
1638     C_UN_D(r1, r2);
1639     w = _jit->pc.w;
1640     BC1T(0);
1641     /* delay slot */
1642     movi(r0, 1);
1643     movi(r0, 0);
1644     patch_at(w, _jit->pc.w);
1645 }
1646 dopi(unord)
1647
1648 static jit_word_t
1649 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1650 {
1651     jit_word_t          w;
1652     C_OLT_D(r1, r2);
1653     w = _jit->pc.w;
1654     BC1T(((i0 - w) >> 2) - 1);
1655     NOP(1);
1656     return (w);
1657 }
1658 dbopi(lt)
1659
1660 static jit_word_t
1661 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1662 {
1663     jit_word_t          w;
1664     C_OLE_D(r1, r2);
1665     w = _jit->pc.w;
1666     BC1T(((i0 - w) >> 2) - 1);
1667     NOP(1);
1668     return (w);
1669 }
1670 dbopi(le)
1671
1672 static jit_word_t
1673 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1674 {
1675     jit_word_t          w;
1676     C_EQ_D(r1, r2);
1677     w = _jit->pc.w;
1678     BC1T(((i0 - w) >> 2) - 1);
1679     NOP(1);
1680     return (w);
1681 }
1682 dbopi(eq)
1683
1684 static jit_word_t
1685 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1686 {
1687     jit_word_t          w;
1688     C_ULT_D(r1, r2);
1689     w = _jit->pc.w;
1690     BC1F(((i0 - w) >> 2) - 1);
1691     NOP(1);
1692     return (w);
1693 }
1694 dbopi(ge)
1695
1696 static jit_word_t
1697 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1698 {
1699     jit_word_t          w;
1700     C_ULE_D(r1, r2);
1701     w = _jit->pc.w;
1702     BC1F(((i0 - w) >> 2) - 1);
1703     NOP(1);
1704     return (w);
1705 }
1706 dbopi(gt)
1707
1708 static jit_word_t
1709 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1710 {
1711     jit_word_t          w;
1712     C_EQ_D(r1, r2);
1713     w = _jit->pc.w;
1714     BC1F(((i0 - w) >> 2) - 1);
1715     NOP(1);
1716     return (w);
1717 }
1718 dbopi(ne)
1719
1720 static jit_word_t
1721 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1722 {
1723     jit_word_t          w;
1724     C_ULT_D(r1, r2);
1725     w = _jit->pc.w;
1726     BC1T(((i0 - w) >> 2) - 1);
1727     NOP(1);
1728     return (w);
1729 }
1730 dbopi(unlt)
1731
1732 static jit_word_t
1733 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1734 {
1735     jit_word_t          w;
1736     C_ULE_D(r1, r2);
1737     w = _jit->pc.w;
1738     BC1T(((i0 - w) >> 2) - 1);
1739     NOP(1);
1740     return (w);
1741 }
1742 dbopi(unle)
1743
1744 static jit_word_t
1745 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1746 {
1747     jit_word_t          w;
1748     C_UEQ_D(r1, r2);
1749     w = _jit->pc.w;
1750     BC1T(((i0 - w) >> 2) - 1);
1751     NOP(1);
1752     return (w);
1753 }
1754 dbopi(uneq)
1755
1756 static jit_word_t
1757 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1758 {
1759     jit_word_t          w;
1760     C_OLT_D(r1, r2);
1761     w = _jit->pc.w;
1762     BC1F(((i0 - w) >> 2) - 1);
1763     NOP(1);
1764     return (w);
1765 }
1766 dbopi(unge)
1767
1768 static jit_word_t
1769 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1770 {
1771     jit_word_t          w;
1772     C_OLE_D(r1, r2);
1773     w = _jit->pc.w;
1774     BC1F(((i0 - w) >> 2) - 1);
1775     NOP(1);
1776     return (w);
1777 }
1778 dbopi(ungt)
1779
1780 static jit_word_t
1781 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1782 {
1783     jit_word_t          w;
1784     C_UEQ_D(r1, r2);
1785     w = _jit->pc.w;
1786     BC1F(((i0 - w) >> 2) - 1);
1787     NOP(1);
1788     return (w);
1789 }
1790 dbopi(ltgt)
1791
1792 static jit_word_t
1793 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1794 {
1795     jit_word_t          w;
1796     C_UN_D(r1, r2);
1797     w = _jit->pc.w;
1798     BC1F(((i0 - w) >> 2) - 1);
1799     NOP(1);
1800     return (w);
1801 }
1802 dbopi(ord)
1803
1804 static jit_word_t
1805 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
1806 {
1807     jit_word_t          w;
1808     C_UN_D(r1, r2);
1809     w = _jit->pc.w;
1810     BC1T(((i0 - w) >> 2) - 1);
1811     NOP(1);
1812     return (w);
1813 }
1814 dbopi(unord)
1815
1816 static void
1817 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1818 {
1819 #if !NEW_ABI
1820     jit_int32_t         reg;
1821 #endif
1822     assert(_jitc->function->self.call & jit_call_varargs);
1823 #if !NEW_ABI
1824     /* Align, if required. */
1825     reg = jit_get_reg(jit_class_gpr);
1826     andi(rn(reg), r1, 7);
1827     addr(r1, r1, rn(reg));
1828     jit_unget_reg(reg);
1829 #endif
1830
1831     /* Load argument. */
1832     ldr_d(r0, r1);
1833
1834     /* Update va_list. */
1835     addi(r1, r1, sizeof(jit_float64_t));
1836 }
1837
1838 #  undef fopi
1839 #  undef fbopi
1840 #  undef dopi
1841 #  undef dbopi
1842 #  undef fpr_bopi
1843 #  undef fpr_opi
1844 #endif