gcc/config/i386/emmintrin.h

   1 /* Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
   2
   3    This file is part of GCC.
   4
   5    GCC 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    GCC 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 GCC; 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 8.0.  */
  29
  30 #ifndef _EMMINTRIN_H_INCLUDED
  31 #define _EMMINTRIN_H_INCLUDED
  32
  33 #ifdef __SSE2__
  34 #include <xmmintrin.h>
  35
  36 /* SSE2 */
  37 typedef double __v2df __attribute__ ((__vector_size__ (16)));
  38 typedef long long __v2di __attribute__ ((__vector_size__ (16)));
  39 typedef int __v4si __attribute__ ((__vector_size__ (16)));
  40 typedef short __v8hi __attribute__ ((__vector_size__ (16)));
  41 typedef char __v16qi __attribute__ ((__vector_size__ (16)));
  42
  43 typedef __v2di __m128i;
  44 typedef __v2df __m128d;
  45
  46 /* Create a selector for use with the SHUFPD instruction.  */
  47 #define _MM_SHUFFLE2(fp1,fp0) \
  48  (((fp1) << 1) | (fp0))
  49
  50 /* Create a vector with element 0 as F and the rest zero.  */
  51 static __inline __m128d
  52 _mm_set_sd (double __F)
  53 {
  54   return (__m128d){ __F, 0 };
  55 }
  56
  57 /* Create a vector with both elements equal to F.  */
  58 static __inline __m128d
  59 _mm_set1_pd (double __F)
  60 {
  61   return (__m128d){ __F, __F };
  62 }
  63
  64 static __inline __m128d
  65 _mm_set_pd1 (double __F)
  66 {
  67   return _mm_set1_pd (__F);
  68 }
  69
  70 /* Create a vector with the lower value X and upper value W.  */
  71 static __inline __m128d
  72 _mm_set_pd (double __W, double __X)
  73 {
  74   return (__m128d){ __X, __W };
  75 }
  76
  77 /* Create a vector with the lower value W and upper value X.  */
  78 static __inline __m128d
  79 _mm_setr_pd (double __W, double __X)
  80 {
  81   return (__m128d){ __W, __X };
  82 }
  83
  84 /* Create a vector of zeros.  */
  85 static __inline __m128d
  86 _mm_setzero_pd (void)
  87 {
  88   return (__m128d){ 0.0, 0.0 };
  89 }
  90
  91 /* Sets the low DPFP value of A from the low value of B.  */
  92 static __inline __m128d
  93 _mm_move_sd (__m128d __A, __m128d __B)
  94 {
  95   return (__m128d) __builtin_ia32_movsd ((__v2df)__A, (__v2df)__B);
  96 }
  97
  98 /* Load two DPFP values from P.  The address must be 16-byte aligned.  */
  99 static __inline __m128d
 100 _mm_load_pd (double const *__P)
 101 {
 102   return *(__m128d *)__P;
 103 }
 104
 105 /* Load two DPFP values from P.  The address need not be 16-byte aligned.  */
 106 static __inline __m128d
 107 _mm_loadu_pd (double const *__P)
 108 {
 109   return __builtin_ia32_loadupd (__P);
 110 }
 111
 112 /* Create a vector with all two elements equal to *P.  */
 113 static __inline __m128d
 114 _mm_load1_pd (double const *__P)
 115 {
 116   return _mm_set1_pd (*__P);
 117 }
 118
 119 /* Create a vector with element 0 as *P and the rest zero.  */
 120 static __inline __m128d
 121 _mm_load_sd (double const *__P)
 122 {
 123   return _mm_set_sd (*__P);
 124 }
 125
 126 static __inline __m128d
 127 _mm_load_pd1 (double const *__P)
 128 {
 129   return _mm_load1_pd (__P);
 130 }
 131
 132 /* Load two DPFP values in reverse order.  The address must be aligned.  */
 133 static __inline __m128d
 134 _mm_loadr_pd (double const *__P)
 135 {
 136   __m128d __tmp = _mm_load_pd (__P);
 137   return __builtin_ia32_shufpd (__tmp, __tmp, _MM_SHUFFLE2 (0,1));
 138 }
 139
 140 /* Store two DPFP values.  The address must be 16-byte aligned.  */
 141 static __inline void
 142 _mm_store_pd (double *__P, __m128d __A)
 143 {
 144   *(__m128d *)__P = __A;
 145 }
 146
 147 /* Store two DPFP values.  The address need not be 16-byte aligned.  */
 148 static __inline void
 149 _mm_storeu_pd (double *__P, __m128d __A)
 150 {
 151   __builtin_ia32_storeupd (__P, __A);
 152 }
 153
 154 /* Stores the lower DPFP value.  */
 155 static __inline void
 156 _mm_store_sd (double *__P, __m128d __A)
 157 {
 158   *__P = __builtin_ia32_vec_ext_v2df (__A, 0);
 159 }
 160
 161 static __inline void
 162 _mm_storel_pd (double *__P, __m128d __A)
 163 {
 164   _mm_store_sd (__P, __A);
 165 }
 166
 167 /* Stores the upper DPFP value.  */
 168 static __inline void
 169 _mm_storeh_pd (double *__P, __m128d __A)
 170 {
 171   *__P = __builtin_ia32_vec_ext_v2df (__A, 1);
 172 }
 173
 174 /* Store the lower DPFP value across two words.
 175    The address must be 16-byte aligned.  */
 176 static __inline void
 177 _mm_store1_pd (double *__P, __m128d __A)
 178 {
 179   _mm_store_pd (__P, __builtin_ia32_shufpd (__A, __A, _MM_SHUFFLE2 (0,0)));
 180 }
 181
 182 static __inline void
 183 _mm_store_pd1 (double *__P, __m128d __A)
 184 {
 185   _mm_store1_pd (__P, __A);
 186 }
 187
 188 /* Store two DPFP values in reverse order.  The address must be aligned.  */
 189 static __inline void
 190 _mm_storer_pd (double *__P, __m128d __A)
 191 {
 192   _mm_store_pd (__P, __builtin_ia32_shufpd (__A, __A, _MM_SHUFFLE2 (0,1)));
 193 }
 194
 195 static __inline int
 196 _mm_cvtsi128_si32 (__m128i __A)
 197 {
 198   return __builtin_ia32_vec_ext_v4si ((__v4si)__A, 0);
 199 }
 200
 201 #ifdef __x86_64__
 202 static __inline long long
 203 _mm_cvtsi128_si64x (__m128i __A)
 204 {
 205   return __builtin_ia32_vec_ext_v2di ((__v2di)__A, 0);
 206 }
 207 #endif
 208
 209 static __inline __m128d
 210 _mm_add_pd (__m128d __A, __m128d __B)
 211 {
 212   return (__m128d)__builtin_ia32_addpd ((__v2df)__A, (__v2df)__B);
 213 }
 214
 215 static __inline __m128d
 216 _mm_add_sd (__m128d __A, __m128d __B)
 217 {
 218   return (__m128d)__builtin_ia32_addsd ((__v2df)__A, (__v2df)__B);
 219 }
 220
 221 static __inline __m128d
 222 _mm_sub_pd (__m128d __A, __m128d __B)
 223 {
 224   return (__m128d)__builtin_ia32_subpd ((__v2df)__A, (__v2df)__B);
 225 }
 226
 227 static __inline __m128d
 228 _mm_sub_sd (__m128d __A, __m128d __B)
 229 {
 230   return (__m128d)__builtin_ia32_subsd ((__v2df)__A, (__v2df)__B);
 231 }
 232
 233 static __inline __m128d
 234 _mm_mul_pd (__m128d __A, __m128d __B)
 235 {
 236   return (__m128d)__builtin_ia32_mulpd ((__v2df)__A, (__v2df)__B);
 237 }
 238
 239 static __inline __m128d
 240 _mm_mul_sd (__m128d __A, __m128d __B)
 241 {
 242   return (__m128d)__builtin_ia32_mulsd ((__v2df)__A, (__v2df)__B);
 243 }
 244
 245 static __inline __m128d
 246 _mm_div_pd (__m128d __A, __m128d __B)
 247 {
 248   return (__m128d)__builtin_ia32_divpd ((__v2df)__A, (__v2df)__B);
 249 }
 250
 251 static __inline __m128d
 252 _mm_div_sd (__m128d __A, __m128d __B)
 253 {
 254   return (__m128d)__builtin_ia32_divsd ((__v2df)__A, (__v2df)__B);
 255 }
 256
 257 static __inline __m128d
 258 _mm_sqrt_pd (__m128d __A)
 259 {
 260   return (__m128d)__builtin_ia32_sqrtpd ((__v2df)__A);
 261 }
 262
 263 /* Return pair {sqrt (A[0), B[1]}.  */
 264 static __inline __m128d
 265 _mm_sqrt_sd (__m128d __A, __m128d __B)
 266 {
 267   __v2df __tmp = __builtin_ia32_movsd ((__v2df)__A, (__v2df)__B);
 268   return (__m128d)__builtin_ia32_sqrtsd ((__v2df)__tmp);
 269 }
 270
 271 static __inline __m128d
 272 _mm_min_pd (__m128d __A, __m128d __B)
 273 {
 274   return (__m128d)__builtin_ia32_minpd ((__v2df)__A, (__v2df)__B);
 275 }
 276
 277 static __inline __m128d
 278 _mm_min_sd (__m128d __A, __m128d __B)
 279 {
 280   return (__m128d)__builtin_ia32_minsd ((__v2df)__A, (__v2df)__B);
 281 }
 282
 283 static __inline __m128d
 284 _mm_max_pd (__m128d __A, __m128d __B)
 285 {
 286   return (__m128d)__builtin_ia32_maxpd ((__v2df)__A, (__v2df)__B);
 287 }
 288
 289 static __inline __m128d
 290 _mm_max_sd (__m128d __A, __m128d __B)
 291 {
 292   return (__m128d)__builtin_ia32_maxsd ((__v2df)__A, (__v2df)__B);
 293 }
 294
 295 static __inline __m128d
 296 _mm_and_pd (__m128d __A, __m128d __B)
 297 {
 298   return (__m128d)__builtin_ia32_andpd ((__v2df)__A, (__v2df)__B);
 299 }
 300
 301 static __inline __m128d
 302 _mm_andnot_pd (__m128d __A, __m128d __B)
 303 {
 304   return (__m128d)__builtin_ia32_andnpd ((__v2df)__A, (__v2df)__B);
 305 }
 306
 307 static __inline __m128d
 308 _mm_or_pd (__m128d __A, __m128d __B)
 309 {
 310   return (__m128d)__builtin_ia32_orpd ((__v2df)__A, (__v2df)__B);
 311 }
 312
 313 static __inline __m128d
 314 _mm_xor_pd (__m128d __A, __m128d __B)
 315 {
 316   return (__m128d)__builtin_ia32_xorpd ((__v2df)__A, (__v2df)__B);
 317 }
 318
 319 static __inline __m128d
 320 _mm_cmpeq_pd (__m128d __A, __m128d __B)
 321 {
 322   return (__m128d)__builtin_ia32_cmpeqpd ((__v2df)__A, (__v2df)__B);
 323 }
 324
 325 static __inline __m128d
 326 _mm_cmplt_pd (__m128d __A, __m128d __B)
 327 {
 328   return (__m128d)__builtin_ia32_cmpltpd ((__v2df)__A, (__v2df)__B);
 329 }
 330
 331 static __inline __m128d
 332 _mm_cmple_pd (__m128d __A, __m128d __B)
 333 {
 334   return (__m128d)__builtin_ia32_cmplepd ((__v2df)__A, (__v2df)__B);
 335 }
 336
 337 static __inline __m128d
 338 _mm_cmpgt_pd (__m128d __A, __m128d __B)
 339 {
 340   return (__m128d)__builtin_ia32_cmpgtpd ((__v2df)__A, (__v2df)__B);
 341 }
 342
 343 static __inline __m128d
 344 _mm_cmpge_pd (__m128d __A, __m128d __B)
 345 {
 346   return (__m128d)__builtin_ia32_cmpgepd ((__v2df)__A, (__v2df)__B);
 347 }
 348
 349 static __inline __m128d
 350 _mm_cmpneq_pd (__m128d __A, __m128d __B)
 351 {
 352   return (__m128d)__builtin_ia32_cmpneqpd ((__v2df)__A, (__v2df)__B);
 353 }
 354
 355 static __inline __m128d
 356 _mm_cmpnlt_pd (__m128d __A, __m128d __B)
 357 {
 358   return (__m128d)__builtin_ia32_cmpnltpd ((__v2df)__A, (__v2df)__B);
 359 }
 360
 361 static __inline __m128d
 362 _mm_cmpnle_pd (__m128d __A, __m128d __B)
 363 {
 364   return (__m128d)__builtin_ia32_cmpnlepd ((__v2df)__A, (__v2df)__B);
 365 }
 366
 367 static __inline __m128d
 368 _mm_cmpngt_pd (__m128d __A, __m128d __B)
 369 {
 370   return (__m128d)__builtin_ia32_cmpngtpd ((__v2df)__A, (__v2df)__B);
 371 }
 372
 373 static __inline __m128d
 374 _mm_cmpnge_pd (__m128d __A, __m128d __B)
 375 {
 376   return (__m128d)__builtin_ia32_cmpngepd ((__v2df)__A, (__v2df)__B);
 377 }
 378
 379 static __inline __m128d
 380 _mm_cmpord_pd (__m128d __A, __m128d __B)
 381 {
 382   return (__m128d)__builtin_ia32_cmpordpd ((__v2df)__A, (__v2df)__B);
 383 }
 384
 385 static __inline __m128d
 386 _mm_cmpunord_pd (__m128d __A, __m128d __B)
 387 {
 388   return (__m128d)__builtin_ia32_cmpunordpd ((__v2df)__A, (__v2df)__B);
 389 }
 390
 391 static __inline __m128d
 392 _mm_cmpeq_sd (__m128d __A, __m128d __B)
 393 {
 394   return (__m128d)__builtin_ia32_cmpeqsd ((__v2df)__A, (__v2df)__B);
 395 }
 396
 397 static __inline __m128d
 398 _mm_cmplt_sd (__m128d __A, __m128d __B)
 399 {
 400   return (__m128d)__builtin_ia32_cmpltsd ((__v2df)__A, (__v2df)__B);
 401 }
 402
 403 static __inline __m128d
 404 _mm_cmple_sd (__m128d __A, __m128d __B)
 405 {
 406   return (__m128d)__builtin_ia32_cmplesd ((__v2df)__A, (__v2df)__B);
 407 }
 408
 409 static __inline __m128d
 410 _mm_cmpgt_sd (__m128d __A, __m128d __B)
 411 {
 412   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
 413                                          (__v2df)
 414                                          __builtin_ia32_cmpltsd ((__v2df) __B,
 415                                                                  (__v2df)
 416                                                                  __A));
 417 }
 418
 419 static __inline __m128d
 420 _mm_cmpge_sd (__m128d __A, __m128d __B)
 421 {
 422   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
 423                                          (__v2df)
 424                                          __builtin_ia32_cmplesd ((__v2df) __B,
 425                                                                  (__v2df)
 426                                                                  __A));
 427 }
 428
 429 static __inline __m128d
 430 _mm_cmpneq_sd (__m128d __A, __m128d __B)
 431 {
 432   return (__m128d)__builtin_ia32_cmpneqsd ((__v2df)__A, (__v2df)__B);
 433 }
 434
 435 static __inline __m128d
 436 _mm_cmpnlt_sd (__m128d __A, __m128d __B)
 437 {
 438   return (__m128d)__builtin_ia32_cmpnltsd ((__v2df)__A, (__v2df)__B);
 439 }
 440
 441 static __inline __m128d
 442 _mm_cmpnle_sd (__m128d __A, __m128d __B)
 443 {
 444   return (__m128d)__builtin_ia32_cmpnlesd ((__v2df)__A, (__v2df)__B);
 445 }
 446
 447 static __inline __m128d
 448 _mm_cmpngt_sd (__m128d __A, __m128d __B)
 449 {
 450   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
 451                                          (__v2df)
 452                                          __builtin_ia32_cmpnltsd ((__v2df) __B,
 453                                                                   (__v2df)
 454                                                                   __A));
 455 }
 456
 457 static __inline __m128d
 458 _mm_cmpnge_sd (__m128d __A, __m128d __B)
 459 {
 460   return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
 461                                          (__v2df)
 462                                          __builtin_ia32_cmpnlesd ((__v2df) __B,
 463                                                                   (__v2df)
 464                                                                   __A));
 465 }
 466
 467 static __inline __m128d
 468 _mm_cmpord_sd (__m128d __A, __m128d __B)
 469 {
 470   return (__m128d)__builtin_ia32_cmpordsd ((__v2df)__A, (__v2df)__B);
 471 }
 472
 473 static __inline __m128d
 474 _mm_cmpunord_sd (__m128d __A, __m128d __B)
 475 {
 476   return (__m128d)__builtin_ia32_cmpunordsd ((__v2df)__A, (__v2df)__B);
 477 }
 478
 479 static __inline int
 480 _mm_comieq_sd (__m128d __A, __m128d __B)
 481 {
 482   return __builtin_ia32_comisdeq ((__v2df)__A, (__v2df)__B);
 483 }
 484
 485 static __inline int
 486 _mm_comilt_sd (__m128d __A, __m128d __B)
 487 {
 488   return __builtin_ia32_comisdlt ((__v2df)__A, (__v2df)__B);
 489 }
 490
 491 static __inline int
 492 _mm_comile_sd (__m128d __A, __m128d __B)
 493 {
 494   return __builtin_ia32_comisdle ((__v2df)__A, (__v2df)__B);
 495 }
 496
 497 static __inline int
 498 _mm_comigt_sd (__m128d __A, __m128d __B)
 499 {
 500   return __builtin_ia32_comisdgt ((__v2df)__A, (__v2df)__B);
 501 }
 502
 503 static __inline int
 504 _mm_comige_sd (__m128d __A, __m128d __B)
 505 {
 506   return __builtin_ia32_comisdge ((__v2df)__A, (__v2df)__B);
 507 }
 508
 509 static __inline int
 510 _mm_comineq_sd (__m128d __A, __m128d __B)
 511 {
 512   return __builtin_ia32_comisdneq ((__v2df)__A, (__v2df)__B);
 513 }
 514
 515 static __inline int
 516 _mm_ucomieq_sd (__m128d __A, __m128d __B)
 517 {
 518   return __builtin_ia32_ucomisdeq ((__v2df)__A, (__v2df)__B);
 519 }
 520
 521 static __inline int
 522 _mm_ucomilt_sd (__m128d __A, __m128d __B)
 523 {
 524   return __builtin_ia32_ucomisdlt ((__v2df)__A, (__v2df)__B);
 525 }
 526
 527 static __inline int
 528 _mm_ucomile_sd (__m128d __A, __m128d __B)
 529 {
 530   return __builtin_ia32_ucomisdle ((__v2df)__A, (__v2df)__B);
 531 }
 532
 533 static __inline int
 534 _mm_ucomigt_sd (__m128d __A, __m128d __B)
 535 {
 536   return __builtin_ia32_ucomisdgt ((__v2df)__A, (__v2df)__B);
 537 }
 538
 539 static __inline int
 540 _mm_ucomige_sd (__m128d __A, __m128d __B)
 541 {
 542   return __builtin_ia32_ucomisdge ((__v2df)__A, (__v2df)__B);
 543 }
 544
 545 static __inline int
 546 _mm_ucomineq_sd (__m128d __A, __m128d __B)
 547 {
 548   return __builtin_ia32_ucomisdneq ((__v2df)__A, (__v2df)__B);
 549 }
 550
 551 /* Create a vector of Qi, where i is the element number.  */
 552
 553 static __inline __m128i
 554 _mm_set_epi64x (long long __q1, long long __q0)
 555 {
 556   return (__m128i)(__v2di){ __q0, __q1 };
 557 }
 558
 559 static __inline __m128i
 560 _mm_set_epi64 (__m64 __q1,  __m64 __q0)
 561 {
 562   return _mm_set_epi64x ((long long)__q1, (long long)__q0);
 563 }
 564
 565 static __inline __m128i
 566 _mm_set_epi32 (int __q3, int __q2, int __q1, int __q0)
 567 {
 568   return (__m128i)(__v4si){ __q0, __q1, __q2, __q3 };
 569 }
 570
 571 static __inline __m128i
 572 _mm_set_epi16 (short __q7, short __q6, short __q5, short __q4,
 573                short __q3, short __q2, short __q1, short __q0)
 574 {
 575   return (__m128i)(__v8hi){ __q0, __q1, __q2, __q3, __q4, __q5, __q6, __q7 };
 576 }
 577
 578 static __inline __m128i
 579 _mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
 580               char __q11, char __q10, char __q09, char __q08,
 581               char __q07, char __q06, char __q05, char __q04,
 582               char __q03, char __q02, char __q01, char __q00)
 583 {
 584   return (__m128i)(__v16qi){
 585     __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
 586     __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15
 587   };
 588 }
 589
 590 /* Set all of the elements of the vector to A.  */
 591
 592 static __inline __m128i
 593 _mm_set1_epi64x (long long __A)
 594 {
 595   return _mm_set_epi64x (__A, __A);
 596 }
 597
 598 static __inline __m128i
 599 _mm_set1_epi64 (__m64 __A)
 600 {
 601   return _mm_set_epi64 (__A, __A);
 602 }
 603
 604 static __inline __m128i
 605 _mm_set1_epi32 (int __A)
 606 {
 607   return _mm_set_epi32 (__A, __A, __A, __A);
 608 }
 609
 610 static __inline __m128i
 611 _mm_set1_epi16 (short __A)
 612 {
 613   return _mm_set_epi16 (__A, __A, __A, __A, __A, __A, __A, __A);
 614 }
 615
 616 static __inline __m128i
 617 _mm_set1_epi8 (char __A)
 618 {
 619   return _mm_set_epi8 (__A, __A, __A, __A, __A, __A, __A, __A,
 620                        __A, __A, __A, __A, __A, __A, __A, __A);
 621 }
 622
 623 /* Create a vector of Qi, where i is the element number.
 624    The parameter order is reversed from the _mm_set_epi* functions.  */
 625
 626 static __inline __m128i
 627 _mm_setr_epi64 (__m64 __q0, __m64 __q1)
 628 {
 629   return _mm_set_epi64 (__q1, __q0);
 630 }
 631
 632 static __inline __m128i
 633 _mm_setr_epi32 (int __q0, int __q1, int __q2, int __q3)
 634 {
 635   return _mm_set_epi32 (__q3, __q2, __q1, __q0);
 636 }
 637
 638 static __inline __m128i
 639 _mm_setr_epi16 (short __q0, short __q1, short __q2, short __q3,
 640                 short __q4, short __q5, short __q6, short __q7)
 641 {
 642   return _mm_set_epi16 (__q7, __q6, __q5, __q4, __q3, __q2, __q1, __q0);
 643 }
 644
 645 static __inline __m128i
 646 _mm_setr_epi8 (char __q00, char __q01, char __q02, char __q03,
 647                char __q04, char __q05, char __q06, char __q07,
 648                char __q08, char __q09, char __q10, char __q11,
 649                char __q12, char __q13, char __q14, char __q15)
 650 {
 651   return _mm_set_epi8 (__q15, __q14, __q13, __q12, __q11, __q10, __q09, __q08,
 652                        __q07, __q06, __q05, __q04, __q03, __q02, __q01, __q00);
 653 }
 654
 655 /* Create a vector with element 0 as *P and the rest zero.  */
 656
 657 static __inline __m128i
 658 _mm_load_si128 (__m128i const *__P)
 659 {
 660   return *__P;
 661 }
 662
 663 static __inline __m128i
 664 _mm_loadu_si128 (__m128i const *__P)
 665 {
 666   return (__m128i) __builtin_ia32_loaddqu ((char const *)__P);
 667 }
 668
 669 static __inline __m128i
 670 _mm_loadl_epi64 (__m128i const *__P)
 671 {
 672   return _mm_set_epi64 ((__m64)0LL, *(__m64 *)__P);
 673 }
 674
 675 static __inline void
 676 _mm_store_si128 (__m128i *__P, __m128i __B)
 677 {
 678   *__P = __B;
 679 }
 680
 681 static __inline void
 682 _mm_storeu_si128 (__m128i *__P, __m128i __B)
 683 {
 684   __builtin_ia32_storedqu ((char *)__P, (__v16qi)__B);
 685 }
 686
 687 static __inline void
 688 _mm_storel_epi64 (__m128i *__P, __m128i __B)
 689 {
 690   *(long long *)__P = __builtin_ia32_vec_ext_v2di ((__v2di)__B, 0);
 691 }
 692
 693 static __inline __m64
 694 _mm_movepi64_pi64 (__m128i __B)
 695 {
 696   return (__m64) __builtin_ia32_vec_ext_v2di ((__v2di)__B, 0);
 697 }
 698
 699 static __inline __m128i
 700 _mm_movpi64_epi64 (__m64 __A)
 701 {
 702   return _mm_set_epi64 ((__m64)0LL, __A);
 703 }
 704
 705 static __inline __m128i
 706 _mm_move_epi64 (__m128i __A)
 707 {
 708   return _mm_set_epi64 ((__m64)0LL, _mm_movepi64_pi64 (__A));
 709 }
 710
 711 /* Create a vector of zeros.  */
 712 static __inline __m128i
 713 _mm_setzero_si128 (void)
 714 {
 715   return (__m128i)(__v4si){ 0, 0, 0, 0 };
 716 }
 717
 718 static __inline __m128d
 719 _mm_cvtepi32_pd (__m128i __A)
 720 {
 721   return (__m128d)__builtin_ia32_cvtdq2pd ((__v4si) __A);
 722 }
 723
 724 static __inline __m128
 725 _mm_cvtepi32_ps (__m128i __A)
 726 {
 727   return (__m128)__builtin_ia32_cvtdq2ps ((__v4si) __A);
 728 }
 729
 730 static __inline __m128i
 731 _mm_cvtpd_epi32 (__m128d __A)
 732 {
 733   return (__m128i)__builtin_ia32_cvtpd2dq ((__v2df) __A);
 734 }
 735
 736 static __inline __m64
 737 _mm_cvtpd_pi32 (__m128d __A)
 738 {
 739   return (__m64)__builtin_ia32_cvtpd2pi ((__v2df) __A);
 740 }
 741
 742 static __inline __m128
 743 _mm_cvtpd_ps (__m128d __A)
 744 {
 745   return (__m128)__builtin_ia32_cvtpd2ps ((__v2df) __A);
 746 }
 747
 748 static __inline __m128i
 749 _mm_cvttpd_epi32 (__m128d __A)
 750 {
 751   return (__m128i)__builtin_ia32_cvttpd2dq ((__v2df) __A);
 752 }
 753
 754 static __inline __m64
 755 _mm_cvttpd_pi32 (__m128d __A)
 756 {
 757   return (__m64)__builtin_ia32_cvttpd2pi ((__v2df) __A);
 758 }
 759
 760 static __inline __m128d
 761 _mm_cvtpi32_pd (__m64 __A)
 762 {
 763   return (__m128d)__builtin_ia32_cvtpi2pd ((__v2si) __A);
 764 }
 765
 766 static __inline __m128i
 767 _mm_cvtps_epi32 (__m128 __A)
 768 {
 769   return (__m128i)__builtin_ia32_cvtps2dq ((__v4sf) __A);
 770 }
 771
 772 static __inline __m128i
 773 _mm_cvttps_epi32 (__m128 __A)
 774 {
 775   return (__m128i)__builtin_ia32_cvttps2dq ((__v4sf) __A);
 776 }
 777
 778 static __inline __m128d
 779 _mm_cvtps_pd (__m128 __A)
 780 {
 781   return (__m128d)__builtin_ia32_cvtps2pd ((__v4sf) __A);
 782 }
 783
 784 static __inline int
 785 _mm_cvtsd_si32 (__m128d __A)
 786 {
 787   return __builtin_ia32_cvtsd2si ((__v2df) __A);
 788 }
 789
 790 #ifdef __x86_64__
 791 static __inline long long
 792 _mm_cvtsd_si64x (__m128d __A)
 793 {
 794   return __builtin_ia32_cvtsd2si64 ((__v2df) __A);
 795 }
 796 #endif
 797
 798 static __inline int
 799 _mm_cvttsd_si32 (__m128d __A)
 800 {
 801   return __builtin_ia32_cvttsd2si ((__v2df) __A);
 802 }
 803
 804 #ifdef __x86_64__
 805 static __inline long long
 806 _mm_cvttsd_si64x (__m128d __A)
 807 {
 808   return __builtin_ia32_cvttsd2si64 ((__v2df) __A);
 809 }
 810 #endif
 811
 812 static __inline __m128
 813 _mm_cvtsd_ss (__m128 __A, __m128d __B)
 814 {
 815   return (__m128)__builtin_ia32_cvtsd2ss ((__v4sf) __A, (__v2df) __B);
 816 }
 817
 818 static __inline __m128d
 819 _mm_cvtsi32_sd (__m128d __A, int __B)
 820 {
 821   return (__m128d)__builtin_ia32_cvtsi2sd ((__v2df) __A, __B);
 822 }
 823
 824 #ifdef __x86_64__
 825 static __inline __m128d
 826 _mm_cvtsi64x_sd (__m128d __A, long long __B)
 827 {
 828   return (__m128d)__builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
 829 }
 830 #endif
 831
 832 static __inline __m128d
 833 _mm_cvtss_sd (__m128d __A, __m128 __B)
 834 {
 835   return (__m128d)__builtin_ia32_cvtss2sd ((__v2df) __A, (__v4sf)__B);
 836 }
 837
 838 #define _mm_shuffle_pd(__A, __B, __C) ((__m128d)__builtin_ia32_shufpd ((__v2df)__A, (__v2df)__B, (__C)))
 839
 840 static __inline __m128d
 841 _mm_unpackhi_pd (__m128d __A, __m128d __B)
 842 {
 843   return (__m128d)__builtin_ia32_unpckhpd ((__v2df)__A, (__v2df)__B);
 844 }
 845
 846 static __inline __m128d
 847 _mm_unpacklo_pd (__m128d __A, __m128d __B)
 848 {
 849   return (__m128d)__builtin_ia32_unpcklpd ((__v2df)__A, (__v2df)__B);
 850 }
 851
 852 static __inline __m128d
 853 _mm_loadh_pd (__m128d __A, double const *__B)
 854 {
 855   return (__m128d)__builtin_ia32_loadhpd ((__v2df)__A, __B);
 856 }
 857
 858 static __inline __m128d
 859 _mm_loadl_pd (__m128d __A, double const *__B)
 860 {
 861   return (__m128d)__builtin_ia32_loadlpd ((__v2df)__A, __B);
 862 }
 863
 864 static __inline int
 865 _mm_movemask_pd (__m128d __A)
 866 {
 867   return __builtin_ia32_movmskpd ((__v2df)__A);
 868 }
 869
 870 static __inline __m128i
 871 _mm_packs_epi16 (__m128i __A, __m128i __B)
 872 {
 873   return (__m128i)__builtin_ia32_packsswb128 ((__v8hi)__A, (__v8hi)__B);
 874 }
 875
 876 static __inline __m128i
 877 _mm_packs_epi32 (__m128i __A, __m128i __B)
 878 {
 879   return (__m128i)__builtin_ia32_packssdw128 ((__v4si)__A, (__v4si)__B);
 880 }
 881
 882 static __inline __m128i
 883 _mm_packus_epi16 (__m128i __A, __m128i __B)
 884 {
 885   return (__m128i)__builtin_ia32_packuswb128 ((__v8hi)__A, (__v8hi)__B);
 886 }
 887
 888 static __inline __m128i
 889 _mm_unpackhi_epi8 (__m128i __A, __m128i __B)
 890 {
 891   return (__m128i)__builtin_ia32_punpckhbw128 ((__v16qi)__A, (__v16qi)__B);
 892 }
 893
 894 static __inline __m128i
 895 _mm_unpackhi_epi16 (__m128i __A, __m128i __B)
 896 {
 897   return (__m128i)__builtin_ia32_punpckhwd128 ((__v8hi)__A, (__v8hi)__B);
 898 }
 899
 900 static __inline __m128i
 901 _mm_unpackhi_epi32 (__m128i __A, __m128i __B)
 902 {
 903   return (__m128i)__builtin_ia32_punpckhdq128 ((__v4si)__A, (__v4si)__B);
 904 }
 905
 906 static __inline __m128i
 907 _mm_unpackhi_epi64 (__m128i __A, __m128i __B)
 908 {
 909   return (__m128i)__builtin_ia32_punpckhqdq128 ((__v2di)__A, (__v2di)__B);
 910 }
 911
 912 static __inline __m128i
 913 _mm_unpacklo_epi8 (__m128i __A, __m128i __B)
 914 {
 915   return (__m128i)__builtin_ia32_punpcklbw128 ((__v16qi)__A, (__v16qi)__B);
 916 }
 917
 918 static __inline __m128i
 919 _mm_unpacklo_epi16 (__m128i __A, __m128i __B)
 920 {
 921   return (__m128i)__builtin_ia32_punpcklwd128 ((__v8hi)__A, (__v8hi)__B);
 922 }
 923
 924 static __inline __m128i
 925 _mm_unpacklo_epi32 (__m128i __A, __m128i __B)
 926 {
 927   return (__m128i)__builtin_ia32_punpckldq128 ((__v4si)__A, (__v4si)__B);
 928 }
 929
 930 static __inline __m128i
 931 _mm_unpacklo_epi64 (__m128i __A, __m128i __B)
 932 {
 933   return (__m128i)__builtin_ia32_punpcklqdq128 ((__v2di)__A, (__v2di)__B);
 934 }
 935
 936 static __inline __m128i
 937 _mm_add_epi8 (__m128i __A, __m128i __B)
 938 {
 939   return (__m128i)__builtin_ia32_paddb128 ((__v16qi)__A, (__v16qi)__B);
 940 }
 941
 942 static __inline __m128i
 943 _mm_add_epi16 (__m128i __A, __m128i __B)
 944 {
 945   return (__m128i)__builtin_ia32_paddw128 ((__v8hi)__A, (__v8hi)__B);
 946 }
 947
 948 static __inline __m128i
 949 _mm_add_epi32 (__m128i __A, __m128i __B)
 950 {
 951   return (__m128i)__builtin_ia32_paddd128 ((__v4si)__A, (__v4si)__B);
 952 }
 953
 954 static __inline __m128i
 955 _mm_add_epi64 (__m128i __A, __m128i __B)
 956 {
 957   return (__m128i)__builtin_ia32_paddq128 ((__v2di)__A, (__v2di)__B);
 958 }
 959
 960 static __inline __m128i
 961 _mm_adds_epi8 (__m128i __A, __m128i __B)
 962 {
 963   return (__m128i)__builtin_ia32_paddsb128 ((__v16qi)__A, (__v16qi)__B);
 964 }
 965
 966 static __inline __m128i
 967 _mm_adds_epi16 (__m128i __A, __m128i __B)
 968 {
 969   return (__m128i)__builtin_ia32_paddsw128 ((__v8hi)__A, (__v8hi)__B);
 970 }
 971
 972 static __inline __m128i
 973 _mm_adds_epu8 (__m128i __A, __m128i __B)
 974 {
 975   return (__m128i)__builtin_ia32_paddusb128 ((__v16qi)__A, (__v16qi)__B);
 976 }
 977
 978 static __inline __m128i
 979 _mm_adds_epu16 (__m128i __A, __m128i __B)
 980 {
 981   return (__m128i)__builtin_ia32_paddusw128 ((__v8hi)__A, (__v8hi)__B);
 982 }
 983
 984 static __inline __m128i
 985 _mm_sub_epi8 (__m128i __A, __m128i __B)
 986 {
 987   return (__m128i)__builtin_ia32_psubb128 ((__v16qi)__A, (__v16qi)__B);
 988 }
 989
 990 static __inline __m128i
 991 _mm_sub_epi16 (__m128i __A, __m128i __B)
 992 {
 993   return (__m128i)__builtin_ia32_psubw128 ((__v8hi)__A, (__v8hi)__B);
 994 }
 995
 996 static __inline __m128i
 997 _mm_sub_epi32 (__m128i __A, __m128i __B)
 998 {
 999   return (__m128i)__builtin_ia32_psubd128 ((__v4si)__A, (__v4si)__B);
1000 }
1001
1002 static __inline __m128i
1003 _mm_sub_epi64 (__m128i __A, __m128i __B)
1004 {
1005   return (__m128i)__builtin_ia32_psubq128 ((__v2di)__A, (__v2di)__B);
1006 }
1007
1008 static __inline __m128i
1009 _mm_subs_epi8 (__m128i __A, __m128i __B)
1010 {
1011   return (__m128i)__builtin_ia32_psubsb128 ((__v16qi)__A, (__v16qi)__B);
1012 }
1013
1014 static __inline __m128i
1015 _mm_subs_epi16 (__m128i __A, __m128i __B)
1016 {
1017   return (__m128i)__builtin_ia32_psubsw128 ((__v8hi)__A, (__v8hi)__B);
1018 }
1019
1020 static __inline __m128i
1021 _mm_subs_epu8 (__m128i __A, __m128i __B)
1022 {
1023   return (__m128i)__builtin_ia32_psubusb128 ((__v16qi)__A, (__v16qi)__B);
1024 }
1025
1026 static __inline __m128i
1027 _mm_subs_epu16 (__m128i __A, __m128i __B)
1028 {
1029   return (__m128i)__builtin_ia32_psubusw128 ((__v8hi)__A, (__v8hi)__B);
1030 }
1031
1032 static __inline __m128i
1033 _mm_madd_epi16 (__m128i __A, __m128i __B)
1034 {
1035   return (__m128i)__builtin_ia32_pmaddwd128 ((__v8hi)__A, (__v8hi)__B);
1036 }
1037
1038 static __inline __m128i
1039 _mm_mulhi_epi16 (__m128i __A, __m128i __B)
1040 {
1041   return (__m128i)__builtin_ia32_pmulhw128 ((__v8hi)__A, (__v8hi)__B);
1042 }
1043
1044 static __inline __m128i
1045 _mm_mullo_epi16 (__m128i __A, __m128i __B)
1046 {
1047   return (__m128i)__builtin_ia32_pmullw128 ((__v8hi)__A, (__v8hi)__B);
1048 }
1049
1050 static __inline __m64
1051 _mm_mul_su32 (__m64 __A, __m64 __B)
1052 {
1053   return (__m64)__builtin_ia32_pmuludq ((__v2si)__A, (__v2si)__B);
1054 }
1055
1056 static __inline __m128i
1057 _mm_mul_epu32 (__m128i __A, __m128i __B)
1058 {
1059   return (__m128i)__builtin_ia32_pmuludq128 ((__v4si)__A, (__v4si)__B);
1060 }
1061
1062 static __inline __m128i
1063 _mm_slli_epi16 (__m128i __A, int __B)
1064 {
1065   return (__m128i)__builtin_ia32_psllwi128 ((__v8hi)__A, __B);
1066 }
1067
1068 static __inline __m128i
1069 _mm_slli_epi32 (__m128i __A, int __B)
1070 {
1071   return (__m128i)__builtin_ia32_pslldi128 ((__v4si)__A, __B);
1072 }
1073
1074 static __inline __m128i
1075 _mm_slli_epi64 (__m128i __A, int __B)
1076 {
1077   return (__m128i)__builtin_ia32_psllqi128 ((__v2di)__A, __B);
1078 }
1079
1080 static __inline __m128i
1081 _mm_srai_epi16 (__m128i __A, int __B)
1082 {
1083   return (__m128i)__builtin_ia32_psrawi128 ((__v8hi)__A, __B);
1084 }
1085
1086 static __inline __m128i
1087 _mm_srai_epi32 (__m128i __A, int __B)
1088 {
1089   return (__m128i)__builtin_ia32_psradi128 ((__v4si)__A, __B);
1090 }
1091
1092 #if 0
1093 static __m128i __attribute__((__always_inline__))
1094 _mm_srli_si128 (__m128i __A, const int __B)
1095 {
1096   return ((__m128i)__builtin_ia32_psrldqi128 (__A, __B))
1097 }
1098
1099 static __m128i __attribute__((__always_inline__))
1100 _mm_srli_si128 (__m128i __A, const int __B)
1101 {
1102   return ((__m128i)__builtin_ia32_pslldqi128 (__A, __B))
1103 }
1104 #else
1105 #define _mm_srli_si128(__A, __B) \
1106   ((__m128i)__builtin_ia32_psrldqi128 (__A, (__B) * 8))
1107 #define _mm_slli_si128(__A, __B) \
1108   ((__m128i)__builtin_ia32_pslldqi128 (__A, (__B) * 8))
1109 #endif
1110
1111 static __inline __m128i
1112 _mm_srli_epi16 (__m128i __A, int __B)
1113 {
1114   return (__m128i)__builtin_ia32_psrlwi128 ((__v8hi)__A, __B);
1115 }
1116
1117 static __inline __m128i
1118 _mm_srli_epi32 (__m128i __A, int __B)
1119 {
1120   return (__m128i)__builtin_ia32_psrldi128 ((__v4si)__A, __B);
1121 }
1122
1123 static __inline __m128i
1124 _mm_srli_epi64 (__m128i __A, int __B)
1125 {
1126   return (__m128i)__builtin_ia32_psrlqi128 ((__v2di)__A, __B);
1127 }
1128
1129 static __inline __m128i
1130 _mm_sll_epi16 (__m128i __A, __m128i __B)
1131 {
1132   return _mm_slli_epi16 (__A, _mm_cvtsi128_si32 (__B));
1133 }
1134
1135 static __inline __m128i
1136 _mm_sll_epi32 (__m128i __A, __m128i __B)
1137 {
1138   return _mm_slli_epi32 (__A, _mm_cvtsi128_si32 (__B));
1139 }
1140
1141 static __inline __m128i
1142 _mm_sll_epi64 (__m128i __A, __m128i __B)
1143 {
1144   return _mm_slli_epi64 (__A, _mm_cvtsi128_si32 (__B));
1145 }
1146
1147 static __inline __m128i
1148 _mm_sra_epi16 (__m128i __A, __m128i __B)
1149 {
1150   return _mm_srai_epi16 (__A, _mm_cvtsi128_si32 (__B));
1151 }
1152
1153 static __inline __m128i
1154 _mm_sra_epi32 (__m128i __A, __m128i __B)
1155 {
1156   return _mm_srai_epi32 (__A, _mm_cvtsi128_si32 (__B));
1157 }
1158
1159 static __inline __m128i
1160 _mm_srl_epi16 (__m128i __A, __m128i __B)
1161 {
1162   return _mm_srli_epi16 (__A, _mm_cvtsi128_si32 (__B));
1163 }
1164
1165 static __inline __m128i
1166 _mm_srl_epi32 (__m128i __A, __m128i __B)
1167 {
1168   return _mm_srli_epi32 (__A, _mm_cvtsi128_si32 (__B));
1169 }
1170
1171 static __inline __m128i
1172 _mm_srl_epi64 (__m128i __A, __m128i __B)
1173 {
1174   return _mm_srli_epi64 (__A, _mm_cvtsi128_si32 (__B));
1175 }
1176
1177 static __inline __m128i
1178 _mm_and_si128 (__m128i __A, __m128i __B)
1179 {
1180   return (__m128i)__builtin_ia32_pand128 ((__v2di)__A, (__v2di)__B);
1181 }
1182
1183 static __inline __m128i
1184 _mm_andnot_si128 (__m128i __A, __m128i __B)
1185 {
1186   return (__m128i)__builtin_ia32_pandn128 ((__v2di)__A, (__v2di)__B);
1187 }
1188
1189 static __inline __m128i
1190 _mm_or_si128 (__m128i __A, __m128i __B)
1191 {
1192   return (__m128i)__builtin_ia32_por128 ((__v2di)__A, (__v2di)__B);
1193 }
1194
1195 static __inline __m128i
1196 _mm_xor_si128 (__m128i __A, __m128i __B)
1197 {
1198   return (__m128i)__builtin_ia32_pxor128 ((__v2di)__A, (__v2di)__B);
1199 }
1200
1201 static __inline __m128i
1202 _mm_cmpeq_epi8 (__m128i __A, __m128i __B)
1203 {
1204   return (__m128i)__builtin_ia32_pcmpeqb128 ((__v16qi)__A, (__v16qi)__B);
1205 }
1206
1207 static __inline __m128i
1208 _mm_cmpeq_epi16 (__m128i __A, __m128i __B)
1209 {
1210   return (__m128i)__builtin_ia32_pcmpeqw128 ((__v8hi)__A, (__v8hi)__B);
1211 }
1212
1213 static __inline __m128i
1214 _mm_cmpeq_epi32 (__m128i __A, __m128i __B)
1215 {
1216   return (__m128i)__builtin_ia32_pcmpeqd128 ((__v4si)__A, (__v4si)__B);
1217 }
1218
1219 static __inline __m128i
1220 _mm_cmplt_epi8 (__m128i __A, __m128i __B)
1221 {
1222   return (__m128i)__builtin_ia32_pcmpgtb128 ((__v16qi)__B, (__v16qi)__A);
1223 }
1224
1225 static __inline __m128i
1226 _mm_cmplt_epi16 (__m128i __A, __m128i __B)
1227 {
1228   return (__m128i)__builtin_ia32_pcmpgtw128 ((__v8hi)__B, (__v8hi)__A);
1229 }
1230
1231 static __inline __m128i
1232 _mm_cmplt_epi32 (__m128i __A, __m128i __B)
1233 {
1234   return (__m128i)__builtin_ia32_pcmpgtd128 ((__v4si)__B, (__v4si)__A);
1235 }
1236
1237 static __inline __m128i
1238 _mm_cmpgt_epi8 (__m128i __A, __m128i __B)
1239 {
1240   return (__m128i)__builtin_ia32_pcmpgtb128 ((__v16qi)__A, (__v16qi)__B);
1241 }
1242
1243 static __inline __m128i
1244 _mm_cmpgt_epi16 (__m128i __A, __m128i __B)
1245 {
1246   return (__m128i)__builtin_ia32_pcmpgtw128 ((__v8hi)__A, (__v8hi)__B);
1247 }
1248
1249 static __inline __m128i
1250 _mm_cmpgt_epi32 (__m128i __A, __m128i __B)
1251 {
1252   return (__m128i)__builtin_ia32_pcmpgtd128 ((__v4si)__A, (__v4si)__B);
1253 }
1254
1255 #if 0
1256 static __inline int __attribute__((__always_inline__))
1257 _mm_extract_epi16 (__m128i const __A, int const __N)
1258 {
1259   return __builtin_ia32_vec_ext_v8hi ((__v8hi)__A, __N);
1260 }
1261
1262 static __inline __m128i __attribute__((__always_inline__))
1263 _mm_insert_epi16 (__m128i const __A, int const __D, int const __N)
1264 {
1265   return (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)__A, __D, __N);
1266 }
1267 #else
1268 #define _mm_extract_epi16(A, N) \
1269   ((int) __builtin_ia32_vec_ext_v8hi ((__v8hi)(A), (N))
1270 #define _mm_insert_epi16(A, D, N) \
1271   ((__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)(A), (D), (N)))
1272 #endif
1273
1274 static __inline __m128i
1275 _mm_max_epi16 (__m128i __A, __m128i __B)
1276 {
1277   return (__m128i)__builtin_ia32_pmaxsw128 ((__v8hi)__A, (__v8hi)__B);
1278 }
1279
1280 static __inline __m128i
1281 _mm_max_epu8 (__m128i __A, __m128i __B)
1282 {
1283   return (__m128i)__builtin_ia32_pmaxub128 ((__v16qi)__A, (__v16qi)__B);
1284 }
1285
1286 static __inline __m128i
1287 _mm_min_epi16 (__m128i __A, __m128i __B)
1288 {
1289   return (__m128i)__builtin_ia32_pminsw128 ((__v8hi)__A, (__v8hi)__B);
1290 }
1291
1292 static __inline __m128i
1293 _mm_min_epu8 (__m128i __A, __m128i __B)
1294 {
1295   return (__m128i)__builtin_ia32_pminub128 ((__v16qi)__A, (__v16qi)__B);
1296 }
1297
1298 static __inline int
1299 _mm_movemask_epi8 (__m128i __A)
1300 {
1301   return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
1302 }
1303
1304 static __inline __m128i
1305 _mm_mulhi_epu16 (__m128i __A, __m128i __B)
1306 {
1307   return (__m128i)__builtin_ia32_pmulhuw128 ((__v8hi)__A, (__v8hi)__B);
1308 }
1309
1310 #define _mm_shufflehi_epi16(__A, __B) ((__m128i)__builtin_ia32_pshufhw ((__v8hi)__A, __B))
1311 #define _mm_shufflelo_epi16(__A, __B) ((__m128i)__builtin_ia32_pshuflw ((__v8hi)__A, __B))
1312 #define _mm_shuffle_epi32(__A, __B) ((__m128i)__builtin_ia32_pshufd ((__v4si)__A, __B))
1313
1314 static __inline void
1315 _mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
1316 {
1317   __builtin_ia32_maskmovdqu ((__v16qi)__A, (__v16qi)__B, __C);
1318 }
1319
1320 static __inline __m128i
1321 _mm_avg_epu8 (__m128i __A, __m128i __B)
1322 {
1323   return (__m128i)__builtin_ia32_pavgb128 ((__v16qi)__A, (__v16qi)__B);
1324 }
1325
1326 static __inline __m128i
1327 _mm_avg_epu16 (__m128i __A, __m128i __B)
1328 {
1329   return (__m128i)__builtin_ia32_pavgw128 ((__v8hi)__A, (__v8hi)__B);
1330 }
1331
1332 static __inline __m128i
1333 _mm_sad_epu8 (__m128i __A, __m128i __B)
1334 {
1335   return (__m128i)__builtin_ia32_psadbw128 ((__v16qi)__A, (__v16qi)__B);
1336 }
1337
1338 static __inline void
1339 _mm_stream_si32 (int *__A, int __B)
1340 {
1341   __builtin_ia32_movnti (__A, __B);
1342 }
1343
1344 static __inline void
1345 _mm_stream_si128 (__m128i *__A, __m128i __B)
1346 {
1347   __builtin_ia32_movntdq ((__v2di *)__A, (__v2di)__B);
1348 }
1349
1350 static __inline void
1351 _mm_stream_pd (double *__A, __m128d __B)
1352 {
1353   __builtin_ia32_movntpd (__A, (__v2df)__B);
1354 }
1355
1356 static __inline void
1357 _mm_clflush (void const *__A)
1358 {
1359   return __builtin_ia32_clflush (__A);
1360 }
1361
1362 static __inline void
1363 _mm_lfence (void)
1364 {
1365   __builtin_ia32_lfence ();
1366 }
1367
1368 static __inline void
1369 _mm_mfence (void)
1370 {
1371   __builtin_ia32_mfence ();
1372 }
1373
1374 static __inline __m128i
1375 _mm_cvtsi32_si128 (int __A)
1376 {
1377   return _mm_set_epi32 (0, 0, 0, __A);
1378 }
1379
1380 #ifdef __x86_64__
1381 static __inline __m128i
1382 _mm_cvtsi64x_si128 (long long __A)
1383 {
1384   return _mm_set_epi64x (0, __A);
1385 }
1386 #endif
1387
1388 #endif /* __SSE2__  */
1389
1390 #endif /* _EMMINTRIN_H_INCLUDED */