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 #  if __BYTE_ORDER == __BIG_ENDIAN
 515     ldxi_i(r0, _FP_REGNO, alloca_offset - 4);
 516 #  else
 517     ldxi_i(r0, _FP_REGNO, alloca_offset - 8);
 518 #  endif
 519     jit_unget_reg(reg);
 520 }
 521
 522 #  if __WORDSIZE == 64
 523 static void
 524 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 525 {
 526     jit_int32_t         reg;
 527     reg = jit_get_reg(jit_class_fpr);
 528     FCTIDZ(rn(reg), r1);
 529     /* use reserved 8 bytes area */
 530     stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg));
 531     ldxi(r0, _FP_REGNO, alloca_offset - 8);
 532     jit_unget_reg(reg);
 533 }
 534 #  endif
 535
 536 #  define fpr_opi(name, type, size)                                     \
 537 static void                                                             \
 538 _##name##i_##type(jit_state_t *_jit,                                    \
 539                   jit_int32_t r0, jit_int32_t r1,                       \
 540                   jit_float##size##_t *i0)                              \
 541 {                                                                       \
 542     jit_int32_t         reg = jit_get_reg(jit_class_fpr);               \
 543     movi_##type(rn(reg), i0);                                           \
 544     name##r_##type(r0, r1, rn(reg));                                    \
 545     jit_unget_reg(reg);                                                 \
 546 }
 547 #  define fpr_bopi(name, type, size)                                    \
 548 static jit_word_t                                                       \
 549 _b##name##i_##type(jit_state_t *_jit,                                   \
 550                   jit_word_t i0, jit_int32_t r0,                        \
 551                   jit_float##size##_t *i1)                              \
 552 {                                                                       \
 553     jit_word_t          word;                                           \
 554     jit_int32_t         reg = jit_get_reg(jit_class_fpr|                \
 555                                           jit_class_nospill);           \
 556     movi_##type(rn(reg), i1);                                           \
 557     word = b##name##r_##type(i0, r0, rn(reg));                          \
 558     jit_unget_reg(reg);                                                 \
 559     return (word);                                                      \
 560 }
 561 #  define fopi(name)                    fpr_opi(name, f, 32)
 562 #  define fbopi(name)                   fpr_bopi(name, f, 32)
 563 #  define dopi(name)                    fpr_opi(name, d, 64)
 564 #  define dbopi(name)                   fpr_bopi(name, d, 64)
 565
 566 fopi(add)
 567 dopi(add)
 568 fopi(sub)
 569 dopi(sub)
 570 fopi(rsb)
 571 dopi(rsb)
 572 fopi(mul)
 573 dopi(mul)
 574 fopi(div)
 575 dopi(div)
 576
 577 static void
 578 _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 579 {
 580     FCMPO(CR_0, r1, r2);
 581     MFCR(r0);
 582     EXTRWI(r0, r0, 1, CR_LT);
 583 }
 584 fopi(lt)
 585 dopi(lt)
 586
 587 static void
 588 _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 589 {
 590     FCMPO(CR_0, r1, r2);
 591     CREQV(CR_GT, CR_GT, CR_UN);
 592     MFCR(r0);
 593     EXTRWI(r0, r0, 1, CR_GT);
 594 }
 595 fopi(le)
 596 dopi(le)
 597
 598 static void
 599 _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 600 {
 601     FCMPO(CR_0, r1, r2);
 602     MFCR(r0);
 603     EXTRWI(r0, r0, 1, CR_EQ);
 604 }
 605 fopi(eq)
 606 dopi(eq)
 607
 608 static void
 609 _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 610 {
 611     FCMPO(CR_0, r1, r2);
 612     CREQV(CR_LT, CR_LT, CR_UN);
 613     MFCR(r0);
 614     EXTRWI(r0, r0, 1, CR_LT);
 615 }
 616 fopi(ge)
 617 dopi(ge)
 618
 619 static void
 620 _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 621 {
 622     FCMPO(CR_0, r1, r2);
 623     MFCR(r0);
 624     EXTRWI(r0, r0, 1, CR_GT);
 625 }
 626 fopi(gt)
 627 dopi(gt)
 628
 629 static void
 630 _ner_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     CRNOT(CR_EQ, CR_EQ);
 634     MFCR(r0);
 635     EXTRWI(r0, r0, 1, CR_EQ);
 636 }
 637 fopi(ne)
 638 dopi(ne)
 639
 640 static void
 641 _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 642 {
 643     FCMPU(CR_0, r1, r2);
 644     CROR(CR_LT, CR_LT, CR_UN);
 645     MFCR(r0);
 646     EXTRWI(r0, r0, 1, CR_LT);
 647 }
 648 fopi(unlt)
 649 dopi(unlt)
 650
 651 static void
 652 _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 653 {
 654     FCMPU(CR_0, r1, r2);
 655     CRNOT(CR_GT, CR_GT);
 656     MFCR(r0);
 657     EXTRWI(r0, r0, 1, CR_GT);
 658 }
 659 fopi(unle)
 660 dopi(unle)
 661
 662 static void
 663 _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 664 {
 665     FCMPU(CR_0, r1, r2);
 666     CROR(CR_EQ, CR_EQ, CR_UN);
 667     MFCR(r0);
 668     EXTRWI(r0, r0, 1, CR_EQ);
 669 }
 670 fopi(uneq)
 671 dopi(uneq)
 672
 673 static void
 674 _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 675 {
 676     FCMPU(CR_0, r1, r2);
 677     CRNOT(CR_LT, CR_LT);
 678     MFCR(r0);
 679     EXTRWI(r0, r0, 1, CR_LT);
 680 }
 681 fopi(unge)
 682 dopi(unge)
 683
 684 static void
 685 _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 686 {
 687     FCMPU(CR_0, r1, r2);
 688     CROR(CR_GT, CR_GT, CR_UN);
 689     MFCR(r0);
 690     EXTRWI(r0, r0, 1, CR_GT);
 691 }
 692 fopi(ungt)
 693 dopi(ungt)
 694
 695 static void
 696 _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 697 {
 698     FCMPU(CR_0, r1, r2);
 699     CROR(CR_GT, CR_GT, CR_LT);
 700     MFCR(r0);
 701     EXTRWI(r0, r0, 1, CR_GT);
 702 }
 703 fopi(ltgt)
 704 dopi(ltgt)
 705
 706 static void
 707 _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 708 {
 709     FCMPU(CR_0, r1, r2);
 710     CRNOT(CR_UN, CR_UN);
 711     MFCR(r0);
 712     EXTRWI(r0, r0, 1, CR_UN);
 713 }
 714 fopi(ord)
 715 dopi(ord)
 716
 717 static void
 718 _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 719 {
 720     FCMPU(CR_0, r1, r2);
 721     MFCR(r0);
 722     EXTRWI(r0, r0, 1, CR_UN);
 723 }
 724 fopi(unord)
 725 dopi(unord)
 726
 727 static jit_word_t
 728 _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 729 {
 730     jit_word_t          d, w;
 731     FCMPO(CR_0, r0, r1);
 732     w = _jit->pc.w;
 733     d = (i0 - w) & ~3;
 734     BLT(d);
 735     return (w);
 736 }
 737 fbopi(lt)
 738 dbopi(lt)
 739
 740 static jit_word_t
 741 _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 742 {
 743     jit_word_t          d, w;
 744     FCMPO(CR_0, r0, r1);
 745     CREQV(CR_GT, CR_GT, CR_UN);
 746     w = _jit->pc.w;
 747     d = (i0 - w) & ~3;
 748     BGT(d);
 749     return (w);
 750 }
 751 fbopi(le)
 752 dbopi(le)
 753
 754 static jit_word_t
 755 _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 756 {
 757     jit_word_t          d, w;
 758     FCMPO(CR_0, r0, r1);
 759     w = _jit->pc.w;
 760     d = (i0 - w) & ~3;
 761     BEQ(d);
 762     return (w);
 763 }
 764 fbopi(eq)
 765 dbopi(eq)
 766
 767 static jit_word_t
 768 _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 769 {
 770     jit_word_t          d, w;
 771     FCMPO(CR_0, r0, r1);
 772     CREQV(CR_LT, CR_LT, CR_UN);
 773     w = _jit->pc.w;
 774     d = (i0 - w) & ~3;
 775     BLT(d);
 776     return (w);
 777 }
 778 fbopi(ge)
 779 dbopi(ge)
 780
 781 static jit_word_t
 782 _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 783 {
 784     jit_word_t          d, w;
 785     FCMPO(CR_0, r0, r1);
 786     w = _jit->pc.w;
 787     d = (i0 - w) & ~3;
 788     BGT(d);
 789     return (w);
 790 }
 791 fbopi(gt)
 792 dbopi(gt)
 793
 794 static jit_word_t
 795 _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 796 {
 797     jit_word_t          d, w;
 798     FCMPO(CR_0, r0, r1);
 799     w = _jit->pc.w;
 800     d = (i0 - w) & ~3;
 801     BNE(d);
 802     return (w);
 803 }
 804 fbopi(ne)
 805 dbopi(ne)
 806
 807 static jit_word_t
 808 _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 809 {
 810     jit_word_t          d, w;
 811     FCMPU(CR_0, r0, r1);
 812     CROR(CR_LT, CR_LT, CR_UN);
 813     w = _jit->pc.w;
 814     d = (i0 - w) & ~3;
 815     BLT(d);
 816     return (w);
 817 }
 818 fbopi(unlt)
 819 dbopi(unlt)
 820
 821 static jit_word_t
 822 _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 823 {
 824     jit_word_t          d, w;
 825     FCMPU(CR_0, r0, r1);
 826     w = _jit->pc.w;
 827     d = (i0 - w) & ~3;
 828     BLE(d);
 829     return (w);
 830 }
 831 fbopi(unle)
 832 dbopi(unle)
 833
 834 static jit_word_t
 835 _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 836 {
 837     jit_word_t          d, w;
 838     FCMPU(CR_0, r0, r1);
 839     CROR(CR_EQ, CR_EQ, CR_UN);
 840     w = _jit->pc.w;
 841     d = (i0 - w) & ~3;
 842     BEQ(d);
 843     return (w);
 844 }
 845 fbopi(uneq)
 846 dbopi(uneq)
 847
 848 static jit_word_t
 849 _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 850 {
 851     jit_word_t          d, w;
 852     FCMPU(CR_0, r0, r1);
 853     w = _jit->pc.w;
 854     d = (i0 - w) & ~3;
 855     BGE(d);
 856     return (w);
 857 }
 858 fbopi(unge)
 859 dbopi(unge)
 860
 861 static jit_word_t
 862 _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 863 {
 864     jit_word_t          d, w;
 865     FCMPU(CR_0, r0, r1);
 866     CROR(CR_GT, CR_GT, CR_UN);
 867     w = _jit->pc.w;
 868     d = (i0 - w) & ~3;
 869     BGT(d);
 870     return (w);
 871 }
 872 fbopi(ungt)
 873 dbopi(ungt)
 874
 875 static jit_word_t
 876 _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 877 {
 878     jit_word_t          d, w;
 879     FCMPU(CR_0, r0, r1);
 880     CROR(CR_EQ, CR_LT, CR_GT);
 881     w = _jit->pc.w;
 882     d = (i0 - w) & ~3;
 883     BEQ(d);
 884     return (w);
 885 }
 886 fbopi(ltgt)
 887 dbopi(ltgt)
 888
 889 static jit_word_t
 890 _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 891 {
 892     jit_word_t          d, w;
 893     FCMPU(CR_0, r0, r1);
 894     w = _jit->pc.w;
 895     d = (i0 - w) & ~3;
 896     BNU(d);
 897     return (w);
 898 }
 899 fbopi(ord)
 900 dbopi(ord)
 901
 902 static jit_word_t
 903 _bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
 904 {
 905     jit_word_t          d, w;
 906     FCMPU(CR_0, r0, r1);
 907     w = _jit->pc.w;
 908     d = (i0 - w) & ~3;
 909     BUN(d);
 910     return (w);
 911 }
 912 fbopi(unord)
 913 dbopi(unord)
 914
 915 static void
 916 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 917 {
 918     jit_bool_t          inv;
 919     jit_int32_t         reg;
 920     jit_word_t          lo, hi;
 921     if (can_sign_extend_short_p(i0))
 922         LFS(r0, _R0_REGNO, i0);
 923     else if (can_sign_extend_int_p(i0)) {
 924         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
 925         lo = (jit_int16_t)(i0 - (hi << 16));
 926         reg = jit_get_reg(jit_class_gpr);
 927         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
 928         LIS(rn(reg), hi);
 929         LFS(r0, rn(reg), lo);
 930         jit_unget_reg(reg);
 931         if (inv)                        jit_unget_reg(_R0);
 932     }
 933     else {
 934         reg = jit_get_reg(jit_class_gpr);
 935         movi(rn(reg), i0);
 936         ldr_f(r0, rn(reg));
 937         jit_unget_reg(reg);
 938     }
 939 }
 940
 941 static void
 942 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 943 {
 944     jit_bool_t          inv;
 945     jit_int32_t         reg;
 946     jit_word_t          lo, hi;
 947     if (can_sign_extend_short_p(i0))
 948         LFD(r0, _R0_REGNO, i0);
 949     else if (can_sign_extend_int_p(i0)) {
 950         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
 951         lo = (jit_int16_t)(i0 - (hi << 16));
 952         reg = jit_get_reg(jit_class_gpr);
 953         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
 954         LIS(rn(reg), hi);
 955         LFD(r0, rn(reg), lo);
 956         jit_unget_reg(reg);
 957         if (inv)                        jit_unget_reg(_R0);
 958     }
 959     else {
 960         reg = jit_get_reg(jit_class_gpr);
 961         movi(rn(reg), i0);
 962         ldr_d(r0, rn(reg));
 963         jit_unget_reg(reg);
 964     }
 965 }
 966
 967 static void
 968 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 969 {
 970     jit_int32_t         reg;
 971     if (r1 == _R0_REGNO) {
 972         if (r2 != _R0_REGNO)
 973             LFSX(r0, r2, r1);
 974         else {
 975             reg = jit_get_reg(jit_class_gpr);
 976             movr(rn(reg), r1);
 977             LFSX(r0, rn(reg), r2);
 978             jit_unget_reg(reg);
 979         }
 980     }
 981     else
 982         LFSX(r0, r1, r2);
 983 }
 984
 985 static void
 986 _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 987 {
 988     jit_int32_t         reg;
 989     if (r1 == _R0_REGNO) {
 990         if (r2 != _R0_REGNO)
 991             LFDX(r0, r2, r1);
 992         else {
 993             reg = jit_get_reg(jit_class_gpr);
 994             movr(rn(reg), r1);
 995             LFDX(r0, rn(reg), r2);
 996             jit_unget_reg(reg);
 997         }
 998     }
 999     else
1000         LFDX(r0, r1, r2);
1001 }
1002
1003 static void
1004 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1005 {
1006     jit_int32_t         reg;
1007     if (i0 == 0)
1008         ldr_f(r0, r1);
1009     else if (can_sign_extend_short_p(i0)) {
1010         if (r1 == _R0_REGNO) {
1011             reg = jit_get_reg(jit_class_gpr);
1012             movr(rn(reg), r1);
1013             LFS(r0, rn(reg), i0);
1014             jit_unget_reg(reg);
1015         }
1016         else
1017             LFS(r0, r1, i0);
1018     }
1019     else {
1020         reg = jit_get_reg(jit_class_gpr);
1021         movi(rn(reg), i0);
1022         ldxr_f(r0, r1, rn(reg));
1023         jit_unget_reg(reg);
1024     }
1025 }
1026
1027 static void
1028 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1029 {
1030     jit_int32_t         reg;
1031     if (i0 == 0)
1032         ldr_d(r0, r1);
1033     else if (can_sign_extend_short_p(i0)) {
1034         if (r1 == _R0_REGNO) {
1035             reg = jit_get_reg(jit_class_gpr);
1036             movr(rn(reg), r1);
1037             LFD(r0, rn(reg), i0);
1038             jit_unget_reg(reg);
1039         }
1040         else
1041             LFD(r0, r1, i0);
1042     }
1043     else {
1044         reg = jit_get_reg(jit_class_gpr);
1045         movi(rn(reg), i0);
1046         ldxr_d(r0, r1, rn(reg));
1047         jit_unget_reg(reg);
1048     }
1049 }
1050
1051 static void
1052 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1053 {
1054     jit_bool_t          inv;
1055     jit_int32_t         reg;
1056     jit_word_t          lo, hi;
1057     if (can_sign_extend_short_p(i0))
1058         STFS(r0, _R0_REGNO, i0);
1059     else if (can_sign_extend_int_p(i0)) {
1060         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
1061         lo = (jit_int16_t)(i0 - (hi << 16));
1062         reg = jit_get_reg(jit_class_gpr);
1063         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
1064         LIS(rn(reg), hi);
1065         STFS(r0, rn(reg), lo);
1066         jit_unget_reg(reg);
1067         if (inv)                        jit_unget_reg(_R0);
1068     }
1069     else {
1070         reg = jit_get_reg(jit_class_gpr);
1071         movi(rn(reg), i0);
1072         str_f(rn(reg), r0);
1073         jit_unget_reg(reg);
1074     }
1075 }
1076
1077 static void
1078 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1079 {
1080     jit_bool_t          inv;
1081     jit_int32_t         reg;
1082     jit_word_t          lo, hi;
1083     if (can_sign_extend_short_p(i0))
1084         STFD(r0, _R0_REGNO, i0);
1085     else if (can_sign_extend_int_p(i0)) {
1086         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
1087         lo = (jit_int16_t)(i0 - (hi << 16));
1088         reg = jit_get_reg(jit_class_gpr);
1089         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
1090         LIS(rn(reg), hi);
1091         STFD(r0, rn(reg), lo);
1092         jit_unget_reg(reg);
1093         if (inv)                        jit_unget_reg(_R0);
1094     }
1095     else {
1096         reg = jit_get_reg(jit_class_gpr);
1097         movi(rn(reg), i0);
1098         str_d(rn(reg), r0);
1099         jit_unget_reg(reg);
1100     }
1101 }
1102
1103 static void
1104 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1105 {
1106     jit_int32_t         reg;
1107     if (r0 == _R0_REGNO) {
1108         if (r1 != _R0_REGNO)
1109             STFSX(r2, r1, r0);
1110         else {
1111             reg = jit_get_reg(jit_class_gpr);
1112             movr(rn(reg), r1);
1113             STFSX(r2, rn(reg), r0);
1114             jit_unget_reg(reg);
1115         }
1116     }
1117     else
1118         STFSX(r2, r0, r1);
1119 }
1120
1121 static void
1122 _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1123 {
1124     jit_int32_t         reg;
1125     if (r0 == _R0_REGNO) {
1126         if (r1 != _R0_REGNO)
1127             STFDX(r2, r1, r0);
1128         else {
1129             reg = jit_get_reg(jit_class_gpr);
1130             movr(rn(reg), r0);
1131             STFDX(r2, rn(reg), r1);
1132             jit_unget_reg(reg);
1133         }
1134     }
1135     else
1136         STFDX(r2, r0, r1);
1137 }
1138
1139 static void
1140 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1141 {
1142     jit_int32_t         reg;
1143     if (i0 == 0)
1144         str_f(r0, r1);
1145     else if (can_sign_extend_short_p(i0)) {
1146         if (r0 == _R0_REGNO) {
1147             reg = jit_get_reg(jit_class_gpr);
1148             movr(rn(reg), i0);
1149             STFS(r1, rn(reg), i0);
1150             jit_unget_reg(reg);
1151         }
1152         else
1153             STFS(r1, r0, i0);
1154     }
1155     else {
1156         reg = jit_get_reg(jit_class_gpr);
1157         movi(rn(reg), i0);
1158         stxr_f(rn(reg), r0, r1);
1159         jit_unget_reg(reg);
1160     }
1161 }
1162
1163 static void
1164 _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1165 {
1166     jit_int32_t         reg;
1167     if (i0 == 0)
1168         str_d(r0, r1);
1169     else if (can_sign_extend_short_p(i0)) {
1170         if (r0 == _R0_REGNO) {
1171             reg = jit_get_reg(jit_class_gpr);
1172             movr(rn(reg), i0);
1173             STFD(r1, rn(reg), i0);
1174             jit_unget_reg(reg);
1175         }
1176         else
1177             STFD(r1, r0, i0);
1178     }
1179     else {
1180         reg = jit_get_reg(jit_class_gpr);
1181         movi(rn(reg), i0);
1182         stxr_d(rn(reg), r0, r1);
1183         jit_unget_reg(reg);
1184     }
1185 }
1186 #endif