deps/lightning/lib/jit_hppa-fpu.c

   1 /*
   2  * Copyright (C) 2013-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21
  22 /* FIXME should actually be hw model/version/etc or other constraint
  23  * that causes a SIGSEGV/SIGILL if using these instructions */
  24 #if 1 //defined(__hpux)
  25 #  define FSTXR                         0
  26 #  define FLDXR                         0
  27 #else
  28 #  define FSTXR                         1
  29 #  define FLDXR                         1
  30 #endif
  31
  32 #define f39(o,b,x,t)                    _f39(_jit,o,b,x,t)
  33 static void _f39(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  34 #define f40(o,b,x,r)                    _f40(_jit,o,b,x,r)
  35 static void _f40(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
  36     maybe_unused;
  37 #define f41(o,b,x,t)                    _f41(_jit,o,b,x,t)
  38 static void _f41(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  39 #define f42(o,b,i,r)                    _f42(_jit,o,b,i,r)
  40 static void _f42(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  41 #define f43(o,b,t,i)                    f1(o,b,t,i)
  42 #define f45(o,r,a,b,fmt,c,d,e,t)        _f45(_jit,o,r,a,b,fmt,c,d,e,t)
  43 static void _f45(jit_state_t*,jit_int32_t,
  44                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  45                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
  46 #define f46(o,r,a,s,df,sf,b,c,d,t)      _f46(_jit,o,r,a,s,df,sf,b,c,d,t)
  47 static void _f46(jit_state_t*,jit_int32_t,jit_int32_t,
  48                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  49                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  50 #define f47(o,r1,r2,a,fmt,b,c,d,t)      f47_48(o,r1,r2,a,fmt,b,c,d,t)
  51 #define f48(o,r1,r2,a,fmt,b,c,d,t)      f47_48(o,r1,r2,a,fmt,b,c,d,t)
  52 #define f47_48(o,r1,r2,y,fmt,b,c,d,t)   _f47_48(_jit,o,r1,r2,y,fmt,b,c,d,t)
  53 static void _f47_48(jit_state_t*,jit_int32_t,
  54                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  55                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  56 #define f49(o,r,a,b,c,f,d,e,g,h,i,t)    f49_52(o,r,a,b,c,f,d,e,g,h,i,t)
  57 #define f51(o,r1,r2,y,a,f,b,d,e,g,h,c)  f49_52(o,r1,r2,y,a,f,b,d,e,g,h,c)
  58 #define f52(o,r1,r2,a,b,f,c,d,e,g,h,t)  f49_52(o,r1,r2,a,b,f,c,d,e,g,h,t)
  59 #define f49_52(o,r1,r2,y,v,f,a,b,u,c,d,t) _f49_52(_jit,o,r1,r2,y,v,f,a,b,u,c,d,t)
  60 static void _f49_52(jit_state_t*,jit_int32_t,
  61                     jit_int32_t,jit_int32_t,jit_int32_t,
  62                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  63                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  64 #define f53(o,r1,r2,ta,ra,f,tm)         _f53(_jit,o,r1,r2,ta,ra,f,tm)
  65 static void _f53(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
  66                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
  67 #define f54(o,r1,r2,a,b,f,c,d,e,g,t)    _f54(_jit,o,r1,r2,a,b,f,c,d,e,g,t)
  68 static void _f54(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
  69                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  70                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
  71 #define FABS_(f,r,t)                    f49(0xe,r,0,3,0,f,0,0,0,0,0,t)
  72 #define FABS_S(r,t)                     FABS_(0,r,t)
  73 #define FABS_D(r,t)                     FABS_(1,r,t)
  74 #define FABS_Q(r,t)                     f45(0xc,r,0,3,3,0,0,0,t)
  75 #define FADD_(f,r1,r2,t)                f52(0xe,r1,r2,0,0,f,3,0,0,0,0,t)
  76 #define FADD_S(r1,r2,t)                 FADD_(0,r1,r2,t)
  77 #define FADD_D(r1,r2,t)                 FADD_(1,r1,r2,t)
  78 #define FADD_Q(r1,r2,t)                 f48(0xc,r1,r2,0,3,3,0,0,t)
  79 #define FPSR_GT                         1
  80 #define FPSR_LT                         2
  81 #define FPSR_EQ                         4
  82 #define FPSR_UN                         8
  83 /*
  84     Actually these are reversed, but easier for the FTEST after the FCMP
  85     fcmp,dbl,false? fr4,fr12            0
  86     fcmp,dbl,false fr4,fr12             1
  87     fcmp,dbl,? fr4,fr12                 2
  88     fcmp,dbl,!<=> fr4,fr12              3               ORD
  89     fcmp,dbl,= fr4,fr12                 4               NE
  90     fcmp,dbl,=t fr4,fr12                5
  91     fcmp,dbl,?= fr4,fr12                6
  92     fcmp,dbl,!<> fr4,fr12               7               LTGT
  93     fcmp,dbl,!?>= fr4,fr12              8
  94     fcmp,dbl,< fr4,fr12                 9               UNGE
  95     fcmp,dbl,?< fr4,fr12                10
  96     fcmp,dbl,!>= fr4,fr12               11              GE
  97     fcmp,dbl,!?> fr4,fr12               12
  98     fcmp,dbl,<= fr4,fr12                13              UNGT
  99     fcmp,dbl,?<= fr4,fr12               14
 100     fcmp,dbl,!> fr4,fr12                15              GT
 101     fcmp,dbl,!?<= fr4,fr12              16
 102     fcmp,dbl,> fr4,fr12                 17              UNLE
 103     fcmp,dbl,?> fr4,fr12                18
 104     fcmp,dbl,!<= fr4,fr12               19              LE
 105     fcmp,dbl,!?< fr4,fr12               20
 106     fcmp,dbl,>= fr4,fr12                21              UNLT
 107     fcmp,dbl,?>= fr4,fr12               22
 108     fcmp,dbl,!< fr4,fr12                23              LT
 109     fcmp,dbl,!?= fr4,fr12               24
 110     fcmp,dbl,<> fr4,fr12                25              UNEQ
 111     fcmp,dbl,!= fr4,fr12                26              EQ
 112     fcmp,dbl,!=t fr4,fr12               27
 113     fcmp,dbl,!? fr4,fr12                28
 114     fcmp,dbl,<=> fr4,fr12               29              UNORD
 115     fcmp,dbl,true? fr4,fr12             30
 116     fcmp,dbl,true fr4,fr12              31
 117  */
 118 #define FCMP_LT                         23
 119 #define FCMP_LE                         19
 120 #define FCMP_EQ                         26
 121 #define FCMP_GE                         11
 122 #define FCMP_GT                         15
 123 #define FCMP_NE                         4
 124 #define FCMP_UNLT                       21
 125 #define FCMP_UNLE                       17
 126 #define FCMP_UNEQ                       25
 127 #define FCMP_UNGE                       9
 128 #define FCMP_UNGT                       13
 129 #define FCMP_LTGT                       7
 130 #define FCMP_ORD                        3
 131 #define FCMP_UNORD                      29
 132 #define FCMP_(f,r1,r2,c)                f51(0xe,r1,r2,0,0,f,2,0,0,0,0,c)
 133 #define FCMP_S_(r1,r2,c)                FCMP_(0,r1,r2,c)
 134 #define FCMP_D_(r1,r2,c)                FCMP_(1,r1,r2,c)
 135 #define FCMP_Q_(r1,r2,c)                f47(0xc,r1,r2,0,3,2,0,0,c)
 136 #define FCMP_S_LT(r1,r2)                FCMP_S_(r1,r2,FCMP_LT)
 137 #define FCMP_D_LT(r1,r2)                FCMP_D_(r1,r2,FCMP_LT)
 138 #define FCMP_Q_LT(r1,r2)                FCMP_Q_(r1,r2,FCMP_LT)
 139 #define FCMP_S_LE(r1,r2)                FCMP_S_(r1,r2,FCMP_LE)
 140 #define FCMP_D_LE(r1,r2)                FCMP_D_(r1,r2,FCMP_LE)
 141 #define FCMP_Q_LE(r1,r2)                FCMP_Q_(r1,r2,FCMP_LE)
 142 #define FCMP_S_EQ(r1,r2)                FCMP_S_(r1,r2,FCMP_EQ)
 143 #define FCMP_D_EQ(r1,r2)                FCMP_D_(r1,r2,FCMP_EQ)
 144 #define FCMP_Q_EQ(r1,r2)                FCMP_Q_(r1,r2,FCMP_EQ)
 145 #define FCMP_S_GE(r1,r2)                FCMP_S_(r1,r2,FCMP_GE)
 146 #define FCMP_D_GE(r1,r2)                FCMP_D_(r1,r2,FCMP_GE)
 147 #define FCMP_Q_GE(r1,r2)                FCMP_Q_(r1,r2,FCMP_GE)
 148 #define FCMP_S_GT(r1,r2)                FCMP_S_(r1,r2,FCMP_GT)
 149 #define FCMP_D_GT(r1,r2)                FCMP_D_(r1,r2,FCMP_GT)
 150 #define FCMP_Q_GT(r1,r2)                FCMP_Q_(r1,r2,FCMP_GT)
 151 #define FCMP_S_NE(r1,r2)                FCMP_S_(r1,r2,FCMP_NE)
 152 #define FCMP_D_NE(r1,r2)                FCMP_D_(r1,r2,FCMP_NE)
 153 #define FCMP_Q_NE(r1,r2)                FCMP_Q_(r1,r2,FCMP_NE)
 154 #define FCMP_S_UNLT(r1,r2)              FCMP_S_(r1,r2,FCMP_UNLT)
 155 #define FCMP_D_UNLT(r1,r2)              FCMP_D_(r1,r2,FCMP_UNLT)
 156 #define FCMP_Q_UNLT(r1,r2)              FCMP_Q_(r1,r2,FCMP_UNLT)
 157 #define FCMP_S_UNLE(r1,r2)              FCMP_S_(r1,r2,FCMP_UNLE)
 158 #define FCMP_D_UNLE(r1,r2)              FCMP_D_(r1,r2,FCMP_UNLE)
 159 #define FCMP_Q_UNLE(r1,r2)              FCMP_Q_(r1,r2,FCMP_UNLE)
 160 #define FCMP_S_UNEQ(r1,r2)              FCMP_S_(r1,r2,FCMP_UNEQ)
 161 #define FCMP_D_UNEQ(r1,r2)              FCMP_D_(r1,r2,FCMP_UNEQ)
 162 #define FCMP_Q_UNEQ(r1,r2)              FCMP_Q_(r1,r2,FCMP_UNEQ)
 163 #define FCMP_S_UNGE(r1,r2)              FCMP_S_(r1,r2,FCMP_UNGE)
 164 #define FCMP_D_UNGE(r1,r2)              FCMP_D_(r1,r2,FCMP_UNGE)
 165 #define FCMP_Q_UNGE(r1,r2)              FCMP_Q_(r1,r2,FCMP_UNGE)
 166 #define FCMP_S_UNGT(r1,r2)              FCMP_S_(r1,r2,FCMP_UNGT)
 167 #define FCMP_D_UNGT(r1,r2)              FCMP_D_(r1,r2,FCMP_UNGT)
 168 #define FCMP_Q_UNGT(r1,r2)              FCMP_Q_(r1,r2,FCMP_UNGT)
 169 #define FCMP_S_LTGT(r1,r2)              FCMP_S_(r1,r2,FCMP_LTGT)
 170 #define FCMP_D_LTGT(r1,r2)              FCMP_D_(r1,r2,FCMP_LTGT)
 171 #define FCMP_Q_LTGT(r1,r2)              FCMP_Q_(r1,r2,FCMP_LTGT)
 172 #define FCMP_S_ORD(r1,r2)               FCMP_S_(r1,r2,FCMP_ORD)
 173 #define FCMP_D_ORD(r1,r2)               FCMP_D_(r1,r2,FCMP_ORD)
 174 #define FCMP_Q_ORD(r1,r2)               FCMP_Q_(r1,r2,FCMP_ORD)
 175 #define FCMP_S_UNORD(r1,r2)             FCMP_S_(r1,r2,FCMP_UNORD)
 176 #define FCMP_D_UNORD(r1,r2)             FCMP_D_(r1,r2,FCMP_UNORD)
 177 #define FCMP_Q_UNORD(r1,r2)             FCMP_Q_(r1,r2,FCMP_UNORD)
 178 #define XFNVFF(s,d,r,t)                 f46(0xc,r,0,0,d,s,1,0,0,t)
 179 #define FCNVFF_Q_S(r,t)                 XFNVFF(3,0,r,t)
 180 #define FCNVFF_Q_D(r,t)                 XFNVFF(3,1,r,t)
 181 #define FCNVFF_S_Q(r,t)                 XFNVFF(0,3,r,t)
 182 #define FCNVFF_D_Q(r,t)                 XFNVFF(1,3,r,t)
 183 #define FCNVFF_(s,d,r,t)                f46(0xc,r,0,0,d,s,1,0,0,t)
 184 #define FCNVFF_S_D(r,t)                 FCNVFF_(0,1,r,t)
 185 #define FCNVFF_D_S(r,t)                 FCNVFF_(1,0,r,t)
 186 #define FCNVXF_(s,d,r,t)                f46(0xc,r,0,1,d,s,1,0,0,t)
 187 #define FCNVXF_S_S(r,t)                 FCNVXF_(0,0,r,t)
 188 #define FCNVXF_S_D(r,t)                 FCNVXF_(0,1,r,t)
 189 #define FCNVXT_(s,d,r,t)                f46(0xc,r,0,3,d,s,1,0,0,t)
 190 #define FCNVXT_S_S(r,t)                 FCNVXT_(0,0,r,t)
 191 #define FCNVXT_D_S(r,t)                 FCNVXT_(1,0,r,t)
 192 #define FCPY_(f,r,t)                    f49(0xe,r,0,2,0,f,0,0,0,0,0,t)
 193 #define FCPY_S(r,t)                     FCPY_(0,r,t)
 194 #define FCPY_D(r,t)                     FCPY_(1,r,t)
 195 #define FCPY_Q(r,t)                     f45(0xc,r,0,2,2,0,0,0,t)
 196 #define FDIV_(f,r1,r2,t)                f52(0xe,r1,r2,3,0,f,3,0,0,0,0,t)
 197 #define FDIV_S(r1,r2,t)                 FDIV_(0,r1,r2,t)
 198 #define FDIV_D(r1,r2,t)                 FDIV_(1,r1,r2,t)
 199 #define FDIV_Q(r1,r2,t)                 f48(0xc,r1,r2,3,3,3,0,0,t)
 200 #define FID()                           f45(0xc,0,0,0,2,0,0,0,0)
 201 #define FLDDL(i,b,t)                    f3(0x14,b,t,i,1)
 202 #define FLDD(x,b,t)                     f39(0xb,b,x,t)
 203 #define FLDDI(i,b,t)                    f41(0xb,b,i,t)
 204 #define FLDWL(i,b,t)                    f43(0x17,b,t,i)
 205 #define FLDW(x,b,t)                     f39(0x9,b,x,t)
 206 #define FLDWI(i,b,t)                    f41(0x9,b,i,t)
 207 #define FMPY_(f,r1,r2,t)                f52(0xe,r1,r2,2,0,f,3,0,0,0,0,t)
 208 #define FMPY_S(r1,r2,t)                 FMPY_(0,r1,r2,t)
 209 #define FMPY_D(r1,r2,t)                 FMPY_(1,r1,r2,t)
 210 #define FMPY_Q(r1,r2,t)                 f48(0xc,r1,r2,2,3,3,0,0,t)
 211 /* FIXME not disassembled */
 212 #define FMPYADD_(f,r1,r2,ta,ra,tm)      f53(0x6,r1,r2,ta,ra,f,tm)
 213 #define FMPYADD_S(r1,r2,ta,ra,tm)       FMPYADD_(0,r1,r2,ta,ra,tm)
 214 #define FMPYADD_D(r1,r2,ta,ra,tm)       FMPYADD_(1,r1,r2,ta,ra,tm)
 215 #define FMPYFADD_(f,r1,r2,ra,t)         f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,0,t)
 216 #define FMPYFADD_S(r1,r2,ra,t)          FMPYFADD_(0,r1,r2,ra,t)
 217 #define FMPYFADD_D(r1,r2,ra,t)          FMPYFADD_(1,r1,r2,ra,t)
 218 #define FMPYNFADD_(f,r1,r2,ra,t)        f54(0x2e,r1,r2,ra>>3,0,f,(ra)&7,0,0,1,t)
 219 #define FMPYNFADD_S(r1,r2,ra,t)         FMPYNFADD_(0,r1,r2,ra,t)
 220 #define FMPYNFADD_D(r1,r2,ra,t)         FMPYNFADD_(1,r1,r2,ra,t)
 221 #define FMPYSUB_(f,r1,r2,ta,ra,tm)      f53(0x26,r1,r2,ta,ra,f,tm)
 222 #define FMPYSUB_S(r1,r2,ta,ra,tm)       FMPYSUB_(0,r1,r2,ta,ra,tm)
 223 #define FMPYSUB_D(r1,r2,ta,ra,tm)       FMPYSUB_(1,r1,r2,ta,ra,tm)
 224 #define FNEG_(f,r,t)                    f49(0xe,r,0,6,0,f,0,0,0,0,0,t)
 225 #define FNEG_S(r,t)                     FNEG_(0,r,t)
 226 #define FNEG_D(r,t)                     FNEG_(1,r,t)
 227 /* FIXME not disassembled */
 228 #define FNEG_Q(r,t)                     f45(0xc,r,0,6,3,0,0,0,t)
 229 #define FNEGABS_(f,r,t)                 f49(0xe,r,0,7,0,f,0,0,0,0,0,t)
 230 #define FNEGABS_S(r,t)                  FNEGABS_(0,r,t)
 231 #define FNEGABS_D(r,t)                  FNEGABS_(1,r,t)
 232 #define FNEGABS_Q(r,t)                  f45(0xc,r,0,7,3,0,0,0,t)
 233 #define FRND_(f,r,t)                    f49(0xe,r,0,5,0,f,0,0,0,0,0,t)
 234 #define FRND_S(r,t)                     FRND_(0,r,t)
 235 #define FRND_D(r,t)                     FRND_(1,r,t)
 236 #define FRND_Q(r,t)                     f45(0xc,r,0,5,3,0,0,0,t)
 237 #define FSQRT_(f,r,t)                   f49(0xe,r,0,4,0,f,0,0,0,0,0,t)
 238 #define FSQRT_S(r,t)                    FSQRT_(0,r,t)
 239 #define FSQRT_D(r,t)                    FSQRT_(1,r,t)
 240 #define FSQRT_Q(r,t)                    f45(0xc,r,0,4,3,0,0,0,t)
 241 #define FSTDL(r,i,b)                    f3(0x1c,b,r,i,1)
 242 #define FSTD(r,x,b)                     f40(0xb,b,x,r)
 243 #define FSTDI(r,i,b)                    f42(0xb,b,i,r)
 244 #define FSTWL(r,i,b)                    f43(0x1f,b,r,i)
 245 #define FSTW(r,x,b)                     f40(0x9,b,x,r)
 246 #define FSTWI(r,i,b)                    f42(0x9,b,i,r)
 247 #define FSUB_(f,r1,r2,t)                f52(0xe,r1,r2,1,0,f,3,0,0,0,0,t)
 248 #define FSUB_S(r1,r2,t)                 FSUB_(0,r1,r2,t)
 249 #define FSUB_D(r1,r2,t)                 FSUB_(1,r1,r2,t)
 250 #define FSUB_Q(r1,r2,t)                 f48(0xc,r1,r2,1,3,3,0,0,t)
 251 #define FTEST_(c)                       f47(0xc,0,0,0,0,2,0,1,c)
 252 #define FTEST()                         f47(0xc,0,0,1,0,2,0,1,0)
 253 #define FTEST_LT()                      FTEST_(FCMP_LT)
 254 #define FTEST_LE()                      FTEST_(FCMP_LE)
 255 #define FTEST_EQ()                      FTEST_(FCMP_EQ)
 256 #define FTEST_GE()                      FTEST_(FCMP_GE)
 257 #define FTEST_GT()                      FTEST_(FCMP_GT)
 258 #define FTEST_NE()                      FTEST_(FCMP_NE)
 259 #define FTEST_UNLT()                    FTEST_(FCMP_UNLT)
 260 #define FTEST_UNLE()                    FTEST_(FCMP_UNLE)
 261 #define FTEST_UNEQ()                    FTEST_(FCMP_UNEQ)
 262 #define FTEST_UNGE()                    FTEST_(FCMP_UNGE)
 263 #define FTEST_UNGT()                    FTEST_(FCMP_UNGT)
 264 #define FTEST_LTGT()                    FTEST_(FCMP_LTGT)
 265 #define FTEST_ORD()                     FTEST_(FCMP_ORD)
 266 #define FTEST_UNORD()                   FTEST_(FCMP_UNORD)
 267 #define XMPYU(r1,r2,t)                  f52(0xe,r1,r2,2,0,0,3,1,0,0,0,t)
 268 #define XMPYU_L_R(r1,r2,t)              f52(0xe,r1,r2,2,1,0,3,1,0,0,0,t)
 269 #define XMPYU_R_L(r1,r2,t)              f52(0xe,r1,r2,2,0,0,3,1,1,0,0,t)
 270 #define XMPYU_R_R(r1,r2,t)              f52(0xe,r1,r2,2,1,0,3,1,1,0,0,t)
 271 #define negr_f(r0,r1)                   FNEG_S(r1,r0)
 272 #define negr_d(r0,r1)                   FNEG_D(r1,r0)
 273 #define sqrtr_f(r0,r1)                  FSQRT_S(r1,r0)
 274 #define fmar_f(r0,r1,r2,r3)             _fmar_f(_jit,r0,r1,r2,r3)
 275 static void _fmar_f(jit_state_t*,
 276                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 277 #define fmsr_f(r0,r1,r2,r3)             _fmsr_f(_jit,r0,r1,r2,r3)
 278 static void _fmsr_f(jit_state_t*,
 279                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 280 #define fnmar_f(r0,r1,r2,r3)            _fnmar_f(_jit,r0,r1,r2,r3)
 281 static void _fnmar_f(jit_state_t*,
 282                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 283 #define fnmsr_f(r0,r1,r2,r3)            _fnmsr_f(_jit,r0,r1,r2,r3)
 284 static void _fnmsr_f(jit_state_t*,
 285                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 286 #define sqrtr_d(r0,r1)                  FSQRT_D(r1,r0)
 287 #define fmar_d(r0,r1,r2,r3)             _fmar_d(_jit,r0,r1,r2,r3)
 288 static void _fmar_d(jit_state_t*,
 289                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 290 #define fmsr_d(r0,r1,r2,r3)             _fmsr_d(_jit,r0,r1,r2,r3)
 291 static void _fmsr_d(jit_state_t*,
 292                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 293 #define fnmar_d(r0,r1,r2,r3)            _fnmar_d(_jit,r0,r1,r2,r3)
 294 static void _fnmar_d(jit_state_t*,
 295                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 296 #define fnmsr_d(r0,r1,r2,r3)            _fnmsr_d(_jit,r0,r1,r2,r3)
 297 static void _fnmsr_d(jit_state_t*,
 298                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 299 #define extr_f(r0,r1)                   _extr_f(_jit,r0,r1)
 300 static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 301 #define extr_d(r0,r1)                   _extr_d(_jit,r0,r1)
 302 static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 303 #define extr_f_d(r0,r1)                 FCNVFF_S_D(r1,r0)
 304 #define extr_d_f(r0,r1)                 FCNVFF_D_S(r1,r0)
 305 #define truncr_f(r0,r1)                 truncr_f_i(r0,r1)
 306 #define truncr_f_i(r0,r1)               _truncr_f_i(_jit,r0,r1)
 307 static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
 308 #define truncr_d(r0,r1)                 truncr_d_i(r0,r1)
 309 #define truncr_d_i(r0,r1)               _truncr_d_i(_jit,r0,r1)
 310 static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
 311 #define movr_f(r0,r1)                   FCPY_S(r1,r0)
 312 #define movi_f(r0,i0)                   _movi_f(_jit,r0,i0)
 313 static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
 314 #define movi_w_f(r0, i0)                _movi_w_f(_jit, r0, i0)
 315 static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t);
 316 #define movr_d(r0,r1)                   FCPY_D(r1,r0)
 317 #define movi_d(r0,i0)                   _movi_d(_jit,r0,i0)
 318 static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
 319 #define movi_ww_d(r0, i0, i1)           _movi_ww_d(_jit, r0, i0, i1)
 320 static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
 321 #define absr_f(r0,r1)                   FABS_S(r1,r0)
 322 #define absr_d(r0,r1)                   FABS_D(r1,r0)
 323 #define addr_f(r0,r1,r2)                FADD_S(r1,r2,r0)
 324 #define addi_f(r0,r1,i0)                _addi_f(_jit,r0,r1,i0)
 325 static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 326 #define addr_d(r0,r1,r2)                FADD_D(r1,r2,r0)
 327 #define addi_d(r0,r1,i0)                _addi_d(_jit,r0,r1,i0)
 328 static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 329 #define subr_f(r0,r1,r2)                FSUB_S(r1,r2,r0)
 330 #define subi_f(r0,r1,i0)                _subi_f(_jit,r0,r1,i0)
 331 static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 332 #define subr_d(r0,r1,r2)                FSUB_D(r1,r2,r0)
 333 #define subi_d(r0,r1,i0)                _subi_d(_jit,r0,r1,i0)
 334 static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 335 #define rsbr_f(r0,r1,r2)                subr_f(r0,r2,r1)
 336 #define rsbi_f(r0,r1,i0)                _rsbi_f(_jit,r0,r1,i0)
 337 static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 338 #define rsbr_d(r0,r1,r2)                subr_d(r0,r2,r1)
 339 #define rsbi_d(r0,r1,i0)                _rsbi_d(_jit,r0,r1,i0)
 340 static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 341 #define mulr_f(r0,r1,r2)                FMPY_S(r1,r2,r0)
 342 #define muli_f(r0,r1,i0)                _muli_f(_jit,r0,r1,i0)
 343 static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 344 #define mulr_d(r0,r1,r2)                FMPY_D(r1,r2,r0)
 345 #define muli_d(r0,r1,i0)                _muli_d(_jit,r0,r1,i0)
 346 static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 347 #define divr_f(r0,r1,r2)                FDIV_S(r1,r2,r0)
 348 #define divi_f(r0,r1,i0)                _divi_f(_jit,r0,r1,i0)
 349 static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 350 #define divr_d(r0,r1,r2)                FDIV_D(r1,r2,r0)
 351 #define divi_d(r0,r1,i0)                _divi_d(_jit,r0,r1,i0)
 352 static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 353 #define cmpr_f(c,r0,r1,r2)              _cmpr_f(_jit,c,r0,r1,r2)
 354 static void _cmpr_f(jit_state_t*,jit_word_t,
 355                     jit_int32_t,jit_int32_t,jit_int32_t);
 356 #define cmpi_f(c,r0,r1,i0)              _cmpi_f(_jit,c,r0,r1,i0)
 357 static void _cmpi_f(jit_state_t*,jit_word_t,
 358                     jit_int32_t,jit_int32_t,jit_float32_t*);
 359 #define cmpr_d(c,r0,r1,r2)              _cmpr_d(_jit,c,r0,r1,r2)
 360 static void _cmpr_d(jit_state_t*,jit_word_t,
 361                     jit_int32_t,jit_int32_t,jit_int32_t);
 362 #define cmpi_d(c,r0,r1,i0)              _cmpi_d(_jit,c,r0,r1,i0)
 363 static void _cmpi_d(jit_state_t*,jit_word_t,
 364                     jit_int32_t,jit_int32_t,jit_float64_t*);
 365 #define ltr_f(r0,r1,r2)                 cmpr_f(FCMP_LT,r0,r1,r2)
 366 #define lti_f(r0,r1,i0)                 cmpi_f(FCMP_LT,r0,r1,i0)
 367 #define ltr_d(r0,r1,r2)                 cmpr_d(FCMP_LT,r0,r1,r2)
 368 #define lti_d(r0,r1,i0)                 cmpi_d(FCMP_LT,r0,r1,i0)
 369 #define ler_f(r0,r1,r2)                 cmpr_f(FCMP_LE,r0,r1,r2)
 370 #define lei_f(r0,r1,i0)                 cmpi_f(FCMP_LE,r0,r1,i0)
 371 #define ler_d(r0,r1,r2)                 cmpr_d(FCMP_LE,r0,r1,r2)
 372 #define lei_d(r0,r1,i0)                 cmpi_d(FCMP_LE,r0,r1,i0)
 373 #define eqr_f(r0,r1,r2)                 cmpr_f(FCMP_EQ,r0,r1,r2)
 374 #define eqi_f(r0,r1,i0)                 cmpi_f(FCMP_EQ,r0,r1,i0)
 375 #define eqr_d(r0,r1,r2)                 cmpr_d(FCMP_EQ,r0,r1,r2)
 376 #define eqi_d(r0,r1,i0)                 cmpi_d(FCMP_EQ,r0,r1,i0)
 377 #define ger_f(r0,r1,r2)                 cmpr_f(FCMP_GE,r0,r1,r2)
 378 #define gei_f(r0,r1,i0)                 cmpi_f(FCMP_GE,r0,r1,i0)
 379 #define ger_d(r0,r1,r2)                 cmpr_d(FCMP_GE,r0,r1,r2)
 380 #define gei_d(r0,r1,i0)                 cmpi_d(FCMP_GE,r0,r1,i0)
 381 #define gtr_f(r0,r1,r2)                 cmpr_f(FCMP_GT,r0,r1,r2)
 382 #define gti_f(r0,r1,i0)                 cmpi_f(FCMP_GT,r0,r1,i0)
 383 #define gtr_d(r0,r1,r2)                 cmpr_d(FCMP_GT,r0,r1,r2)
 384 #define gti_d(r0,r1,i0)                 cmpi_d(FCMP_GT,r0,r1,i0)
 385 #define ner_f(r0,r1,r2)                 cmpr_f(FCMP_NE,r0,r1,r2)
 386 #define nei_f(r0,r1,i0)                 cmpi_f(FCMP_NE,r0,r1,i0)
 387 #define ner_d(r0,r1,r2)                 cmpr_d(FCMP_NE,r0,r1,r2)
 388 #define nei_d(r0,r1,i0)                 cmpi_d(FCMP_NE,r0,r1,i0)
 389 #define unltr_f(r0,r1,r2)               cmpr_f(FCMP_UNLT,r0,r1,r2)
 390 #define unlti_f(r0,r1,i0)               cmpi_f(FCMP_UNLT,r0,r1,i0)
 391 #define unltr_d(r0,r1,r2)               cmpr_d(FCMP_UNLT,r0,r1,r2)
 392 #define unlti_d(r0,r1,i0)               cmpi_d(FCMP_UNLT,r0,r1,i0)
 393 #define unler_f(r0,r1,r2)               cmpr_f(FCMP_UNLE,r0,r1,r2)
 394 #define unlei_f(r0,r1,i0)               cmpi_f(FCMP_UNLE,r0,r1,i0)
 395 #define unler_d(r0,r1,r2)               cmpr_d(FCMP_UNLE,r0,r1,r2)
 396 #define unlei_d(r0,r1,i0)               cmpi_d(FCMP_UNLE,r0,r1,i0)
 397 #define uneqr_f(r0,r1,r2)               cmpr_f(FCMP_UNEQ,r0,r1,r2)
 398 #define uneqi_f(r0,r1,i0)               cmpi_f(FCMP_UNEQ,r0,r1,i0)
 399 #define uneqr_d(r0,r1,r2)               cmpr_d(FCMP_UNEQ,r0,r1,r2)
 400 #define uneqi_d(r0,r1,i0)               cmpi_d(FCMP_UNEQ,r0,r1,i0)
 401 #define unger_f(r0,r1,r2)               cmpr_f(FCMP_UNGE,r0,r1,r2)
 402 #define ungei_f(r0,r1,i0)               cmpi_f(FCMP_UNGE,r0,r1,i0)
 403 #define unger_d(r0,r1,r2)               cmpr_d(FCMP_UNGE,r0,r1,r2)
 404 #define ungei_d(r0,r1,i0)               cmpi_d(FCMP_UNGE,r0,r1,i0)
 405 #define ungtr_f(r0,r1,r2)               cmpr_f(FCMP_UNGT,r0,r1,r2)
 406 #define ungti_f(r0,r1,i0)               cmpi_f(FCMP_UNGT,r0,r1,i0)
 407 #define ungtr_d(r0,r1,r2)               cmpr_d(FCMP_UNGT,r0,r1,r2)
 408 #define ungti_d(r0,r1,i0)               cmpi_d(FCMP_UNGT,r0,r1,i0)
 409 #define ltgtr_f(r0,r1,r2)               cmpr_f(FCMP_LTGT,r0,r1,r2)
 410 #define ltgti_f(r0,r1,i0)               cmpi_f(FCMP_LTGT,r0,r1,i0)
 411 #define ltgtr_d(r0,r1,r2)               cmpr_d(FCMP_LTGT,r0,r1,r2)
 412 #define ltgti_d(r0,r1,i0)               cmpi_d(FCMP_LTGT,r0,r1,i0)
 413 #define ordr_f(r0,r1,r2)                cmpr_f(FCMP_ORD,r0,r1,r2)
 414 #define ordi_f(r0,r1,i0)                cmpi_f(FCMP_ORD,r0,r1,i0)
 415 #define ordr_d(r0,r1,r2)                cmpr_d(FCMP_ORD,r0,r1,r2)
 416 #define ordi_d(r0,r1,i0)                cmpi_d(FCMP_ORD,r0,r1,i0)
 417 #define unordr_f(r0,r1,r2)              cmpr_f(FCMP_UNORD,r0,r1,r2)
 418 #define unordi_f(r0,r1,i0)              cmpi_f(FCMP_UNORD,r0,r1,i0)
 419 #define unordr_d(r0,r1,r2)              cmpr_d(FCMP_UNORD,r0,r1,r2)
 420 #define unordi_d(r0,r1,i0)              cmpi_d(FCMP_UNORD,r0,r1,i0)
 421 #define ldr_f(r0,r1)                    FLDWI(0,r1,r0)
 422 #define ldi_f(r0,i0)                    _ldi_f(_jit,r0,i0)
 423 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 424 #if FLDXR
 425 #  define ldxr_f(r0,r1,r2)              FLDW(r2,r1,r0)
 426 #  define ldxr_d(r0,r1,r2)              FLDD(r2,r1,r0)
 427 #else
 428 #define ldxr_f(r0,r1,r2)                _ldxr_f(_jit,r0,r1,r2)
 429 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 430 #define ldxr_d(r0,r1,r2)                _ldxr_d(_jit,r0,r1,r2)
 431 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 432 #endif
 433 #define ldxi_f(r0,r1,i0)                _ldxi_f(_jit,r0,r1,i0)
 434 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 435 #define ldr_d(r0,r1)                    FLDDI(0,r1,r0)
 436 #define ldi_d(r0,i0)                    _ldi_d(_jit,r0,i0)
 437 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 438 #define ldxi_d(r0,r1,i0)                _ldxi_d(_jit,r0,r1,i0)
 439 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 440 #define str_f(r0,r1)                    FSTWI(r1,0,r0)
 441 #define sti_f(i0,r0)                    _sti_f(_jit,i0,r0)
 442 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 443 #if FSTXR
 444 #  define stxr_f(r0,r1,r2)              FSTW(r2,r1,r0)
 445 #  define stxr_d(r0,r1,r2)              FSTD(r2,r1,r0)
 446 #else
 447 #  define stxr_f(r0,r1,r2)              _stxr_f(_jit,r0,r1,r2)
 448 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 449 #  define stxr_d(r0,r1,r2)              _stxr_d(_jit,r0,r1,r2)
 450 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 451 #endif
 452 #define stxi_f(i0,r0,r1)                _stxi_f(_jit,i0,r0,r1)
 453 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 454 #define str_d(r0,r1)                    FSTDI(r1,0,r0)
 455 #define sti_d(i0,r0)                    _sti_d(_jit,i0,r0)
 456 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 457 #define stxi_d(i0,r0,r1)                _stxi_d(_jit,i0,r0,r1)
 458 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 459 #define bcmpr_f(c,i0,r0,r1)             _bcmpr_f(_jit,c,i0,r0,r1)
 460 static jit_word_t _bcmpr_f(jit_state_t*,jit_word_t,
 461                            jit_word_t,jit_int32_t,jit_int32_t);
 462 #define bcmpi_f(c,i0,r0,i1)             _bcmpi_f(_jit,c,i0,r0,i1)
 463 static jit_word_t _bcmpi_f(jit_state_t*,jit_word_t,
 464                            jit_word_t,jit_int32_t,jit_float32_t*);
 465 #define bcmpr_d(c,i0,r0,r1)             _bcmpr_d(_jit,c,i0,r0,r1)
 466 static jit_word_t _bcmpr_d(jit_state_t*,jit_word_t,
 467                            jit_word_t,jit_int32_t,jit_int32_t);
 468 #define bcmpi_d(c,i0,r0,i1)             _bcmpi_d(_jit,c,i0,r0,i1)
 469 static jit_word_t _bcmpi_d(jit_state_t*,jit_word_t,
 470                            jit_word_t,jit_int32_t,jit_float64_t*);
 471 #define bltr_f(i0,r0,r1)                bcmpr_f(FCMP_LT,i0,r0,r1)
 472 #define blti_f(i0,r0,i1)                bcmpi_f(FCMP_LT,i0,r0,i1)
 473 #define bltr_d(i0,r0,r1)                bcmpr_d(FCMP_LT,i0,r0,r1)
 474 #define blti_d(i0,r0,i1)                bcmpi_d(FCMP_LT,i0,r0,i1)
 475 #define bler_f(i0,r0,r1)                bcmpr_f(FCMP_LE,i0,r0,r1)
 476 #define blei_f(i0,r0,i1)                bcmpi_f(FCMP_LE,i0,r0,i1)
 477 #define bler_d(i0,r0,r1)                bcmpr_d(FCMP_LE,i0,r0,r1)
 478 #define blei_d(i0,r0,i1)                bcmpi_d(FCMP_LE,i0,r0,i1)
 479 #define beqr_f(i0,r0,r1)                bcmpr_f(FCMP_EQ,i0,r0,r1)
 480 #define beqi_f(i0,r0,i1)                bcmpi_f(FCMP_EQ,i0,r0,i1)
 481 #define beqr_d(i0,r0,r1)                bcmpr_d(FCMP_EQ,i0,r0,r1)
 482 #define beqi_d(i0,r0,i1)                bcmpi_d(FCMP_EQ,i0,r0,i1)
 483 #define bger_f(i0,r0,r1)                bcmpr_f(FCMP_GE,i0,r0,r1)
 484 #define bgei_f(i0,r0,i1)                bcmpi_f(FCMP_GE,i0,r0,i1)
 485 #define bger_d(i0,r0,r1)                bcmpr_d(FCMP_GE,i0,r0,r1)
 486 #define bgei_d(i0,r0,i1)                bcmpi_d(FCMP_GE,i0,r0,i1)
 487 #define bgtr_f(i0,r0,r1)                bcmpr_f(FCMP_GT,i0,r0,r1)
 488 #define bgti_f(i0,r0,i1)                bcmpi_f(FCMP_GT,i0,r0,i1)
 489 #define bgtr_d(i0,r0,r1)                bcmpr_d(FCMP_GT,i0,r0,r1)
 490 #define bgti_d(i0,r0,i1)                bcmpi_d(FCMP_GT,i0,r0,i1)
 491 #define bner_f(i0,r0,r1)                bcmpr_f(FCMP_NE,i0,r0,r1)
 492 #define bnei_f(i0,r0,i1)                bcmpi_f(FCMP_NE,i0,r0,i1)
 493 #define bner_d(i0,r0,r1)                bcmpr_d(FCMP_NE,i0,r0,r1)
 494 #define bnei_d(i0,r0,i1)                bcmpi_d(FCMP_NE,i0,r0,i1)
 495 #define bunltr_f(i0,r0,r1)              bcmpr_f(FCMP_UNLT,i0,r0,r1)
 496 #define bunlti_f(i0,r0,i1)              bcmpi_f(FCMP_UNLT,i0,r0,i1)
 497 #define bunltr_d(i0,r0,r1)              bcmpr_d(FCMP_UNLT,i0,r0,r1)
 498 #define bunlti_d(i0,r0,i1)              bcmpi_d(FCMP_UNLT,i0,r0,i1)
 499 #define bunler_f(i0,r0,r1)              bcmpr_f(FCMP_UNLE,i0,r0,r1)
 500 #define bunlei_f(i0,r0,i1)              bcmpi_f(FCMP_UNLE,i0,r0,i1)
 501 #define bunler_d(i0,r0,r1)              bcmpr_d(FCMP_UNLE,i0,r0,r1)
 502 #define bunlei_d(i0,r0,i1)              bcmpi_d(FCMP_UNLE,i0,r0,i1)
 503 #define buneqr_f(i0,r0,r1)              bcmpr_f(FCMP_UNEQ,i0,r0,r1)
 504 #define buneqi_f(i0,r0,i1)              bcmpi_f(FCMP_UNEQ,i0,r0,i1)
 505 #define buneqr_d(i0,r0,r1)              bcmpr_d(FCMP_UNEQ,i0,r0,r1)
 506 #define buneqi_d(i0,r0,i1)              bcmpi_d(FCMP_UNEQ,i0,r0,i1)
 507 #define bunger_f(i0,r0,r1)              bcmpr_f(FCMP_UNGE,i0,r0,r1)
 508 #define bungei_f(i0,r0,i1)              bcmpi_f(FCMP_UNGE,i0,r0,i1)
 509 #define bunger_d(i0,r0,r1)              bcmpr_d(FCMP_UNGE,i0,r0,r1)
 510 #define bungei_d(i0,r0,i1)              bcmpi_d(FCMP_UNGE,i0,r0,i1)
 511 #define bungtr_f(i0,r0,r1)              bcmpr_f(FCMP_UNGT,i0,r0,r1)
 512 #define bungti_f(i0,r0,i1)              bcmpi_f(FCMP_UNGT,i0,r0,i1)
 513 #define bungtr_d(i0,r0,r1)              bcmpr_d(FCMP_UNGT,i0,r0,r1)
 514 #define bungti_d(i0,r0,i1)              bcmpi_d(FCMP_UNGT,i0,r0,i1)
 515 #define bltgtr_f(i0,r0,r1)              bcmpr_f(FCMP_LTGT,i0,r0,r1)
 516 #define bltgti_f(i0,r0,i1)              bcmpi_f(FCMP_LTGT,i0,r0,i1)
 517 #define bltgtr_d(i0,r0,r1)              bcmpr_d(FCMP_LTGT,i0,r0,r1)
 518 #define bltgti_d(i0,r0,i1)              bcmpi_d(FCMP_LTGT,i0,r0,i1)
 519 #define bordr_f(i0,r0,r1)               bcmpr_f(FCMP_ORD,i0,r0,r1)
 520 #define bordi_f(i0,r0,i1)               bcmpi_f(FCMP_ORD,i0,r0,i1)
 521 #define bordr_d(i0,r0,r1)               bcmpr_d(FCMP_ORD,i0,r0,r1)
 522 #define bordi_d(i0,r0,i1)               bcmpi_d(FCMP_ORD,i0,r0,i1)
 523 #define bunordr_f(i0,r0,r1)             bcmpr_f(FCMP_UNORD,i0,r0,r1)
 524 #define bunordi_f(i0,r0,i1)             bcmpi_f(FCMP_UNORD,i0,r0,i1)
 525 #define bunordr_d(i0,r0,r1)             bcmpr_d(FCMP_UNORD,i0,r0,r1)
 526 #define bunordi_d(i0,r0,i1)             bcmpi_d(FCMP_UNORD,i0,r0,i1)
 527 #define vaarg_d(r0, r1)                 _vaarg_d(_jit, r0, r1)
 528 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 529 #endif
 530
 531 #if CODE
 532 static void
 533 _f39(jit_state_t *_jit, jit_int32_t o,
 534      jit_int32_t b, jit_int32_t x, jit_int32_t t)
 535 {
 536     assert(!(o & ~0x3f));
 537     assert(!(b & ~0x1f));
 538     assert(!(x & ~0x1f));
 539     assert(!(t & ~0x1f));
 540     ii((o<<26)|(b<<21)|(x<<16)|t);
 541 }
 542
 543 static void
 544 _f40(jit_state_t *_jit, jit_int32_t o,
 545      jit_int32_t b, jit_int32_t x, jit_int32_t r)
 546 {
 547     assert(!(o & ~0x3f));
 548     assert(!(b & ~0x1f));
 549     assert(!(x & ~0x1f));
 550     assert(!(r & ~0x1f));
 551     ii((o<<26)|(b<<21)|(x<<16)|(1<<9)|r);
 552 }
 553
 554 static void
 555 _f41(jit_state_t *_jit, jit_int32_t o,
 556      jit_int32_t b, jit_int32_t x, jit_int32_t t)
 557 {
 558     assert(!(o & ~0x3f));
 559     assert(!(b & ~0x1f));
 560     assert(x >= -16 && x < 15);
 561     assert(!(t & ~0x1f));
 562     ii((o<<26)|(b<<21)|(low_sign_unext(x,5)<<16)|(1<<12)|t);
 563 }
 564
 565 static void
 566 _f42(jit_state_t *_jit, jit_int32_t o,
 567      jit_int32_t b, jit_int32_t i, jit_int32_t r)
 568 {
 569     assert(!(o & ~0x3f));
 570     assert(!(b & ~0x1f));
 571     assert(i >= -16 && i < 15);
 572     assert(!(r & ~0x1f));
 573     ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(1<<12)|(1<<9)|r);
 574 }
 575
 576 static void
 577 _f45(jit_state_t *_jit, jit_int32_t o,
 578      jit_int32_t r, jit_int32_t a, jit_int32_t b, jit_int32_t fmt,
 579      jit_int32_t c, jit_int32_t d, jit_int32_t e, jit_int32_t t)
 580 {
 581     assert(!(o   & ~0x3f));
 582     assert(!(r   & ~0x1f));
 583     assert(!(a   & ~0x1f));
 584     assert(!(b   &  ~0x7));
 585     assert(!(fmt &  ~0x3));
 586     assert(!(c   &  ~0x3));
 587     assert(!(d   &  ~0x7));
 588     assert(!(e   &  ~0x1));
 589     assert(!(t   & ~0x1f));
 590     ii((o<<26)|(r<<21)|(a<<16)|(fmt<<13)|(b<<11)|(c<<9)|(d<<6)|(e<<5)|t);
 591 }
 592
 593 static void
 594 _f46(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
 595      jit_int32_t a, jit_int32_t s, jit_int32_t df, jit_int32_t sf,
 596      jit_int32_t b, jit_int32_t c, jit_int32_t d, jit_int32_t t)
 597 {
 598     assert(!(o  & ~0x3f));
 599     assert(!(r  & ~0x1f));
 600     assert(!(a  &  ~0x7));
 601     assert(!(s  &  ~0x7));
 602     assert(!(df &  ~0x3));
 603     assert(!(sf &  ~0x3));
 604     assert(!(b  &  ~0x3));
 605     assert(!(c  &  ~0x7));
 606     assert(!(d  &  ~0x1));
 607     assert(!(t  & ~0x1f));
 608     ii((o<<26)|(r<<21)|(a<<18)|(s<<15)|
 609        (df<<13)|(sf<<11)|(b<<9)|(c<<6)|(d<<5)|t);
 610 }
 611
 612 static void
 613 _f47_48(jit_state_t *_jit, jit_int32_t o,
 614         jit_int32_t r2, jit_int32_t r1, jit_int32_t y, jit_int32_t fmt,
 615         jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t t)
 616 {
 617     assert(!(o   & ~0x3f));
 618     assert(!(r2  & ~0x1f));
 619     assert(!(r1  & ~0x1f));
 620     assert(!(y   &  ~0x7));
 621     assert(!(fmt &  ~0x3));
 622     assert(!(a   &  ~0x3));
 623     assert(!(b   &  ~0x7));
 624     assert(!(c   &  ~0x1));
 625     assert(!(t   & ~0x1f));
 626     ii((o<<26)|(r2<<21)|(r1<<16)|(y<<13)|(fmt<<11)|(a<<9)|(b<<6)|(c<<5)|t);
 627 }
 628
 629 static void
 630 _f49_52(jit_state_t *_jit, jit_int32_t o,
 631         jit_int32_t r1, jit_int32_t r2, jit_int32_t y,
 632         jit_int32_t v, jit_int32_t f, jit_int32_t a, jit_int32_t b,
 633         jit_int32_t u, jit_int32_t c, jit_int32_t d, jit_int32_t t)
 634 {
 635     assert(!(o  & ~0x3f));
 636     assert(!(r1 & ~0x1f));
 637     assert(!(r2 & ~0x3f));
 638     assert(!(y  &  ~0x7));
 639     assert(!(v  &  ~0x1));
 640     assert(!(f  &  ~0x1));
 641     assert(!(a  &  ~0x3));
 642     assert(!(b  &  ~0x1));
 643     assert(!(u  &  ~0x1));
 644     assert(!(c  &  ~0x1));
 645     assert(!(d  &  ~0x1));
 646     assert(!(t  & ~0x1f));
 647     ii((o<<26)|(r1<<21)|(r2<<16)|(y<<13)|(v<<12)|
 648        (f<<11)|(a<<9)|(b<<8)|(u<<7)|(c<<6)|(d<<5)|t);
 649 }
 650
 651 static void
 652 _f53(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2,
 653      jit_int32_t ta, jit_int32_t ra, jit_int32_t f, jit_int32_t tm)
 654 {
 655     assert(!(o  & ~0x3f));
 656     assert(!(r1 & ~0x1f));
 657     assert(!(r2 & ~0x1f));
 658     assert(!(ta & ~0x1f));
 659     assert(!(ra & ~0x1f));
 660     assert(!(f  &  ~0x1));
 661     assert(!(tm & ~0x1f));
 662     assert(ra != tm ||
 663            (ta == r1 || ta == r2 || ta == tm) ||
 664            (f && ra == 1) || (!f && !ra));
 665     ii((o<<26)|(r1<<21)|(r2<<16)|(ta<<11)|(ra<<6)|(f<<5)|tm);
 666 }
 667
 668 static void
 669 _f54(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2,
 670      jit_int32_t a, jit_int32_t b, jit_int32_t f, jit_int32_t c,
 671      jit_int32_t d, jit_int32_t e, jit_int32_t g, jit_int32_t t)
 672 {
 673     assert(!(o  & ~0x3f));
 674     assert(!(r1 & ~0x1f));
 675     assert(!(r2 & ~0x1f));
 676     assert(!(a  &  ~0x7));
 677     assert(!(b  &  ~0x1));
 678     assert(!(f  &  ~0x1));
 679     assert(!(c  &  ~0x7));
 680     assert(!(e  &  ~0x1));
 681     assert(!(e  &  ~0x1));
 682     assert(!(g  &  ~0x1));
 683     assert(!(t  & ~0x1f));
 684     ii((o<<26)|(r1<<21)|(r2<<16)|(a<<13)|
 685        (b<<12)|(f<11)|(c<<8)|(d<<7)|(e<<6)|(g<<5)|t);
 686 }
 687
 688 static void
 689 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 690 {
 691     stxi(alloca_offset - 8, _FP_REGNO, r1);
 692     ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
 693     FCNVXF_S_S(r0, r0);
 694 }
 695
 696 static void
 697 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 698 {
 699     stxi(alloca_offset - 8, _FP_REGNO, r1);
 700     ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
 701     FCNVXF_S_D(r0, r0);
 702 }
 703
 704 static void
 705 _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 706 {
 707     jit_int32_t         reg;
 708     reg = jit_get_reg(jit_class_fpr);
 709     FCNVXT_S_S(r1, rn(reg));
 710     stxi_f(alloca_offset - 8, _FP_REGNO, rn(reg));
 711     ldxi(r0, _FP_REGNO, alloca_offset - 8);
 712     jit_unget_reg(reg);
 713 }
 714
 715 static void
 716 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 717 {
 718     jit_int32_t         reg;
 719     reg = jit_get_reg(jit_class_fpr);
 720     FCNVXT_D_S(r1, rn(reg));
 721     stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg));
 722     ldxi(r0, _FP_REGNO, alloca_offset - 8);
 723     jit_unget_reg(reg);
 724 }
 725
 726 static void
 727 _fmar_f(jit_state_t *_jit,
 728         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 729 {
 730 #if 1
 731     jit_int32_t         reg;
 732     if (r0 != r3) {
 733         mulr_f(r0, r1, r2);
 734         addr_f(r0, r0, r3);
 735     }
 736     else {
 737         reg = jit_get_reg(jit_class_fpr);
 738         mulr_f(rn(reg), r1, r2);
 739         addr_f(r0, rn(reg), r3);
 740         jit_unget_reg(reg);
 741     }
 742 #else
 743     FMPYFADD_S(r1, r2, r3, r0);
 744 #endif
 745 }
 746
 747 static void
 748 _fmsr_f(jit_state_t *_jit,
 749         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 750 {
 751     jit_int32_t         reg;
 752     if (r0 != r3) {
 753         mulr_f(r0, r1, r2);
 754         subr_f(r0, r0, r3);
 755     }
 756     else {
 757         reg = jit_get_reg(jit_class_fpr);
 758         mulr_f(rn(reg), r1, r2);
 759         subr_f(r0, rn(reg), r3);
 760         jit_unget_reg(reg);
 761     }
 762 }
 763
 764 static void
 765 _fnmar_f(jit_state_t *_jit,
 766         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 767 {
 768     jit_int32_t         t0;
 769     t0 = jit_get_reg(jit_class_fpr);
 770     negr_f(rn(t0), r1);
 771     mulr_f(rn(t0), rn(t0), r2);
 772     subr_f(r0, rn(t0), r3);
 773     jit_unget_reg(t0);
 774 }
 775
 776 static void
 777 _fnmsr_f(jit_state_t *_jit,
 778         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 779 {
 780     jit_int32_t         t0;
 781     t0 = jit_get_reg(jit_class_fpr);
 782     negr_f(rn(t0), r1);
 783     mulr_f(rn(t0), rn(t0), r2);
 784     addr_f(r0, rn(t0), r3);
 785     jit_unget_reg(t0);
 786 }
 787
 788 static void
 789 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
 790 {
 791     union {
 792         jit_int32_t      i;
 793         jit_float32_t    f;
 794     } data;
 795     jit_int32_t          reg;
 796
 797     if (_jitc->no_data) {
 798         data.f = *i0;
 799         reg = jit_get_reg(jit_class_gpr);
 800         movi(rn(reg), data.i);
 801         stxi_i(alloca_offset - 8, _FP_REGNO, rn(reg));
 802         jit_unget_reg(reg);
 803         ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
 804     }
 805     else
 806         ldi_f(r0, (jit_word_t)i0);
 807 }
 808
 809 static void
 810 _movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 811 {
 812     jit_int32_t                reg;
 813     reg = jit_get_reg(jit_class_gpr);
 814     movi(rn(reg), i0);
 815     movr_w_f(r0, rn(reg));
 816     jit_unget_reg(reg);
 817 }
 818
 819 static void
 820 _fmar_d(jit_state_t *_jit,
 821         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 822 {
 823 #if 1
 824     jit_int32_t         reg;
 825     if (r0 != r3) {
 826         mulr_d(r0, r1, r2);
 827         addr_d(r0, r0, r3);
 828     }
 829     else {
 830         reg = jit_get_reg(jit_class_fpr);
 831         mulr_d(rn(reg), r1, r2);
 832         addr_d(r0, rn(reg), r3);
 833         jit_unget_reg(reg);
 834     }
 835 #else
 836     FMPYFADD_D(r1, r2, r3, r0);
 837 #endif
 838 }
 839
 840 static void
 841 _fmsr_d(jit_state_t *_jit,
 842         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 843 {
 844     jit_int32_t         reg;
 845     if (r0 != r3) {
 846         mulr_d(r0, r1, r2);
 847         subr_d(r0, r0, r3);
 848     }
 849     else {
 850         reg = jit_get_reg(jit_class_fpr);
 851         mulr_d(rn(reg), r1, r2);
 852         subr_d(r0, rn(reg), r3);
 853         jit_unget_reg(reg);
 854     }
 855 }
 856
 857 static void
 858 _fnmar_d(jit_state_t *_jit,
 859         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 860 {
 861     jit_int32_t         t0;
 862     t0 = jit_get_reg(jit_class_fpr);
 863     negr_d(rn(t0), r1);
 864     mulr_d(rn(t0), rn(t0), r2);
 865     subr_d(r0, rn(t0), r3);
 866     jit_unget_reg(t0);
 867 }
 868
 869 static void
 870 _fnmsr_d(jit_state_t *_jit,
 871         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 872 {
 873     jit_int32_t         t0;
 874     t0 = jit_get_reg(jit_class_fpr);
 875     negr_d(rn(t0), r1);
 876     mulr_d(rn(t0), rn(t0), r2);
 877     addr_d(r0, rn(t0), r3);
 878     jit_unget_reg(t0);
 879 }
 880
 881 static void
 882 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
 883 {
 884     union {
 885         jit_int32_t      ii[2];
 886         jit_word_t       w;
 887         jit_float64_t    d;
 888     } data;
 889     jit_int32_t          reg;
 890
 891     data.d = *i0;
 892     if (_jitc->no_data) {
 893         data.d = *i0;
 894         reg = jit_get_reg(jit_class_gpr);
 895         movi(rn(reg), data.ii[0]);
 896         stxi_i(alloca_offset - 8, _FP_REGNO, rn(reg));
 897         movi(rn(reg), data.ii[1]);
 898         stxi_i(alloca_offset - 4, _FP_REGNO, rn(reg));
 899         jit_unget_reg(reg);
 900         ldxi_d(r0, _FP_REGNO, alloca_offset - 8);
 901     }
 902     else
 903         ldi_d(r0, (jit_word_t)i0);
 904 }
 905
 906 static void
 907 _movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
 908 {
 909     jit_int32_t                t0, t1;
 910     t0 = jit_get_reg(jit_class_gpr);
 911     t1 = jit_get_reg(jit_class_gpr);
 912     movi(rn(t0), i0);
 913     movi(rn(t1), i1);
 914     movr_ww_d(r0, rn(t0), rn(t1));
 915     jit_unget_reg(t1);
 916     jit_unget_reg(t0);
 917 }
 918
 919 #define fpr_opi(name, type, size)                                       \
 920 static void                                                             \
 921 _##name##i_##type(jit_state_t *_jit,                                    \
 922                   jit_int32_t r0, jit_int32_t r1,                       \
 923                   jit_float##size##_t *i0)                              \
 924 {                                                                       \
 925     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
 926     movi_##type(rn(reg), i0);                                           \
 927     name##r_##type(r0, r1, rn(reg));                                    \
 928     jit_unget_reg(reg);                                                 \
 929 }
 930 #define fopi(name)                      fpr_opi(name, f, 32)
 931 #define dopi(name)                      fpr_opi(name, d, 64)
 932
 933 fopi(add)
 934 dopi(add)
 935 fopi(sub)
 936 dopi(sub)
 937 fopi(rsb)
 938 dopi(rsb)
 939 fopi(mul)
 940 dopi(mul)
 941 fopi(div)
 942 dopi(div)
 943
 944 static void
 945 _cmpr_f(jit_state_t *_jit, jit_word_t c,
 946         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 947 {
 948     LDI(0, r0);
 949     FCMP_S_(r1, r2, c);
 950     FTEST();
 951     LDI(1, r0);
 952 }
 953
 954 static void
 955 _cmpi_f(jit_state_t *_jit, jit_word_t c,
 956         jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
 957 {
 958     jit_int32_t         reg = jit_get_reg(jit_class_fpr);
 959     movi_f(rn(reg), i0);
 960     cmpr_f(c, r0, r1, rn(reg));
 961     jit_unget_reg(reg);
 962 }
 963
 964 static void
 965 _cmpr_d(jit_state_t *_jit, jit_word_t c,
 966         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 967 {
 968     LDI(0, r0);
 969     FCMP_D_(r1, r2, c);
 970     FTEST();
 971     LDI(1, r0);
 972 }
 973
 974 static void
 975 _cmpi_d(jit_state_t *_jit, jit_word_t c,
 976         jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 977 {
 978     jit_int32_t         reg = jit_get_reg(jit_class_fpr);
 979     movi_d(rn(reg), i0);
 980     cmpr_d(c, r0, r1, rn(reg));
 981     jit_unget_reg(reg);
 982 }
 983
 984 static void
 985 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 986 {
 987     jit_int32_t         reg;
 988     assert(!(i0 & 3));
 989     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
 990         FLDWL(i0, _R0_REGNO, r0);
 991     else {
 992         reg = jit_get_reg(jit_class_gpr);
 993         movi(rn(reg), i0);
 994         ldr_f(r0, rn(reg));
 995         jit_unget_reg(reg);
 996     }
 997 }
 998
 999 #if !FLDXR
1000 static void
1001 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1002 {
1003     jit_int32_t         reg;
1004     reg = jit_get_reg(jit_class_gpr);
1005     addr(rn(reg), r1, r2);
1006     ldr_f(r0, rn(reg));
1007     jit_unget_reg(reg);
1008 }
1009
1010 static void
1011 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1012 {
1013     jit_int32_t         reg;
1014     reg = jit_get_reg(jit_class_gpr);
1015     addr(rn(reg), r1, r2);
1016     ldr_d(r0, rn(reg));
1017     jit_unget_reg(reg);
1018 }
1019 #endif
1020
1021 static void
1022 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1023 {
1024     jit_int32_t         reg;
1025     if (i0 >= -16 && i0 <= 15)
1026         FLDWI(i0, r1, r0);
1027     /* |im11a|0|t|i| */
1028     else if (FLDXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
1029         FLDWL(i0, r1, r0);
1030     else {
1031         reg = jit_get_reg(jit_class_gpr);
1032         movi(rn(reg), i0);
1033         ldxr_f(r0, r1, rn(reg));
1034         jit_unget_reg(reg);
1035     }
1036 }
1037
1038 static void
1039 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1040 {
1041     jit_int32_t         reg;
1042     assert(!(i0 & 7));
1043     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
1044         FLDDL(i0, _R0_REGNO, r0);
1045     else {
1046         reg = jit_get_reg(jit_class_gpr);
1047         movi(rn(reg), i0);
1048         ldr_d(r0, rn(reg));
1049         jit_unget_reg(reg);
1050     }
1051 }
1052
1053 static void
1054 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1055 {
1056     jit_int32_t         reg;
1057     if (i0 >= -16 && i0 <= 15)
1058         FLDDI(i0, r1, r0);
1059     /* |im10a|m|a|1|i| */
1060     else if (FLDXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
1061         FLDDL(i0, r1, r0);
1062     else {
1063         reg = jit_get_reg(jit_class_gpr);
1064         movi(rn(reg), i0);
1065         ldxr_d(r0, r1, rn(reg));
1066         jit_unget_reg(reg);
1067     }
1068 }
1069
1070 static void
1071 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1072 {
1073     jit_int32_t         reg;
1074     assert(!(i0 & 3));
1075     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
1076         FSTWL(r0, i0, _R0_REGNO);
1077     else {
1078         reg = jit_get_reg(jit_class_gpr);
1079         movi(rn(reg), i0);
1080         str_f(rn(reg), r0);
1081         jit_unget_reg(reg);
1082     }
1083 }
1084
1085 #if !FSTXR
1086 static void
1087 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1088 {
1089     jit_int32_t         reg;
1090     reg = jit_get_reg(jit_class_gpr);
1091     addr(rn(reg), r0, r1);
1092     str_f(rn(reg), r2);
1093     jit_unget_reg(reg);
1094 }
1095
1096 static void
1097 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1098 {
1099     jit_int32_t         reg;
1100     reg = jit_get_reg(jit_class_gpr);
1101     addr(rn(reg), r0, r1);
1102     str_d(rn(reg), r2);
1103     jit_unget_reg(reg);
1104 }
1105 #endif
1106
1107 static void
1108 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1109 {
1110     jit_int32_t         reg;
1111     if (i0 >= -16 && i0 <= 15)
1112         FSTWI(r1, i0, r0);
1113     /* |im11a|0|t|i| */
1114     else if (FSTXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
1115         FSTWL(r1, i0, r0);
1116     else {
1117         reg = jit_get_reg(jit_class_gpr);
1118 #if FSTXR
1119         movi(rn(reg), i0);
1120         stxr_f(rn(reg), r0, r1);
1121 #else
1122         addi(rn(reg), r0, i0);
1123         str_f(rn(reg), r1);
1124 #endif
1125         jit_unget_reg(reg);
1126     }
1127 }
1128
1129 static void
1130 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1131 {
1132     jit_int32_t         reg;
1133     assert(!(i0 & 7));
1134     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
1135         FSTDL(r0, i0, _R0_REGNO);
1136     else {
1137         reg = jit_get_reg(jit_class_gpr);
1138         movi(rn(reg), i0);
1139         str_d(rn(reg), r0);
1140         jit_unget_reg(reg);
1141     }
1142 }
1143
1144 static void
1145 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1146 {
1147     jit_int32_t         reg;
1148     if (i0 >= -16 && i0 <= 15)
1149         FSTDI(r1, i0, r0);
1150     /* |im10a|m|a|1|i| */
1151     else if (FSTXR && i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
1152         FSTDL(r1, i0, r0);
1153     else {
1154         reg = jit_get_reg(jit_class_gpr);
1155 #if FSTXR
1156         movi(rn(reg), i0);
1157         stxr_d(rn(reg), r0, r1);
1158 #else
1159         addi(rn(reg), r0, i0);
1160         str_d(rn(reg), r1);
1161 #endif
1162         jit_unget_reg(reg);
1163     }
1164 }
1165
1166 static jit_word_t
1167 _bcmpr_f(jit_state_t *_jit, jit_word_t c,
1168          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1169 {
1170     jit_word_t          w;
1171     FCMP_S_(r0, r1, c);
1172     FTEST();
1173     w = _jit->pc.w;
1174     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
1175     NOP();
1176     return (w);
1177 }
1178
1179 static jit_word_t
1180 _bcmpi_f(jit_state_t *_jit, jit_word_t c,
1181          jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
1182 {
1183     jit_word_t          w;
1184     jit_int32_t         reg;
1185     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
1186     movi_f(rn(reg), i1);
1187     FCMP_S_(r0, rn(reg), c);
1188     FTEST();
1189     w = _jit->pc.w;
1190     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
1191     NOP();
1192     jit_unget_reg(reg);
1193     return (w);
1194 }
1195
1196 static jit_word_t
1197 _bcmpr_d(jit_state_t *_jit, jit_word_t c,
1198          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1199 {
1200     jit_word_t          w;
1201     FCMP_D_(r0, r1, c);
1202     FTEST();
1203     w = _jit->pc.w;
1204     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
1205     NOP();
1206     return (w);
1207 }
1208
1209 static jit_word_t
1210 _bcmpi_d(jit_state_t *_jit, jit_word_t c,
1211          jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
1212 {
1213     jit_word_t          w;
1214     jit_int32_t         reg;
1215     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
1216     movi_d(rn(reg), i1);
1217     FCMP_D_(r0, rn(reg), c);
1218     FTEST();
1219     w = _jit->pc.w;
1220     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
1221     NOP();
1222     jit_unget_reg(reg);
1223     return (w);
1224 }
1225
1226 static void
1227 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1228 {
1229     jit_int32_t         reg;
1230
1231     assert(_jitc->function->self.call & jit_call_varargs);
1232
1233     /* Align pointer if required. */
1234     reg = jit_get_reg(jit_class_gpr);
1235     andi(rn(reg), r1, 7);
1236     subr(r1, r1, rn(reg));
1237     jit_unget_reg(reg);
1238
1239     /* Adjust vararg stack pointer. */
1240     subi(r1, r1, 8);
1241
1242     /* Load argument. */
1243     ldr_d(r0, r1);
1244 }
1245 #endif