gcc/config/i386/xmmintrin.h

   1 /* Copyright (C) 2002 Free Software Foundation, Inc.
   2
   3    This file is part of GNU CC.
   4
   5    GNU CC is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    GNU CC is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with GNU CC; see the file COPYING.  If not, write to
  17    the Free Software Foundation, 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 /* As a special exception, if you include this header file into source
  21    files compiled by GCC, this header file does not by itself cause
  22    the resulting executable to be covered by the GNU General Public
  23    License.  This exception does not however invalidate any other
  24    reasons why the executable file might be covered by the GNU General
  25    Public License.  */
  26
  27 /* Implemented from the specification included in the Intel C++ Compiler
  28    User Guide and Reference, version 5.0.  */
  29
  30 #ifndef _XMMINTRIN_H_INCLUDED
  31 #define _XMMINTRIN_H_INCLUDED
  32
  33 /* We need type definitions from the MMX header file.  */
  34 #include <mmintrin.h>
  35
  36 /* The data type indended for user use.  */
  37 typedef int __m128 __attribute__ ((__mode__(__V4SF__)));
  38
  39 /* Internal data types for implementing the instrinsics.  */
  40 typedef int __v4sf __attribute__ ((__mode__(__V4SF__)));
  41 typedef int __v4si __attribute__ ((__mode__(__V4SI__)));
  42
  43 /* Create a selector for use with the SHUFPS instruction.  */
  44 #define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \
  45  (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
  46
  47 /* Constants for use with _mm_prefetch.  */
  48 enum _mm_hint
  49 {
  50   _MM_HINT_T0 = 3,
  51   _MM_HINT_T1 = 2,
  52   _MM_HINT_T2 = 1,
  53   _MM_HINT_NTA = 0
  54 };
  55
  56 /* Bits in the MXCSR.  */
  57 #define _MM_EXCEPT_MASK       0x003f
  58 #define _MM_EXCEPT_INVALID    0x0001
  59 #define _MM_EXCEPT_DENORM     0x0002
  60 #define _MM_EXCEPT_DIV_ZERO   0x0004
  61 #define _MM_EXCEPT_OVERFLOW   0x0008
  62 #define _MM_EXCEPT_UNDERFLOW  0x0010
  63 #define _MM_EXCEPT_INEXACT    0x0020
  64
  65 #define _MM_MASK_MASK         0x1f80
  66 #define _MM_MASK_INVALID      0x0080
  67 #define _MM_MASK_DENORM       0x0100
  68 #define _MM_MASK_DIV_ZERO     0x0200
  69 #define _MM_MASK_OVERFLOW     0x0400
  70 #define _MM_MASK_UNDERFLOW    0x0800
  71 #define _MM_MASK_INEXACT      0x1000
  72
  73 #define _MM_ROUND_MASK        0x6000
  74 #define _MM_ROUND_NEAREST     0x0000
  75 #define _MM_ROUND_DOWN        0x2000
  76 #define _MM_ROUND_UP          0x4000
  77 #define _MM_ROUND_TOWARD_ZERO 0x6000
  78
  79 #define _MM_FLUSH_ZERO_MASK   0x8000
  80 #define _MM_FLUSH_ZERO_ON     0x8000
  81 #define _MM_FLUSH_ZERO_OFF    0x0000
  82
  83 /* Perform the respective operation on the lower SPFP (single-precision
  84    floating-point) values of A and B; the upper three SPFP values are
  85    passed through from A.  */
  86
  87 static __inline __m128
  88 _mm_add_ss (__m128 __A, __m128 __B)
  89 {
  90   return (__m128) __builtin_ia32_addss ((__v4sf)__A, (__v4sf)__B);
  91 }
  92
  93 static __inline __m128
  94 _mm_sub_ss (__m128 __A, __m128 __B)
  95 {
  96   return (__m128) __builtin_ia32_subss ((__v4sf)__A, (__v4sf)__B);
  97 }
  98
  99 static __inline __m128
 100 _mm_mul_ss (__m128 __A, __m128 __B)
 101 {
 102   return (__m128) __builtin_ia32_mulss ((__v4sf)__A, (__v4sf)__B);
 103 }
 104
 105 static __inline __m128
 106 _mm_div_ss (__m128 __A, __m128 __B)
 107 {
 108   return (__m128) __builtin_ia32_divss ((__v4sf)__A, (__v4sf)__B);
 109 }
 110
 111 static __inline __m128
 112 _mm_sqrt_ss (__m128 __A)
 113 {
 114   return (__m128) __builtin_ia32_sqrtss ((__v4sf)__A);
 115 }
 116
 117 static __inline __m128
 118 _mm_rcp_ss (__m128 __A)
 119 {
 120   return (__m128) __builtin_ia32_rcpss ((__v4sf)__A);
 121 }
 122
 123 static __inline __m128
 124 _mm_rsqrt_ss (__m128 __A)
 125 {
 126   return (__m128) __builtin_ia32_rsqrtss ((__v4sf)__A);
 127 }
 128
 129 static __inline __m128
 130 _mm_min_ss (__m128 __A, __m128 __B)
 131 {
 132   return (__m128) __builtin_ia32_minss ((__v4sf)__A, (__v4sf)__B);
 133 }
 134
 135 static __inline __m128
 136 _mm_max_ss (__m128 __A, __m128 __B)
 137 {
 138   return (__m128) __builtin_ia32_maxss ((__v4sf)__A, (__v4sf)__B);
 139 }
 140
 141 /* Perform the respective operation on the four SPFP values in A and B.  */
 142
 143 static __inline __m128
 144 _mm_add_ps (__m128 __A, __m128 __B)
 145 {
 146   return (__m128) __builtin_ia32_addps ((__v4sf)__A, (__v4sf)__B);
 147 }
 148
 149 static __inline __m128
 150 _mm_sub_ps (__m128 __A, __m128 __B)
 151 {
 152   return (__m128) __builtin_ia32_subps ((__v4sf)__A, (__v4sf)__B);
 153 }
 154
 155 static __inline __m128
 156 _mm_mul_ps (__m128 __A, __m128 __B)
 157 {
 158   return (__m128) __builtin_ia32_mulps ((__v4sf)__A, (__v4sf)__B);
 159 }
 160
 161 static __inline __m128
 162 _mm_div_ps (__m128 __A, __m128 __B)
 163 {
 164   return (__m128) __builtin_ia32_divps ((__v4sf)__A, (__v4sf)__B);
 165 }
 166
 167 static __inline __m128
 168 _mm_sqrt_ps (__m128 __A)
 169 {
 170   return (__m128) __builtin_ia32_sqrtps ((__v4sf)__A);
 171 }
 172
 173 static __inline __m128
 174 _mm_rcp_ps (__m128 __A)
 175 {
 176   return (__m128) __builtin_ia32_rcpps ((__v4sf)__A);
 177 }
 178
 179 static __inline __m128
 180 _mm_rsqrt_ps (__m128 __A)
 181 {
 182   return (__m128) __builtin_ia32_rsqrtps ((__v4sf)__A);
 183 }
 184
 185 static __inline __m128
 186 _mm_min_ps (__m128 __A, __m128 __B)
 187 {
 188   return (__m128) __builtin_ia32_minps ((__v4sf)__A, (__v4sf)__B);
 189 }
 190
 191 static __inline __m128
 192 _mm_max_ps (__m128 __A, __m128 __B)
 193 {
 194   return (__m128) __builtin_ia32_maxps ((__v4sf)__A, (__v4sf)__B);
 195 }
 196
 197 /* Perform logical bit-wise operations on 128-bit values.  */
 198
 199 static __inline __m128
 200 _mm_and_ps (__m128 __A, __m128 __B)
 201 {
 202   return __builtin_ia32_andps (__A, __B);
 203 }
 204
 205 static __inline __m128
 206 _mm_andnot_ps (__m128 __A, __m128 __B)
 207 {
 208   return __builtin_ia32_andnps (__A, __B);
 209 }
 210
 211 static __inline __m128
 212 _mm_or_ps (__m128 __A, __m128 __B)
 213 {
 214   return __builtin_ia32_orps (__A, __B);
 215 }
 216
 217 static __inline __m128
 218 _mm_xor_ps (__m128 __A, __m128 __B)
 219 {
 220   return __builtin_ia32_xorps (__A, __B);
 221 }
 222
 223 /* Perform a comparison on the lower SPFP values of A and B.  If the
 224    comparison is true, place a mask of all ones in the result, otherwise a
 225    mask of zeros.  The upper three SPFP values are passed through from A.  */
 226
 227 static __inline __m128
 228 _mm_cmpeq_ss (__m128 __A, __m128 __B)
 229 {
 230   return (__m128) __builtin_ia32_cmpeqss ((__v4sf)__A, (__v4sf)__B);
 231 }
 232
 233 static __inline __m128
 234 _mm_cmplt_ss (__m128 __A, __m128 __B)
 235 {
 236   return (__m128) __builtin_ia32_cmpltss ((__v4sf)__A, (__v4sf)__B);
 237 }
 238
 239 static __inline __m128
 240 _mm_cmple_ss (__m128 __A, __m128 __B)
 241 {
 242   return (__m128) __builtin_ia32_cmpless ((__v4sf)__A, (__v4sf)__B);
 243 }
 244
 245 static __inline __m128
 246 _mm_cmpgt_ss (__m128 __A, __m128 __B)
 247 {
 248   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 249                                         (__v4sf)
 250                                         __builtin_ia32_cmpltss ((__v4sf) __B,
 251                                                                 (__v4sf)
 252                                                                 __A));
 253 }
 254
 255 static __inline __m128
 256 _mm_cmpge_ss (__m128 __A, __m128 __B)
 257 {
 258   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 259                                         (__v4sf)
 260                                         __builtin_ia32_cmpless ((__v4sf) __B,
 261                                                                 (__v4sf)
 262                                                                 __A));
 263 }
 264
 265 static __inline __m128
 266 _mm_cmpneq_ss (__m128 __A, __m128 __B)
 267 {
 268   return (__m128) __builtin_ia32_cmpneqss ((__v4sf)__A, (__v4sf)__B);
 269 }
 270
 271 static __inline __m128
 272 _mm_cmpnlt_ss (__m128 __A, __m128 __B)
 273 {
 274   return (__m128) __builtin_ia32_cmpnltss ((__v4sf)__A, (__v4sf)__B);
 275 }
 276
 277 static __inline __m128
 278 _mm_cmpnle_ss (__m128 __A, __m128 __B)
 279 {
 280   return (__m128) __builtin_ia32_cmpnless ((__v4sf)__A, (__v4sf)__B);
 281 }
 282
 283 static __inline __m128
 284 _mm_cmpngt_ss (__m128 __A, __m128 __B)
 285 {
 286   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 287                                         (__v4sf)
 288                                         __builtin_ia32_cmpnltss ((__v4sf) __B,
 289                                                                  (__v4sf)
 290                                                                  __A));
 291 }
 292
 293 static __inline __m128
 294 _mm_cmpnge_ss (__m128 __A, __m128 __B)
 295 {
 296   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 297                                         (__v4sf)
 298                                         __builtin_ia32_cmpnless ((__v4sf) __B,
 299                                                                  (__v4sf)
 300                                                                  __A));
 301 }
 302
 303 static __inline __m128
 304 _mm_cmpord_ss (__m128 __A, __m128 __B)
 305 {
 306   return (__m128) __builtin_ia32_cmpordss ((__v4sf)__A, (__v4sf)__B);
 307 }
 308
 309 static __inline __m128
 310 _mm_cmpunord_ss (__m128 __A, __m128 __B)
 311 {
 312   return (__m128) __builtin_ia32_cmpunordss ((__v4sf)__A, (__v4sf)__B);
 313 }
 314
 315 /* Perform a comparison on the four SPFP values of A and B.  For each
 316    element, if the comparison is true, place a mask of all ones in the
 317    result, otherwise a mask of zeros.  */
 318
 319 static __inline __m128
 320 _mm_cmpeq_ps (__m128 __A, __m128 __B)
 321 {
 322   return (__m128) __builtin_ia32_cmpeqps ((__v4sf)__A, (__v4sf)__B);
 323 }
 324
 325 static __inline __m128
 326 _mm_cmplt_ps (__m128 __A, __m128 __B)
 327 {
 328   return (__m128) __builtin_ia32_cmpltps ((__v4sf)__A, (__v4sf)__B);
 329 }
 330
 331 static __inline __m128
 332 _mm_cmple_ps (__m128 __A, __m128 __B)
 333 {
 334   return (__m128) __builtin_ia32_cmpleps ((__v4sf)__A, (__v4sf)__B);
 335 }
 336
 337 static __inline __m128
 338 _mm_cmpgt_ps (__m128 __A, __m128 __B)
 339 {
 340   return (__m128) __builtin_ia32_cmpgtps ((__v4sf)__A, (__v4sf)__B);
 341 }
 342
 343 static __inline __m128
 344 _mm_cmpge_ps (__m128 __A, __m128 __B)
 345 {
 346   return (__m128) __builtin_ia32_cmpgeps ((__v4sf)__A, (__v4sf)__B);
 347 }
 348
 349 static __inline __m128
 350 _mm_cmpneq_ps (__m128 __A, __m128 __B)
 351 {
 352   return (__m128) __builtin_ia32_cmpneqps ((__v4sf)__A, (__v4sf)__B);
 353 }
 354
 355 static __inline __m128
 356 _mm_cmpnlt_ps (__m128 __A, __m128 __B)
 357 {
 358   return (__m128) __builtin_ia32_cmpnltps ((__v4sf)__A, (__v4sf)__B);
 359 }
 360
 361 static __inline __m128
 362 _mm_cmpnle_ps (__m128 __A, __m128 __B)
 363 {
 364   return (__m128) __builtin_ia32_cmpnleps ((__v4sf)__A, (__v4sf)__B);
 365 }
 366
 367 static __inline __m128
 368 _mm_cmpngt_ps (__m128 __A, __m128 __B)
 369 {
 370   return (__m128) __builtin_ia32_cmpngtps ((__v4sf)__A, (__v4sf)__B);
 371 }
 372
 373 static __inline __m128
 374 _mm_cmpnge_ps (__m128 __A, __m128 __B)
 375 {
 376   return (__m128) __builtin_ia32_cmpngeps ((__v4sf)__A, (__v4sf)__B);
 377 }
 378
 379 static __inline __m128
 380 _mm_cmpord_ps (__m128 __A, __m128 __B)
 381 {
 382   return (__m128) __builtin_ia32_cmpordps ((__v4sf)__A, (__v4sf)__B);
 383 }
 384
 385 static __inline __m128
 386 _mm_cmpunord_ps (__m128 __A, __m128 __B)
 387 {
 388   return (__m128) __builtin_ia32_cmpunordps ((__v4sf)__A, (__v4sf)__B);
 389 }
 390
 391 /* Compare the lower SPFP values of A and B and return 1 if true
 392    and 0 if false.  */
 393
 394 static __inline int
 395 _mm_comieq_ss (__m128 __A, __m128 __B)
 396 {
 397   return __builtin_ia32_comieq ((__v4sf)__A, (__v4sf)__B);
 398 }
 399
 400 static __inline int
 401 _mm_comilt_ss (__m128 __A, __m128 __B)
 402 {
 403   return __builtin_ia32_comilt ((__v4sf)__A, (__v4sf)__B);
 404 }
 405
 406 static __inline int
 407 _mm_comile_ss (__m128 __A, __m128 __B)
 408 {
 409   return __builtin_ia32_comile ((__v4sf)__A, (__v4sf)__B);
 410 }
 411
 412 static __inline int
 413 _mm_comigt_ss (__m128 __A, __m128 __B)
 414 {
 415   return __builtin_ia32_comigt ((__v4sf)__A, (__v4sf)__B);
 416 }
 417
 418 static __inline int
 419 _mm_comige_ss (__m128 __A, __m128 __B)
 420 {
 421   return __builtin_ia32_comige ((__v4sf)__A, (__v4sf)__B);
 422 }
 423
 424 static __inline int
 425 _mm_comineq_ss (__m128 __A, __m128 __B)
 426 {
 427   return __builtin_ia32_comineq ((__v4sf)__A, (__v4sf)__B);
 428 }
 429
 430 static __inline int
 431 _mm_ucomieq_ss (__m128 __A, __m128 __B)
 432 {
 433   return __builtin_ia32_ucomieq ((__v4sf)__A, (__v4sf)__B);
 434 }
 435
 436 static __inline int
 437 _mm_ucomilt_ss (__m128 __A, __m128 __B)
 438 {
 439   return __builtin_ia32_ucomilt ((__v4sf)__A, (__v4sf)__B);
 440 }
 441
 442 static __inline int
 443 _mm_ucomile_ss (__m128 __A, __m128 __B)
 444 {
 445   return __builtin_ia32_ucomile ((__v4sf)__A, (__v4sf)__B);
 446 }
 447
 448 static __inline int
 449 _mm_ucomigt_ss (__m128 __A, __m128 __B)
 450 {
 451   return __builtin_ia32_ucomigt ((__v4sf)__A, (__v4sf)__B);
 452 }
 453
 454 static __inline int
 455 _mm_ucomige_ss (__m128 __A, __m128 __B)
 456 {
 457   return __builtin_ia32_ucomige ((__v4sf)__A, (__v4sf)__B);
 458 }
 459
 460 static __inline int
 461 _mm_ucomineq_ss (__m128 __A, __m128 __B)
 462 {
 463   return __builtin_ia32_ucomineq ((__v4sf)__A, (__v4sf)__B);
 464 }
 465
 466 /* Convert the lower SPFP value to a 32-bit integer according to the current
 467    rounding mode.  */
 468 static __inline int
 469 _mm_cvtss_si32 (__m128 __A)
 470 {
 471   return __builtin_ia32_cvtss2si ((__v4sf) __A);
 472 }
 473
 474 /* Convert the two lower SPFP values to 32-bit integers according to the
 475    current rounding mode.  Return the integers in packed form.  */
 476 static __inline __m64
 477 _mm_cvtps_pi32 (__m128 __A)
 478 {
 479   return (__m64) __builtin_ia32_cvtps2pi ((__v4sf) __A);
 480 }
 481
 482 /* Truncate the lower SPFP value to a 32-bit integer.  */
 483 static __inline int
 484 _mm_cvttss_si32 (__m128 __A)
 485 {
 486   return __builtin_ia32_cvttss2si ((__v4sf) __A);
 487 }
 488
 489 /* Truncate the two lower SPFP values to 32-bit integers.  Return the
 490    integers in packed form.  */
 491 static __inline __m64
 492 _mm_cvttps_pi32 (__m128 __A)
 493 {
 494   return (__m64) __builtin_ia32_cvttps2pi ((__v4sf) __A);
 495 }
 496
 497 /* Convert B to a SPFP value and insert it as element zero in A.  */
 498 static __inline __m128
 499 _mm_cvtsi32_ss (__m128 __A, int __B)
 500 {
 501   return (__m128) __builtin_ia32_cvtsi2ss ((__v4sf) __A, __B);
 502 }
 503
 504 /* Convert the two 32-bit values in B to SPFP form and insert them
 505    as the two lower elements in A.  */
 506 static __inline __m128
 507 _mm_cvtpi32_ps (__m128 __A, __m64 __B)
 508 {
 509   return (__m128) __builtin_ia32_cvtpi2ps ((__v4sf) __A, (__v2si)__B);
 510 }
 511
 512 /* Convert the four signed 16-bit values in A to SPFP form.  */
 513 static __inline __m128
 514 _mm_cvtpi16_ps (__m64 __A)
 515 {
 516   __v4hi __sign;
 517   __v2si __hisi, __losi;
 518   __v4sf __r;
 519
 520   /* This comparison against zero gives us a mask that can be used to
 521      fill in the missing sign bits in the unpack operations below, so
 522      that we get signed values after unpacking.  */
 523   __sign = (__v4hi) __builtin_ia32_mmx_zero ();
 524   __sign = __builtin_ia32_pcmpgtw (__sign, (__v4hi)__A);
 525
 526   /* Convert the four words to doublewords.  */
 527   __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, __sign);
 528   __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, __sign);
 529
 530   /* Convert the doublewords to floating point two at a time.  */
 531   __r = (__v4sf) __builtin_ia32_setzerops ();
 532   __r = __builtin_ia32_cvtpi2ps (__r, __hisi);
 533   __r = __builtin_ia32_movlhps (__r, __r);
 534   __r = __builtin_ia32_cvtpi2ps (__r, __losi);
 535
 536   return (__m128) __r;
 537 }
 538
 539 /* Convert the four unsigned 16-bit values in A to SPFP form.  */
 540 static __inline __m128
 541 _mm_cvtpu16_ps (__m64 __A)
 542 {
 543   __v4hi __zero = (__v4hi) __builtin_ia32_mmx_zero ();
 544   __v2si __hisi, __losi;
 545   __v4sf __r;
 546
 547   /* Convert the four words to doublewords.  */
 548   __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, __zero);
 549   __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, __zero);
 550
 551   /* Convert the doublewords to floating point two at a time.  */
 552   __r = (__v4sf) __builtin_ia32_setzerops ();
 553   __r = __builtin_ia32_cvtpi2ps (__r, __hisi);
 554   __r = __builtin_ia32_movlhps (__r, __r);
 555   __r = __builtin_ia32_cvtpi2ps (__r, __losi);
 556
 557   return (__m128) __r;
 558 }
 559
 560 /* Convert the low four signed 8-bit values in A to SPFP form.  */
 561 static __inline __m128
 562 _mm_cvtpi8_ps (__m64 __A)
 563 {
 564   __v8qi __sign;
 565
 566   /* This comparison against zero gives us a mask that can be used to
 567      fill in the missing sign bits in the unpack operations below, so
 568      that we get signed values after unpacking.  */
 569   __sign = (__v8qi) __builtin_ia32_mmx_zero ();
 570   __sign = __builtin_ia32_pcmpgtb (__sign, (__v8qi)__A);
 571
 572   /* Convert the four low bytes to words.  */
 573   __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, __sign);
 574
 575   return _mm_cvtpi16_ps(__A);
 576 }
 577
 578 /* Convert the low four unsigned 8-bit values in A to SPFP form.  */
 579 static __inline __m128
 580 _mm_cvtpu8_ps(__m64 __A)
 581 {
 582   __v8qi __zero = (__v8qi) __builtin_ia32_mmx_zero ();
 583   __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, __zero);
 584   return _mm_cvtpu16_ps(__A);
 585 }
 586
 587 /* Convert the four signed 32-bit values in A and B to SPFP form.  */
 588 static __inline __m128
 589 _mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
 590 {
 591   __v4sf __zero = (__v4sf) __builtin_ia32_setzerops ();
 592   __v4sf __sfa = __builtin_ia32_cvtpi2ps (__zero, (__v2si)__A);
 593   __v4sf __sfb = __builtin_ia32_cvtpi2ps (__zero, (__v2si)__B);
 594   return (__m128) __builtin_ia32_movlhps (__sfa, __sfb);
 595 }
 596
 597 /* Convert the four SPFP values in A to four signed 16-bit integers.  */
 598 static __inline __m64
 599 _mm_cvtps_pi16(__m128 __A)
 600 {
 601   __v4sf __hisf = (__v4sf)__A;
 602   __v4sf __losf = __builtin_ia32_movhlps (__hisf, __hisf);
 603   __v2si __hisi = __builtin_ia32_cvtps2pi (__hisf);
 604   __v2si __losi = __builtin_ia32_cvtps2pi (__losf);
 605   return (__m64) __builtin_ia32_packssdw (__losi, __hisi);
 606 }
 607
 608 /* Convert the four SPFP values in A to four signed 8-bit integers.  */
 609 static __inline __m64
 610 _mm_cvtps_pi8(__m128 __A)
 611 {
 612   __v4hi __tmp = (__v4hi) _mm_cvtps_pi16 (__A);
 613   __v4hi __zero = (__v4hi) __builtin_ia32_mmx_zero ();
 614   return (__m64) __builtin_ia32_packsswb (__tmp, __zero);
 615 }
 616
 617 /* Selects four specific SPFP values from A and B based on MASK.  */
 618 #if 0
 619 static __inline __m128
 620 _mm_shuffle_ps (__m128 __A, __m128 __B, int __mask)
 621 {
 622   return (__m128) __builtin_ia32_shufps ((__v4sf)__A, (__v4sf)__B, __mask);
 623 }
 624 #else
 625 #define _mm_shuffle_ps(A, B, MASK) \
 626  ((__m128) __builtin_ia32_shufps ((__v4sf)(A), (__v4sf)(B), (MASK)))
 627 #endif
 628
 629
 630 /* Selects and interleaves the upper two SPFP values from A and B.  */
 631 static __inline __m128
 632 _mm_unpackhi_ps (__m128 __A, __m128 __B)
 633 {
 634   return (__m128) __builtin_ia32_unpckhps ((__v4sf)__A, (__v4sf)__B);
 635 }
 636
 637 /* Selects and interleaves the lower two SPFP values from A and B.  */
 638 static __inline __m128
 639 _mm_unpacklo_ps (__m128 __A, __m128 __B)
 640 {
 641   return (__m128) __builtin_ia32_unpcklps ((__v4sf)__A, (__v4sf)__B);
 642 }
 643
 644 /* Sets the upper two SPFP values with 64-bits of data loaded from P;
 645    the lower two values are passed through from A.  */
 646 static __inline __m128
 647 _mm_loadh_pi (__m128 __A, __m64 *__P)
 648 {
 649   return (__m128) __builtin_ia32_loadhps ((__v4sf)__A, (__v2si *)__P);
 650 }
 651
 652 /* Stores the upper two SPFP values of A into P.  */
 653 static __inline void
 654 _mm_storeh_pi (__m64 *__P, __m128 __A)
 655 {
 656   __builtin_ia32_storehps ((__v2si *)__P, (__v4sf)__A);
 657 }
 658
 659 /* Moves the upper two values of B into the lower two values of A.  */
 660 static __inline __m128
 661 _mm_movehl_ps (__m128 __A, __m128 __B)
 662 {
 663   return (__m128) __builtin_ia32_movhlps ((__v4sf)__A, (__v4sf)__B);
 664 }
 665
 666 /* Moves the lower two values of B into the upper two values of A.  */
 667 static __inline __m128
 668 _mm_movelh_ps (__m128 __A, __m128 __B)
 669 {
 670   return (__m128) __builtin_ia32_movlhps ((__v4sf)__A, (__v4sf)__B);
 671 }
 672
 673 /* Sets the lower two SPFP values with 64-bits of data loaded from P;
 674    the upper two values are passed through from A.  */
 675 static __inline __m128
 676 _mm_loadl_pi (__m128 __A, __m64 *__P)
 677 {
 678   return (__m128) __builtin_ia32_loadlps ((__v4sf)__A, (__v2si *)__P);
 679 }
 680
 681 /* Stores the lower two SPFP values of A into P.  */
 682 static __inline void
 683 _mm_storel_pi (__m64 *__P, __m128 __A)
 684 {
 685   __builtin_ia32_storelps ((__v2si *)__P, (__v4sf)__A);
 686 }
 687
 688 /* Creates a 4-bit mask from the most significant bits of the SPFP values.  */
 689 static __inline int
 690 _mm_movemask_ps (__m128 __A)
 691 {
 692   return __builtin_ia32_movmskps ((__v4sf)__A);
 693 }
 694
 695 /* Return the contents of the control register.  */
 696 static __inline unsigned int
 697 _mm_getcsr (void)
 698 {
 699   return __builtin_ia32_stmxcsr ();
 700 }
 701
 702 /* Read exception bits from the control register.  */
 703 static __inline unsigned int
 704 _MM_GET_EXCEPTION_STATE (void)
 705 {
 706   return _mm_getcsr() & _MM_EXCEPT_MASK;
 707 }
 708
 709 static __inline unsigned int
 710 _MM_GET_EXCEPTION_MASK (void)
 711 {
 712   return _mm_getcsr() & _MM_MASK_MASK;
 713 }
 714
 715 static __inline unsigned int
 716 _MM_GET_ROUNDING_MODE (void)
 717 {
 718   return _mm_getcsr() & _MM_ROUND_MASK;
 719 }
 720
 721 static __inline unsigned int
 722 _MM_GET_FLUSH_ZERO_MODE (void)
 723 {
 724   return _mm_getcsr() & _MM_FLUSH_ZERO_MASK;
 725 }
 726
 727 /* Set the control register to I.  */
 728 static __inline void
 729 _mm_setcsr (unsigned int __I)
 730 {
 731   __builtin_ia32_ldmxcsr (__I);
 732 }
 733
 734 /* Set exception bits in the control register.  */
 735 static __inline void
 736 _MM_SET_EXCEPTION_STATE(unsigned int __mask)
 737 {
 738   _mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | __mask);
 739 }
 740
 741 static __inline void
 742 _MM_SET_EXCEPTION_MASK (unsigned int __mask)
 743 {
 744   _mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | __mask);
 745 }
 746
 747 static __inline void
 748 _MM_SET_ROUNDING_MODE (unsigned int __mode)
 749 {
 750   _mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | __mode);
 751 }
 752
 753 static __inline void
 754 _MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
 755 {
 756   _mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | __mode);
 757 }
 758
 759 /* Create a vector with element 0 as *P and the rest zero.  */
 760 static __inline __m128
 761 _mm_load_ss (float *__P)
 762 {
 763   return (__m128) __builtin_ia32_loadss (__P);
 764 }
 765
 766 /* Create a vector with all four elements equal to *P.  */
 767 static __inline __m128
 768 _mm_load1_ps (float *__P)
 769 {
 770   __v4sf __tmp = __builtin_ia32_loadss (__P);
 771   return (__m128) __builtin_ia32_shufps (__tmp, __tmp, _MM_SHUFFLE (0,0,0,0));
 772 }
 773
 774 static __inline __m128
 775 _mm_load_ps1 (float *__P)
 776 {
 777   return _mm_load1_ps (__P);
 778 }
 779
 780 /* Load four SPFP values from P.  The address must be 16-byte aligned.  */
 781 static __inline __m128
 782 _mm_load_ps (float *__P)
 783 {
 784   return (__m128) __builtin_ia32_loadaps (__P);
 785 }
 786
 787 /* Load four SPFP values from P.  The address need not be 16-byte aligned.  */
 788 static __inline __m128
 789 _mm_loadu_ps (float *__P)
 790 {
 791   return (__m128) __builtin_ia32_loadups (__P);
 792 }
 793
 794 /* Load four SPFP values in reverse order.  The address must be aligned.  */
 795 static __inline __m128
 796 _mm_loadr_ps (float *__P)
 797 {
 798   __v4sf __tmp = __builtin_ia32_loadaps (__P);
 799   return (__m128) __builtin_ia32_shufps (__tmp, __tmp, _MM_SHUFFLE (0,1,2,3));
 800 }
 801
 802 /* Create a vector with element 0 as F and the rest zero.  */
 803 static __inline __m128
 804 _mm_set_ss (float __F)
 805 {
 806   return (__m128) __builtin_ia32_loadss (&__F);
 807 }
 808
 809 /* Create a vector with all four elements equal to F.  */
 810 static __inline __m128
 811 _mm_set1_ps (float __F)
 812 {
 813   __v4sf __tmp = __builtin_ia32_loadss (&__F);
 814   return (__m128) __builtin_ia32_shufps (__tmp, __tmp, _MM_SHUFFLE (0,0,0,0));
 815 }
 816
 817 static __inline __m128
 818 _mm_set_ps1 (float __F)
 819 {
 820   return _mm_set1_ps (__F);
 821 }
 822
 823 /* Create the vector [Z Y X W].  */
 824 static __inline __m128
 825 _mm_set_ps (float __Z, float __Y, float __X, float __W)
 826 {
 827   union {
 828     float __a[4];
 829     __m128 __v;
 830   } __u;
 831
 832   __u.__a[0] = __W;
 833   __u.__a[1] = __X;
 834   __u.__a[2] = __Y;
 835   __u.__a[3] = __Z;
 836
 837   return __u.__v;
 838 }
 839
 840 /* Create the vector [W X Y Z].  */
 841 static __inline __m128
 842 _mm_setr_ps (float __Z, float __Y, float __X, float __W)
 843 {
 844   return _mm_set_ps (__W, __X, __Y, __Z);
 845 }
 846
 847 /* Create a vector of zeros.  */
 848 static __inline __m128
 849 _mm_setzero_ps (void)
 850 {
 851   return (__m128) __builtin_ia32_setzerops ();
 852 }
 853
 854 /* Stores the lower SPFP value.  */
 855 static __inline void
 856 _mm_store_ss (float *__P, __m128 __A)
 857 {
 858   __builtin_ia32_storess (__P, (__v4sf)__A);
 859 }
 860
 861 /* Store the lower SPFP value across four words.  */
 862 static __inline void
 863 _mm_store1_ps (float *__P, __m128 __A)
 864 {
 865   __v4sf __va = (__v4sf)__A;
 866   __v4sf __tmp = __builtin_ia32_shufps (__va, __va, _MM_SHUFFLE (0,0,0,0));
 867   __builtin_ia32_storeaps (__P, __tmp);
 868 }
 869
 870 static __inline void
 871 _mm_store_ps1 (float *__P, __m128 __A)
 872 {
 873   _mm_store1_ps (__P, __A);
 874 }
 875
 876 /* Store four SPFP values.  The address must be 16-byte aligned.  */
 877 static __inline void
 878 _mm_store_ps (float *__P, __m128 __A)
 879 {
 880   __builtin_ia32_storeaps (__P, (__v4sf)__A);
 881 }
 882
 883 /* Store four SPFP values.  The address need not be 16-byte aligned.  */
 884 static __inline void
 885 _mm_storeu_ps (float *__P, __m128 __A)
 886 {
 887   __builtin_ia32_storeups (__P, (__v4sf)__A);
 888 }
 889
 890 /* Store four SPFP values in reverse order.  The address must be aligned.  */
 891 static __inline void
 892 _mm_storer_ps (float *__P, __m128 __A)
 893 {
 894   __v4sf __va = (__v4sf)__A;
 895   __v4sf __tmp = __builtin_ia32_shufps (__va, __va, _MM_SHUFFLE (0,1,2,3));
 896   __builtin_ia32_storeaps (__P, __tmp);
 897 }
 898
 899 /* Sets the low SPFP value of A from the low value of B.  */
 900 static __inline __m128
 901 _mm_move_ss (__m128 __A, __m128 __B)
 902 {
 903   return (__m128) __builtin_ia32_movss ((__v4sf)__A, (__v4sf)__B);
 904 }
 905
 906 /* Extracts one of the four words of A.  The selector N must be immediate.  */
 907 #if 0
 908 static __inline int
 909 _mm_extract_pi16 (__m64 __A, int __N)
 910 {
 911   return __builtin_ia32_pextrw ((__v4hi)__A, __N);
 912 }
 913 #else
 914 #define _mm_extract_pi16(A, N) \
 915   __builtin_ia32_pextrw ((__v4hi)(A), (N))
 916 #endif
 917
 918 /* Inserts word D into one of four words of A.  The selector N must be
 919    immediate.  */
 920 #if 0
 921 static __inline __m64
 922 _mm_insert_pi16 (__m64 __A, int __D, int __N)
 923 {
 924   return (__m64)__builtin_ia32_pinsrw ((__v4hi)__A, __D, __N);
 925 }
 926 #else
 927 #define _mm_insert_pi16(A, D, N) \
 928   ((__m64) __builtin_ia32_pinsrw ((__v4hi)(A), (D), (N)))
 929 #endif
 930
 931 /* Compute the element-wise maximum of signed 16-bit values.  */
 932 static __inline __m64
 933 _mm_max_pi16 (__m64 __A, __m64 __B)
 934 {
 935   return (__m64) __builtin_ia32_pmaxsw ((__v4hi)__A, (__v4hi)__B);
 936 }
 937
 938 /* Compute the element-wise maximum of unsigned 8-bit values.  */
 939 static __inline __m64
 940 _mm_max_pu8 (__m64 __A, __m64 __B)
 941 {
 942   return (__m64) __builtin_ia32_pmaxub ((__v8qi)__A, (__v8qi)__B);
 943 }
 944
 945 /* Compute the element-wise minimum of signed 16-bit values.  */
 946 static __inline __m64
 947 _mm_min_pi16 (__m64 __A, __m64 __B)
 948 {
 949   return (__m64) __builtin_ia32_pminsw ((__v4hi)__A, (__v4hi)__B);
 950 }
 951
 952 /* Compute the element-wise minimum of unsigned 8-bit values.  */
 953 static __inline __m64
 954 _mm_min_pu8 (__m64 __A, __m64 __B)
 955 {
 956   return (__m64) __builtin_ia32_pminub ((__v8qi)__A, (__v8qi)__B);
 957 }
 958
 959 /* Create an 8-bit mask of the signs of 8-bit values.  */
 960 static __inline int
 961 _mm_movemask_pi8 (__m64 __A)
 962 {
 963   return __builtin_ia32_pmovmskb ((__v8qi)__A);
 964 }
 965
 966 /* Multiply four unsigned 16-bit values in A by four unsigned 16-bit values
 967    in B and produce the high 16 bits of the 32-bit results.  */
 968 static __inline __m64
 969 _mm_mulhi_pu16 (__m64 __A, __m64 __B)
 970 {
 971   return (__m64) __builtin_ia32_pmulhuw ((__v4hi)__A, (__v4hi)__B);
 972 }
 973
 974 /* Return a combination of the four 16-bit values in A.  The selector
 975    must be an immediate.  */
 976 #if 0
 977 static __inline __m64
 978 _mm_shuffle_pi16 (__m64 __A, int __N)
 979 {
 980   return (__m64) __builtin_ia32_pshufw ((__v4hi)__A, __N);
 981 }
 982 #else
 983 #define _mm_shuffle_pi16(A, N) \
 984   ((__m64) __builtin_ia32_pshufw ((__v4hi)(A), (N)))
 985 #endif
 986
 987 /* Conditionally store byte elements of A into P.  The high bit of each
 988    byte in the selector N determines whether the corresponding byte from
 989    A is stored.  */
 990 static __inline void
 991 _mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
 992 {
 993   __builtin_ia32_maskmovq ((__v8qi)__A, (__v8qi)__N, __P);
 994 }
 995
 996 /* Compute the rounded averages of the unsigned 8-bit values in A and B.  */
 997 static __inline __m64
 998 _mm_avg_pu8 (__m64 __A, __m64 __B)
 999 {
1000   return (__m64) __builtin_ia32_pavgb ((__v8qi)__A, (__v8qi)__B);
1001 }
1002
1003 /* Compute the rounded averages of the unsigned 16-bit values in A and B.  */
1004 static __inline __m64
1005 _mm_avg_pu16 (__m64 __A, __m64 __B)
1006 {
1007   return (__m64) __builtin_ia32_pavgw ((__v4hi)__A, (__v4hi)__B);
1008 }
1009
1010 /* Compute the sum of the absolute differences of the unsigned 8-bit
1011    values in A and B.  Return the value in the lower 16-bit word; the
1012    upper words are cleared.  */
1013 static __inline __m64
1014 _mm_sad_pu8 (__m64 __A, __m64 __B)
1015 {
1016   return (__m64) __builtin_ia32_psadbw ((__v8qi)__A, (__v8qi)__B);
1017 }
1018
1019 /* Loads one cache line from address P to a location "closer" to the
1020    processor.  The selector I specifies the type of prefetch operation.  */
1021 #if 0
1022 static __inline void
1023 _mm_prefetch (void *__P, enum _mm_hint __I)
1024 {
1025   __builtin_prefetch (__P, 0, __I);
1026 }
1027 #else
1028 #define _mm_prefetch(P, I) \
1029   __builtin_prefetch ((P), 0, (I))
1030 #endif
1031
1032 /* Stores the data in A to the address P without polluting the caches.  */
1033 static __inline void
1034 _mm_stream_pi (__m64 *__P, __m64 __A)
1035 {
1036   __builtin_ia32_movntq (__P, __A);
1037 }
1038
1039 /* Likewise.  The address must be 16-byte aligned.  */
1040 static __inline void
1041 _mm_stream_ps (float *__P, __m128 __A)
1042 {
1043   __builtin_ia32_movntps (__P, (__v4sf)__A);
1044 }
1045
1046 /* Guarantees that every preceeding store is globally visible before
1047    any subsequent store.  */
1048 static __inline void
1049 _mm_sfence (void)
1050 {
1051   __builtin_ia32_sfence ();
1052 }
1053
1054 /* The execution of the next instruction is delayed by an implementation
1055    specific amount of time.  The instruction does not modify the
1056    architectural state.  */
1057 static __inline void
1058 _mm_pause (void)
1059 {
1060   __asm__ __volatile__ ("rep; nop" : : );
1061 }
1062
1063 /* Transpose the 4x4 matrix composed of row[0-3].  */
1064 #define _MM_TRANSPOSE4_PS(row0, row1, row2, row3)                       \
1065 do {                                                                    \
1066   __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3);    \
1067   __v4sf __t0 = __builtin_ia32_shufps (__r0, __r1, 0x44);               \
1068   __v4sf __t1 = __builtin_ia32_shufps (__r0, __r1, 0xEE);               \
1069   __v4sf __t2 = __builtin_ia32_shufps (__r2, __r3, 0x44);               \
1070   __v4sf __t3 = __builtin_ia32_shufps (__r2, __r3, 0xEE);               \
1071   (row0) = __builtin_ia32_shufps (__t0, __t1, 0x88);                    \
1072   (row1) = __builtin_ia32_shufps (__t0, __t1, 0xDD);                    \
1073   (row2) = __builtin_ia32_shufps (__t2, __t3, 0x88);                    \
1074   (row3) = __builtin_ia32_shufps (__t2, __t3, 0xDD);                    \
1075 } while (0)
1076
1077 #ifdef __SSE2__
1078 /* SSE2 */
1079 typedef int __v2df __attribute__ ((mode (V2DF)));
1080 typedef int __v2di __attribute__ ((mode (V2DI)));
1081 typedef int __v4si __attribute__ ((mode (V4SI)));
1082 typedef int __v8hi __attribute__ ((mode (V8HI)));
1083 typedef int __v16qi __attribute__ ((mode (V16QI)));
1084
1085 #define __m128i __v2di
1086 #define __m128d __v2df
1087
1088 static __inline __m128d
1089 _mm_add_pd (__m128d __A, __m128d __B)
1090 {
1091   return (__m128d)__builtin_ia32_addpd ((__v2df)__A, (__v2df)__B);
1092 }
1093
1094 static __inline __m128d
1095 _mm_add_sd (__m128d __A, __m128d __B)
1096 {
1097   return (__m128d)__builtin_ia32_addsd ((__v2df)__A, (__v2df)__B);
1098 }
1099
1100 static __inline __m128d
1101 _mm_sub_pd (__m128d __A, __m128d __B)
1102 {
1103   return (__m128d)__builtin_ia32_subpd ((__v2df)__A, (__v2df)__B);
1104 }
1105
1106 static __inline __m128d
1107 _mm_sub_sd (__m128d __A, __m128d __B)
1108 {
1109   return (__m128d)__builtin_ia32_subsd ((__v2df)__A, (__v2df)__B);
1110 }
1111
1112 static __inline __m128d
1113 _mm_mul_pd (__m128d __A, __m128d __B)
1114 {
1115   return (__m128d)__builtin_ia32_mulpd ((__v2df)__A, (__v2df)__B);
1116 }
1117
1118 static __inline __m128d
1119 _mm_mul_sd (__m128d __A, __m128d __B)
1120 {
1121   return (__m128d)__builtin_ia32_mulsd ((__v2df)__A, (__v2df)__B);
1122 }
1123
1124 static __inline __m128d
1125 _mm_div_pd (__m128d __A, __m128d __B)
1126 {
1127   return (__m128d)__builtin_ia32_divpd ((__v2df)__A, (__v2df)__B);
1128 }
1129
1130 static __inline __m128d
1131 _mm_div_sd (__m128d __A, __m128d __B)
1132 {
1133   return (__m128d)__builtin_ia32_divsd ((__v2df)__A, (__v2df)__B);
1134 }
1135
1136 static __inline __m128d
1137 _mm_sqrt_pd (__m128d __A)
1138 {
1139   return (__m128d)__builtin_ia32_sqrtpd ((__v2df)__A);
1140 }
1141
1142 static __inline __m128d
1143 _mm_sqrt_sd (__m128d __A)
1144 {
1145   return (__m128d)__builtin_ia32_sqrtsd ((__v2df)__A);
1146 }
1147
1148 static __inline __m128d
1149 _mm_min_pd (__m128d __A, __m128d __B)
1150 {
1151   return (__m128d)__builtin_ia32_minpd ((__v2df)__A, (__v2df)__B);
1152 }
1153
1154 static __inline __m128d
1155 _mm_min_sd (__m128d __A, __m128d __B)
1156 {
1157   return (__m128d)__builtin_ia32_minsd ((__v2df)__A, (__v2df)__B);
1158 }
1159
1160 static __inline __m128d
1161 _mm_max_pd (__m128d __A, __m128d __B)
1162 {
1163   return (__m128d)__builtin_ia32_maxpd ((__v2df)__A, (__v2df)__B);
1164 }
1165
1166 static __inline __m128d
1167 _mm_max_sd (__m128d __A, __m128d __B)
1168 {
1169   return (__m128d)__builtin_ia32_minsd ((__v2df)__A, (__v2df)__B);
1170 }
1171
1172 static __inline __m128d
1173 _mm_and_pd (__m128d __A, __m128d __B)
1174 {
1175   return (__m128d)__builtin_ia32_andpd ((__v2df)__A, (__v2df)__B);
1176 }
1177
1178 static __inline __m128d
1179 _mm_andnot_pd (__m128d __A, __m128d __B)
1180 {
1181   return (__m128d)__builtin_ia32_andnpd ((__v2df)__A, (__v2df)__B);
1182 }
1183
1184 static __inline __m128d
1185 _mm_or_pd (__m128d __A, __m128d __B)
1186 {
1187   return (__m128d)__builtin_ia32_orpd ((__v2df)__A, (__v2df)__B);
1188 }
1189
1190 static __inline __m128d
1191 _mm_xor_pd (__m128d __A, __m128d __B)
1192 {
1193   return (__m128d)__builtin_ia32_xorpd ((__v2df)__A, (__v2df)__B);
1194 }
1195
1196 static __inline __m128d
1197 _mm_cmpeq_pd (__m128d __A, __m128d __B)
1198 {
1199   return (__m128d)__builtin_ia32_cmpeqpd ((__v2df)__A, (__v2df)__B);
1200 }
1201
1202 static __inline __m128d
1203 _mm_cmplt_pd (__m128d __A, __m128d __B)
1204 {
1205   return (__m128d)__builtin_ia32_cmpltpd ((__v2df)__A, (__v2df)__B);
1206 }
1207
1208 static __inline __m128d
1209 _mm_cmple_pd (__m128d __A, __m128d __B)
1210 {
1211   return (__m128d)__builtin_ia32_cmplepd ((__v2df)__A, (__v2df)__B);
1212 }
1213
1214 static __inline __m128d
1215 _mm_cmpgt_pd (__m128d __A, __m128d __B)
1216 {
1217   return (__m128d)__builtin_ia32_cmpgtpd ((__v2df)__A, (__v2df)__B);
1218 }
1219
1220 static __inline __m128d
1221 _mm_cmpge_pd (__m128d __A, __m128d __B)
1222 {
1223   return (__m128d)__builtin_ia32_cmpgepd ((__v2df)__A, (__v2df)__B);
1224 }
1225
1226 static __inline __m128d
1227 _mm_cmpneq_pd (__m128d __A, __m128d __B)
1228 {
1229   return (__m128d)__builtin_ia32_cmpneqpd ((__v2df)__A, (__v2df)__B);
1230 }
1231
1232 static __inline __m128d
1233 _mm_cmpnlt_pd (__m128d __A, __m128d __B)
1234 {
1235   return (__m128d)__builtin_ia32_cmpnltpd ((__v2df)__A, (__v2df)__B);
1236 }
1237
1238 static __inline __m128d
1239 _mm_cmpnle_pd (__m128d __A, __m128d __B)
1240 {
1241   return (__m128d)__builtin_ia32_cmpnlepd ((__v2df)__A, (__v2df)__B);
1242 }
1243
1244 static __inline __m128d
1245 _mm_cmpngt_pd (__m128d __A, __m128d __B)
1246 {
1247   return (__m128d)__builtin_ia32_cmpngtpd ((__v2df)__A, (__v2df)__B);
1248 }
1249
1250 static __inline __m128d
1251 _mm_cmpnge_pd (__m128d __A, __m128d __B)
1252 {
1253   return (__m128d)__builtin_ia32_cmpngepd ((__v2df)__A, (__v2df)__B);
1254 }
1255
1256 static __inline __m128d
1257 _mm_cmpord_pd (__m128d __A, __m128d __B)
1258 {
1259   return (__m128d)__builtin_ia32_cmpordpd ((__v2df)__A, (__v2df)__B);
1260 }
1261
1262 static __inline __m128d
1263 _mm_cmpunord_pd (__m128d __A, __m128d __B)
1264 {
1265   return (__m128d)__builtin_ia32_cmpunordpd ((__v2df)__A, (__v2df)__B);
1266 }
1267
1268 static __inline __m128d
1269 _mm_cmpeq_sd (__m128d __A, __m128d __B)
1270 {
1271   return (__m128d)__builtin_ia32_cmpeqsd ((__v2df)__A, (__v2df)__B);
1272 }
1273
1274 static __inline __m128d
1275 _mm_cmplt_sd (__m128d __A, __m128d __B)
1276 {
1277   return (__m128d)__builtin_ia32_cmpltsd ((__v2df)__A, (__v2df)__B);
1278 }
1279
1280 static __inline __m128d
1281 _mm_cmple_sd (__m128d __A, __m128d __B)
1282 {
1283   return (__m128d)__builtin_ia32_cmplesd ((__v2df)__A, (__v2df)__B);
1284 }
1285
1286 static __inline __m128d
1287 _mm_cmpgt_sd (__m128d __A, __m128d __B)
1288 {
1289   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
1290                                          (__v2df)
1291                                          __builtin_ia32_cmpltsd ((__v2df) __B,
1292                                                                  (__v2df)
1293                                                                  __A));
1294 }
1295
1296 static __inline __m128d
1297 _mm_cmpge_sd (__m128d __A, __m128d __B)
1298 {
1299   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
1300                                          (__v2df)
1301                                          __builtin_ia32_cmplesd ((__v2df) __B,
1302                                                                  (__v2df)
1303                                                                  __A));
1304 }
1305
1306 static __inline __m128d
1307 _mm_cmpneq_sd (__m128d __A, __m128d __B)
1308 {
1309   return (__m128d)__builtin_ia32_cmpneqsd ((__v2df)__A, (__v2df)__B);
1310 }
1311
1312 static __inline __m128d
1313 _mm_cmpnlt_sd (__m128d __A, __m128d __B)
1314 {
1315   return (__m128d)__builtin_ia32_cmpnltsd ((__v2df)__A, (__v2df)__B);
1316 }
1317
1318 static __inline __m128d
1319 _mm_cmpnle_sd (__m128d __A, __m128d __B)
1320 {
1321   return (__m128d)__builtin_ia32_cmpnlesd ((__v2df)__A, (__v2df)__B);
1322 }
1323
1324 static __inline __m128d
1325 _mm_cmpngt_sd (__m128d __A, __m128d __B)
1326 {
1327   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
1328                                          (__v2df)
1329                                          __builtin_ia32_cmpnltsd ((__v2df) __B,
1330                                                                   (__v2df)
1331                                                                   __A));
1332 }
1333
1334 static __inline __m128d
1335 _mm_cmpnge_sd (__m128d __A, __m128d __B)
1336 {
1337   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
1338                                          (__v2df)
1339                                          __builtin_ia32_cmpnlesd ((__v2df) __B,
1340                                                                   (__v2df)
1341                                                                   __A));
1342 }
1343
1344 static __inline __m128d
1345 _mm_cmpord_sd (__m128d __A, __m128d __B)
1346 {
1347   return (__m128d)__builtin_ia32_cmpordsd ((__v2df)__A, (__v2df)__B);
1348 }
1349
1350 static __inline __m128d
1351 _mm_cmpunord_sd (__m128d __A, __m128d __B)
1352 {
1353   return (__m128d)__builtin_ia32_cmpunordsd ((__v2df)__A, (__v2df)__B);
1354 }
1355
1356 static __inline int
1357 _mm_comieq_sd (__m128d __A, __m128d __B)
1358 {
1359   return __builtin_ia32_comisdeq ((__v2df)__A, (__v2df)__B);
1360 }
1361
1362 static __inline int
1363 _mm_comilt_sd (__m128d __A, __m128d __B)
1364 {
1365   return __builtin_ia32_comisdlt ((__v2df)__A, (__v2df)__B);
1366 }
1367
1368 static __inline int
1369 _mm_comile_sd (__m128d __A, __m128d __B)
1370 {
1371   return __builtin_ia32_comisdle ((__v2df)__A, (__v2df)__B);
1372 }
1373
1374 static __inline int
1375 _mm_comigt_sd (__m128d __A, __m128d __B)
1376 {
1377   return __builtin_ia32_comisdgt ((__v2df)__A, (__v2df)__B);
1378 }
1379
1380 static __inline int
1381 _mm_comige_sd (__m128d __A, __m128d __B)
1382 {
1383   return __builtin_ia32_comisdge ((__v2df)__A, (__v2df)__B);
1384 }
1385
1386 static __inline int
1387 _mm_comineq_sd (__m128d __A, __m128d __B)
1388 {
1389   return __builtin_ia32_comisdneq ((__v2df)__A, (__v2df)__B);
1390 }
1391
1392 static __inline int
1393 _mm_ucomieq_sd (__m128d __A, __m128d __B)
1394 {
1395   return __builtin_ia32_ucomisdeq ((__v2df)__A, (__v2df)__B);
1396 }
1397
1398 static __inline int
1399 _mm_ucomilt_sd (__m128d __A, __m128d __B)
1400 {
1401   return __builtin_ia32_ucomisdlt ((__v2df)__A, (__v2df)__B);
1402 }
1403
1404 static __inline int
1405 _mm_ucomile_sd (__m128d __A, __m128d __B)
1406 {
1407   return __builtin_ia32_ucomisdle ((__v2df)__A, (__v2df)__B);
1408 }
1409
1410 static __inline int
1411 _mm_ucomigt_sd (__m128d __A, __m128d __B)
1412 {
1413   return __builtin_ia32_ucomisdgt ((__v2df)__A, (__v2df)__B);
1414 }
1415
1416 static __inline int
1417 _mm_ucomige_sd (__m128d __A, __m128d __B)
1418 {
1419   return __builtin_ia32_ucomisdge ((__v2df)__A, (__v2df)__B);
1420 }
1421
1422 static __inline int
1423 _mm_ucomineq_sd (__m128d __A, __m128d __B)
1424 {
1425   return __builtin_ia32_ucomisdneq ((__v2df)__A, (__v2df)__B);
1426 }
1427
1428 static __inline __m128d
1429 _mm_cvtepi32_pd (__m128i __A)
1430 {
1431   return (__m128d)__builtin_ia32_cvtdq2pd ((__v4si) __A);
1432 }
1433
1434 static __inline __m128d
1435 _mm_cvtepi32_ps (__m128i __A)
1436 {
1437   return (__m128d)__builtin_ia32_cvtdq2ps ((__v4si) __A);
1438 }
1439
1440 static __inline __m128d
1441 _mm_cvtpd_epi32 (__m128d __A)
1442 {
1443   return (__m128d)__builtin_ia32_cvtpd2dq ((__v2df) __A);
1444 }
1445
1446 static __inline __m64
1447 _mm_cvtpd_pi32 (__m128d __A)
1448 {
1449   return (__m64)__builtin_ia32_cvtpd2pi ((__v2df) __A);
1450 }
1451
1452 static __inline __m128d
1453 _mm_cvtpd_ps (__m128d __A)
1454 {
1455   return (__m128d)__builtin_ia32_cvtpd2ps ((__v2df) __A);
1456 }
1457
1458 static __inline __m128d
1459 _mm_cvttpd_epi32 (__m128d __A)
1460 {
1461   return (__m128d)__builtin_ia32_cvttpd2dq ((__v2df) __A);
1462 }
1463
1464 static __inline __m64
1465 _mm_cvttpd_pi32 (__m128d __A)
1466 {
1467   return (__m64)__builtin_ia32_cvttpd2pi ((__v2df) __A);
1468 }
1469
1470 static __inline __m128d
1471 _mm_cvtpi32_pd (__m64 __A)
1472 {
1473   return (__m128d)__builtin_ia32_cvtpi2pd ((__v2si) __A);
1474 }
1475
1476 static __inline __m128d
1477 _mm_cvtps_epi32 (__m128d __A)
1478 {
1479   return (__m128d)__builtin_ia32_cvtps2dq ((__v4sf) __A);
1480 }
1481
1482 static __inline __m128d
1483 _mm_cvttps_epi32 (__m128d __A)
1484 {
1485   return (__m128d)__builtin_ia32_cvttps2dq ((__v4sf) __A);
1486 }
1487
1488 static __inline __m128d
1489 _mm_cvtps_pd (__m128d __A)
1490 {
1491   return (__m128d)__builtin_ia32_cvtps2pd ((__v4sf) __A);
1492 }
1493
1494 static __inline int
1495 _mm_cvtsd_si32 (__m128d __A)
1496 {
1497   return __builtin_ia32_cvtsd2si ((__v2df) __A);
1498 }
1499
1500 static __inline int
1501 _mm_cvttsd_si32 (__m128d __A)
1502 {
1503   return __builtin_ia32_cvttsd2si ((__v2df) __A);
1504 }
1505
1506 static __inline __m128d
1507 _mm_cvtsd_ss (__m128d __A, __m128d __B)
1508 {
1509   return (__m128d)__builtin_ia32_cvtsd2ss ((__v4sf) __A, (__v2df) __B);
1510 }
1511
1512 static __inline __m128d
1513 _mm_cvtsi32_sd (__m128d __A, int __B)
1514 {
1515   return (__m128d)__builtin_ia32_cvtsi2sd ((__v2df) __A, __B);
1516 }
1517
1518 static __inline __m128d
1519 _mm_cvtss_sd (__m128d __A, __m128d __B)
1520 {
1521   return (__m128d)__builtin_ia32_cvtss2sd ((__v2df) __A, (__v4sf)__B);
1522 }
1523
1524 #define _mm_shuffle_pd(__A, __B, __C) ((__m128d)__builtin_ia32_shufpd ((__v2df)__A, (__v2df)__B, (__C)))
1525
1526 static __inline __m128d
1527 _mm_unpackhi_pd (__m128d __A, __m128d __B)
1528 {
1529   return (__m128d)__builtin_ia32_unpckhpd ((__v2df)__A, (__v2df)__B);
1530 }
1531
1532 static __inline __m128d
1533 _mm_unpacklo_pd (__m128d __A, __m128d __B)
1534 {
1535   return (__m128d)__builtin_ia32_unpcklpd ((__v2df)__A, (__v2df)__B);
1536 }
1537
1538 static __inline __m128d
1539 _mm_loadh_pd (__m128d __A, double *__B)
1540 {
1541   return (__m128d)__builtin_ia32_loadhpd ((__v2df)__A, (__v2si *)__B);
1542 }
1543
1544 static __inline void
1545 _mm_storeh_pd (__m128d *__A, double __B)
1546 {
1547   __v2df __tmp = __builtin_ia32_loadsd (&__B);
1548   __builtin_ia32_storehpd ((__v2si *)__A, __tmp);
1549 }
1550
1551 static __inline __m128d
1552 _mm_loadl_pd (__m128d __A, double *__B)
1553 {
1554   return (__m128d)__builtin_ia32_loadlpd ((__v2df)__A, (__v2si *)__B);
1555 }
1556
1557 static __inline void
1558 _mm_storel_pd (__m128d *__A, double __B)
1559 {
1560   __v2df __tmp = __builtin_ia32_loadsd (&__B);
1561   __builtin_ia32_storelpd ((__v2si *)__A, __tmp);
1562 }
1563
1564 static __inline int
1565 _mm_movemask_pd (__m128d __A)
1566 {
1567   return __builtin_ia32_movmskpd ((__v2df)__A);
1568 }
1569
1570 static __inline __m128i
1571 _mm_packs_epi16 (__m128i __A, __m128i __B)
1572 {
1573   return (__m128i)__builtin_ia32_packsswb128 ((__v8hi)__A, (__v8hi)__B);
1574 }
1575
1576 static __inline __m128i
1577 _mm_packs_epi32 (__m128i __A, __m128i __B)
1578 {
1579   return (__m128i)__builtin_ia32_packssdw128 ((__v4si)__A, (__v4si)__B);
1580 }
1581
1582 static __inline __m128i
1583 _mm_packus_epi16 (__m128i __A, __m128i __B)
1584 {
1585   return (__m128i)__builtin_ia32_packuswb128 ((__v8hi)__A, (__v8hi)__B);
1586 }
1587
1588 static __inline __m128i
1589 _mm_unpackhi_epi8 (__m128i __A, __m128i __B)
1590 {
1591   return (__m128i)__builtin_ia32_punpckhbw128 ((__v16qi)__A, (__v16qi)__B);
1592 }
1593
1594 static __inline __m128i
1595 _mm_unpackhi_epi16 (__m128i __A, __m128i __B)
1596 {
1597   return (__m128i)__builtin_ia32_punpckhwd128 ((__v8hi)__A, (__v8hi)__B);
1598 }
1599
1600 static __inline __m128i
1601 _mm_unpackhi_epi32 (__m128i __A, __m128i __B)
1602 {
1603   return (__m128i)__builtin_ia32_punpckhdq128 ((__v4si)__A, (__v4si)__B);
1604 }
1605
1606 static __inline __m128i
1607 _mm_unpacklo_epi8 (__m128i __A, __m128i __B)
1608 {
1609   return (__m128i)__builtin_ia32_punpcklbw128 ((__v16qi)__A, (__v16qi)__B);
1610 }
1611
1612 static __inline __m128i
1613 _mm_unpacklo_epi16 (__m128i __A, __m128i __B)
1614 {
1615   return (__m128i)__builtin_ia32_punpcklwd128 ((__v8hi)__A, (__v8hi)__B);
1616 }
1617
1618 static __inline __m128i
1619 _mm_unpacklo_epi32 (__m128i __A, __m128i __B)
1620 {
1621   return (__m128i)__builtin_ia32_punpckldq128 ((__v4si)__A, (__v4si)__B);
1622 }
1623
1624 static __inline __m128i
1625 _mm_add_epi8 (__m128i __A, __m128i __B)
1626 {
1627   return (__m128i)__builtin_ia32_paddb128 ((__v16qi)__A, (__v16qi)__B);
1628 }
1629
1630 static __inline __m128i
1631 _mm_add_epi16 (__m128i __A, __m128i __B)
1632 {
1633   return (__m128i)__builtin_ia32_paddw128 ((__v8hi)__A, (__v8hi)__B);
1634 }
1635
1636 static __inline __m128i
1637 _mm_add_epi32 (__m128i __A, __m128i __B)
1638 {
1639   return (__m128i)__builtin_ia32_paddd128 ((__v4si)__A, (__v4si)__B);
1640 }
1641
1642 static __inline __m128i
1643 _mm_add_epi64 (__m128i __A, __m128i __B)
1644 {
1645   return (__m128i)__builtin_ia32_paddq128 ((__v4si)__A, (__v4si)__B);
1646 }
1647
1648 static __inline __m128i
1649 _mm_adds_epi8 (__m128i __A, __m128i __B)
1650 {
1651   return (__m128i)__builtin_ia32_paddsb128 ((__v16qi)__A, (__v16qi)__B);
1652 }
1653
1654 static __inline __m128i
1655 _mm_adds_epi16 (__m128i __A, __m128i __B)
1656 {
1657   return (__m128i)__builtin_ia32_paddsw128 ((__v8hi)__A, (__v8hi)__B);
1658 }
1659
1660 static __inline __m128i
1661 _mm_adds_epu8 (__m128i __A, __m128i __B)
1662 {
1663   return (__m128i)__builtin_ia32_paddusb128 ((__v16qi)__A, (__v16qi)__B);
1664 }
1665
1666 static __inline __m128i
1667 _mm_adds_epu16 (__m128i __A, __m128i __B)
1668 {
1669   return (__m128i)__builtin_ia32_paddusw128 ((__v8hi)__A, (__v8hi)__B);
1670 }
1671
1672 static __inline __m128i
1673 _mm_sub_epi8 (__m128i __A, __m128i __B)
1674 {
1675   return (__m128i)__builtin_ia32_psubb128 ((__v16qi)__A, (__v16qi)__B);
1676 }
1677
1678 static __inline __m128i
1679 _mm_sub_epi16 (__m128i __A, __m128i __B)
1680 {
1681   return (__m128i)__builtin_ia32_psubw128 ((__v8hi)__A, (__v8hi)__B);
1682 }
1683
1684 static __inline __m128i
1685 _mm_sub_epi32 (__m128i __A, __m128i __B)
1686 {
1687   return (__m128i)__builtin_ia32_psubd128 ((__v4si)__A, (__v4si)__B);
1688 }
1689
1690 static __inline __m128i
1691 _mm_sub_epi64 (__m128i __A, __m128i __B)
1692 {
1693   return (__m128i)__builtin_ia32_psubq128 ((__v4si)__A, (__v4si)__B);
1694 }
1695
1696 static __inline __m128i
1697 _mm_subs_epi8 (__m128i __A, __m128i __B)
1698 {
1699   return (__m128i)__builtin_ia32_psubsb128 ((__v16qi)__A, (__v16qi)__B);
1700 }
1701
1702 static __inline __m128i
1703 _mm_subs_epi16 (__m128i __A, __m128i __B)
1704 {
1705   return (__m128i)__builtin_ia32_psubsw128 ((__v8hi)__A, (__v8hi)__B);
1706 }
1707
1708 static __inline __m128i
1709 _mm_subs_epu8 (__m128i __A, __m128i __B)
1710 {
1711   return (__m128i)__builtin_ia32_psubusb128 ((__v16qi)__A, (__v16qi)__B);
1712 }
1713
1714 static __inline __m128i
1715 _mm_subs_epu16 (__m128i __A, __m128i __B)
1716 {
1717   return (__m128i)__builtin_ia32_psubusw128 ((__v8hi)__A, (__v8hi)__B);
1718 }
1719
1720 static __inline __m128i
1721 _mm_madd_epi16 (__m128i __A, __m128i __B)
1722 {
1723   return (__m128i)__builtin_ia32_pmaddwd128 ((__v8hi)__A, (__v8hi)__B);
1724 }
1725
1726 static __inline __m128i
1727 _mm_mulhi_epi16 (__m128i __A, __m128i __B)
1728 {
1729   return (__m128i)__builtin_ia32_pmulhw128 ((__v8hi)__A, (__v8hi)__B);
1730 }
1731
1732 static __inline __m128i
1733 _mm_mullo_epi16 (__m128i __A, __m128i __B)
1734 {
1735   return (__m128i)__builtin_ia32_pmullw128 ((__v8hi)__A, (__v8hi)__B);
1736 }
1737
1738 static __inline __m64
1739 _mm_mul_pu16 (__m64 __A, __m64 __B)
1740 {
1741   return (__m64)__builtin_ia32_pmuludq ((__v2si)__A, (__v2si)__B);
1742 }
1743
1744 static __inline __m128i
1745 _mm_mul_epu16 (__m128i __A, __m128i __B)
1746 {
1747   return (__m128i)__builtin_ia32_pmuludq128 ((__v4si)__A, (__v4si)__B);
1748 }
1749
1750 static __inline __m128i
1751 _mm_sll_epi16 (__m128i __A, __m128i __B)
1752 {
1753   return (__m128i)__builtin_ia32_psllw128 ((__v8hi)__A, (__v2di)__B);
1754 }
1755
1756 static __inline __m128i
1757 _mm_sll_epi32 (__m128i __A, __m128i __B)
1758 {
1759   return (__m128i)__builtin_ia32_pslld128 ((__v4si)__A, (__v2di)__B);
1760 }
1761
1762 static __inline __m128i
1763 _mm_sll_epi64 (__m128i __A, __m128i __B)
1764 {
1765   return (__m128i)__builtin_ia32_psllq128 ((__v2di)__A, (__v2di)__B);
1766 }
1767
1768 static __inline __m128i
1769 _mm_sra_epi16 (__m128i __A, __m128i __B)
1770 {
1771   return (__m128i)__builtin_ia32_psraw128 ((__v8hi)__A, (__v2di)__B);
1772 }
1773
1774 static __inline __m128i
1775 _mm_sra_epi32 (__m128i __A, __m128i __B)
1776 {
1777   return (__m128i)__builtin_ia32_psrad128 ((__v4si)__A, (__v2di)__B);
1778 }
1779
1780 static __inline __m128i
1781 _mm_srl_epi16 (__m128i __A, __m128i __B)
1782 {
1783   return (__m128i)__builtin_ia32_psrlw128 ((__v8hi)__A, (__v2di)__B);
1784 }
1785
1786 static __inline __m128i
1787 _mm_srl_epi32 (__m128i __A, __m128i __B)
1788 {
1789   return (__m128i)__builtin_ia32_psrld128 ((__v4si)__A, (__v2di)__B);
1790 }
1791
1792 static __inline __m128i
1793 _mm_srl_epi64 (__m128i __A, __m128i __B)
1794 {
1795   return (__m128i)__builtin_ia32_psrlq128 ((__v2di)__A, (__v2di)__B);
1796 }
1797
1798 static __inline __m128i
1799 _mm_slli_epi16 (__m128i __A, int __B)
1800 {
1801   return (__m128i)__builtin_ia32_psllwi128 ((__v8hi)__A, __B);
1802 }
1803
1804 static __inline __m128i
1805 _mm_slli_epi32 (__m128i __A, int __B)
1806 {
1807   return (__m128i)__builtin_ia32_pslldi128 ((__v4si)__A, __B);
1808 }
1809
1810 static __inline __m128i
1811 _mm_slli_epi64 (__m128i __A, int __B)
1812 {
1813   return (__m128i)__builtin_ia32_psllqi128 ((__v2di)__A, __B);
1814 }
1815
1816 static __inline __m128i
1817 _mm_srai_epi16 (__m128i __A, int __B)
1818 {
1819   return (__m128i)__builtin_ia32_psrawi128 ((__v8hi)__A, __B);
1820 }
1821
1822 static __inline __m128i
1823 _mm_srai_epi32 (__m128i __A, int __B)
1824 {
1825   return (__m128i)__builtin_ia32_psradi128 ((__v4si)__A, __B);
1826 }
1827
1828 static __inline __m128i
1829 _mm_srli_epi16 (__m128i __A, int __B)
1830 {
1831   return (__m128i)__builtin_ia32_psrlwi128 ((__v8hi)__A, __B);
1832 }
1833
1834 static __inline __m128i
1835 _mm_srli_epi32 (__m128i __A, int __B)
1836 {
1837   return (__m128i)__builtin_ia32_psrldi128 ((__v4si)__A, __B);
1838 }
1839
1840 static __inline __m128i
1841 _mm_srli_epi64 (__m128i __A, int __B)
1842 {
1843   return (__m128i)__builtin_ia32_psrlqi128 ((__v2di)__A, __B);
1844 }
1845
1846 static __inline __m128i
1847 _mm_and_si128 (__m128i __A, __m128i __B)
1848 {
1849   return (__m128i)__builtin_ia32_pand128 ((__v2di)__A, (__v2di)__B);
1850 }
1851
1852 static __inline __m128i
1853 _mm_andnot_si128 (__m128i __A, __m128i __B)
1854 {
1855   return (__m128i)__builtin_ia32_pandn128 ((__v2di)__A, (__v2di)__B);
1856 }
1857
1858 static __inline __m128i
1859 _mm_or_si128 (__m128i __A, __m128i __B)
1860 {
1861   return (__m128i)__builtin_ia32_por128 ((__v2di)__A, (__v2di)__B);
1862 }
1863
1864 static __inline __m128i
1865 _mm_xor_si128 (__m128i __A, __m128i __B)
1866 {
1867   return (__m128i)__builtin_ia32_pxor128 ((__v2di)__A, (__v2di)__B);
1868 }
1869
1870 static __inline __m128i
1871 _mm_cmpeq_epi8 (__m128i __A, __m128i __B)
1872 {
1873   return (__m128i)__builtin_ia32_pcmpeqb128 ((__v16qi)__A, (__v16qi)__B);
1874 }
1875
1876 static __inline __m128i
1877 _mm_cmpeq_epi16 (__m128i __A, __m128i __B)
1878 {
1879   return (__m128i)__builtin_ia32_pcmpeqw128 ((__v8hi)__A, (__v8hi)__B);
1880 }
1881
1882 static __inline __m128i
1883 _mm_cmpeq_epi32 (__m128i __A, __m128i __B)
1884 {
1885   return (__m128i)__builtin_ia32_pcmpeqd128 ((__v4si)__A, (__v4si)__B);
1886 }
1887
1888 static __inline __m128i
1889 _mm_cmpgt_epi8 (__m128i __A, __m128i __B)
1890 {
1891   return (__m128i)__builtin_ia32_pcmpgtb128 ((__v16qi)__A, (__v16qi)__B);
1892 }
1893
1894 static __inline __m128i
1895 _mm_cmpgt_epi16 (__m128i __A, __m128i __B)
1896 {
1897   return (__m128i)__builtin_ia32_pcmpgtw128 ((__v8hi)__A, (__v8hi)__B);
1898 }
1899
1900 static __inline __m128i
1901 _mm_cmpgt_epi32 (__m128i __A, __m128i __B)
1902 {
1903   return (__m128i)__builtin_ia32_pcmpgtd128 ((__v4si)__A, (__v4si)__B);
1904 }
1905
1906 #define _mm_extract_epi16(__A, __B) __builtin_ia32_pextrw128 ((__v8hi)__A, __B)
1907
1908 #define _mm_insert_epi16 (__A, __B, __C) ((__m128i)__builtin_ia32_pinsrw128 ((__v8hi)__A, __B, __C))
1909
1910 static __inline __m128i
1911 _mm_max_epi16 (__m128i __A, __m128i __B)
1912 {
1913   return (__m128i)__builtin_ia32_pmaxsw128 ((__v8hi)__A, (__v8hi)__B);
1914 }
1915
1916 static __inline __m128i
1917 _mm_max_epu8 (__m128i __A, __m128i __B)
1918 {
1919   return (__m128i)__builtin_ia32_pmaxub128 ((__v16qi)__A, (__v16qi)__B);
1920 }
1921
1922 static __inline __m128i
1923 _mm_min_epi16 (__m128i __A, __m128i __B)
1924 {
1925   return (__m128i)__builtin_ia32_pminsw128 ((__v8hi)__A, (__v8hi)__B);
1926 }
1927
1928 static __inline __m128i
1929 _mm_min_epu8 (__m128i __A, __m128i __B)
1930 {
1931   return (__m128i)__builtin_ia32_pminub128 ((__v16qi)__A, (__v16qi)__B);
1932 }
1933
1934 static __inline int
1935 _mm_movemask_epi8 (__m128i __A)
1936 {
1937   return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
1938 }
1939
1940 static __inline __m128i
1941 _mm_mulhi_epu16 (__m128i __A, __m128i __B)
1942 {
1943   return (__m128i)__builtin_ia32_pmulhuw128 ((__v8hi)__A, (__v8hi)__B);
1944 }
1945
1946 #define _mm_shufflehi_epi16(__A, __B) ((__m128i)__builtin_ia32_pshufhw128 ((__v8hi)__A, __B))
1947 #define _mm_shufflelo_epi16(__A, __B) ((__m128i)__builtin_ia32_pshuflw128 ((__v8hi)__A, __B))
1948 #define _mm_shuffle_epi32(__A, __B) ((__m128i)__builtin_ia32_pshufd ((__v4si)__A, __B))
1949
1950 static __inline void
1951 _mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
1952 {
1953   __builtin_ia32_maskmovdqu ((__v16qi)__A, (__v16qi)__B, __C);
1954 }
1955
1956 static __inline __m128i
1957 _mm_avg_epu8 (__m128i __A, __m128i __B)
1958 {
1959   return (__m128i)__builtin_ia32_pavgb128 ((__v16qi)__A, (__v16qi)__B);
1960 }
1961
1962 static __inline __m128i
1963 _mm_avg_epu16 (__m128i __A, __m128i __B)
1964 {
1965   return (__m128i)__builtin_ia32_pavgw128 ((__v8hi)__A, (__v8hi)__B);
1966 }
1967
1968 static __inline __m128i
1969 _mm_sad_epu8 (__m128i __A, __m128i __B)
1970 {
1971   return (__m128i)__builtin_ia32_psadbw128 ((__v16qi)__A, (__v16qi)__B);
1972 }
1973
1974 static __inline void
1975 _mm_stream_si32 (int *__A, int __B)
1976 {
1977   __builtin_ia32_movnti (__A, __B);
1978 }
1979
1980 static __inline void
1981 _mm_stream_si128 (__m128i *__A, __m128i __B)
1982 {
1983   __builtin_ia32_movntdq ((__v2di *)__A, (__v2di)__B);
1984 }
1985
1986 static __inline void
1987 _mm_stream_pd (__m128d *__A, __m128d __B)
1988 {
1989   __builtin_ia32_movntpd (__A, (__v2df)__B);
1990 }
1991
1992 static __inline __m128i
1993 _mm_movpi64_epi64 (__m64 __A)
1994 {
1995   return (__m128i)__builtin_ia32_movq2dq ((unsigned long long)__A);
1996 }
1997
1998 static __inline void
1999 _mm_clflush (void *__A)
2000 {
2001   return __builtin_ia32_clflush (__A);
2002 }
2003
2004 static __inline void
2005 _mm_lfence (void)
2006 {
2007   __builtin_ia32_lfence ();
2008 }
2009
2010 static __inline void
2011 _mm_mfence (void)
2012 {
2013   __builtin_ia32_mfence ();
2014 }
2015
2016 #endif /* __SSE2_BUILTINS__  */
2017
2018 #endif /* _XMMINTRIN_H_INCLUDED */