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