contrib/gcc-5.0/gcc/config/i386/xmmintrin.h

   1 /* Copyright (C) 2002-2015 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 3, 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    Under Section 7 of GPL version 3, you are granted additional
  16    permissions described in the GCC Runtime Library Exception, version
  17    3.1, as published by the Free Software Foundation.
  18
  19    You should have received a copy of the GNU General Public License and
  20    a copy of the GCC Runtime Library Exception along with this program;
  21    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22    <http://www.gnu.org/licenses/>.  */
  23
  24 /* Implemented from the specification included in the Intel C++ Compiler
  25    User Guide and Reference, version 9.0.  */
  26
  27 #ifndef _XMMINTRIN_H_INCLUDED
  28 #define _XMMINTRIN_H_INCLUDED
  29
  30 /* We need type definitions from the MMX header file.  */
  31 #include <mmintrin.h>
  32
  33 /* Get _mm_malloc () and _mm_free ().  */
  34 #include <mm_malloc.h>
  35
  36 /* Constants for use with _mm_prefetch.  */
  37 enum _mm_hint
  38 {
  39   /* _MM_HINT_ET is _MM_HINT_T with set 3rd bit.  */
  40   _MM_HINT_ET0 = 7,
  41   _MM_HINT_ET1 = 6,
  42   _MM_HINT_T0 = 3,
  43   _MM_HINT_T1 = 2,
  44   _MM_HINT_T2 = 1,
  45   _MM_HINT_NTA = 0
  46 };
  47
  48 /* Loads one cache line from address P to a location "closer" to the
  49    processor.  The selector I specifies the type of prefetch operation.  */
  50 #ifdef __OPTIMIZE__
  51 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
  52 _mm_prefetch (const void *__P, enum _mm_hint __I)
  53 {
  54   __builtin_prefetch (__P, (__I & 0x4) >> 2, __I & 0x3);
  55 }
  56 #else
  57 #define _mm_prefetch(P, I) \
  58   __builtin_prefetch ((P), ((I & 0x4) >> 2), (I & 0x3))
  59 #endif
  60
  61 #ifndef __SSE__
  62 #pragma GCC push_options
  63 #pragma GCC target("sse")
  64 #define __DISABLE_SSE__
  65 #endif /* __SSE__ */
  66
  67 /* The Intel API is flexible enough that we must allow aliasing with other
  68    vector types, and their scalar components.  */
  69 typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
  70
  71 /* Internal data types for implementing the intrinsics.  */
  72 typedef float __v4sf __attribute__ ((__vector_size__ (16)));
  73
  74 /* Create a selector for use with the SHUFPS instruction.  */
  75 #define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \
  76  (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
  77
  78 /* Bits in the MXCSR.  */
  79 #define _MM_EXCEPT_MASK       0x003f
  80 #define _MM_EXCEPT_INVALID    0x0001
  81 #define _MM_EXCEPT_DENORM     0x0002
  82 #define _MM_EXCEPT_DIV_ZERO   0x0004
  83 #define _MM_EXCEPT_OVERFLOW   0x0008
  84 #define _MM_EXCEPT_UNDERFLOW  0x0010
  85 #define _MM_EXCEPT_INEXACT    0x0020
  86
  87 #define _MM_MASK_MASK         0x1f80
  88 #define _MM_MASK_INVALID      0x0080
  89 #define _MM_MASK_DENORM       0x0100
  90 #define _MM_MASK_DIV_ZERO     0x0200
  91 #define _MM_MASK_OVERFLOW     0x0400
  92 #define _MM_MASK_UNDERFLOW    0x0800
  93 #define _MM_MASK_INEXACT      0x1000
  94
  95 #define _MM_ROUND_MASK        0x6000
  96 #define _MM_ROUND_NEAREST     0x0000
  97 #define _MM_ROUND_DOWN        0x2000
  98 #define _MM_ROUND_UP          0x4000
  99 #define _MM_ROUND_TOWARD_ZERO 0x6000
 100
 101 #define _MM_FLUSH_ZERO_MASK   0x8000
 102 #define _MM_FLUSH_ZERO_ON     0x8000
 103 #define _MM_FLUSH_ZERO_OFF    0x0000
 104
 105 /* Create an undefined vector.  */
 106 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 107 _mm_undefined_ps (void)
 108 {
 109   __m128 __Y = __Y;
 110   return __Y;
 111 }
 112
 113 /* Create a vector of zeros.  */
 114 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 115 _mm_setzero_ps (void)
 116 {
 117   return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f };
 118 }
 119
 120 /* Perform the respective operation on the lower SPFP (single-precision
 121    floating-point) values of A and B; the upper three SPFP values are
 122    passed through from A.  */
 123
 124 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 125 _mm_add_ss (__m128 __A, __m128 __B)
 126 {
 127   return (__m128) __builtin_ia32_addss ((__v4sf)__A, (__v4sf)__B);
 128 }
 129
 130 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 131 _mm_sub_ss (__m128 __A, __m128 __B)
 132 {
 133   return (__m128) __builtin_ia32_subss ((__v4sf)__A, (__v4sf)__B);
 134 }
 135
 136 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 137 _mm_mul_ss (__m128 __A, __m128 __B)
 138 {
 139   return (__m128) __builtin_ia32_mulss ((__v4sf)__A, (__v4sf)__B);
 140 }
 141
 142 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 143 _mm_div_ss (__m128 __A, __m128 __B)
 144 {
 145   return (__m128) __builtin_ia32_divss ((__v4sf)__A, (__v4sf)__B);
 146 }
 147
 148 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 149 _mm_sqrt_ss (__m128 __A)
 150 {
 151   return (__m128) __builtin_ia32_sqrtss ((__v4sf)__A);
 152 }
 153
 154 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 155 _mm_rcp_ss (__m128 __A)
 156 {
 157   return (__m128) __builtin_ia32_rcpss ((__v4sf)__A);
 158 }
 159
 160 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 161 _mm_rsqrt_ss (__m128 __A)
 162 {
 163   return (__m128) __builtin_ia32_rsqrtss ((__v4sf)__A);
 164 }
 165
 166 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 167 _mm_min_ss (__m128 __A, __m128 __B)
 168 {
 169   return (__m128) __builtin_ia32_minss ((__v4sf)__A, (__v4sf)__B);
 170 }
 171
 172 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 173 _mm_max_ss (__m128 __A, __m128 __B)
 174 {
 175   return (__m128) __builtin_ia32_maxss ((__v4sf)__A, (__v4sf)__B);
 176 }
 177
 178 /* Perform the respective operation on the four SPFP values in A and B.  */
 179
 180 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 181 _mm_add_ps (__m128 __A, __m128 __B)
 182 {
 183   return (__m128) ((__v4sf)__A + (__v4sf)__B);
 184 }
 185
 186 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 187 _mm_sub_ps (__m128 __A, __m128 __B)
 188 {
 189   return (__m128) ((__v4sf)__A - (__v4sf)__B);
 190 }
 191
 192 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 193 _mm_mul_ps (__m128 __A, __m128 __B)
 194 {
 195   return (__m128) ((__v4sf)__A * (__v4sf)__B);
 196 }
 197
 198 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 199 _mm_div_ps (__m128 __A, __m128 __B)
 200 {
 201   return (__m128) ((__v4sf)__A / (__v4sf)__B);
 202 }
 203
 204 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 205 _mm_sqrt_ps (__m128 __A)
 206 {
 207   return (__m128) __builtin_ia32_sqrtps ((__v4sf)__A);
 208 }
 209
 210 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 211 _mm_rcp_ps (__m128 __A)
 212 {
 213   return (__m128) __builtin_ia32_rcpps ((__v4sf)__A);
 214 }
 215
 216 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 217 _mm_rsqrt_ps (__m128 __A)
 218 {
 219   return (__m128) __builtin_ia32_rsqrtps ((__v4sf)__A);
 220 }
 221
 222 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 223 _mm_min_ps (__m128 __A, __m128 __B)
 224 {
 225   return (__m128) __builtin_ia32_minps ((__v4sf)__A, (__v4sf)__B);
 226 }
 227
 228 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 229 _mm_max_ps (__m128 __A, __m128 __B)
 230 {
 231   return (__m128) __builtin_ia32_maxps ((__v4sf)__A, (__v4sf)__B);
 232 }
 233
 234 /* Perform logical bit-wise operations on 128-bit values.  */
 235
 236 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 237 _mm_and_ps (__m128 __A, __m128 __B)
 238 {
 239   return __builtin_ia32_andps (__A, __B);
 240 }
 241
 242 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 243 _mm_andnot_ps (__m128 __A, __m128 __B)
 244 {
 245   return __builtin_ia32_andnps (__A, __B);
 246 }
 247
 248 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 249 _mm_or_ps (__m128 __A, __m128 __B)
 250 {
 251   return __builtin_ia32_orps (__A, __B);
 252 }
 253
 254 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 255 _mm_xor_ps (__m128 __A, __m128 __B)
 256 {
 257   return __builtin_ia32_xorps (__A, __B);
 258 }
 259
 260 /* Perform a comparison on the lower SPFP values of A and B.  If the
 261    comparison is true, place a mask of all ones in the result, otherwise a
 262    mask of zeros.  The upper three SPFP values are passed through from A.  */
 263
 264 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 265 _mm_cmpeq_ss (__m128 __A, __m128 __B)
 266 {
 267   return (__m128) __builtin_ia32_cmpeqss ((__v4sf)__A, (__v4sf)__B);
 268 }
 269
 270 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 271 _mm_cmplt_ss (__m128 __A, __m128 __B)
 272 {
 273   return (__m128) __builtin_ia32_cmpltss ((__v4sf)__A, (__v4sf)__B);
 274 }
 275
 276 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 277 _mm_cmple_ss (__m128 __A, __m128 __B)
 278 {
 279   return (__m128) __builtin_ia32_cmpless ((__v4sf)__A, (__v4sf)__B);
 280 }
 281
 282 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 283 _mm_cmpgt_ss (__m128 __A, __m128 __B)
 284 {
 285   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 286                                         (__v4sf)
 287                                         __builtin_ia32_cmpltss ((__v4sf) __B,
 288                                                                 (__v4sf)
 289                                                                 __A));
 290 }
 291
 292 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 293 _mm_cmpge_ss (__m128 __A, __m128 __B)
 294 {
 295   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 296                                         (__v4sf)
 297                                         __builtin_ia32_cmpless ((__v4sf) __B,
 298                                                                 (__v4sf)
 299                                                                 __A));
 300 }
 301
 302 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 303 _mm_cmpneq_ss (__m128 __A, __m128 __B)
 304 {
 305   return (__m128) __builtin_ia32_cmpneqss ((__v4sf)__A, (__v4sf)__B);
 306 }
 307
 308 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 309 _mm_cmpnlt_ss (__m128 __A, __m128 __B)
 310 {
 311   return (__m128) __builtin_ia32_cmpnltss ((__v4sf)__A, (__v4sf)__B);
 312 }
 313
 314 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 315 _mm_cmpnle_ss (__m128 __A, __m128 __B)
 316 {
 317   return (__m128) __builtin_ia32_cmpnless ((__v4sf)__A, (__v4sf)__B);
 318 }
 319
 320 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 321 _mm_cmpngt_ss (__m128 __A, __m128 __B)
 322 {
 323   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 324                                         (__v4sf)
 325                                         __builtin_ia32_cmpnltss ((__v4sf) __B,
 326                                                                  (__v4sf)
 327                                                                  __A));
 328 }
 329
 330 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 331 _mm_cmpnge_ss (__m128 __A, __m128 __B)
 332 {
 333   return (__m128) __builtin_ia32_movss ((__v4sf) __A,
 334                                         (__v4sf)
 335                                         __builtin_ia32_cmpnless ((__v4sf) __B,
 336                                                                  (__v4sf)
 337                                                                  __A));
 338 }
 339
 340 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 341 _mm_cmpord_ss (__m128 __A, __m128 __B)
 342 {
 343   return (__m128) __builtin_ia32_cmpordss ((__v4sf)__A, (__v4sf)__B);
 344 }
 345
 346 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 347 _mm_cmpunord_ss (__m128 __A, __m128 __B)
 348 {
 349   return (__m128) __builtin_ia32_cmpunordss ((__v4sf)__A, (__v4sf)__B);
 350 }
 351
 352 /* Perform a comparison on the four SPFP values of A and B.  For each
 353    element, if the comparison is true, place a mask of all ones in the
 354    result, otherwise a mask of zeros.  */
 355
 356 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 357 _mm_cmpeq_ps (__m128 __A, __m128 __B)
 358 {
 359   return (__m128) __builtin_ia32_cmpeqps ((__v4sf)__A, (__v4sf)__B);
 360 }
 361
 362 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 363 _mm_cmplt_ps (__m128 __A, __m128 __B)
 364 {
 365   return (__m128) __builtin_ia32_cmpltps ((__v4sf)__A, (__v4sf)__B);
 366 }
 367
 368 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 369 _mm_cmple_ps (__m128 __A, __m128 __B)
 370 {
 371   return (__m128) __builtin_ia32_cmpleps ((__v4sf)__A, (__v4sf)__B);
 372 }
 373
 374 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 375 _mm_cmpgt_ps (__m128 __A, __m128 __B)
 376 {
 377   return (__m128) __builtin_ia32_cmpgtps ((__v4sf)__A, (__v4sf)__B);
 378 }
 379
 380 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 381 _mm_cmpge_ps (__m128 __A, __m128 __B)
 382 {
 383   return (__m128) __builtin_ia32_cmpgeps ((__v4sf)__A, (__v4sf)__B);
 384 }
 385
 386 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 387 _mm_cmpneq_ps (__m128 __A, __m128 __B)
 388 {
 389   return (__m128) __builtin_ia32_cmpneqps ((__v4sf)__A, (__v4sf)__B);
 390 }
 391
 392 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 393 _mm_cmpnlt_ps (__m128 __A, __m128 __B)
 394 {
 395   return (__m128) __builtin_ia32_cmpnltps ((__v4sf)__A, (__v4sf)__B);
 396 }
 397
 398 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 399 _mm_cmpnle_ps (__m128 __A, __m128 __B)
 400 {
 401   return (__m128) __builtin_ia32_cmpnleps ((__v4sf)__A, (__v4sf)__B);
 402 }
 403
 404 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 405 _mm_cmpngt_ps (__m128 __A, __m128 __B)
 406 {
 407   return (__m128) __builtin_ia32_cmpngtps ((__v4sf)__A, (__v4sf)__B);
 408 }
 409
 410 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 411 _mm_cmpnge_ps (__m128 __A, __m128 __B)
 412 {
 413   return (__m128) __builtin_ia32_cmpngeps ((__v4sf)__A, (__v4sf)__B);
 414 }
 415
 416 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 417 _mm_cmpord_ps (__m128 __A, __m128 __B)
 418 {
 419   return (__m128) __builtin_ia32_cmpordps ((__v4sf)__A, (__v4sf)__B);
 420 }
 421
 422 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 423 _mm_cmpunord_ps (__m128 __A, __m128 __B)
 424 {
 425   return (__m128) __builtin_ia32_cmpunordps ((__v4sf)__A, (__v4sf)__B);
 426 }
 427
 428 /* Compare the lower SPFP values of A and B and return 1 if true
 429    and 0 if false.  */
 430
 431 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 432 _mm_comieq_ss (__m128 __A, __m128 __B)
 433 {
 434   return __builtin_ia32_comieq ((__v4sf)__A, (__v4sf)__B);
 435 }
 436
 437 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 438 _mm_comilt_ss (__m128 __A, __m128 __B)
 439 {
 440   return __builtin_ia32_comilt ((__v4sf)__A, (__v4sf)__B);
 441 }
 442
 443 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 444 _mm_comile_ss (__m128 __A, __m128 __B)
 445 {
 446   return __builtin_ia32_comile ((__v4sf)__A, (__v4sf)__B);
 447 }
 448
 449 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 450 _mm_comigt_ss (__m128 __A, __m128 __B)
 451 {
 452   return __builtin_ia32_comigt ((__v4sf)__A, (__v4sf)__B);
 453 }
 454
 455 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 456 _mm_comige_ss (__m128 __A, __m128 __B)
 457 {
 458   return __builtin_ia32_comige ((__v4sf)__A, (__v4sf)__B);
 459 }
 460
 461 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 462 _mm_comineq_ss (__m128 __A, __m128 __B)
 463 {
 464   return __builtin_ia32_comineq ((__v4sf)__A, (__v4sf)__B);
 465 }
 466
 467 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 468 _mm_ucomieq_ss (__m128 __A, __m128 __B)
 469 {
 470   return __builtin_ia32_ucomieq ((__v4sf)__A, (__v4sf)__B);
 471 }
 472
 473 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 474 _mm_ucomilt_ss (__m128 __A, __m128 __B)
 475 {
 476   return __builtin_ia32_ucomilt ((__v4sf)__A, (__v4sf)__B);
 477 }
 478
 479 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 480 _mm_ucomile_ss (__m128 __A, __m128 __B)
 481 {
 482   return __builtin_ia32_ucomile ((__v4sf)__A, (__v4sf)__B);
 483 }
 484
 485 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 486 _mm_ucomigt_ss (__m128 __A, __m128 __B)
 487 {
 488   return __builtin_ia32_ucomigt ((__v4sf)__A, (__v4sf)__B);
 489 }
 490
 491 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 492 _mm_ucomige_ss (__m128 __A, __m128 __B)
 493 {
 494   return __builtin_ia32_ucomige ((__v4sf)__A, (__v4sf)__B);
 495 }
 496
 497 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 498 _mm_ucomineq_ss (__m128 __A, __m128 __B)
 499 {
 500   return __builtin_ia32_ucomineq ((__v4sf)__A, (__v4sf)__B);
 501 }
 502
 503 /* Convert the lower SPFP value to a 32-bit integer according to the current
 504    rounding mode.  */
 505 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 506 _mm_cvtss_si32 (__m128 __A)
 507 {
 508   return __builtin_ia32_cvtss2si ((__v4sf) __A);
 509 }
 510
 511 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 512 _mm_cvt_ss2si (__m128 __A)
 513 {
 514   return _mm_cvtss_si32 (__A);
 515 }
 516
 517 #ifdef __x86_64__
 518 /* Convert the lower SPFP value to a 32-bit integer according to the
 519    current rounding mode.  */
 520
 521 /* Intel intrinsic.  */
 522 extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 523 _mm_cvtss_si64 (__m128 __A)
 524 {
 525   return __builtin_ia32_cvtss2si64 ((__v4sf) __A);
 526 }
 527
 528 /* Microsoft intrinsic.  */
 529 extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 530 _mm_cvtss_si64x (__m128 __A)
 531 {
 532   return __builtin_ia32_cvtss2si64 ((__v4sf) __A);
 533 }
 534 #endif
 535
 536 /* Convert the two lower SPFP values to 32-bit integers according to the
 537    current rounding mode.  Return the integers in packed form.  */
 538 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 539 _mm_cvtps_pi32 (__m128 __A)
 540 {
 541   return (__m64) __builtin_ia32_cvtps2pi ((__v4sf) __A);
 542 }
 543
 544 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 545 _mm_cvt_ps2pi (__m128 __A)
 546 {
 547   return _mm_cvtps_pi32 (__A);
 548 }
 549
 550 /* Truncate the lower SPFP value to a 32-bit integer.  */
 551 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 552 _mm_cvttss_si32 (__m128 __A)
 553 {
 554   return __builtin_ia32_cvttss2si ((__v4sf) __A);
 555 }
 556
 557 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 558 _mm_cvtt_ss2si (__m128 __A)
 559 {
 560   return _mm_cvttss_si32 (__A);
 561 }
 562
 563 #ifdef __x86_64__
 564 /* Truncate the lower SPFP value to a 32-bit integer.  */
 565
 566 /* Intel intrinsic.  */
 567 extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 568 _mm_cvttss_si64 (__m128 __A)
 569 {
 570   return __builtin_ia32_cvttss2si64 ((__v4sf) __A);
 571 }
 572
 573 /* Microsoft intrinsic.  */
 574 extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 575 _mm_cvttss_si64x (__m128 __A)
 576 {
 577   return __builtin_ia32_cvttss2si64 ((__v4sf) __A);
 578 }
 579 #endif
 580
 581 /* Truncate the two lower SPFP values to 32-bit integers.  Return the
 582    integers in packed form.  */
 583 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 584 _mm_cvttps_pi32 (__m128 __A)
 585 {
 586   return (__m64) __builtin_ia32_cvttps2pi ((__v4sf) __A);
 587 }
 588
 589 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 590 _mm_cvtt_ps2pi (__m128 __A)
 591 {
 592   return _mm_cvttps_pi32 (__A);
 593 }
 594
 595 /* Convert B to a SPFP value and insert it as element zero in A.  */
 596 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 597 _mm_cvtsi32_ss (__m128 __A, int __B)
 598 {
 599   return (__m128) __builtin_ia32_cvtsi2ss ((__v4sf) __A, __B);
 600 }
 601
 602 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 603 _mm_cvt_si2ss (__m128 __A, int __B)
 604 {
 605   return _mm_cvtsi32_ss (__A, __B);
 606 }
 607
 608 #ifdef __x86_64__
 609 /* Convert B to a SPFP value and insert it as element zero in A.  */
 610
 611 /* Intel intrinsic.  */
 612 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 613 _mm_cvtsi64_ss (__m128 __A, long long __B)
 614 {
 615   return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
 616 }
 617
 618 /* Microsoft intrinsic.  */
 619 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 620 _mm_cvtsi64x_ss (__m128 __A, long long __B)
 621 {
 622   return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
 623 }
 624 #endif
 625
 626 /* Convert the two 32-bit values in B to SPFP form and insert them
 627    as the two lower elements in A.  */
 628 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 629 _mm_cvtpi32_ps (__m128 __A, __m64 __B)
 630 {
 631   return (__m128) __builtin_ia32_cvtpi2ps ((__v4sf) __A, (__v2si)__B);
 632 }
 633
 634 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 635 _mm_cvt_pi2ps (__m128 __A, __m64 __B)
 636 {
 637   return _mm_cvtpi32_ps (__A, __B);
 638 }
 639
 640 /* Convert the four signed 16-bit values in A to SPFP form.  */
 641 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 642 _mm_cvtpi16_ps (__m64 __A)
 643 {
 644   __v4hi __sign;
 645   __v2si __hisi, __losi;
 646   __v4sf __zero, __ra, __rb;
 647
 648   /* This comparison against zero gives us a mask that can be used to
 649      fill in the missing sign bits in the unpack operations below, so
 650      that we get signed values after unpacking.  */
 651   __sign = __builtin_ia32_pcmpgtw ((__v4hi)0LL, (__v4hi)__A);
 652
 653   /* Convert the four words to doublewords.  */
 654   __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, __sign);
 655   __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, __sign);
 656
 657   /* Convert the doublewords to floating point two at a time.  */
 658   __zero = (__v4sf) _mm_setzero_ps ();
 659   __ra = __builtin_ia32_cvtpi2ps (__zero, __losi);
 660   __rb = __builtin_ia32_cvtpi2ps (__ra, __hisi);
 661
 662   return (__m128) __builtin_ia32_movlhps (__ra, __rb);
 663 }
 664
 665 /* Convert the four unsigned 16-bit values in A to SPFP form.  */
 666 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 667 _mm_cvtpu16_ps (__m64 __A)
 668 {
 669   __v2si __hisi, __losi;
 670   __v4sf __zero, __ra, __rb;
 671
 672   /* Convert the four words to doublewords.  */
 673   __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, (__v4hi)0LL);
 674   __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, (__v4hi)0LL);
 675
 676   /* Convert the doublewords to floating point two at a time.  */
 677   __zero = (__v4sf) _mm_setzero_ps ();
 678   __ra = __builtin_ia32_cvtpi2ps (__zero, __losi);
 679   __rb = __builtin_ia32_cvtpi2ps (__ra, __hisi);
 680
 681   return (__m128) __builtin_ia32_movlhps (__ra, __rb);
 682 }
 683
 684 /* Convert the low four signed 8-bit values in A to SPFP form.  */
 685 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 686 _mm_cvtpi8_ps (__m64 __A)
 687 {
 688   __v8qi __sign;
 689
 690   /* This comparison against zero gives us a mask that can be used to
 691      fill in the missing sign bits in the unpack operations below, so
 692      that we get signed values after unpacking.  */
 693   __sign = __builtin_ia32_pcmpgtb ((__v8qi)0LL, (__v8qi)__A);
 694
 695   /* Convert the four low bytes to words.  */
 696   __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, __sign);
 697
 698   return _mm_cvtpi16_ps(__A);
 699 }
 700
 701 /* Convert the low four unsigned 8-bit values in A to SPFP form.  */
 702 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 703 _mm_cvtpu8_ps(__m64 __A)
 704 {
 705   __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, (__v8qi)0LL);
 706   return _mm_cvtpu16_ps(__A);
 707 }
 708
 709 /* Convert the four signed 32-bit values in A and B to SPFP form.  */
 710 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 711 _mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
 712 {
 713   __v4sf __zero = (__v4sf) _mm_setzero_ps ();
 714   __v4sf __sfa = __builtin_ia32_cvtpi2ps (__zero, (__v2si)__A);
 715   __v4sf __sfb = __builtin_ia32_cvtpi2ps (__sfa, (__v2si)__B);
 716   return (__m128) __builtin_ia32_movlhps (__sfa, __sfb);
 717 }
 718
 719 /* Convert the four SPFP values in A to four signed 16-bit integers.  */
 720 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 721 _mm_cvtps_pi16(__m128 __A)
 722 {
 723   __v4sf __hisf = (__v4sf)__A;
 724   __v4sf __losf = __builtin_ia32_movhlps (__hisf, __hisf);
 725   __v2si __hisi = __builtin_ia32_cvtps2pi (__hisf);
 726   __v2si __losi = __builtin_ia32_cvtps2pi (__losf);
 727   return (__m64) __builtin_ia32_packssdw (__hisi, __losi);
 728 }
 729
 730 /* Convert the four SPFP values in A to four signed 8-bit integers.  */
 731 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 732 _mm_cvtps_pi8(__m128 __A)
 733 {
 734   __v4hi __tmp = (__v4hi) _mm_cvtps_pi16 (__A);
 735   return (__m64) __builtin_ia32_packsswb (__tmp, (__v4hi)0LL);
 736 }
 737
 738 /* Selects four specific SPFP values from A and B based on MASK.  */
 739 #ifdef __OPTIMIZE__
 740 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 741 _mm_shuffle_ps (__m128 __A, __m128 __B, int const __mask)
 742 {
 743   return (__m128) __builtin_ia32_shufps ((__v4sf)__A, (__v4sf)__B, __mask);
 744 }
 745 #else
 746 #define _mm_shuffle_ps(A, B, MASK)                                      \
 747   ((__m128) __builtin_ia32_shufps ((__v4sf)(__m128)(A),                 \
 748                                    (__v4sf)(__m128)(B), (int)(MASK)))
 749 #endif
 750
 751 /* Selects and interleaves the upper two SPFP values from A and B.  */
 752 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 753 _mm_unpackhi_ps (__m128 __A, __m128 __B)
 754 {
 755   return (__m128) __builtin_ia32_unpckhps ((__v4sf)__A, (__v4sf)__B);
 756 }
 757
 758 /* Selects and interleaves the lower two SPFP values from A and B.  */
 759 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 760 _mm_unpacklo_ps (__m128 __A, __m128 __B)
 761 {
 762   return (__m128) __builtin_ia32_unpcklps ((__v4sf)__A, (__v4sf)__B);
 763 }
 764
 765 /* Sets the upper two SPFP values with 64-bits of data loaded from P;
 766    the lower two values are passed through from A.  */
 767 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 768 _mm_loadh_pi (__m128 __A, __m64 const *__P)
 769 {
 770   return (__m128) __builtin_ia32_loadhps ((__v4sf)__A, (const __v2sf *)__P);
 771 }
 772
 773 /* Stores the upper two SPFP values of A into P.  */
 774 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 775 _mm_storeh_pi (__m64 *__P, __m128 __A)
 776 {
 777   __builtin_ia32_storehps ((__v2sf *)__P, (__v4sf)__A);
 778 }
 779
 780 /* Moves the upper two values of B into the lower two values of A.  */
 781 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 782 _mm_movehl_ps (__m128 __A, __m128 __B)
 783 {
 784   return (__m128) __builtin_ia32_movhlps ((__v4sf)__A, (__v4sf)__B);
 785 }
 786
 787 /* Moves the lower two values of B into the upper two values of A.  */
 788 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 789 _mm_movelh_ps (__m128 __A, __m128 __B)
 790 {
 791   return (__m128) __builtin_ia32_movlhps ((__v4sf)__A, (__v4sf)__B);
 792 }
 793
 794 /* Sets the lower two SPFP values with 64-bits of data loaded from P;
 795    the upper two values are passed through from A.  */
 796 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 797 _mm_loadl_pi (__m128 __A, __m64 const *__P)
 798 {
 799   return (__m128) __builtin_ia32_loadlps ((__v4sf)__A, (const __v2sf *)__P);
 800 }
 801
 802 /* Stores the lower two SPFP values of A into P.  */
 803 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 804 _mm_storel_pi (__m64 *__P, __m128 __A)
 805 {
 806   __builtin_ia32_storelps ((__v2sf *)__P, (__v4sf)__A);
 807 }
 808
 809 /* Creates a 4-bit mask from the most significant bits of the SPFP values.  */
 810 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 811 _mm_movemask_ps (__m128 __A)
 812 {
 813   return __builtin_ia32_movmskps ((__v4sf)__A);
 814 }
 815
 816 /* Return the contents of the control register.  */
 817 extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 818 _mm_getcsr (void)
 819 {
 820   return __builtin_ia32_stmxcsr ();
 821 }
 822
 823 /* Read exception bits from the control register.  */
 824 extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 825 _MM_GET_EXCEPTION_STATE (void)
 826 {
 827   return _mm_getcsr() & _MM_EXCEPT_MASK;
 828 }
 829
 830 extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 831 _MM_GET_EXCEPTION_MASK (void)
 832 {
 833   return _mm_getcsr() & _MM_MASK_MASK;
 834 }
 835
 836 extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 837 _MM_GET_ROUNDING_MODE (void)
 838 {
 839   return _mm_getcsr() & _MM_ROUND_MASK;
 840 }
 841
 842 extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 843 _MM_GET_FLUSH_ZERO_MODE (void)
 844 {
 845   return _mm_getcsr() & _MM_FLUSH_ZERO_MASK;
 846 }
 847
 848 /* Set the control register to I.  */
 849 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 850 _mm_setcsr (unsigned int __I)
 851 {
 852   __builtin_ia32_ldmxcsr (__I);
 853 }
 854
 855 /* Set exception bits in the control register.  */
 856 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 857 _MM_SET_EXCEPTION_STATE(unsigned int __mask)
 858 {
 859   _mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | __mask);
 860 }
 861
 862 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 863 _MM_SET_EXCEPTION_MASK (unsigned int __mask)
 864 {
 865   _mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | __mask);
 866 }
 867
 868 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 869 _MM_SET_ROUNDING_MODE (unsigned int __mode)
 870 {
 871   _mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | __mode);
 872 }
 873
 874 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 875 _MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
 876 {
 877   _mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | __mode);
 878 }
 879
 880 /* Create a vector with element 0 as F and the rest zero.  */
 881 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 882 _mm_set_ss (float __F)
 883 {
 884   return __extension__ (__m128)(__v4sf){ __F, 0.0f, 0.0f, 0.0f };
 885 }
 886
 887 /* Create a vector with all four elements equal to F.  */
 888 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 889 _mm_set1_ps (float __F)
 890 {
 891   return __extension__ (__m128)(__v4sf){ __F, __F, __F, __F };
 892 }
 893
 894 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 895 _mm_set_ps1 (float __F)
 896 {
 897   return _mm_set1_ps (__F);
 898 }
 899
 900 /* Create a vector with element 0 as *P and the rest zero.  */
 901 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 902 _mm_load_ss (float const *__P)
 903 {
 904   return _mm_set_ss (*__P);
 905 }
 906
 907 /* Create a vector with all four elements equal to *P.  */
 908 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 909 _mm_load1_ps (float const *__P)
 910 {
 911   return _mm_set1_ps (*__P);
 912 }
 913
 914 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 915 _mm_load_ps1 (float const *__P)
 916 {
 917   return _mm_load1_ps (__P);
 918 }
 919
 920 /* Load four SPFP values from P.  The address must be 16-byte aligned.  */
 921 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 922 _mm_load_ps (float const *__P)
 923 {
 924   return (__m128) *(__v4sf *)__P;
 925 }
 926
 927 /* Load four SPFP values from P.  The address need not be 16-byte aligned.  */
 928 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 929 _mm_loadu_ps (float const *__P)
 930 {
 931   return (__m128) __builtin_ia32_loadups (__P);
 932 }
 933
 934 /* Load four SPFP values in reverse order.  The address must be aligned.  */
 935 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 936 _mm_loadr_ps (float const *__P)
 937 {
 938   __v4sf __tmp = *(__v4sf *)__P;
 939   return (__m128) __builtin_ia32_shufps (__tmp, __tmp, _MM_SHUFFLE (0,1,2,3));
 940 }
 941
 942 /* Create the vector [Z Y X W].  */
 943 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 944 _mm_set_ps (const float __Z, const float __Y, const float __X, const float __W)
 945 {
 946   return __extension__ (__m128)(__v4sf){ __W, __X, __Y, __Z };
 947 }
 948
 949 /* Create the vector [W X Y Z].  */
 950 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 951 _mm_setr_ps (float __Z, float __Y, float __X, float __W)
 952 {
 953   return __extension__ (__m128)(__v4sf){ __Z, __Y, __X, __W };
 954 }
 955
 956 /* Stores the lower SPFP value.  */
 957 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 958 _mm_store_ss (float *__P, __m128 __A)
 959 {
 960   *__P = ((__v4sf)__A)[0];
 961 }
 962
 963 extern __inline float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 964 _mm_cvtss_f32 (__m128 __A)
 965 {
 966   return ((__v4sf)__A)[0];
 967 }
 968
 969 /* Store four SPFP values.  The address must be 16-byte aligned.  */
 970 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 971 _mm_store_ps (float *__P, __m128 __A)
 972 {
 973   *(__v4sf *)__P = (__v4sf)__A;
 974 }
 975
 976 /* Store four SPFP values.  The address need not be 16-byte aligned.  */
 977 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 978 _mm_storeu_ps (float *__P, __m128 __A)
 979 {
 980   __builtin_ia32_storeups (__P, (__v4sf)__A);
 981 }
 982
 983 /* Store the lower SPFP value across four words.  */
 984 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 985 _mm_store1_ps (float *__P, __m128 __A)
 986 {
 987   __v4sf __va = (__v4sf)__A;
 988   __v4sf __tmp = __builtin_ia32_shufps (__va, __va, _MM_SHUFFLE (0,0,0,0));
 989   _mm_storeu_ps (__P, __tmp);
 990 }
 991
 992 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 993 _mm_store_ps1 (float *__P, __m128 __A)
 994 {
 995   _mm_store1_ps (__P, __A);
 996 }
 997
 998 /* Store four SPFP values in reverse order.  The address must be aligned.  */
 999 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1000 _mm_storer_ps (float *__P, __m128 __A)
1001 {
1002   __v4sf __va = (__v4sf)__A;
1003   __v4sf __tmp = __builtin_ia32_shufps (__va, __va, _MM_SHUFFLE (0,1,2,3));
1004   _mm_store_ps (__P, __tmp);
1005 }
1006
1007 /* Sets the low SPFP value of A from the low value of B.  */
1008 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1009 _mm_move_ss (__m128 __A, __m128 __B)
1010 {
1011   return (__m128) __builtin_ia32_movss ((__v4sf)__A, (__v4sf)__B);
1012 }
1013
1014 /* Extracts one of the four words of A.  The selector N must be immediate.  */
1015 #ifdef __OPTIMIZE__
1016 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1017 _mm_extract_pi16 (__m64 const __A, int const __N)
1018 {
1019   return __builtin_ia32_vec_ext_v4hi ((__v4hi)__A, __N);
1020 }
1021
1022 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1023 _m_pextrw (__m64 const __A, int const __N)
1024 {
1025   return _mm_extract_pi16 (__A, __N);
1026 }
1027 #else
1028 #define _mm_extract_pi16(A, N)  \
1029   ((int) __builtin_ia32_vec_ext_v4hi ((__v4hi)(__m64)(A), (int)(N)))
1030
1031 #define _m_pextrw(A, N) _mm_extract_pi16(A, N)
1032 #endif
1033
1034 /* Inserts word D into one of four words of A.  The selector N must be
1035    immediate.  */
1036 #ifdef __OPTIMIZE__
1037 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1038 _mm_insert_pi16 (__m64 const __A, int const __D, int const __N)
1039 {
1040   return (__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)__A, __D, __N);
1041 }
1042
1043 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1044 _m_pinsrw (__m64 const __A, int const __D, int const __N)
1045 {
1046   return _mm_insert_pi16 (__A, __D, __N);
1047 }
1048 #else
1049 #define _mm_insert_pi16(A, D, N)                                \
1050   ((__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)(__m64)(A),     \
1051                                         (int)(D), (int)(N)))
1052
1053 #define _m_pinsrw(A, D, N) _mm_insert_pi16(A, D, N)
1054 #endif
1055
1056 /* Compute the element-wise maximum of signed 16-bit values.  */
1057 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1058 _mm_max_pi16 (__m64 __A, __m64 __B)
1059 {
1060   return (__m64) __builtin_ia32_pmaxsw ((__v4hi)__A, (__v4hi)__B);
1061 }
1062
1063 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1064 _m_pmaxsw (__m64 __A, __m64 __B)
1065 {
1066   return _mm_max_pi16 (__A, __B);
1067 }
1068
1069 /* Compute the element-wise maximum of unsigned 8-bit values.  */
1070 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1071 _mm_max_pu8 (__m64 __A, __m64 __B)
1072 {
1073   return (__m64) __builtin_ia32_pmaxub ((__v8qi)__A, (__v8qi)__B);
1074 }
1075
1076 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1077 _m_pmaxub (__m64 __A, __m64 __B)
1078 {
1079   return _mm_max_pu8 (__A, __B);
1080 }
1081
1082 /* Compute the element-wise minimum of signed 16-bit values.  */
1083 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1084 _mm_min_pi16 (__m64 __A, __m64 __B)
1085 {
1086   return (__m64) __builtin_ia32_pminsw ((__v4hi)__A, (__v4hi)__B);
1087 }
1088
1089 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1090 _m_pminsw (__m64 __A, __m64 __B)
1091 {
1092   return _mm_min_pi16 (__A, __B);
1093 }
1094
1095 /* Compute the element-wise minimum of unsigned 8-bit values.  */
1096 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1097 _mm_min_pu8 (__m64 __A, __m64 __B)
1098 {
1099   return (__m64) __builtin_ia32_pminub ((__v8qi)__A, (__v8qi)__B);
1100 }
1101
1102 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1103 _m_pminub (__m64 __A, __m64 __B)
1104 {
1105   return _mm_min_pu8 (__A, __B);
1106 }
1107
1108 /* Create an 8-bit mask of the signs of 8-bit values.  */
1109 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1110 _mm_movemask_pi8 (__m64 __A)
1111 {
1112   return __builtin_ia32_pmovmskb ((__v8qi)__A);
1113 }
1114
1115 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1116 _m_pmovmskb (__m64 __A)
1117 {
1118   return _mm_movemask_pi8 (__A);
1119 }
1120
1121 /* Multiply four unsigned 16-bit values in A by four unsigned 16-bit values
1122    in B and produce the high 16 bits of the 32-bit results.  */
1123 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1124 _mm_mulhi_pu16 (__m64 __A, __m64 __B)
1125 {
1126   return (__m64) __builtin_ia32_pmulhuw ((__v4hi)__A, (__v4hi)__B);
1127 }
1128
1129 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1130 _m_pmulhuw (__m64 __A, __m64 __B)
1131 {
1132   return _mm_mulhi_pu16 (__A, __B);
1133 }
1134
1135 /* Return a combination of the four 16-bit values in A.  The selector
1136    must be an immediate.  */
1137 #ifdef __OPTIMIZE__
1138 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1139 _mm_shuffle_pi16 (__m64 __A, int const __N)
1140 {
1141   return (__m64) __builtin_ia32_pshufw ((__v4hi)__A, __N);
1142 }
1143
1144 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1145 _m_pshufw (__m64 __A, int const __N)
1146 {
1147   return _mm_shuffle_pi16 (__A, __N);
1148 }
1149 #else
1150 #define _mm_shuffle_pi16(A, N) \
1151   ((__m64) __builtin_ia32_pshufw ((__v4hi)(__m64)(A), (int)(N)))
1152
1153 #define _m_pshufw(A, N) _mm_shuffle_pi16 (A, N)
1154 #endif
1155
1156 /* Conditionally store byte elements of A into P.  The high bit of each
1157    byte in the selector N determines whether the corresponding byte from
1158    A is stored.  */
1159 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1160 _mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
1161 {
1162   __builtin_ia32_maskmovq ((__v8qi)__A, (__v8qi)__N, __P);
1163 }
1164
1165 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1166 _m_maskmovq (__m64 __A, __m64 __N, char *__P)
1167 {
1168   _mm_maskmove_si64 (__A, __N, __P);
1169 }
1170
1171 /* Compute the rounded averages of the unsigned 8-bit values in A and B.  */
1172 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1173 _mm_avg_pu8 (__m64 __A, __m64 __B)
1174 {
1175   return (__m64) __builtin_ia32_pavgb ((__v8qi)__A, (__v8qi)__B);
1176 }
1177
1178 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1179 _m_pavgb (__m64 __A, __m64 __B)
1180 {
1181   return _mm_avg_pu8 (__A, __B);
1182 }
1183
1184 /* Compute the rounded averages of the unsigned 16-bit values in A and B.  */
1185 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1186 _mm_avg_pu16 (__m64 __A, __m64 __B)
1187 {
1188   return (__m64) __builtin_ia32_pavgw ((__v4hi)__A, (__v4hi)__B);
1189 }
1190
1191 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1192 _m_pavgw (__m64 __A, __m64 __B)
1193 {
1194   return _mm_avg_pu16 (__A, __B);
1195 }
1196
1197 /* Compute the sum of the absolute differences of the unsigned 8-bit
1198    values in A and B.  Return the value in the lower 16-bit word; the
1199    upper words are cleared.  */
1200 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1201 _mm_sad_pu8 (__m64 __A, __m64 __B)
1202 {
1203   return (__m64) __builtin_ia32_psadbw ((__v8qi)__A, (__v8qi)__B);
1204 }
1205
1206 extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1207 _m_psadbw (__m64 __A, __m64 __B)
1208 {
1209   return _mm_sad_pu8 (__A, __B);
1210 }
1211
1212 /* Stores the data in A to the address P without polluting the caches.  */
1213 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1214 _mm_stream_pi (__m64 *__P, __m64 __A)
1215 {
1216   __builtin_ia32_movntq ((unsigned long long *)__P, (unsigned long long)__A);
1217 }
1218
1219 /* Likewise.  The address must be 16-byte aligned.  */
1220 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1221 _mm_stream_ps (float *__P, __m128 __A)
1222 {
1223   __builtin_ia32_movntps (__P, (__v4sf)__A);
1224 }
1225
1226 /* Guarantees that every preceding store is globally visible before
1227    any subsequent store.  */
1228 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1229 _mm_sfence (void)
1230 {
1231   __builtin_ia32_sfence ();
1232 }
1233
1234 /* Transpose the 4x4 matrix composed of row[0-3].  */
1235 #define _MM_TRANSPOSE4_PS(row0, row1, row2, row3)                       \
1236 do {                                                                    \
1237   __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3);    \
1238   __v4sf __t0 = __builtin_ia32_unpcklps (__r0, __r1);                   \
1239   __v4sf __t1 = __builtin_ia32_unpcklps (__r2, __r3);                   \
1240   __v4sf __t2 = __builtin_ia32_unpckhps (__r0, __r1);                   \
1241   __v4sf __t3 = __builtin_ia32_unpckhps (__r2, __r3);                   \
1242   (row0) = __builtin_ia32_movlhps (__t0, __t1);                         \
1243   (row1) = __builtin_ia32_movhlps (__t1, __t0);                         \
1244   (row2) = __builtin_ia32_movlhps (__t2, __t3);                         \
1245   (row3) = __builtin_ia32_movhlps (__t3, __t2);                         \
1246 } while (0)
1247
1248 /* For backward source compatibility.  */
1249 # include <emmintrin.h>
1250
1251 #ifdef __DISABLE_SSE__
1252 #undef __DISABLE_SSE__
1253 #pragma GCC pop_options
1254 #endif /* __DISABLE_SSE__ */
1255
1256 /* The execution of the next instruction is delayed by an implementation
1257    specific amount of time.  The instruction does not modify the
1258    architectural state.  This is after the pop_options pragma because
1259    it does not require SSE support in the processor--the encoding is a
1260    nop on processors that do not support it.  */
1261 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1262 _mm_pause (void)
1263 {
1264   __builtin_ia32_pause ();
1265 }
1266
1267 #endif /* _XMMINTRIN_H_INCLUDED */