target-i386/ops_sse_header.h

   1 /*
   2  *  MMX/3DNow!/SSE/SSE2/SSE3/PNI support
   3  *
   4  *  Copyright (c) 2005 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #if SHIFT == 0
  21 #define Reg MMXReg
  22 #define SUFFIX _mmx
  23 #else
  24 #define Reg XMMReg
  25 #define SUFFIX _xmm
  26 #endif
  27
  28 void glue(helper_psrlw, SUFFIX)(Reg *d, Reg *s);
  29 void glue(helper_psraw, SUFFIX)(Reg *d, Reg *s);
  30 void glue(helper_psllw, SUFFIX)(Reg *d, Reg *s);
  31 void glue(helper_psrld, SUFFIX)(Reg *d, Reg *s);
  32 void glue(helper_psrad, SUFFIX)(Reg *d, Reg *s);
  33 void glue(helper_pslld, SUFFIX)(Reg *d, Reg *s);
  34 void glue(helper_psrlq, SUFFIX)(Reg *d, Reg *s);
  35 void glue(helper_psllq, SUFFIX)(Reg *d, Reg *s);
  36
  37 #if SHIFT == 1
  38 void glue(helper_psrldq, SUFFIX)(Reg *d, Reg *s);
  39 void glue(helper_pslldq, SUFFIX)(Reg *d, Reg *s);
  40 #endif
  41
  42 #define SSE_HELPER_B(name, F)\
  43     void glue(name, SUFFIX) (Reg *d, Reg *s);
  44
  45 #define SSE_HELPER_W(name, F)\
  46     void glue(name, SUFFIX) (Reg *d, Reg *s);
  47
  48 #define SSE_HELPER_L(name, F)\
  49     void glue(name, SUFFIX) (Reg *d, Reg *s);
  50
  51 #define SSE_HELPER_Q(name, F)\
  52     void glue(name, SUFFIX) (Reg *d, Reg *s);
  53
  54 SSE_HELPER_B(helper_paddb, FADD);
  55 SSE_HELPER_W(helper_paddw, FADD);
  56 SSE_HELPER_L(helper_paddl, FADD);
  57 SSE_HELPER_Q(helper_paddq, FADD);
  58
  59 SSE_HELPER_B(helper_psubb, FSUB);
  60 SSE_HELPER_W(helper_psubw, FSUB);
  61 SSE_HELPER_L(helper_psubl, FSUB);
  62 SSE_HELPER_Q(helper_psubq, FSUB);
  63
  64 SSE_HELPER_B(helper_paddusb, FADDUB);
  65 SSE_HELPER_B(helper_paddsb, FADDSB);
  66 SSE_HELPER_B(helper_psubusb, FSUBUB);
  67 SSE_HELPER_B(helper_psubsb, FSUBSB);
  68
  69 SSE_HELPER_W(helper_paddusw, FADDUW);
  70 SSE_HELPER_W(helper_paddsw, FADDSW);
  71 SSE_HELPER_W(helper_psubusw, FSUBUW);
  72 SSE_HELPER_W(helper_psubsw, FSUBSW);
  73
  74 SSE_HELPER_B(helper_pminub, FMINUB);
  75 SSE_HELPER_B(helper_pmaxub, FMAXUB);
  76
  77 SSE_HELPER_W(helper_pminsw, FMINSW);
  78 SSE_HELPER_W(helper_pmaxsw, FMAXSW);
  79
  80 SSE_HELPER_Q(helper_pand, FAND);
  81 SSE_HELPER_Q(helper_pandn, FANDN);
  82 SSE_HELPER_Q(helper_por, FOR);
  83 SSE_HELPER_Q(helper_pxor, FXOR);
  84
  85 SSE_HELPER_B(helper_pcmpgtb, FCMPGTB);
  86 SSE_HELPER_W(helper_pcmpgtw, FCMPGTW);
  87 SSE_HELPER_L(helper_pcmpgtl, FCMPGTL);
  88
  89 SSE_HELPER_B(helper_pcmpeqb, FCMPEQ);
  90 SSE_HELPER_W(helper_pcmpeqw, FCMPEQ);
  91 SSE_HELPER_L(helper_pcmpeql, FCMPEQ);
  92
  93 SSE_HELPER_W(helper_pmullw, FMULLW);
  94 #if SHIFT == 0
  95 SSE_HELPER_W(helper_pmulhrw, FMULHRW);
  96 #endif
  97 SSE_HELPER_W(helper_pmulhuw, FMULHUW);
  98 SSE_HELPER_W(helper_pmulhw, FMULHW);
  99
 100 SSE_HELPER_B(helper_pavgb, FAVG);
 101 SSE_HELPER_W(helper_pavgw, FAVG);
 102
 103 void glue(helper_pmuludq, SUFFIX) (Reg *d, Reg *s);
 104 void glue(helper_pmaddwd, SUFFIX) (Reg *d, Reg *s);
 105
 106 void glue(helper_psadbw, SUFFIX) (Reg *d, Reg *s);
 107 void glue(helper_maskmov, SUFFIX) (Reg *d, Reg *s);
 108 void glue(helper_movl_mm_T0, SUFFIX) (Reg *d, uint32_t val);
 109 #ifdef TARGET_X86_64
 110 void glue(helper_movq_mm_T0, SUFFIX) (Reg *d, uint64_t val);
 111 #endif
 112
 113 #if SHIFT == 0
 114 void glue(helper_pshufw, SUFFIX) (Reg *d, Reg *s, int order);
 115 #else
 116 void helper_shufps(Reg *d, Reg *s, int order);
 117 void helper_shufpd(Reg *d, Reg *s, int order);
 118 void glue(helper_pshufd, SUFFIX) (Reg *d, Reg *s, int order);
 119 void glue(helper_pshuflw, SUFFIX) (Reg *d, Reg *s, int order);
 120 void glue(helper_pshufhw, SUFFIX) (Reg *d, Reg *s, int order);
 121 #endif
 122
 123 #if SHIFT == 1
 124 /* FPU ops */
 125 /* XXX: not accurate */
 126
 127 #define SSE_HELPER_S(name, F)\
 128     void helper_ ## name ## ps (Reg *d, Reg *s);        \
 129     void helper_ ## name ## ss (Reg *d, Reg *s);        \
 130     void helper_ ## name ## pd (Reg *d, Reg *s);        \
 131     void helper_ ## name ## sd (Reg *d, Reg *s);
 132
 133 SSE_HELPER_S(add, FPU_ADD);
 134 SSE_HELPER_S(sub, FPU_SUB);
 135 SSE_HELPER_S(mul, FPU_MUL);
 136 SSE_HELPER_S(div, FPU_DIV);
 137 SSE_HELPER_S(min, FPU_MIN);
 138 SSE_HELPER_S(max, FPU_MAX);
 139 SSE_HELPER_S(sqrt, FPU_SQRT);
 140
 141
 142 void helper_cvtps2pd(Reg *d, Reg *s);
 143 void helper_cvtpd2ps(Reg *d, Reg *s);
 144 void helper_cvtss2sd(Reg *d, Reg *s);
 145 void helper_cvtsd2ss(Reg *d, Reg *s);
 146 void helper_cvtdq2ps(Reg *d, Reg *s);
 147 void helper_cvtdq2pd(Reg *d, Reg *s);
 148 void helper_cvtpi2ps(XMMReg *d, MMXReg *s);
 149 void helper_cvtpi2pd(XMMReg *d, MMXReg *s);
 150 void helper_cvtsi2ss(XMMReg *d, uint32_t val);
 151 void helper_cvtsi2sd(XMMReg *d, uint32_t val);
 152
 153 #ifdef TARGET_X86_64
 154 void helper_cvtsq2ss(XMMReg *d, uint64_t val);
 155 void helper_cvtsq2sd(XMMReg *d, uint64_t val);
 156 #endif
 157
 158 void helper_cvtps2dq(XMMReg *d, XMMReg *s);
 159 void helper_cvtpd2dq(XMMReg *d, XMMReg *s);
 160 void helper_cvtps2pi(MMXReg *d, XMMReg *s);
 161 void helper_cvtpd2pi(MMXReg *d, XMMReg *s);
 162 int32_t helper_cvtss2si(XMMReg *s);
 163 int32_t helper_cvtsd2si(XMMReg *s);
 164 #ifdef TARGET_X86_64
 165 int64_t helper_cvtss2sq(XMMReg *s);
 166 int64_t helper_cvtsd2sq(XMMReg *s);
 167 #endif
 168
 169 void helper_cvttps2dq(XMMReg *d, XMMReg *s);
 170 void helper_cvttpd2dq(XMMReg *d, XMMReg *s);
 171 void helper_cvttps2pi(MMXReg *d, XMMReg *s);
 172 void helper_cvttpd2pi(MMXReg *d, XMMReg *s);
 173 int32_t helper_cvttss2si(XMMReg *s);
 174 int32_t helper_cvttsd2si(XMMReg *s);
 175 #ifdef TARGET_X86_64
 176 int64_t helper_cvttss2sq(XMMReg *s);
 177 int64_t helper_cvttsd2sq(XMMReg *s);
 178 #endif
 179
 180 void helper_rsqrtps(XMMReg *d, XMMReg *s);
 181 void helper_rsqrtss(XMMReg *d, XMMReg *s);
 182 void helper_rcpps(XMMReg *d, XMMReg *s);
 183 void helper_rcpss(XMMReg *d, XMMReg *s);
 184 void helper_haddps(XMMReg *d, XMMReg *s);
 185 void helper_haddpd(XMMReg *d, XMMReg *s);
 186 void helper_hsubps(XMMReg *d, XMMReg *s);
 187 void helper_hsubpd(XMMReg *d, XMMReg *s);
 188 void helper_addsubps(XMMReg *d, XMMReg *s);
 189 void helper_addsubpd(XMMReg *d, XMMReg *s);
 190
 191 #define SSE_HELPER_CMP(name, F)\
 192     void helper_ ## name ## ps (Reg *d, Reg *s);        \
 193     void helper_ ## name ## ss (Reg *d, Reg *s);        \
 194     void helper_ ## name ## pd (Reg *d, Reg *s);        \
 195     void helper_ ## name ## sd (Reg *d, Reg *s);
 196
 197 SSE_HELPER_CMP(cmpeq, FPU_CMPEQ);
 198 SSE_HELPER_CMP(cmplt, FPU_CMPLT);
 199 SSE_HELPER_CMP(cmple, FPU_CMPLE);
 200 SSE_HELPER_CMP(cmpunord, FPU_CMPUNORD);
 201 SSE_HELPER_CMP(cmpneq, FPU_CMPNEQ);
 202 SSE_HELPER_CMP(cmpnlt, FPU_CMPNLT);
 203 SSE_HELPER_CMP(cmpnle, FPU_CMPNLE);
 204 SSE_HELPER_CMP(cmpord, FPU_CMPORD);
 205
 206 void helper_ucomiss(Reg *d, Reg *s);
 207 void helper_comiss(Reg *d, Reg *s);
 208 void helper_ucomisd(Reg *d, Reg *s);
 209 void helper_comisd(Reg *d, Reg *s);
 210 uint32_t helper_movmskps(Reg *s);
 211 uint32_t helper_movmskpd(Reg *s);
 212 #endif
 213
 214 uint32_t glue(helper_pmovmskb, SUFFIX)(Reg *s);
 215 void glue(helper_packsswb, SUFFIX) (Reg *d, Reg *s);
 216 void glue(helper_packuswb, SUFFIX) (Reg *d, Reg *s);
 217 void glue(helper_packssdw, SUFFIX) (Reg *d, Reg *s);
 218 #define UNPCK_OP(base_name, base)                               \
 219     void glue(helper_punpck ## base_name ## bw, SUFFIX) (Reg *d, Reg *s); \
 220     void glue(helper_punpck ## base_name ## wd, SUFFIX) (Reg *d, Reg *s); \
 221     void glue(helper_punpck ## base_name ## dq, SUFFIX) (Reg *d, Reg *s);
 222
 223 UNPCK_OP(l, 0);
 224 UNPCK_OP(h, 1);
 225
 226 #if SHIFT == 1
 227 void glue(helper_punpcklqdq, SUFFIX) (Reg *d, Reg *s);
 228 void glue(helper_punpckhqdq, SUFFIX) (Reg *d, Reg *s);
 229 #endif
 230
 231 /* 3DNow! float ops */
 232 #if SHIFT == 0
 233 void helper_pi2fd(MMXReg *d, MMXReg *s);
 234 void helper_pi2fw(MMXReg *d, MMXReg *s);
 235 void helper_pf2id(MMXReg *d, MMXReg *s);
 236 void helper_pf2iw(MMXReg *d, MMXReg *s);
 237 void helper_pfacc(MMXReg *d, MMXReg *s);
 238 void helper_pfadd(MMXReg *d, MMXReg *s);
 239 void helper_pfcmpeq(MMXReg *d, MMXReg *s);
 240 void helper_pfcmpge(MMXReg *d, MMXReg *s);
 241 void helper_pfcmpgt(MMXReg *d, MMXReg *s);
 242 void helper_pfmax(MMXReg *d, MMXReg *s);
 243 void helper_pfmin(MMXReg *d, MMXReg *s);
 244 void helper_pfmul(MMXReg *d, MMXReg *s);
 245 void helper_pfnacc(MMXReg *d, MMXReg *s);
 246 void helper_pfpnacc(MMXReg *d, MMXReg *s);
 247 void helper_pfrcp(MMXReg *d, MMXReg *s);
 248 void helper_pfrsqrt(MMXReg *d, MMXReg *s);
 249 void helper_pfsub(MMXReg *d, MMXReg *s);
 250 void helper_pfsubr(MMXReg *d, MMXReg *s);
 251 void helper_pswapd(MMXReg *d, MMXReg *s);
 252 #endif
 253
 254 #undef SHIFT
 255 #undef Reg
 256 #undef SUFFIX
 257
 258 #undef SSE_HELPER_B
 259 #undef SSE_HELPER_W
 260 #undef SSE_HELPER_L
 261 #undef SSE_HELPER_Q
 262 #undef SSE_HELPER_S
 263 #undef SSE_HELPER_CMP
 264 #undef UNPCK_OP