deps/lightning/lib/jit_ppc-fpu.c

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