deps/lightning/lib/jit_ppc-fpu.c

   1 /*
   2  * Copyright (C) 2012-2019  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 FA(o,d,a,b,c,x)                 _FA(_jit,o,d,a,b,c,x,0)
  22 #define FA_(o,d,a,b,c,x)                _FA(_jit,o,d,a,b,c,x,1)
  23 static void _FA(jit_state_t*,int,int,int,int,int,int,int);
  24 #define FXFL(o,m,b,x)                   _FXFL(_jit,o,m,b,x,0)
  25 #define FXFL_(o,m,b,x)                  _FXFL(_jit,o,m,b,x,1)
  26 static void _FXFL(jit_state_t*,int,int,int,int,int) maybe_unused;
  27 #  define FABS(d,b)                     FX(63,d,0,b,264)
  28 #  define FABS_(d,b)                    FX_(63,d,0,b,264)
  29 #  define FADD(d,a,b)                   FA(63,d,a,b,0,21)
  30 #  define FADD_(d,a,b)                  FA_(63,d,a,b,0,21)
  31 #  define FADDS(d,a,b)                  FA(59,d,a,b,0,21)
  32 #  define FADDS_(d,a,b)                 FA_(59,d,a,b,0,21)
  33 #  define FCFID(d,b)                    FX(63,d,0,b,846)
  34 #  define FCMPO(cr,a,b)                 FC(63,cr,0,a,b,32)
  35 #  define FCMPU(cr,a,b)                 FC(63,cr,0,a,b,0)
  36 #  define FCTIW(d,b)                    FX(63,d,0,b,14)
  37 #  define FCTIW_(d,b)                   FX_(63,d,0,b,14)
  38 #  define FCTIWZ(d,b)                   FX(63,d,0,b,15)
  39 #  define FCTIWZ_(d,b)                  FX_(63,d,0,b,15)
  40 #  define FCTID(d,b)                    FX(63,d,0,b,814)
  41 #  define FCTID_(d,b)                   FX_(63,d,0,b,814)
  42 #  define FCTIDZ(d,b)                   FX(63,d,0,b,815)
  43 #  define FCTIDZ_(d,b)                  FX_(63,d,0,b,815)
  44 #  define FDIV(d,a,b)                   FA(63,d,a,b,0,18)
  45 #  define FDIV_(d,a,b)                  FA_(63,d,a,b,0,18)
  46 #  define FDIVS(d,a,b)                  FA(59,d,a,b,0,18)
  47 #  define FDIVS_(d,a,b)                 FA_(59,d,a,b,0,18)
  48 #  define FMADD(d,a,b,c)                FA(63,d,a,b,c,29)
  49 #  define FMADD_(d,a,b,c)               FA(63,d,a,b,c,29)
  50 #  define FMADDS(d,a,b,c)               FA(59,d,a,b,c,29)
  51 #  define FMADDS_(d,a,b,c)              FA(59,d,a,b,c,29)
  52 #  define FMR(d,b)                      FX(63,d,0,b,72)
  53 #  define FMR_(d,b)                     FX_(63,d,0,b,72)
  54 #  define FMSUB(d,a,b,c)                FA(63,d,a,b,c,28)
  55 #  define FMSUB_(d,a,b,c)               FA(63,d,a,b,c,28)
  56 #  define FMSUBS(d,a,b,c)               FA(59,d,a,b,c,28)
  57 #  define FMSUBS_(d,a,b,c)              FA(59,d,a,b,c,28)
  58 #  define FMUL(d,a,c)                   FA(63,d,a,0,c,25)
  59 #  define FMUL_(d,a,c)                  FA_(63,d,a,0,c,25)
  60 #  define FMULS(d,a,c)                  FA(59,d,a,0,c,25)
  61 #  define FMULS_(d,a,c)                 FA_(59,d,a,0,c,25)
  62 #  define FNABS(d,b)                    FX(63,d,0,b,136)
  63 #  define FNABS_(d,b)                   FX_(63,d,0,b,136)
  64 #  define FNEG(d,b)                     FX(63,d,0,b,40)
  65 #  define FNEG_(d,b)                    FX_(63,d,0,b,40)
  66 #  define FNMADD(d,a,b,c)               FA(63,d,a,b,c,31)
  67 #  define FNMADD_(d,a,b,c)              FA_(63,d,a,b,c,31)
  68 #  define FNMADDS(d,a,b,c)              FA(59,d,a,b,c,31)
  69 #  define FNMADDS_(d,a,b,c)             FA_(59,d,a,b,c,31)
  70 #  define FNMSUB(d,a,b,c)               FA(63,d,a,b,c,30)
  71 #  define FNMSUB_(d,a,b,c)              FA_(63,d,a,b,c,30)
  72 #  define FNMSUBS(d,a,b,c)              FA(59,d,a,b,c,30)
  73 #  define FNMSUBS_(d,a,b,c)             FA_(59,d,a,b,c,30)
  74 #  define FRES(d,b)                     FA(59,d,0,b,0,24)
  75 #  define FRES_(d,b)                    FA_(59,d,0,b,0,24)
  76 #  define FRSP(d,b)                     FA(63,d,0,b,0,12)
  77 #  define FRSP_(d,b)                    FA_(63,d,0,b,0,12)
  78 #  define FRSQTRE(d,b)                  FA(63,d,0,b,0,26)
  79 #  define FRSQTRE_(d,b)                 FA_(63,d,0,b,0,26)
  80 #  define FSEL(d,a,b,c)                 FA(63,d,a,b,c,23)
  81 #  define FSEL_(d,a,b,c)                FA_(63,d,a,b,c,23)
  82 #  define FSQRT(d,b)                    FA(63,d,0,b,0,22)
  83 #  define FSQRT_(d,b)                   FA_(63,d,0,b,0,22)
  84 #  define FSQRTS(d,b)                   FA(59,d,0,b,0,22)
  85 #  define FSQRTS_(d,b)                  FA_(59,d,0,b,0,22)
  86 #  define FSUB(d,a,b)                   FA(63,d,a,b,0,20)
  87 #  define FSUB_(d,a,b)                  FA(63,d,a,b,0,20)
  88 #  define FSUBS(d,a,b)                  FA(59,d,a,b,0,20)
  89 #  define FSUBS_(d,a,b)                 FA(59,d,a,b,0,20)
  90 #  define LFD(d,a,s)                    FDs(50,d,a,s)
  91 #  define LFDU(d,a,s)                   FDs(51,d,a,s)
  92 #  define LFDUX(d,a,b)                  FX(31,d,a,b,631)
  93 #  define LFDX(d,a,b)                   FX(31,d,a,b,599)
  94 #  define LFS(d,a,s)                    FDs(48,d,a,s)
  95 #  define LFSU(d,a,s)                   FDs(49,d,a,s)
  96 #  define LFSUX(d,a,b)                  FX(31,d,a,b,567)
  97 #  define LFSX(d,a,b)                   FX(31,d,a,b,535)
  98 #  define MCRFS(d,s)                    FXL(63,d<<2,(s)<<2,64)
  99 #  define MFFS(d)                       FX(63,d,0,0,583)
 100 #  define MFFS_(d)                      FX_(63,d,0,0,583)
 101 #  define MTFSB0(d)                     FX(63,d,0,0,70)
 102 #  define MTFSB0_(d)                    FX_(63,d,0,0,70)
 103 #  define MTFSB1(d)                     FX(63,d,0,0,38)
 104 #  define MTFSB1_(d)                    FX_(63,d,0,0,38)
 105 #  define MTFSF(m,b)                    FXFL(63,m,b,711)
 106 #  define MTFSF_(m,b)                   FXFL_(63,m,b,711)
 107 #  define MTFSFI(d,i)                   FX(63,d<<2,0,i<<1,134)
 108 #  define MTFSFI_(d,i)                  FX_(63,d<<2,0,i<<1,134)
 109 #  define STFD(s,a,d)                   FDs(54,s,a,d)
 110 #  define STFDU(s,a,d)                  FDs(55,s,a,d)
 111 #  define STFDUX(s,a,b)                 FX(31,s,a,b,759)
 112 #  define STFDX(s,a,b)                  FX(31,s,a,b,727)
 113 #  define STFIWX(s,a,b)                 FX(31,s,a,b,983)
 114 #  define STFS(s,a,d)                   FDs(52,s,a,d)
 115 #  define STFSU(s,a,d)                  FDs(53,s,a,d)
 116 #  define STFSUX(s,a,b)                 FX(31,s,a,b,695)
 117 #  define STFSX(s,a,b)                  FX(31,s,a,b,663)
 118 #  define movr_f(r0,r1)                 movr_d(r0,r1)
 119 #  define movr_d(r0,r1)                 _movr_d(_jit,r0,r1)
 120 static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 121 #  define movi_f(r0,i0)                 _movi_f(_jit,r0,i0)
 122 static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
 123 #  define movi_d(r0,i0)                 _movi_d(_jit,r0,i0)
 124 static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
 125 #  define extr_f(r0,r1)                 extr_d(r0,r1)
 126 #  define extr_d(r0,r1)                 _extr_d(_jit,r0,r1)
 127 static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 128 #  define truncr_f(r0,r1)               truncr_d(r0,r1)
 129 #  define truncr_f_i(r0,r1)             truncr_d_i(r0,r1)
 130 #  define truncr_d_i(r0,r1)             _truncr_d_i(_jit,r0,r1)
 131 static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
 132 #  if __WORDSIZE == 32
 133 #    define truncr_d(r0,r1)             truncr_d_i(r0,r1)
 134 #  else
 135 #    define truncr_d(r0,r1)             truncr_d_l(r0,r1)
 136 #    define truncr_f_l(r0,r1)           truncr_d_l(r0,r1)
 137 #    define truncr_d_l(r0,r1)           _truncr_d_l(_jit,r0,r1)
 138 static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
 139 #  endif
 140 #  define extr_d_f(r0,r1)               FRSP(r0,r1)
 141 #  define extr_f_d(r0,r1)               movr_d(r0,r1)
 142 #  define absr_f(r0,r1)                 absr_d(r0,r1)
 143 #  define absr_d(r0,r1)                 FABS(r0,r1)
 144 #  define negr_f(r0,r1)                 negr_d(r0,r1)
 145 #  define negr_d(r0,r1)                 FNEG(r0,r1)
 146 #  ifdef _ARCH_PPCSQ
 147 #    define sqrtr_f(r0,r1)              FSQRTS(r0,r1)
 148 #    define sqrtr_d(r0,r1)              FSQRT(r0,r1)
 149 #  else
 150 extern float sqrtf(float);
 151 #    define sqrtr_f(r0,r1)              _sqrtr_f(_jit,r0,r1)
 152 static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t);
 153 extern double sqrt(double);
 154 #    define sqrtr_d(r0,r1)              _sqrtr_d(_jit,r0,r1)
 155 static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 156 #  endif
 157 #  define addr_f(r0,r1,r2)              FADDS(r0,r1,r2)
 158 #  define addr_d(r0,r1,r2)              FADD(r0,r1,r2)
 159 #  define addi_f(r0,r1,i0)              _addi_f(_jit,r0,r1,i0)
 160 static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 161 #  define addi_d(r0,r1,i0)              _addi_d(_jit,r0,r1,i0)
 162 static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 163 #  define subr_f(r0,r1,r2)              FSUBS(r0,r1,r2)
 164 #  define subi_f(r0,r1,i0)              _subi_f(_jit,r0,r1,i0)
 165 static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 166 #  define subr_d(r0,r1,r2)              FSUB(r0,r1,r2)
 167 #  define subi_d(r0,r1,i0)              _subi_d(_jit,r0,r1,i0)
 168 static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 169 #  define rsbr_f(r0,r1,r2)              subr_f(r0,r2,r1)
 170 #  define rsbi_f(r0,r1,i0)              _rsbi_f(_jit,r0,r1,i0)
 171 static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 172 #  define rsbr_d(r0,r1,r2)              subr_d(r0,r2,r1)
 173 #  define rsbi_d(r0,r1,i0)              _rsbi_d(_jit,r0,r1,i0)
 174 static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 175 #  define mulr_f(r0,r1,r2)              FMULS(r0,r1,r2)
 176 #  define muli_f(r0,r1,i0)              _muli_f(_jit,r0,r1,i0)
 177 static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 178 #  define mulr_d(r0,r1,r2)              FMUL(r0,r1,r2)
 179 #  define muli_d(r0,r1,i0)              _muli_d(_jit,r0,r1,i0)
 180 static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 181 #  define divr_f(r0,r1,r2)              FDIVS(r0,r1,r2)
 182 #  define divi_f(r0,r1,i0)              _divi_f(_jit,r0,r1,i0)
 183 static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 184 #  define divr_d(r0,r1,r2)              FDIV(r0,r1,r2)
 185 #  define divi_d(r0,r1,i0)              _divi_d(_jit,r0,r1,i0)
 186 static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 187 #  define ltr_f(r0,r1,r2)               ltr_d(r0,r1,r2)
 188 #  define ltr_d(r0,r1,r2)               _ltr_d(_jit,r0,r1,r2)
 189 static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 190 #  define lti_f(r0,r1,i0)               _lti_f(_jit,r0,r1,i0)
 191 static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 192 #  define lti_d(r0,r1,i0)               _lti_d(_jit,r0,r1,i0)
 193 static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 194 #  define ler_f(r0,r1,r2)               ler_d(r0,r1,r2)
 195 #  define ler_d(r0,r1,r2)               _ler_d(_jit,r0,r1,r2)
 196 static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 197 #  define lei_f(r0,r1,i0)               _lei_f(_jit,r0,r1,i0)
 198 static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 199 #  define lei_d(r0,r1,i0)               _lei_d(_jit,r0,r1,i0)
 200 static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 201 #  define eqr_f(r0,r1,r2)               eqr_d(r0,r1,r2)
 202 #  define eqr_d(r0,r1,r2)               _eqr_d(_jit,r0,r1,r2)
 203 static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 204 #  define eqi_f(r0,r1,i0)               _eqi_f(_jit,r0,r1,i0)
 205 static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 206 #  define eqi_d(r0,r1,i0)               _eqi_d(_jit,r0,r1,i0)
 207 static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 208 #  define ger_f(r0,r1,r2)               ger_d(r0,r1,r2)
 209 #  define ger_d(r0,r1,r2)               _ger_d(_jit,r0,r1,r2)
 210 static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 211 #  define gei_f(r0,r1,i0)               _gei_f(_jit,r0,r1,i0)
 212 static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 213 #  define gei_d(r0,r1,i0)               _gei_d(_jit,r0,r1,i0)
 214 static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 215 #  define gtr_f(r0,r1,r2)               gtr_d(r0,r1,r2)
 216 #  define gtr_d(r0,r1,r2)               _gtr_d(_jit,r0,r1,r2)
 217 static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 218 #  define gti_f(r0,r1,i0)               _gti_f(_jit,r0,r1,i0)
 219 static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 220 #  define gti_d(r0,r1,i0)               _gti_d(_jit,r0,r1,i0)
 221 static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 222 #  define ner_f(r0,r1,r2)               ner_d(r0,r1,r2)
 223 #  define ner_d(r0,r1,r2)               _ner_d(_jit,r0,r1,r2)
 224 static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 225 #  define nei_f(r0,r1,i0)               _nei_f(_jit,r0,r1,i0)
 226 static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 227 #  define nei_d(r0,r1,i0)               _nei_d(_jit,r0,r1,i0)
 228 static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 229 #  define unltr_f(r0,r1,r2)             unltr_d(r0,r1,r2)
 230 #  define unltr_d(r0,r1,r2)             _unltr_d(_jit,r0,r1,r2)
 231 static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 232 #  define unlti_f(r0,r1,i0)             _unlti_f(_jit,r0,r1,i0)
 233 static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 234 #  define unlti_d(r0,r1,i0)             _unlti_d(_jit,r0,r1,i0)
 235 static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 236 #  define unler_f(r0,r1,r2)             unler_d(r0,r1,r2)
 237 #  define unler_d(r0,r1,r2)             _unler_d(_jit,r0,r1,r2)
 238 static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 239 #  define unlei_f(r0,r1,i0)             _unlei_f(_jit,r0,r1,i0)
 240 static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 241 #  define unlei_d(r0,r1,i0)             _unlei_d(_jit,r0,r1,i0)
 242 static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 243 #  define uneqr_f(r0,r1,r2)             uneqr_d(r0,r1,r2)
 244 #  define uneqr_d(r0,r1,r2)             _uneqr_d(_jit,r0,r1,r2)
 245 static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 246 #  define uneqi_f(r0,r1,i0)             _uneqi_f(_jit,r0,r1,i0)
 247 static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 248 #  define uneqi_d(r0,r1,i0)             _uneqi_d(_jit,r0,r1,i0)
 249 static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 250 #  define unger_f(r0,r1,r2)             unger_d(r0,r1,r2)
 251 #  define unger_d(r0,r1,r2)             _unger_d(_jit,r0,r1,r2)
 252 static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 253 #  define ungei_f(r0,r1,i0)             _ungei_f(_jit,r0,r1,i0)
 254 static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 255 #  define ungei_d(r0,r1,i0)             _ungei_d(_jit,r0,r1,i0)
 256 static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 257 #  define ungtr_f(r0,r1,r2)             ungtr_d(r0,r1,r2)
 258 #  define ungtr_d(r0,r1,r2)             _ungtr_d(_jit,r0,r1,r2)
 259 static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 260 #  define ungti_f(r0,r1,i0)             _ungti_f(_jit,r0,r1,i0)
 261 static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 262 #  define ungti_d(r0,r1,i0)             _ungti_d(_jit,r0,r1,i0)
 263 static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 264 #  define ltgtr_f(r0,r1,r2)             ltgtr_d(r0,r1,r2)
 265 #  define ltgtr_d(r0,r1,r2)             _ltgtr_d(_jit,r0,r1,r2)
 266 static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 267 #  define ltgti_f(r0,r1,i0)             _ltgti_f(_jit,r0,r1,i0)
 268 static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 269 #  define ltgti_d(r0,r1,i0)             _ltgti_d(_jit,r0,r1,i0)
 270 static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 271 #  define ordr_f(r0,r1,r2)              ordr_d(r0,r1,r2)
 272 #  define ordr_d(r0,r1,r2)              _ordr_d(_jit,r0,r1,r2)
 273 static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 274 #  define ordi_f(r0,r1,i0)              _ordi_f(_jit,r0,r1,i0)
 275 static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 276 #  define ordi_d(r0,r1,i0)              _ordi_d(_jit,r0,r1,i0)
 277 static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 278 #  define unordr_f(r0,r1,r2)            unordr_d(r0,r1,r2)
 279 #  define unordr_d(r0,r1,r2)            _unordr_d(_jit,r0,r1,r2)
 280 static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 281 #  define unordi_f(r0,r1,i0)            _unordi_f(_jit,r0,r1,i0)
 282 static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
 283 #  define unordi_d(r0,r1,i0)            _unordi_d(_jit,r0,r1,i0)
 284 static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 285 #  define bltr_f(i0,r0,r1)              bltr_d(i0,r0,r1)
 286 #  define bltr_d(i0,r0,r1)              _bltr_d(_jit,i0,r0,r1)
 287 static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 288 #  define blti_f(i0,r0,i1)              _blti_f(_jit,i0,r0,i1)
 289 static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 290 #  define blti_d(i0,r0,i1)              _blti_d(_jit,i0,r0,i1)
 291 static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 292 #  define bler_f(i0,r0,r1)              bler_d(i0,r0,r1)
 293 #  define bler_d(i0,r0,r1)              _bler_d(_jit,i0,r0,r1)
 294 static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 295 #  define blei_f(i0,r0,i1)              _blei_f(_jit,i0,r0,i1)
 296 static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 297 #  define blei_d(i0,r0,i1)              _blei_d(_jit,i0,r0,i1)
 298 static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 299 #  define beqr_f(i0,r0,r1)              beqr_d(i0,r0,r1)
 300 #  define beqr_d(i0,r0,r1)              _beqr_d(_jit,i0,r0,r1)
 301 static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 302 #  define beqi_f(i0,r0,i1)              _beqi_f(_jit,i0,r0,i1)
 303 static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 304 #  define beqi_d(i0,r0,i1)              _beqi_d(_jit,i0,r0,i1)
 305 static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 306 #  define bger_f(i0,r0,r1)              bger_d(i0,r0,r1)
 307 #  define bger_d(i0,r0,r1)              _bger_d(_jit,i0,r0,r1)
 308 static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 309 #  define bgei_f(i0,r0,i1)              _bgei_f(_jit,i0,r0,i1)
 310 static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 311 #  define bgei_d(i0,r0,i1)              _bgei_d(_jit,i0,r0,i1)
 312 static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 313 #  define bgtr_f(i0,r0,r1)              bgtr_d(i0,r0,r1)
 314 #  define bgtr_d(i0,r0,r1)              _bgtr_d(_jit,i0,r0,r1)
 315 static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 316 #  define bgti_f(i0,r0,i1)              _bgti_f(_jit,i0,r0,i1)
 317 static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 318 #  define bgti_d(i0,r0,i1)              _bgti_d(_jit,i0,r0,i1)
 319 static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 320 #  define bner_f(i0,r0,r1)              bner_d(i0,r0,r1)
 321 #  define bner_d(i0,r0,r1)              _bner_d(_jit,i0,r0,r1)
 322 static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 323 #  define bnei_f(i0,r0,i1)              _bnei_f(_jit,i0,r0,i1)
 324 static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 325 #  define bnei_d(i0,r0,i1)              _bnei_d(_jit,i0,r0,i1)
 326 static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 327 #  define bunltr_f(i0,r0,r1)            bunltr_d(i0,r0,r1)
 328 #  define bunltr_d(i0,r0,r1)            _bunltr_d(_jit,i0,r0,r1)
 329 static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 330 #  define bunlti_f(i0,r0,i1)            _bunlti_f(_jit,i0,r0,i1)
 331 static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 332 #  define bunlti_d(i0,r0,i1)            _bunlti_d(_jit,i0,r0,i1)
 333 static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 334 #  define bunler_f(i0,r0,r1)            bunler_d(i0,r0,r1)
 335 #  define bunler_d(i0,r0,r1)            _bunler_d(_jit,i0,r0,r1)
 336 static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 337 #  define bunlei_f(i0,r0,i1)            _bunlei_f(_jit,i0,r0,i1)
 338 static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 339 #  define bunlei_d(i0,r0,i1)            _bunlei_d(_jit,i0,r0,i1)
 340 static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 341 #  define buneqr_f(i0,r0,r1)            buneqr_d(i0,r0,r1)
 342 #  define buneqr_d(i0,r0,r1)            _buneqr_d(_jit,i0,r0,r1)
 343 static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 344 #  define buneqi_f(i0,r0,i1)            _buneqi_f(_jit,i0,r0,i1)
 345 static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 346 #  define buneqi_d(i0,r0,i1)            _buneqi_d(_jit,i0,r0,i1)
 347 static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 348 #  define bunger_f(i0,r0,r1)            bunger_d(i0,r0,r1)
 349 #  define bunger_d(i0,r0,r1)            _bunger_d(_jit,i0,r0,r1)
 350 static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 351 #  define bungei_f(i0,r0,i1)            _bungei_f(_jit,i0,r0,i1)
 352 static jit_word_t _bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 353 #  define bungei_d(i0,r0,i1)            _bungei_d(_jit,i0,r0,i1)
 354 static jit_word_t _bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 355 #  define bungtr_f(i0,r0,r1)            bungtr_d(i0,r0,r1)
 356 #  define bungtr_d(i0,r0,r1)            _bungtr_d(_jit,i0,r0,r1)
 357 static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 358 #  define bungti_f(i0,r0,i1)            _bungti_f(_jit,i0,r0,i1)
 359 static jit_word_t _bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 360 #  define bungti_d(i0,r0,i1)            _bungti_d(_jit,i0,r0,i1)
 361 static jit_word_t _bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 362 #  define bltgtr_f(i0,r0,r1)            bltgtr_d(i0,r0,r1)
 363 #  define bltgtr_d(i0,r0,r1)            _bltgtr_d(_jit,i0,r0,r1)
 364 static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 365 #  define bltgti_f(i0,r0,i1)            _bltgti_f(_jit,i0,r0,i1)
 366 static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 367 #  define bltgti_d(i0,r0,i1)            _bltgti_d(_jit,i0,r0,i1)
 368 static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 369 #  define bordr_f(i0,r0,r1)             bordr_d(i0,r0,r1)
 370 #  define bordr_d(i0,r0,r1)             _bordr_d(_jit,i0,r0,r1)
 371 static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 372 #  define bordi_f(i0,r0,i1)             _bordi_f(_jit,i0,r0,i1)
 373 static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 374 #  define bordi_d(i0,r0,i1)             _bordi_d(_jit,i0,r0,i1)
 375 static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 376 #  define bunordr_f(i0,r0,r1)           bunordr_d(i0,r0,r1)
 377 #  define bunordr_d(i0,r0,r1)           _bunordr_d(_jit,i0,r0,r1)
 378 static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 379 #  define bunordi_f(i0,r0,i1)           _bunordi_f(_jit,i0,r0,i1)
 380 static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
 381 #  define bunordi_d(i0,r0,i1)           _bunordi_d(_jit,i0,r0,i1)
 382 static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
 383 #  define ldr_f(r0,r1)                  LFSX(r0, _R0_REGNO, r1)
 384 #  define ldi_f(r0,i0)                  _ldi_f(_jit,r0,i0)
 385 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
 386 #  define ldxr_f(r0,r1,r2)              _ldxr_f(_jit,r0,r1,r2)
 387 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 388 #  define ldxi_f(r0,r1,i0)              _ldxi_f(_jit,r0,r1,i0)
 389 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 390 #  define str_f(r0,r1)                  STFSX(r1, _R0_REGNO, r0)
 391 #  define sti_f(i0,r0)                  _sti_f(_jit,i0,r0)
 392 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
 393 #  define stxr_f(r0,r1,r2)              _stxr_f(_jit,r0,r1,r2)
 394 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 395 #  define stxi_f(i0,r0,r1)              _stxi_f(_jit,i0,r0,r1)
 396 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 397 #  define ldr_d(r0,r1)                  LFDX(r0, _R0_REGNO, r1)
 398 #  define ldi_d(r0,i0)                  _ldi_d(_jit,r0,i0)
 399 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
 400 #  define ldxr_d(r0,r1,r2)              _ldxr_d(_jit,r0,r1,r2)
 401 static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 402 #  define ldxi_d(r0,r1,i0)              _ldxi_d(_jit,r0,r1,i0)
 403 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 404 #  define str_d(r0,r1)                  STFDX(r1, _R0_REGNO, r0)
 405 #  define sti_d(i0,r0)                  _sti_d(_jit,i0,r0)
 406 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
 407 #  define stxr_d(r0,r1,r2)              _stxr_d(_jit,r0,r1,r2)
 408 static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 409 #  define stxi_d(i0,r0,r1)              _stxi_d(_jit,i0,r0,r1)
 410 static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 411 #endif
 412
 413 #if CODE
 414 #  define _u16(v)                       ((v) & 0xffff)
 415 static void
 416 _FA(jit_state_t *_jit, int o, int d, int a, int b, int c, int x, int r)
 417 {
 418     assert(!(o & ~((1 << 6) - 1)));
 419     assert(!(d & ~((1 << 5) - 1)));
 420     assert(!(a & ~((1 << 5) - 1)));
 421     assert(!(b & ~((1 << 5) - 1)));
 422     assert(!(c & ~((1 << 5) - 1)));
 423     assert(!(x & ~((1 << 5) - 1)));
 424     assert(!(r & ~((1 << 1) - 1)));
 425     ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(c<<6)|(x<<1)|r);
 426 }
 427
 428 static void
 429 _FXFL(jit_state_t *_jit, int o, int m, int b, int x, int r)
 430 {
 431     assert(!(o & ~((1 <<  6) - 1)));
 432     assert(!(m & ~((1 <<  8) - 1)));
 433     assert(!(b & ~((1 <<  5) - 1)));
 434     assert(!(x & ~((1 << 10) - 1)));
 435     assert(!(r & ~((1 <<  1) - 1)));
 436     ii((o<<26)|(m<<17)|(b<<11)|(x<<1)|r);
 437 }
 438
 439 static void
 440 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 441 {
 442     if (r0 != r1)
 443         FMR(r0,r1);
 444 }
 445
 446 static void
 447 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
 448 {
 449     union {
 450         jit_int32_t      i;
 451         jit_float32_t    f;
 452     } data;
 453     jit_int32_t          reg;
 454
 455     if (_jitc->no_data) {
 456         data.f = *i0;
 457         reg = jit_get_reg(jit_class_gpr);
 458         movi(rn(reg), data.i & 0xffffffff);
 459         stxi_i(alloca_offset - 4, _FP_REGNO, rn(reg));
 460         jit_unget_reg(reg);
 461         ldxi_f(r0, _FP_REGNO, alloca_offset - 4);
 462     }
 463     else
 464         ldi_f(r0, (jit_word_t)i0);
 465 }
 466
 467 static void
 468 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
 469 {
 470     union {
 471         jit_int32_t      i[2];
 472         jit_word_t       w;
 473         jit_float64_t    d;
 474     } data;
 475     jit_int32_t          reg;
 476
 477     if (_jitc->no_data) {
 478         data.d = *i0;
 479         reg = jit_get_reg(jit_class_gpr);
 480 #  if __WORDSIZE == 32
 481         movi(rn(reg), data.i[0]);
 482         stxi(alloca_offset - 8, _FP_REGNO, rn(reg));
 483         movi(rn(reg), data.i[1]);
 484         stxi(alloca_offset - 4, _FP_REGNO, rn(reg));
 485 #  else
 486         movi(rn(reg), data.w);
 487         stxi(alloca_offset - 8, _FP_REGNO, rn(reg));
 488 #  endif
 489         jit_unget_reg(reg);
 490         ldxi_d(r0, _FP_REGNO, alloca_offset - 8);
 491     }
 492     else
 493         ldi_d(r0, (jit_word_t)i0);
 494 }
 495
 496 static void
 497 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 498 {
 499 #  if __WORDSIZE == 32
 500     jit_int32_t         reg, freg, off1, off2;
 501
 502 #  if __BYTE_ORDER == __BIG_ENDIAN
 503     off1 = alloca_offset - 8;
 504     off2 = alloca_offset - 4;
 505 #  else
 506     off1 = alloca_offset - 4;
 507     off2 = alloca_offset - 8;
 508 #  endif
 509
 510     reg = jit_get_reg(jit_class_gpr);
 511     freg = jit_get_reg(jit_class_fpr);
 512
 513     movi(rn(reg), 0x43300000);
 514     stxi_i(off1, _FP_REGNO, rn(reg));
 515     movi(rn(reg), 0x80000000);
 516     stxi_i(off2, _FP_REGNO, rn(reg));
 517     ldxi_d(rn(freg), _FP_REGNO, alloca_offset - 8);
 518     xorr(rn(reg), r1, rn(reg));
 519     stxi_i(off2, _FP_REGNO, rn(reg));
 520     ldxi_d(r0, _FP_REGNO, alloca_offset - 8);
 521     subr_d(r0, r0, rn(freg));
 522
 523     jit_unget_reg(reg);
 524     jit_unget_reg(freg);
 525 #  else
 526     stxi(alloca_offset - 8, _FP_REGNO, r1);
 527     ldxi_d(r0, _FP_REGNO, alloca_offset - 8);
 528     FCFID(r0, r0);
 529 #  endif
 530 }
 531
 532 static void
 533 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 534 {
 535     jit_int32_t         reg;
 536     reg = jit_get_reg(jit_class_fpr);
 537     FCTIWZ(rn(reg), r1);
 538     /* use reserved 8 bytes area */
 539     stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg));
 540 #  if __BYTE_ORDER == __BIG_ENDIAN
 541     ldxi_i(r0, _FP_REGNO, alloca_offset - 4);
 542 #  else
 543     ldxi_i(r0, _FP_REGNO, alloca_offset - 8);
 544 #  endif
 545     jit_unget_reg(reg);
 546 }
 547
 548 #  if __WORDSIZE == 64
 549 static void
 550 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 551 {
 552     jit_int32_t         reg;
 553     reg = jit_get_reg(jit_class_fpr);
 554     FCTIDZ(rn(reg), r1);
 555     /* use reserved 8 bytes area */
 556     stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg));
 557     ldxi(r0, _FP_REGNO, alloca_offset - 8);
 558     jit_unget_reg(reg);
 559 }
 560 #  endif
 561
 562 #  ifndef _ARCH_PPCSQ
 563 static void
 564 _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 565 {
 566     movr_f(rn(JIT_FA0), r1);
 567     calli((jit_word_t)sqrtf
 568 #  if _CALL_SYSV
 569           , 0
 570 #  endif
 571           );
 572     movr_f(r0, rn(JIT_FRET));
 573 }
 574
 575 static void
 576 _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 577 {
 578     movr_d(rn(JIT_FA0), r1);
 579     calli((jit_word_t)sqrt
 580 #  if _CALL_SYSV
 581           , 0
 582 #  endif
 583           );
 584     movr_d(r0, rn(JIT_FRET));
 585 }
 586 #  endif
 587
 588 #  define fpr_opi(name, type, size)                                     \
 589 static void                                                             \
 590 _##name##i_##type(jit_state_t *_jit,                                    \
 591                   jit_int32_t r0, jit_int32_t r1,                       \
 592                   jit_float##size##_t *i0)                              \
 593 {                                                                       \
 594     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
 595     movi_##type(rn(reg), i0);                                           \
 596     name##r_##type(r0, r1, rn(reg));                                    \
 597     jit_unget_reg(reg);                                                 \
 598 }
 599 #  define fpr_bopi(name, type, size)                                    \
 600 static jit_word_t                                                       \
 601 _b##name##i_##type(jit_state_t *_jit,                                   \
 602                   jit_word_t i0, jit_int32_t r0,                        \
 603                   jit_float##size##_t *i1)                              \
 604 {                                                                       \
 605     jit_word_t          word;                                           \
 606     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
 607                                           jit_class_nospill);           \
 608     movi_##type(rn(reg), i1);                                           \
 609     word = b##name##r_##type(i0, r0, rn(reg));                          \
 610     jit_unget_reg(reg);                                                 \
 611     return (word);                                                      \
 612 }
 613 #  define fopi(name)                    fpr_opi(name, f, 32)
 614 #  define fbopi(name)                   fpr_bopi(name, f, 32)
 615 #  define dopi(name)                    fpr_opi(name, d, 64)
 616 #  define dbopi(name)                   fpr_bopi(name, d, 64)
 617
 618 fopi(add)
 619 dopi(add)
 620 fopi(sub)
 621 dopi(sub)
 622 fopi(rsb)
 623 dopi(rsb)
 624 fopi(mul)
 625 dopi(mul)
 626 fopi(div)
 627 dopi(div)
 628
 629 static void
 630 _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 631 {
 632     FCMPO(CR_0, r1, r2);
 633     MFCR(r0);
 634     EXTRWI(r0, r0, 1, CR_LT);
 635 }
 636 fopi(lt)
 637 dopi(lt)
 638
 639 static void
 640 _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 641 {
 642     FCMPO(CR_0, r1, r2);
 643     CREQV(CR_GT, CR_GT, CR_UN);
 644     MFCR(r0);
 645     EXTRWI(r0, r0, 1, CR_GT);
 646 }
 647 fopi(le)
 648 dopi(le)
 649
 650 static void
 651 _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 652 {
 653     FCMPO(CR_0, r1, r2);
 654     MFCR(r0);
 655     EXTRWI(r0, r0, 1, CR_EQ);
 656 }
 657 fopi(eq)
 658 dopi(eq)
 659
 660 static void
 661 _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 662 {
 663     FCMPO(CR_0, r1, r2);
 664     CREQV(CR_LT, CR_LT, CR_UN);
 665     MFCR(r0);
 666     EXTRWI(r0, r0, 1, CR_LT);
 667 }
 668 fopi(ge)
 669 dopi(ge)
 670
 671 static void
 672 _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 673 {
 674     FCMPO(CR_0, r1, r2);
 675     MFCR(r0);
 676     EXTRWI(r0, r0, 1, CR_GT);
 677 }
 678 fopi(gt)
 679 dopi(gt)
 680
 681 static void
 682 _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 683 {
 684     FCMPO(CR_0, r1, r2);
 685     CRNOT(CR_EQ, CR_EQ);
 686     MFCR(r0);
 687     EXTRWI(r0, r0, 1, CR_EQ);
 688 }
 689 fopi(ne)
 690 dopi(ne)
 691
 692 static void
 693 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 694 {
 695     FCMPU(CR_0, r1, r2);
 696     CROR(CR_LT, CR_LT, CR_UN);
 697     MFCR(r0);
 698     EXTRWI(r0, r0, 1, CR_LT);
 699 }
 700 fopi(unlt)
 701 dopi(unlt)
 702
 703 static void
 704 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 705 {
 706     FCMPU(CR_0, r1, r2);
 707     CRNOT(CR_GT, CR_GT);
 708     MFCR(r0);
 709     EXTRWI(r0, r0, 1, CR_GT);
 710 }
 711 fopi(unle)
 712 dopi(unle)
 713
 714 static void
 715 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 716 {
 717     FCMPU(CR_0, r1, r2);
 718     CROR(CR_EQ, CR_EQ, CR_UN);
 719     MFCR(r0);
 720     EXTRWI(r0, r0, 1, CR_EQ);
 721 }
 722 fopi(uneq)
 723 dopi(uneq)
 724
 725 static void
 726 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 727 {
 728     FCMPU(CR_0, r1, r2);
 729     CRNOT(CR_LT, CR_LT);
 730     MFCR(r0);
 731     EXTRWI(r0, r0, 1, CR_LT);
 732 }
 733 fopi(unge)
 734 dopi(unge)
 735
 736 static void
 737 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 738 {
 739     FCMPU(CR_0, r1, r2);
 740     CROR(CR_GT, CR_GT, CR_UN);
 741     MFCR(r0);
 742     EXTRWI(r0, r0, 1, CR_GT);
 743 }
 744 fopi(ungt)
 745 dopi(ungt)
 746
 747 static void
 748 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 749 {
 750     FCMPU(CR_0, r1, r2);
 751     CROR(CR_GT, CR_GT, CR_LT);
 752     MFCR(r0);
 753     EXTRWI(r0, r0, 1, CR_GT);
 754 }
 755 fopi(ltgt)
 756 dopi(ltgt)
 757
 758 static void
 759 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 760 {
 761     FCMPU(CR_0, r1, r2);
 762     CRNOT(CR_UN, CR_UN);
 763     MFCR(r0);
 764     EXTRWI(r0, r0, 1, CR_UN);
 765 }
 766 fopi(ord)
 767 dopi(ord)
 768
 769 static void
 770 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 771 {
 772     FCMPU(CR_0, r1, r2);
 773     MFCR(r0);
 774     EXTRWI(r0, r0, 1, CR_UN);
 775 }
 776 fopi(unord)
 777 dopi(unord)
 778
 779 static jit_word_t
 780 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 781 {
 782     jit_word_t          d, w;
 783     FCMPO(CR_0, r0, r1);
 784     w = _jit->pc.w;
 785     d = (i0 - w) & ~3;
 786     BLT(d);
 787     return (w);
 788 }
 789 fbopi(lt)
 790 dbopi(lt)
 791
 792 static jit_word_t
 793 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 794 {
 795     jit_word_t          d, w;
 796     FCMPO(CR_0, r0, r1);
 797     CREQV(CR_GT, CR_GT, CR_UN);
 798     w = _jit->pc.w;
 799     d = (i0 - w) & ~3;
 800     BGT(d);
 801     return (w);
 802 }
 803 fbopi(le)
 804 dbopi(le)
 805
 806 static jit_word_t
 807 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 808 {
 809     jit_word_t          d, w;
 810     FCMPO(CR_0, r0, r1);
 811     w = _jit->pc.w;
 812     d = (i0 - w) & ~3;
 813     BEQ(d);
 814     return (w);
 815 }
 816 fbopi(eq)
 817 dbopi(eq)
 818
 819 static jit_word_t
 820 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 821 {
 822     jit_word_t          d, w;
 823     FCMPO(CR_0, r0, r1);
 824     CREQV(CR_LT, CR_LT, CR_UN);
 825     w = _jit->pc.w;
 826     d = (i0 - w) & ~3;
 827     BLT(d);
 828     return (w);
 829 }
 830 fbopi(ge)
 831 dbopi(ge)
 832
 833 static jit_word_t
 834 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 835 {
 836     jit_word_t          d, w;
 837     FCMPO(CR_0, r0, r1);
 838     w = _jit->pc.w;
 839     d = (i0 - w) & ~3;
 840     BGT(d);
 841     return (w);
 842 }
 843 fbopi(gt)
 844 dbopi(gt)
 845
 846 static jit_word_t
 847 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 848 {
 849     jit_word_t          d, w;
 850     FCMPO(CR_0, r0, r1);
 851     w = _jit->pc.w;
 852     d = (i0 - w) & ~3;
 853     BNE(d);
 854     return (w);
 855 }
 856 fbopi(ne)
 857 dbopi(ne)
 858
 859 static jit_word_t
 860 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 861 {
 862     jit_word_t          d, w;
 863     FCMPU(CR_0, r0, r1);
 864     CROR(CR_LT, CR_LT, CR_UN);
 865     w = _jit->pc.w;
 866     d = (i0 - w) & ~3;
 867     BLT(d);
 868     return (w);
 869 }
 870 fbopi(unlt)
 871 dbopi(unlt)
 872
 873 static jit_word_t
 874 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 875 {
 876     jit_word_t          d, w;
 877     FCMPU(CR_0, r0, r1);
 878     w = _jit->pc.w;
 879     d = (i0 - w) & ~3;
 880     BLE(d);
 881     return (w);
 882 }
 883 fbopi(unle)
 884 dbopi(unle)
 885
 886 static jit_word_t
 887 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 888 {
 889     jit_word_t          d, w;
 890     FCMPU(CR_0, r0, r1);
 891     CROR(CR_EQ, CR_EQ, CR_UN);
 892     w = _jit->pc.w;
 893     d = (i0 - w) & ~3;
 894     BEQ(d);
 895     return (w);
 896 }
 897 fbopi(uneq)
 898 dbopi(uneq)
 899
 900 static jit_word_t
 901 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 902 {
 903     jit_word_t          d, w;
 904     FCMPU(CR_0, r0, r1);
 905     w = _jit->pc.w;
 906     d = (i0 - w) & ~3;
 907     BGE(d);
 908     return (w);
 909 }
 910 fbopi(unge)
 911 dbopi(unge)
 912
 913 static jit_word_t
 914 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 915 {
 916     jit_word_t          d, w;
 917     FCMPU(CR_0, r0, r1);
 918     CROR(CR_GT, CR_GT, CR_UN);
 919     w = _jit->pc.w;
 920     d = (i0 - w) & ~3;
 921     BGT(d);
 922     return (w);
 923 }
 924 fbopi(ungt)
 925 dbopi(ungt)
 926
 927 static jit_word_t
 928 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 929 {
 930     jit_word_t          d, w;
 931     FCMPU(CR_0, r0, r1);
 932     CROR(CR_EQ, CR_LT, CR_GT);
 933     w = _jit->pc.w;
 934     d = (i0 - w) & ~3;
 935     BEQ(d);
 936     return (w);
 937 }
 938 fbopi(ltgt)
 939 dbopi(ltgt)
 940
 941 static jit_word_t
 942 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 943 {
 944     jit_word_t          d, w;
 945     FCMPU(CR_0, r0, r1);
 946     w = _jit->pc.w;
 947     d = (i0 - w) & ~3;
 948     BNU(d);
 949     return (w);
 950 }
 951 fbopi(ord)
 952 dbopi(ord)
 953
 954 static jit_word_t
 955 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 956 {
 957     jit_word_t          d, w;
 958     FCMPU(CR_0, r0, r1);
 959     w = _jit->pc.w;
 960     d = (i0 - w) & ~3;
 961     BUN(d);
 962     return (w);
 963 }
 964 fbopi(unord)
 965 dbopi(unord)
 966
 967 static void
 968 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 969 {
 970     jit_bool_t          inv;
 971     jit_int32_t         reg;
 972     jit_word_t          lo, hi;
 973     if (can_sign_extend_short_p(i0))
 974         LFS(r0, _R0_REGNO, i0);
 975     else if (can_sign_extend_int_p(i0)) {
 976         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
 977         lo = (jit_int16_t)(i0 - (hi << 16));
 978         reg = jit_get_reg(jit_class_gpr);
 979         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
 980         LIS(rn(reg), hi);
 981         LFS(r0, rn(reg), lo);
 982         jit_unget_reg(reg);
 983         if (inv)                        jit_unget_reg(_R0);
 984     }
 985     else {
 986         reg = jit_get_reg(jit_class_gpr);
 987         movi(rn(reg), i0);
 988         ldr_f(r0, rn(reg));
 989         jit_unget_reg(reg);
 990     }
 991 }
 992
 993 static void
 994 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 995 {
 996     jit_bool_t          inv;
 997     jit_int32_t         reg;
 998     jit_word_t          lo, hi;
 999     if (can_sign_extend_short_p(i0))
1000         LFD(r0, _R0_REGNO, i0);
1001     else if (can_sign_extend_int_p(i0)) {
1002         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
1003         lo = (jit_int16_t)(i0 - (hi << 16));
1004         reg = jit_get_reg(jit_class_gpr);
1005         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
1006         LIS(rn(reg), hi);
1007         LFD(r0, rn(reg), lo);
1008         jit_unget_reg(reg);
1009         if (inv)                        jit_unget_reg(_R0);
1010     }
1011     else {
1012         reg = jit_get_reg(jit_class_gpr);
1013         movi(rn(reg), i0);
1014         ldr_d(r0, rn(reg));
1015         jit_unget_reg(reg);
1016     }
1017 }
1018
1019 static void
1020 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1021 {
1022     jit_int32_t         reg;
1023     if (r1 == _R0_REGNO) {
1024         if (r2 != _R0_REGNO)
1025             LFSX(r0, r2, r1);
1026         else {
1027             reg = jit_get_reg(jit_class_gpr);
1028             movr(rn(reg), r1);
1029             LFSX(r0, rn(reg), r2);
1030             jit_unget_reg(reg);
1031         }
1032     }
1033     else
1034         LFSX(r0, r1, r2);
1035 }
1036
1037 static void
1038 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1039 {
1040     jit_int32_t         reg;
1041     if (r1 == _R0_REGNO) {
1042         if (r2 != _R0_REGNO)
1043             LFDX(r0, r2, r1);
1044         else {
1045             reg = jit_get_reg(jit_class_gpr);
1046             movr(rn(reg), r1);
1047             LFDX(r0, rn(reg), r2);
1048             jit_unget_reg(reg);
1049         }
1050     }
1051     else
1052         LFDX(r0, r1, r2);
1053 }
1054
1055 static void
1056 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1057 {
1058     jit_int32_t         reg;
1059     if (i0 == 0)
1060         ldr_f(r0, r1);
1061     else if (can_sign_extend_short_p(i0)) {
1062         if (r1 == _R0_REGNO) {
1063             reg = jit_get_reg(jit_class_gpr);
1064             movr(rn(reg), r1);
1065             LFS(r0, rn(reg), i0);
1066             jit_unget_reg(reg);
1067         }
1068         else
1069             LFS(r0, r1, i0);
1070     }
1071     else {
1072         reg = jit_get_reg(jit_class_gpr);
1073         movi(rn(reg), i0);
1074         ldxr_f(r0, r1, rn(reg));
1075         jit_unget_reg(reg);
1076     }
1077 }
1078
1079 static void
1080 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1081 {
1082     jit_int32_t         reg;
1083     if (i0 == 0)
1084         ldr_d(r0, r1);
1085     else if (can_sign_extend_short_p(i0)) {
1086         if (r1 == _R0_REGNO) {
1087             reg = jit_get_reg(jit_class_gpr);
1088             movr(rn(reg), r1);
1089             LFD(r0, rn(reg), i0);
1090             jit_unget_reg(reg);
1091         }
1092         else
1093             LFD(r0, r1, i0);
1094     }
1095     else {
1096         reg = jit_get_reg(jit_class_gpr);
1097         movi(rn(reg), i0);
1098         ldxr_d(r0, r1, rn(reg));
1099         jit_unget_reg(reg);
1100     }
1101 }
1102
1103 static void
1104 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1105 {
1106     jit_bool_t          inv;
1107     jit_int32_t         reg;
1108     jit_word_t          lo, hi;
1109     if (can_sign_extend_short_p(i0))
1110         STFS(r0, _R0_REGNO, i0);
1111     else if (can_sign_extend_int_p(i0)) {
1112         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
1113         lo = (jit_int16_t)(i0 - (hi << 16));
1114         reg = jit_get_reg(jit_class_gpr);
1115         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
1116         LIS(rn(reg), hi);
1117         STFS(r0, rn(reg), lo);
1118         jit_unget_reg(reg);
1119         if (inv)                        jit_unget_reg(_R0);
1120     }
1121     else {
1122         reg = jit_get_reg(jit_class_gpr);
1123         movi(rn(reg), i0);
1124         str_f(rn(reg), r0);
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_bool_t          inv;
1133     jit_int32_t         reg;
1134     jit_word_t          lo, hi;
1135     if (can_sign_extend_short_p(i0))
1136         STFD(r0, _R0_REGNO, i0);
1137     else if (can_sign_extend_int_p(i0)) {
1138         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
1139         lo = (jit_int16_t)(i0 - (hi << 16));
1140         reg = jit_get_reg(jit_class_gpr);
1141         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
1142         LIS(rn(reg), hi);
1143         STFD(r0, rn(reg), lo);
1144         jit_unget_reg(reg);
1145         if (inv)                        jit_unget_reg(_R0);
1146     }
1147     else {
1148         reg = jit_get_reg(jit_class_gpr);
1149         movi(rn(reg), i0);
1150         str_d(rn(reg), r0);
1151         jit_unget_reg(reg);
1152     }
1153 }
1154
1155 static void
1156 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1157 {
1158     jit_int32_t         reg;
1159     if (r0 == _R0_REGNO) {
1160         if (r1 != _R0_REGNO)
1161             STFSX(r2, r1, r0);
1162         else {
1163             reg = jit_get_reg(jit_class_gpr);
1164             movr(rn(reg), r1);
1165             STFSX(r2, rn(reg), r0);
1166             jit_unget_reg(reg);
1167         }
1168     }
1169     else
1170         STFSX(r2, r0, r1);
1171 }
1172
1173 static void
1174 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1175 {
1176     jit_int32_t         reg;
1177     if (r0 == _R0_REGNO) {
1178         if (r1 != _R0_REGNO)
1179             STFDX(r2, r1, r0);
1180         else {
1181             reg = jit_get_reg(jit_class_gpr);
1182             movr(rn(reg), r0);
1183             STFDX(r2, rn(reg), r1);
1184             jit_unget_reg(reg);
1185         }
1186     }
1187     else
1188         STFDX(r2, r0, r1);
1189 }
1190
1191 static void
1192 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1193 {
1194     jit_int32_t         reg;
1195     if (i0 == 0)
1196         str_f(r0, r1);
1197     else if (can_sign_extend_short_p(i0)) {
1198         if (r0 == _R0_REGNO) {
1199             reg = jit_get_reg(jit_class_gpr);
1200             movr(rn(reg), i0);
1201             STFS(r1, rn(reg), i0);
1202             jit_unget_reg(reg);
1203         }
1204         else
1205             STFS(r1, r0, i0);
1206     }
1207     else {
1208         reg = jit_get_reg(jit_class_gpr);
1209         movi(rn(reg), i0);
1210         stxr_f(rn(reg), r0, r1);
1211         jit_unget_reg(reg);
1212     }
1213 }
1214
1215 static void
1216 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1217 {
1218     jit_int32_t         reg;
1219     if (i0 == 0)
1220         str_d(r0, r1);
1221     else if (can_sign_extend_short_p(i0)) {
1222         if (r0 == _R0_REGNO) {
1223             reg = jit_get_reg(jit_class_gpr);
1224             movr(rn(reg), i0);
1225             STFD(r1, rn(reg), i0);
1226             jit_unget_reg(reg);
1227         }
1228         else
1229             STFD(r1, r0, i0);
1230     }
1231     else {
1232         reg = jit_get_reg(jit_class_gpr);
1233         movi(rn(reg), i0);
1234         stxr_d(rn(reg), r0, r1);
1235         jit_unget_reg(reg);
1236     }
1237 }
1238 #endif