contrib/llvm/tools/clang/lib/Headers/xmmintrin.h

   1 /*===---- xmmintrin.h - SSE intrinsics -------------------------------------===
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  *
  21  *===-----------------------------------------------------------------------===
  22  */
  23
  24 #ifndef __XMMINTRIN_H
  25 #define __XMMINTRIN_H
  26
  27 #ifndef __SSE__
  28 #error "SSE instruction set not enabled"
  29 #else
  30
  31 #include <mmintrin.h>
  32
  33 typedef int __v4si __attribute__((__vector_size__(16)));
  34 typedef float __v4sf __attribute__((__vector_size__(16)));
  35 typedef float __m128 __attribute__((__vector_size__(16)));
  36
  37 // This header should only be included in a hosted environment as it depends on
  38 // a standard library to provide allocation routines.
  39 #if __STDC_HOSTED__
  40 #include <mm_malloc.h>
  41 #endif
  42
  43 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  44 _mm_add_ss(__m128 a, __m128 b)
  45 {
  46   a[0] += b[0];
  47   return a;
  48 }
  49
  50 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  51 _mm_add_ps(__m128 a, __m128 b)
  52 {
  53   return a + b;
  54 }
  55
  56 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  57 _mm_sub_ss(__m128 a, __m128 b)
  58 {
  59   a[0] -= b[0];
  60   return a;
  61 }
  62
  63 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  64 _mm_sub_ps(__m128 a, __m128 b)
  65 {
  66   return a - b;
  67 }
  68
  69 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  70 _mm_mul_ss(__m128 a, __m128 b)
  71 {
  72   a[0] *= b[0];
  73   return a;
  74 }
  75
  76 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  77 _mm_mul_ps(__m128 a, __m128 b)
  78 {
  79   return a * b;
  80 }
  81
  82 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  83 _mm_div_ss(__m128 a, __m128 b)
  84 {
  85   a[0] /= b[0];
  86   return a;
  87 }
  88
  89 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  90 _mm_div_ps(__m128 a, __m128 b)
  91 {
  92   return a / b;
  93 }
  94
  95 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
  96 _mm_sqrt_ss(__m128 a)
  97 {
  98   return __builtin_ia32_sqrtss(a);
  99 }
 100
 101 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 102 _mm_sqrt_ps(__m128 a)
 103 {
 104   return __builtin_ia32_sqrtps(a);
 105 }
 106
 107 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 108 _mm_rcp_ss(__m128 a)
 109 {
 110   return __builtin_ia32_rcpss(a);
 111 }
 112
 113 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 114 _mm_rcp_ps(__m128 a)
 115 {
 116   return __builtin_ia32_rcpps(a);
 117 }
 118
 119 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 120 _mm_rsqrt_ss(__m128 a)
 121 {
 122   return __builtin_ia32_rsqrtss(a);
 123 }
 124
 125 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 126 _mm_rsqrt_ps(__m128 a)
 127 {
 128   return __builtin_ia32_rsqrtps(a);
 129 }
 130
 131 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 132 _mm_min_ss(__m128 a, __m128 b)
 133 {
 134   return __builtin_ia32_minss(a, b);
 135 }
 136
 137 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 138 _mm_min_ps(__m128 a, __m128 b)
 139 {
 140   return __builtin_ia32_minps(a, b);
 141 }
 142
 143 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 144 _mm_max_ss(__m128 a, __m128 b)
 145 {
 146   return __builtin_ia32_maxss(a, b);
 147 }
 148
 149 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 150 _mm_max_ps(__m128 a, __m128 b)
 151 {
 152   return __builtin_ia32_maxps(a, b);
 153 }
 154
 155 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 156 _mm_and_ps(__m128 a, __m128 b)
 157 {
 158   return (__m128)((__v4si)a & (__v4si)b);
 159 }
 160
 161 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 162 _mm_andnot_ps(__m128 a, __m128 b)
 163 {
 164   return (__m128)(~(__v4si)a & (__v4si)b);
 165 }
 166
 167 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 168 _mm_or_ps(__m128 a, __m128 b)
 169 {
 170   return (__m128)((__v4si)a | (__v4si)b);
 171 }
 172
 173 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 174 _mm_xor_ps(__m128 a, __m128 b)
 175 {
 176   return (__m128)((__v4si)a ^ (__v4si)b);
 177 }
 178
 179 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 180 _mm_cmpeq_ss(__m128 a, __m128 b)
 181 {
 182   return (__m128)__builtin_ia32_cmpss(a, b, 0);
 183 }
 184
 185 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 186 _mm_cmpeq_ps(__m128 a, __m128 b)
 187 {
 188   return (__m128)__builtin_ia32_cmpps(a, b, 0);
 189 }
 190
 191 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 192 _mm_cmplt_ss(__m128 a, __m128 b)
 193 {
 194   return (__m128)__builtin_ia32_cmpss(a, b, 1);
 195 }
 196
 197 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 198 _mm_cmplt_ps(__m128 a, __m128 b)
 199 {
 200   return (__m128)__builtin_ia32_cmpps(a, b, 1);
 201 }
 202
 203 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 204 _mm_cmple_ss(__m128 a, __m128 b)
 205 {
 206   return (__m128)__builtin_ia32_cmpss(a, b, 2);
 207 }
 208
 209 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 210 _mm_cmple_ps(__m128 a, __m128 b)
 211 {
 212   return (__m128)__builtin_ia32_cmpps(a, b, 2);
 213 }
 214
 215 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 216 _mm_cmpgt_ss(__m128 a, __m128 b)
 217 {
 218   return (__m128)__builtin_ia32_cmpss(b, a, 1);
 219 }
 220
 221 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 222 _mm_cmpgt_ps(__m128 a, __m128 b)
 223 {
 224   return (__m128)__builtin_ia32_cmpps(b, a, 1);
 225 }
 226
 227 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 228 _mm_cmpge_ss(__m128 a, __m128 b)
 229 {
 230   return (__m128)__builtin_ia32_cmpss(b, a, 2);
 231 }
 232
 233 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 234 _mm_cmpge_ps(__m128 a, __m128 b)
 235 {
 236   return (__m128)__builtin_ia32_cmpps(b, a, 2);
 237 }
 238
 239 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 240 _mm_cmpneq_ss(__m128 a, __m128 b)
 241 {
 242   return (__m128)__builtin_ia32_cmpss(a, b, 4);
 243 }
 244
 245 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 246 _mm_cmpneq_ps(__m128 a, __m128 b)
 247 {
 248   return (__m128)__builtin_ia32_cmpps(a, b, 4);
 249 }
 250
 251 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 252 _mm_cmpnlt_ss(__m128 a, __m128 b)
 253 {
 254   return (__m128)__builtin_ia32_cmpss(a, b, 5);
 255 }
 256
 257 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 258 _mm_cmpnlt_ps(__m128 a, __m128 b)
 259 {
 260   return (__m128)__builtin_ia32_cmpps(a, b, 5);
 261 }
 262
 263 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 264 _mm_cmpnle_ss(__m128 a, __m128 b)
 265 {
 266   return (__m128)__builtin_ia32_cmpss(a, b, 6);
 267 }
 268
 269 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 270 _mm_cmpnle_ps(__m128 a, __m128 b)
 271 {
 272   return (__m128)__builtin_ia32_cmpps(a, b, 6);
 273 }
 274
 275 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 276 _mm_cmpngt_ss(__m128 a, __m128 b)
 277 {
 278   return (__m128)__builtin_ia32_cmpss(b, a, 5);
 279 }
 280
 281 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 282 _mm_cmpngt_ps(__m128 a, __m128 b)
 283 {
 284   return (__m128)__builtin_ia32_cmpps(b, a, 5);
 285 }
 286
 287 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 288 _mm_cmpnge_ss(__m128 a, __m128 b)
 289 {
 290   return (__m128)__builtin_ia32_cmpss(b, a, 6);
 291 }
 292
 293 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 294 _mm_cmpnge_ps(__m128 a, __m128 b)
 295 {
 296   return (__m128)__builtin_ia32_cmpps(b, a, 6);
 297 }
 298
 299 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 300 _mm_cmpord_ss(__m128 a, __m128 b)
 301 {
 302   return (__m128)__builtin_ia32_cmpss(a, b, 7);
 303 }
 304
 305 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 306 _mm_cmpord_ps(__m128 a, __m128 b)
 307 {
 308   return (__m128)__builtin_ia32_cmpps(a, b, 7);
 309 }
 310
 311 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 312 _mm_cmpunord_ss(__m128 a, __m128 b)
 313 {
 314   return (__m128)__builtin_ia32_cmpss(a, b, 3);
 315 }
 316
 317 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 318 _mm_cmpunord_ps(__m128 a, __m128 b)
 319 {
 320   return (__m128)__builtin_ia32_cmpps(a, b, 3);
 321 }
 322
 323 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 324 _mm_comieq_ss(__m128 a, __m128 b)
 325 {
 326   return __builtin_ia32_comieq(a, b);
 327 }
 328
 329 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 330 _mm_comilt_ss(__m128 a, __m128 b)
 331 {
 332   return __builtin_ia32_comilt(a, b);
 333 }
 334
 335 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 336 _mm_comile_ss(__m128 a, __m128 b)
 337 {
 338   return __builtin_ia32_comile(a, b);
 339 }
 340
 341 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 342 _mm_comigt_ss(__m128 a, __m128 b)
 343 {
 344   return __builtin_ia32_comigt(a, b);
 345 }
 346
 347 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 348 _mm_comige_ss(__m128 a, __m128 b)
 349 {
 350   return __builtin_ia32_comige(a, b);
 351 }
 352
 353 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 354 _mm_comineq_ss(__m128 a, __m128 b)
 355 {
 356   return __builtin_ia32_comineq(a, b);
 357 }
 358
 359 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 360 _mm_ucomieq_ss(__m128 a, __m128 b)
 361 {
 362   return __builtin_ia32_ucomieq(a, b);
 363 }
 364
 365 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 366 _mm_ucomilt_ss(__m128 a, __m128 b)
 367 {
 368   return __builtin_ia32_ucomilt(a, b);
 369 }
 370
 371 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 372 _mm_ucomile_ss(__m128 a, __m128 b)
 373 {
 374   return __builtin_ia32_ucomile(a, b);
 375 }
 376
 377 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 378 _mm_ucomigt_ss(__m128 a, __m128 b)
 379 {
 380   return __builtin_ia32_ucomigt(a, b);
 381 }
 382
 383 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 384 _mm_ucomige_ss(__m128 a, __m128 b)
 385 {
 386   return __builtin_ia32_ucomige(a, b);
 387 }
 388
 389 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 390 _mm_ucomineq_ss(__m128 a, __m128 b)
 391 {
 392   return __builtin_ia32_ucomineq(a, b);
 393 }
 394
 395 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 396 _mm_cvtss_si32(__m128 a)
 397 {
 398   return __builtin_ia32_cvtss2si(a);
 399 }
 400
 401 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 402 _mm_cvt_ss2si(__m128 a)
 403 {
 404   return _mm_cvtss_si32(a);
 405 }
 406
 407 #ifdef __x86_64__
 408
 409 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
 410 _mm_cvtss_si64(__m128 a)
 411 {
 412   return __builtin_ia32_cvtss2si64(a);
 413 }
 414
 415 #endif
 416
 417 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 418 _mm_cvtps_pi32(__m128 a)
 419 {
 420   return (__m64)__builtin_ia32_cvtps2pi(a);
 421 }
 422
 423 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 424 _mm_cvt_ps2pi(__m128 a)
 425 {
 426   return _mm_cvtps_pi32(a);
 427 }
 428
 429 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 430 _mm_cvttss_si32(__m128 a)
 431 {
 432   return a[0];
 433 }
 434
 435 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 436 _mm_cvtt_ss2si(__m128 a)
 437 {
 438   return _mm_cvttss_si32(a);
 439 }
 440
 441 static __inline__ long long __attribute__((__always_inline__, __nodebug__))
 442 _mm_cvttss_si64(__m128 a)
 443 {
 444   return a[0];
 445 }
 446
 447 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 448 _mm_cvttps_pi32(__m128 a)
 449 {
 450   return (__m64)__builtin_ia32_cvttps2pi(a);
 451 }
 452
 453 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 454 _mm_cvtt_ps2pi(__m128 a)
 455 {
 456   return _mm_cvttps_pi32(a);
 457 }
 458
 459 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 460 _mm_cvtsi32_ss(__m128 a, int b)
 461 {
 462   a[0] = b;
 463   return a;
 464 }
 465
 466 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 467 _mm_cvt_si2ss(__m128 a, int b)
 468 {
 469   return _mm_cvtsi32_ss(a, b);
 470 }
 471
 472 #ifdef __x86_64__
 473
 474 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 475 _mm_cvtsi64_ss(__m128 a, long long b)
 476 {
 477   a[0] = b;
 478   return a;
 479 }
 480
 481 #endif
 482
 483 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 484 _mm_cvtpi32_ps(__m128 a, __m64 b)
 485 {
 486   return __builtin_ia32_cvtpi2ps(a, (__v2si)b);
 487 }
 488
 489 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 490 _mm_cvt_pi2ps(__m128 a, __m64 b)
 491 {
 492   return _mm_cvtpi32_ps(a, b);
 493 }
 494
 495 static __inline__ float __attribute__((__always_inline__, __nodebug__))
 496 _mm_cvtss_f32(__m128 a)
 497 {
 498   return a[0];
 499 }
 500
 501 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 502 _mm_loadh_pi(__m128 a, const __m64 *p)
 503 {
 504   __m128 b;
 505   b[0] = *(float*)p;
 506   b[1] = *((float*)p+1);
 507   return __builtin_shufflevector(a, b, 0, 1, 4, 5);
 508 }
 509
 510 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 511 _mm_loadl_pi(__m128 a, const __m64 *p)
 512 {
 513   __m128 b;
 514   b[0] = *(float*)p;
 515   b[1] = *((float*)p+1);
 516   return __builtin_shufflevector(a, b, 4, 5, 2, 3);
 517 }
 518
 519 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 520 _mm_load_ss(const float *p)
 521 {
 522   return (__m128){ *p, 0, 0, 0 };
 523 }
 524
 525 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 526 _mm_load1_ps(const float *p)
 527 {
 528   return (__m128){ *p, *p, *p, *p };
 529 }
 530
 531 #define        _mm_load_ps1(p) _mm_load1_ps(p)
 532
 533 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 534 _mm_load_ps(const float *p)
 535 {
 536   return *(__m128*)p;
 537 }
 538
 539 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 540 _mm_loadu_ps(const float *p)
 541 {
 542   return __builtin_ia32_loadups(p);
 543 }
 544
 545 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 546 _mm_loadr_ps(const float *p)
 547 {
 548   __m128 a = _mm_load_ps(p);
 549   return __builtin_shufflevector(a, a, 3, 2, 1, 0);
 550 }
 551
 552 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 553 _mm_set_ss(float w)
 554 {
 555   return (__m128){ w, 0, 0, 0 };
 556 }
 557
 558 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 559 _mm_set1_ps(float w)
 560 {
 561   return (__m128){ w, w, w, w };
 562 }
 563
 564 // Microsoft specific.
 565 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 566 _mm_set_ps1(float w)
 567 {
 568     return _mm_set1_ps(w);
 569 }
 570
 571 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 572 _mm_set_ps(float z, float y, float x, float w)
 573 {
 574   return (__m128){ w, x, y, z };
 575 }
 576
 577 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 578 _mm_setr_ps(float z, float y, float x, float w)
 579 {
 580   return (__m128){ z, y, x, w };
 581 }
 582
 583 static __inline__ __m128 __attribute__((__always_inline__))
 584 _mm_setzero_ps(void)
 585 {
 586   return (__m128){ 0, 0, 0, 0 };
 587 }
 588
 589 static __inline__ void __attribute__((__always_inline__))
 590 _mm_storeh_pi(__m64 *p, __m128 a)
 591 {
 592   __builtin_ia32_storehps((__v2si *)p, a);
 593 }
 594
 595 static __inline__ void __attribute__((__always_inline__))
 596 _mm_storel_pi(__m64 *p, __m128 a)
 597 {
 598   __builtin_ia32_storelps((__v2si *)p, a);
 599 }
 600
 601 static __inline__ void __attribute__((__always_inline__))
 602 _mm_store_ss(float *p, __m128 a)
 603 {
 604   *p = a[0];
 605 }
 606
 607 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 608 _mm_storeu_ps(float *p, __m128 a)
 609 {
 610   __builtin_ia32_storeups(p, a);
 611 }
 612
 613 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 614 _mm_store1_ps(float *p, __m128 a)
 615 {
 616   a = __builtin_shufflevector(a, a, 0, 0, 0, 0);
 617   _mm_storeu_ps(p, a);
 618 }
 619
 620 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 621 _mm_store_ps1(float *p, __m128 a)
 622 {
 623     return _mm_store1_ps(p, a);
 624 }
 625
 626 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 627 _mm_store_ps(float *p, __m128 a)
 628 {
 629   *(__m128 *)p = a;
 630 }
 631
 632 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 633 _mm_storer_ps(float *p, __m128 a)
 634 {
 635   a = __builtin_shufflevector(a, a, 3, 2, 1, 0);
 636   _mm_store_ps(p, a);
 637 }
 638
 639 #define _MM_HINT_T0 3
 640 #define _MM_HINT_T1 2
 641 #define _MM_HINT_T2 1
 642 #define _MM_HINT_NTA 0
 643
 644 /* FIXME: We have to #define this because "sel" must be a constant integer, and
 645    Sema doesn't do any form of constant propagation yet. */
 646
 647 #define _mm_prefetch(a, sel) (__builtin_prefetch((void *)(a), 0, sel))
 648
 649 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 650 _mm_stream_pi(__m64 *p, __m64 a)
 651 {
 652   __builtin_ia32_movntq(p, a);
 653 }
 654
 655 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 656 _mm_stream_ps(float *p, __m128 a)
 657 {
 658   __builtin_ia32_movntps(p, a);
 659 }
 660
 661 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 662 _mm_sfence(void)
 663 {
 664   __builtin_ia32_sfence();
 665 }
 666
 667 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 668 _mm_extract_pi16(__m64 a, int n)
 669 {
 670   __v4hi b = (__v4hi)a;
 671   return (unsigned short)b[n & 3];
 672 }
 673
 674 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 675 _mm_insert_pi16(__m64 a, int d, int n)
 676 {
 677    __v4hi b = (__v4hi)a;
 678    b[n & 3] = d;
 679    return (__m64)b;
 680 }
 681
 682 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 683 _mm_max_pi16(__m64 a, __m64 b)
 684 {
 685   return (__m64)__builtin_ia32_pmaxsw((__v4hi)a, (__v4hi)b);
 686 }
 687
 688 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 689 _mm_max_pu8(__m64 a, __m64 b)
 690 {
 691   return (__m64)__builtin_ia32_pmaxub((__v8qi)a, (__v8qi)b);
 692 }
 693
 694 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 695 _mm_min_pi16(__m64 a, __m64 b)
 696 {
 697   return (__m64)__builtin_ia32_pminsw((__v4hi)a, (__v4hi)b);
 698 }
 699
 700 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 701 _mm_min_pu8(__m64 a, __m64 b)
 702 {
 703   return (__m64)__builtin_ia32_pminub((__v8qi)a, (__v8qi)b);
 704 }
 705
 706 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 707 _mm_movemask_pi8(__m64 a)
 708 {
 709   return __builtin_ia32_pmovmskb((__v8qi)a);
 710 }
 711
 712 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 713 _mm_mulhi_pu16(__m64 a, __m64 b)
 714 {
 715   return (__m64)__builtin_ia32_pmulhuw((__v4hi)a, (__v4hi)b);
 716 }
 717
 718 #define _mm_shuffle_pi16(a, n) \
 719   ((__m64)__builtin_ia32_pshufw(a, n))
 720
 721 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 722 _mm_maskmove_si64(__m64 d, __m64 n, char *p)
 723 {
 724   __builtin_ia32_maskmovq((__v8qi)d, (__v8qi)n, p);
 725 }
 726
 727 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 728 _mm_avg_pu8(__m64 a, __m64 b)
 729 {
 730   return (__m64)__builtin_ia32_pavgb((__v8qi)a, (__v8qi)b);
 731 }
 732
 733 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 734 _mm_avg_pu16(__m64 a, __m64 b)
 735 {
 736   return (__m64)__builtin_ia32_pavgw((__v4hi)a, (__v4hi)b);
 737 }
 738
 739 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 740 _mm_sad_pu8(__m64 a, __m64 b)
 741 {
 742   return (__m64)__builtin_ia32_psadbw((__v8qi)a, (__v8qi)b);
 743 }
 744
 745 static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
 746 _mm_getcsr(void)
 747 {
 748   return __builtin_ia32_stmxcsr();
 749 }
 750
 751 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 752 _mm_setcsr(unsigned int i)
 753 {
 754   __builtin_ia32_ldmxcsr(i);
 755 }
 756
 757 #define _mm_shuffle_ps(a, b, mask) \
 758         (__builtin_shufflevector((__v4sf)(a), (__v4sf)(b),                \
 759                                  (mask) & 0x3, ((mask) & 0xc) >> 2, \
 760                                  (((mask) & 0x30) >> 4) + 4, \
 761                                  (((mask) & 0xc0) >> 6) + 4))
 762
 763 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 764 _mm_unpackhi_ps(__m128 a, __m128 b)
 765 {
 766   return __builtin_shufflevector(a, b, 2, 6, 3, 7);
 767 }
 768
 769 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 770 _mm_unpacklo_ps(__m128 a, __m128 b)
 771 {
 772   return __builtin_shufflevector(a, b, 0, 4, 1, 5);
 773 }
 774
 775 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 776 _mm_move_ss(__m128 a, __m128 b)
 777 {
 778   return __builtin_shufflevector(a, b, 4, 1, 2, 3);
 779 }
 780
 781 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 782 _mm_movehl_ps(__m128 a, __m128 b)
 783 {
 784   return __builtin_shufflevector(a, b, 6, 7, 2, 3);
 785 }
 786
 787 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 788 _mm_movelh_ps(__m128 a, __m128 b)
 789 {
 790   return __builtin_shufflevector(a, b, 0, 1, 4, 5);
 791 }
 792
 793 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 794 _mm_cvtpi16_ps(__m64 a)
 795 {
 796   __m64 b, c;
 797   __m128 r;
 798
 799   b = _mm_setzero_si64();
 800   b = _mm_cmpgt_pi16(b, a);
 801   c = _mm_unpackhi_pi16(a, b);
 802   r = _mm_setzero_ps();
 803   r = _mm_cvtpi32_ps(r, c);
 804   r = _mm_movelh_ps(r, r);
 805   c = _mm_unpacklo_pi16(a, b);
 806   r = _mm_cvtpi32_ps(r, c);
 807
 808   return r;
 809 }
 810
 811 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 812 _mm_cvtpu16_ps(__m64 a)
 813 {
 814   __m64 b, c;
 815   __m128 r;
 816
 817   b = _mm_setzero_si64();
 818   c = _mm_unpackhi_pi16(a, b);
 819   r = _mm_setzero_ps();
 820   r = _mm_cvtpi32_ps(r, c);
 821   r = _mm_movelh_ps(r, r);
 822   c = _mm_unpacklo_pi16(a, b);
 823   r = _mm_cvtpi32_ps(r, c);
 824
 825   return r;
 826 }
 827
 828 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 829 _mm_cvtpi8_ps(__m64 a)
 830 {
 831   __m64 b;
 832
 833   b = _mm_setzero_si64();
 834   b = _mm_cmpgt_pi8(b, a);
 835   b = _mm_unpacklo_pi8(a, b);
 836
 837   return _mm_cvtpi16_ps(b);
 838 }
 839
 840 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 841 _mm_cvtpu8_ps(__m64 a)
 842 {
 843   __m64 b;
 844
 845   b = _mm_setzero_si64();
 846   b = _mm_unpacklo_pi8(a, b);
 847
 848   return _mm_cvtpi16_ps(b);
 849 }
 850
 851 static __inline__ __m128 __attribute__((__always_inline__, __nodebug__))
 852 _mm_cvtpi32x2_ps(__m64 a, __m64 b)
 853 {
 854   __m128 c;
 855
 856   c = _mm_setzero_ps();
 857   c = _mm_cvtpi32_ps(c, b);
 858   c = _mm_movelh_ps(c, c);
 859
 860   return _mm_cvtpi32_ps(c, a);
 861 }
 862
 863 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 864 _mm_cvtps_pi16(__m128 a)
 865 {
 866   __m64 b, c;
 867
 868   b = _mm_cvtps_pi32(a);
 869   a = _mm_movehl_ps(a, a);
 870   c = _mm_cvtps_pi32(a);
 871
 872   return _mm_packs_pi16(b, c);
 873 }
 874
 875 static __inline__ __m64 __attribute__((__always_inline__, __nodebug__))
 876 _mm_cvtps_pi8(__m128 a)
 877 {
 878   __m64 b, c;
 879
 880   b = _mm_cvtps_pi16(a);
 881   c = _mm_setzero_si64();
 882
 883   return _mm_packs_pi16(b, c);
 884 }
 885
 886 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 887 _mm_movemask_ps(__m128 a)
 888 {
 889   return __builtin_ia32_movmskps(a);
 890 }
 891
 892 #define _MM_SHUFFLE(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))
 893
 894 #define _MM_EXCEPT_INVALID    (0x0001)
 895 #define _MM_EXCEPT_DENORM     (0x0002)
 896 #define _MM_EXCEPT_DIV_ZERO   (0x0004)
 897 #define _MM_EXCEPT_OVERFLOW   (0x0008)
 898 #define _MM_EXCEPT_UNDERFLOW  (0x0010)
 899 #define _MM_EXCEPT_INEXACT    (0x0020)
 900 #define _MM_EXCEPT_MASK       (0x003f)
 901
 902 #define _MM_MASK_INVALID      (0x0080)
 903 #define _MM_MASK_DENORM       (0x0100)
 904 #define _MM_MASK_DIV_ZERO     (0x0200)
 905 #define _MM_MASK_OVERFLOW     (0x0400)
 906 #define _MM_MASK_UNDERFLOW    (0x0800)
 907 #define _MM_MASK_INEXACT      (0x1000)
 908 #define _MM_MASK_MASK         (0x1f80)
 909
 910 #define _MM_ROUND_NEAREST     (0x0000)
 911 #define _MM_ROUND_DOWN        (0x2000)
 912 #define _MM_ROUND_UP          (0x4000)
 913 #define _MM_ROUND_TOWARD_ZERO (0x6000)
 914 #define _MM_ROUND_MASK        (0x6000)
 915
 916 #define _MM_FLUSH_ZERO_MASK   (0x8000)
 917 #define _MM_FLUSH_ZERO_ON     (0x8000)
 918 #define _MM_FLUSH_ZERO_OFF    (0x8000)
 919
 920 #define _MM_GET_EXCEPTION_MASK() (_mm_getcsr() & _MM_MASK_MASK)
 921 #define _MM_GET_EXCEPTION_STATE() (_mm_getcsr() & _MM_EXCEPT_MASK)
 922 #define _MM_GET_FLUSH_ZERO_MODE() (_mm_getcsr() & _MM_FLUSH_ZERO_MASK)
 923 #define _MM_GET_ROUNDING_MODE() (_mm_getcsr() & _MM_ROUND_MASK)
 924
 925 #define _MM_SET_EXCEPTION_MASK(x) (_mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | (x)))
 926 #define _MM_SET_EXCEPTION_STATE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | (x)))
 927 #define _MM_SET_FLUSH_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | (x)))
 928 #define _MM_SET_ROUNDING_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | (x)))
 929
 930 #define _MM_TRANSPOSE4_PS(row0, row1, row2, row3) \
 931 do { \
 932   __m128 tmp3, tmp2, tmp1, tmp0; \
 933   tmp0 = _mm_unpacklo_ps((row0), (row1)); \
 934   tmp2 = _mm_unpacklo_ps((row2), (row3)); \
 935   tmp1 = _mm_unpackhi_ps((row0), (row1)); \
 936   tmp3 = _mm_unpackhi_ps((row2), (row3)); \
 937   (row0) = _mm_movelh_ps(tmp0, tmp2); \
 938   (row1) = _mm_movehl_ps(tmp2, tmp0); \
 939   (row2) = _mm_movelh_ps(tmp1, tmp3); \
 940   (row3) = _mm_movehl_ps(tmp3, tmp1); \
 941 } while (0)
 942
 943 /* Aliases for compatibility. */
 944 #define _m_pextrw _mm_extract_pi16
 945 #define _m_pinsrw _mm_insert_pi16
 946 #define _m_pmaxsw _mm_max_pi16
 947 #define _m_pmaxub _mm_max_pu8
 948 #define _m_pminsw _mm_min_pi16
 949 #define _m_pminub _mm_min_pu8
 950 #define _m_pmovmskb _mm_movemask_pi8
 951 #define _m_pmulhuw _mm_mulhi_pu16
 952 #define _m_pshufw _mm_shuffle_pi16
 953 #define _m_maskmovq _mm_maskmove_si64
 954 #define _m_pavgb _mm_avg_pu8
 955 #define _m_pavgw _mm_avg_pu16
 956 #define _m_psadbw _mm_sad_pu8
 957 #define _m_ _mm_
 958 #define _m_ _mm_
 959
 960 /* Ugly hack for backwards-compatibility (compatible with gcc) */
 961 #ifdef __SSE2__
 962 #include <emmintrin.h>
 963 #endif
 964
 965 #endif /* __SSE__ */
 966
 967 #endif /* __XMMINTRIN_H */