1 /*===---- smmintrin.h - SSE4 intrinsics ------------------------------------=== 2 * 3 * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 * See https://llvm.org/LICENSE.txt for license information. 5 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 * 7 *===-----------------------------------------------------------------------=== 8 */ 9 10 #ifndef __SMMINTRIN_H 11 #define __SMMINTRIN_H 12 13 #if !defined(__i386__) && !defined(__x86_64__) 14 #error "This header is only meant to be used on x86 and x64 architecture" 15 #endif 16 17 #include <tmmintrin.h> 18 19 /* Define the default attributes for the functions in this file. */ 20 #define __DEFAULT_FN_ATTRS \ 21 __attribute__((__always_inline__, __nodebug__, __target__("sse4.1"), \ 22 __min_vector_width__(128))) 23 24 /* SSE4 Rounding macros. */ 25 #define _MM_FROUND_TO_NEAREST_INT 0x00 26 #define _MM_FROUND_TO_NEG_INF 0x01 27 #define _MM_FROUND_TO_POS_INF 0x02 28 #define _MM_FROUND_TO_ZERO 0x03 29 #define _MM_FROUND_CUR_DIRECTION 0x04 30 31 #define _MM_FROUND_RAISE_EXC 0x00 32 #define _MM_FROUND_NO_EXC 0x08 33 34 #define _MM_FROUND_NINT (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_NEAREST_INT) 35 #define _MM_FROUND_FLOOR (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_NEG_INF) 36 #define _MM_FROUND_CEIL (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_POS_INF) 37 #define _MM_FROUND_TRUNC (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_ZERO) 38 #define _MM_FROUND_RINT (_MM_FROUND_RAISE_EXC | _MM_FROUND_CUR_DIRECTION) 39 #define _MM_FROUND_NEARBYINT (_MM_FROUND_NO_EXC | _MM_FROUND_CUR_DIRECTION) 40 41 /// Rounds up each element of the 128-bit vector of [4 x float] to an 42 /// integer and returns the rounded values in a 128-bit vector of 43 /// [4 x float]. 44 /// 45 /// \headerfile <x86intrin.h> 46 /// 47 /// \code 48 /// __m128 _mm_ceil_ps(__m128 X); 49 /// \endcode 50 /// 51 /// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction. 52 /// 53 /// \param X 54 /// A 128-bit vector of [4 x float] values to be rounded up. 55 /// \returns A 128-bit vector of [4 x float] containing the rounded values. 56 #define _mm_ceil_ps(X) _mm_round_ps((X), _MM_FROUND_CEIL) 57 58 /// Rounds up each element of the 128-bit vector of [2 x double] to an 59 /// integer and returns the rounded values in a 128-bit vector of 60 /// [2 x double]. 61 /// 62 /// \headerfile <x86intrin.h> 63 /// 64 /// \code 65 /// __m128d _mm_ceil_pd(__m128d X); 66 /// \endcode 67 /// 68 /// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction. 69 /// 70 /// \param X 71 /// A 128-bit vector of [2 x double] values to be rounded up. 72 /// \returns A 128-bit vector of [2 x double] containing the rounded values. 73 #define _mm_ceil_pd(X) _mm_round_pd((X), _MM_FROUND_CEIL) 74 75 /// Copies three upper elements of the first 128-bit vector operand to 76 /// the corresponding three upper elements of the 128-bit result vector of 77 /// [4 x float]. Rounds up the lowest element of the second 128-bit vector 78 /// operand to an integer and copies it to the lowest element of the 128-bit 79 /// result vector of [4 x float]. 80 /// 81 /// \headerfile <x86intrin.h> 82 /// 83 /// \code 84 /// __m128 _mm_ceil_ss(__m128 X, __m128 Y); 85 /// \endcode 86 /// 87 /// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction. 88 /// 89 /// \param X 90 /// A 128-bit vector of [4 x float]. The values stored in bits [127:32] are 91 /// copied to the corresponding bits of the result. 92 /// \param Y 93 /// A 128-bit vector of [4 x float]. The value stored in bits [31:0] is 94 /// rounded up to the nearest integer and copied to the corresponding bits 95 /// of the result. 96 /// \returns A 128-bit vector of [4 x float] containing the copied and rounded 97 /// values. 98 #define _mm_ceil_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_CEIL) 99 100 /// Copies the upper element of the first 128-bit vector operand to the 101 /// corresponding upper element of the 128-bit result vector of [2 x double]. 102 /// Rounds up the lower element of the second 128-bit vector operand to an 103 /// integer and copies it to the lower element of the 128-bit result vector 104 /// of [2 x double]. 105 /// 106 /// \headerfile <x86intrin.h> 107 /// 108 /// \code 109 /// __m128d _mm_ceil_sd(__m128d X, __m128d Y); 110 /// \endcode 111 /// 112 /// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction. 113 /// 114 /// \param X 115 /// A 128-bit vector of [2 x double]. The value stored in bits [127:64] is 116 /// copied to the corresponding bits of the result. 117 /// \param Y 118 /// A 128-bit vector of [2 x double]. The value stored in bits [63:0] is 119 /// rounded up to the nearest integer and copied to the corresponding bits 120 /// of the result. 121 /// \returns A 128-bit vector of [2 x double] containing the copied and rounded 122 /// values. 123 #define _mm_ceil_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_CEIL) 124 125 /// Rounds down each element of the 128-bit vector of [4 x float] to an 126 /// an integer and returns the rounded values in a 128-bit vector of 127 /// [4 x float]. 128 /// 129 /// \headerfile <x86intrin.h> 130 /// 131 /// \code 132 /// __m128 _mm_floor_ps(__m128 X); 133 /// \endcode 134 /// 135 /// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction. 136 /// 137 /// \param X 138 /// A 128-bit vector of [4 x float] values to be rounded down. 139 /// \returns A 128-bit vector of [4 x float] containing the rounded values. 140 #define _mm_floor_ps(X) _mm_round_ps((X), _MM_FROUND_FLOOR) 141 142 /// Rounds down each element of the 128-bit vector of [2 x double] to an 143 /// integer and returns the rounded values in a 128-bit vector of 144 /// [2 x double]. 145 /// 146 /// \headerfile <x86intrin.h> 147 /// 148 /// \code 149 /// __m128d _mm_floor_pd(__m128d X); 150 /// \endcode 151 /// 152 /// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction. 153 /// 154 /// \param X 155 /// A 128-bit vector of [2 x double]. 156 /// \returns A 128-bit vector of [2 x double] containing the rounded values. 157 #define _mm_floor_pd(X) _mm_round_pd((X), _MM_FROUND_FLOOR) 158 159 /// Copies three upper elements of the first 128-bit vector operand to 160 /// the corresponding three upper elements of the 128-bit result vector of 161 /// [4 x float]. Rounds down the lowest element of the second 128-bit vector 162 /// operand to an integer and copies it to the lowest element of the 128-bit 163 /// result vector of [4 x float]. 164 /// 165 /// \headerfile <x86intrin.h> 166 /// 167 /// \code 168 /// __m128 _mm_floor_ss(__m128 X, __m128 Y); 169 /// \endcode 170 /// 171 /// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction. 172 /// 173 /// \param X 174 /// A 128-bit vector of [4 x float]. The values stored in bits [127:32] are 175 /// copied to the corresponding bits of the result. 176 /// \param Y 177 /// A 128-bit vector of [4 x float]. The value stored in bits [31:0] is 178 /// rounded down to the nearest integer and copied to the corresponding bits 179 /// of the result. 180 /// \returns A 128-bit vector of [4 x float] containing the copied and rounded 181 /// values. 182 #define _mm_floor_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_FLOOR) 183 184 /// Copies the upper element of the first 128-bit vector operand to the 185 /// corresponding upper element of the 128-bit result vector of [2 x double]. 186 /// Rounds down the lower element of the second 128-bit vector operand to an 187 /// integer and copies it to the lower element of the 128-bit result vector 188 /// of [2 x double]. 189 /// 190 /// \headerfile <x86intrin.h> 191 /// 192 /// \code 193 /// __m128d _mm_floor_sd(__m128d X, __m128d Y); 194 /// \endcode 195 /// 196 /// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction. 197 /// 198 /// \param X 199 /// A 128-bit vector of [2 x double]. The value stored in bits [127:64] is 200 /// copied to the corresponding bits of the result. 201 /// \param Y 202 /// A 128-bit vector of [2 x double]. The value stored in bits [63:0] is 203 /// rounded down to the nearest integer and copied to the corresponding bits 204 /// of the result. 205 /// \returns A 128-bit vector of [2 x double] containing the copied and rounded 206 /// values. 207 #define _mm_floor_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_FLOOR) 208 209 /// Rounds each element of the 128-bit vector of [4 x float] to an 210 /// integer value according to the rounding control specified by the second 211 /// argument and returns the rounded values in a 128-bit vector of 212 /// [4 x float]. 213 /// 214 /// \headerfile <x86intrin.h> 215 /// 216 /// \code 217 /// __m128 _mm_round_ps(__m128 X, const int M); 218 /// \endcode 219 /// 220 /// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction. 221 /// 222 /// \param X 223 /// A 128-bit vector of [4 x float]. 224 /// \param M 225 /// An integer value that specifies the rounding operation. \n 226 /// Bits [7:4] are reserved. \n 227 /// Bit [3] is a precision exception value: \n 228 /// 0: A normal PE exception is used \n 229 /// 1: The PE field is not updated \n 230 /// Bit [2] is the rounding control source: \n 231 /// 0: Use bits [1:0] of \a M \n 232 /// 1: Use the current MXCSR setting \n 233 /// Bits [1:0] contain the rounding control definition: \n 234 /// 00: Nearest \n 235 /// 01: Downward (toward negative infinity) \n 236 /// 10: Upward (toward positive infinity) \n 237 /// 11: Truncated 238 /// \returns A 128-bit vector of [4 x float] containing the rounded values. 239 #define _mm_round_ps(X, M) \ 240 ((__m128)__builtin_ia32_roundps((__v4sf)(__m128)(X), (M))) 241 242 /// Copies three upper elements of the first 128-bit vector operand to 243 /// the corresponding three upper elements of the 128-bit result vector of 244 /// [4 x float]. Rounds the lowest element of the second 128-bit vector 245 /// operand to an integer value according to the rounding control specified 246 /// by the third argument and copies it to the lowest element of the 128-bit 247 /// result vector of [4 x float]. 248 /// 249 /// \headerfile <x86intrin.h> 250 /// 251 /// \code 252 /// __m128 _mm_round_ss(__m128 X, __m128 Y, const int M); 253 /// \endcode 254 /// 255 /// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction. 256 /// 257 /// \param X 258 /// A 128-bit vector of [4 x float]. The values stored in bits [127:32] are 259 /// copied to the corresponding bits of the result. 260 /// \param Y 261 /// A 128-bit vector of [4 x float]. The value stored in bits [31:0] is 262 /// rounded to the nearest integer using the specified rounding control and 263 /// copied to the corresponding bits of the result. 264 /// \param M 265 /// An integer value that specifies the rounding operation. \n 266 /// Bits [7:4] are reserved. \n 267 /// Bit [3] is a precision exception value: \n 268 /// 0: A normal PE exception is used \n 269 /// 1: The PE field is not updated \n 270 /// Bit [2] is the rounding control source: \n 271 /// 0: Use bits [1:0] of \a M \n 272 /// 1: Use the current MXCSR setting \n 273 /// Bits [1:0] contain the rounding control definition: \n 274 /// 00: Nearest \n 275 /// 01: Downward (toward negative infinity) \n 276 /// 10: Upward (toward positive infinity) \n 277 /// 11: Truncated 278 /// \returns A 128-bit vector of [4 x float] containing the copied and rounded 279 /// values. 280 #define _mm_round_ss(X, Y, M) \ 281 ((__m128)__builtin_ia32_roundss((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), \ 282 (M))) 283 284 /// Rounds each element of the 128-bit vector of [2 x double] to an 285 /// integer value according to the rounding control specified by the second 286 /// argument and returns the rounded values in a 128-bit vector of 287 /// [2 x double]. 288 /// 289 /// \headerfile <x86intrin.h> 290 /// 291 /// \code 292 /// __m128d _mm_round_pd(__m128d X, const int M); 293 /// \endcode 294 /// 295 /// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction. 296 /// 297 /// \param X 298 /// A 128-bit vector of [2 x double]. 299 /// \param M 300 /// An integer value that specifies the rounding operation. \n 301 /// Bits [7:4] are reserved. \n 302 /// Bit [3] is a precision exception value: \n 303 /// 0: A normal PE exception is used \n 304 /// 1: The PE field is not updated \n 305 /// Bit [2] is the rounding control source: \n 306 /// 0: Use bits [1:0] of \a M \n 307 /// 1: Use the current MXCSR setting \n 308 /// Bits [1:0] contain the rounding control definition: \n 309 /// 00: Nearest \n 310 /// 01: Downward (toward negative infinity) \n 311 /// 10: Upward (toward positive infinity) \n 312 /// 11: Truncated 313 /// \returns A 128-bit vector of [2 x double] containing the rounded values. 314 #define _mm_round_pd(X, M) \ 315 ((__m128d)__builtin_ia32_roundpd((__v2df)(__m128d)(X), (M))) 316 317 /// Copies the upper element of the first 128-bit vector operand to the 318 /// corresponding upper element of the 128-bit result vector of [2 x double]. 319 /// Rounds the lower element of the second 128-bit vector operand to an 320 /// integer value according to the rounding control specified by the third 321 /// argument and copies it to the lower element of the 128-bit result vector 322 /// of [2 x double]. 323 /// 324 /// \headerfile <x86intrin.h> 325 /// 326 /// \code 327 /// __m128d _mm_round_sd(__m128d X, __m128d Y, const int M); 328 /// \endcode 329 /// 330 /// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction. 331 /// 332 /// \param X 333 /// A 128-bit vector of [2 x double]. The value stored in bits [127:64] is 334 /// copied to the corresponding bits of the result. 335 /// \param Y 336 /// A 128-bit vector of [2 x double]. The value stored in bits [63:0] is 337 /// rounded to the nearest integer using the specified rounding control and 338 /// copied to the corresponding bits of the result. 339 /// \param M 340 /// An integer value that specifies the rounding operation. \n 341 /// Bits [7:4] are reserved. \n 342 /// Bit [3] is a precision exception value: \n 343 /// 0: A normal PE exception is used \n 344 /// 1: The PE field is not updated \n 345 /// Bit [2] is the rounding control source: \n 346 /// 0: Use bits [1:0] of \a M \n 347 /// 1: Use the current MXCSR setting \n 348 /// Bits [1:0] contain the rounding control definition: \n 349 /// 00: Nearest \n 350 /// 01: Downward (toward negative infinity) \n 351 /// 10: Upward (toward positive infinity) \n 352 /// 11: Truncated 353 /// \returns A 128-bit vector of [2 x double] containing the copied and rounded 354 /// values. 355 #define _mm_round_sd(X, Y, M) \ 356 ((__m128d)__builtin_ia32_roundsd((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), \ 357 (M))) 358 359 /* SSE4 Packed Blending Intrinsics. */ 360 /// Returns a 128-bit vector of [2 x double] where the values are 361 /// selected from either the first or second operand as specified by the 362 /// third operand, the control mask. 363 /// 364 /// \headerfile <x86intrin.h> 365 /// 366 /// \code 367 /// __m128d _mm_blend_pd(__m128d V1, __m128d V2, const int M); 368 /// \endcode 369 /// 370 /// This intrinsic corresponds to the <c> VBLENDPD / BLENDPD </c> instruction. 371 /// 372 /// \param V1 373 /// A 128-bit vector of [2 x double]. 374 /// \param V2 375 /// A 128-bit vector of [2 x double]. 376 /// \param M 377 /// An immediate integer operand, with mask bits [1:0] specifying how the 378 /// values are to be copied. The position of the mask bit corresponds to the 379 /// index of a copied value. When a mask bit is 0, the corresponding 64-bit 380 /// element in operand \a V1 is copied to the same position in the result. 381 /// When a mask bit is 1, the corresponding 64-bit element in operand \a V2 382 /// is copied to the same position in the result. 383 /// \returns A 128-bit vector of [2 x double] containing the copied values. 384 #define _mm_blend_pd(V1, V2, M) \ 385 ((__m128d)__builtin_ia32_blendpd((__v2df)(__m128d)(V1), \ 386 (__v2df)(__m128d)(V2), (int)(M))) 387 388 /// Returns a 128-bit vector of [4 x float] where the values are selected 389 /// from either the first or second operand as specified by the third 390 /// operand, the control mask. 391 /// 392 /// \headerfile <x86intrin.h> 393 /// 394 /// \code 395 /// __m128 _mm_blend_ps(__m128 V1, __m128 V2, const int M); 396 /// \endcode 397 /// 398 /// This intrinsic corresponds to the <c> VBLENDPS / BLENDPS </c> instruction. 399 /// 400 /// \param V1 401 /// A 128-bit vector of [4 x float]. 402 /// \param V2 403 /// A 128-bit vector of [4 x float]. 404 /// \param M 405 /// An immediate integer operand, with mask bits [3:0] specifying how the 406 /// values are to be copied. The position of the mask bit corresponds to the 407 /// index of a copied value. When a mask bit is 0, the corresponding 32-bit 408 /// element in operand \a V1 is copied to the same position in the result. 409 /// When a mask bit is 1, the corresponding 32-bit element in operand \a V2 410 /// is copied to the same position in the result. 411 /// \returns A 128-bit vector of [4 x float] containing the copied values. 412 #define _mm_blend_ps(V1, V2, M) \ 413 ((__m128)__builtin_ia32_blendps((__v4sf)(__m128)(V1), (__v4sf)(__m128)(V2), \ 414 (int)(M))) 415 416 /// Returns a 128-bit vector of [2 x double] where the values are 417 /// selected from either the first or second operand as specified by the 418 /// third operand, the control mask. 419 /// 420 /// \headerfile <x86intrin.h> 421 /// 422 /// This intrinsic corresponds to the <c> VBLENDVPD / BLENDVPD </c> instruction. 423 /// 424 /// \param __V1 425 /// A 128-bit vector of [2 x double]. 426 /// \param __V2 427 /// A 128-bit vector of [2 x double]. 428 /// \param __M 429 /// A 128-bit vector operand, with mask bits 127 and 63 specifying how the 430 /// values are to be copied. The position of the mask bit corresponds to the 431 /// most significant bit of a copied value. When a mask bit is 0, the 432 /// corresponding 64-bit element in operand \a __V1 is copied to the same 433 /// position in the result. When a mask bit is 1, the corresponding 64-bit 434 /// element in operand \a __V2 is copied to the same position in the result. 435 /// \returns A 128-bit vector of [2 x double] containing the copied values. 436 static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_blendv_pd(__m128d __V1, 437 __m128d __V2, 438 __m128d __M) { 439 return (__m128d)__builtin_ia32_blendvpd((__v2df)__V1, (__v2df)__V2, 440 (__v2df)__M); 441 } 442 443 /// Returns a 128-bit vector of [4 x float] where the values are 444 /// selected from either the first or second operand as specified by the 445 /// third operand, the control mask. 446 /// 447 /// \headerfile <x86intrin.h> 448 /// 449 /// This intrinsic corresponds to the <c> VBLENDVPS / BLENDVPS </c> instruction. 450 /// 451 /// \param __V1 452 /// A 128-bit vector of [4 x float]. 453 /// \param __V2 454 /// A 128-bit vector of [4 x float]. 455 /// \param __M 456 /// A 128-bit vector operand, with mask bits 127, 95, 63, and 31 specifying 457 /// how the values are to be copied. The position of the mask bit corresponds 458 /// to the most significant bit of a copied value. When a mask bit is 0, the 459 /// corresponding 32-bit element in operand \a __V1 is copied to the same 460 /// position in the result. When a mask bit is 1, the corresponding 32-bit 461 /// element in operand \a __V2 is copied to the same position in the result. 462 /// \returns A 128-bit vector of [4 x float] containing the copied values. 463 static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_blendv_ps(__m128 __V1, 464 __m128 __V2, 465 __m128 __M) { 466 return (__m128)__builtin_ia32_blendvps((__v4sf)__V1, (__v4sf)__V2, 467 (__v4sf)__M); 468 } 469 470 /// Returns a 128-bit vector of [16 x i8] where the values are selected 471 /// from either of the first or second operand as specified by the third 472 /// operand, the control mask. 473 /// 474 /// \headerfile <x86intrin.h> 475 /// 476 /// This intrinsic corresponds to the <c> VPBLENDVB / PBLENDVB </c> instruction. 477 /// 478 /// \param __V1 479 /// A 128-bit vector of [16 x i8]. 480 /// \param __V2 481 /// A 128-bit vector of [16 x i8]. 482 /// \param __M 483 /// A 128-bit vector operand, with mask bits 127, 119, 111...7 specifying 484 /// how the values are to be copied. The position of the mask bit corresponds 485 /// to the most significant bit of a copied value. When a mask bit is 0, the 486 /// corresponding 8-bit element in operand \a __V1 is copied to the same 487 /// position in the result. When a mask bit is 1, the corresponding 8-bit 488 /// element in operand \a __V2 is copied to the same position in the result. 489 /// \returns A 128-bit vector of [16 x i8] containing the copied values. 490 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_blendv_epi8(__m128i __V1, 491 __m128i __V2, 492 __m128i __M) { 493 return (__m128i)__builtin_ia32_pblendvb128((__v16qi)__V1, (__v16qi)__V2, 494 (__v16qi)__M); 495 } 496 497 /// Returns a 128-bit vector of [8 x i16] where the values are selected 498 /// from either of the first or second operand as specified by the third 499 /// operand, the control mask. 500 /// 501 /// \headerfile <x86intrin.h> 502 /// 503 /// \code 504 /// __m128i _mm_blend_epi16(__m128i V1, __m128i V2, const int M); 505 /// \endcode 506 /// 507 /// This intrinsic corresponds to the <c> VPBLENDW / PBLENDW </c> instruction. 508 /// 509 /// \param V1 510 /// A 128-bit vector of [8 x i16]. 511 /// \param V2 512 /// A 128-bit vector of [8 x i16]. 513 /// \param M 514 /// An immediate integer operand, with mask bits [7:0] specifying how the 515 /// values are to be copied. The position of the mask bit corresponds to the 516 /// index of a copied value. When a mask bit is 0, the corresponding 16-bit 517 /// element in operand \a V1 is copied to the same position in the result. 518 /// When a mask bit is 1, the corresponding 16-bit element in operand \a V2 519 /// is copied to the same position in the result. 520 /// \returns A 128-bit vector of [8 x i16] containing the copied values. 521 #define _mm_blend_epi16(V1, V2, M) \ 522 ((__m128i)__builtin_ia32_pblendw128((__v8hi)(__m128i)(V1), \ 523 (__v8hi)(__m128i)(V2), (int)(M))) 524 525 /* SSE4 Dword Multiply Instructions. */ 526 /// Multiples corresponding elements of two 128-bit vectors of [4 x i32] 527 /// and returns the lower 32 bits of the each product in a 128-bit vector of 528 /// [4 x i32]. 529 /// 530 /// \headerfile <x86intrin.h> 531 /// 532 /// This intrinsic corresponds to the <c> VPMULLD / PMULLD </c> instruction. 533 /// 534 /// \param __V1 535 /// A 128-bit integer vector. 536 /// \param __V2 537 /// A 128-bit integer vector. 538 /// \returns A 128-bit integer vector containing the products of both operands. 539 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi32(__m128i __V1, 540 __m128i __V2) { 541 return (__m128i)((__v4su)__V1 * (__v4su)__V2); 542 } 543 544 /// Multiplies corresponding even-indexed elements of two 128-bit 545 /// vectors of [4 x i32] and returns a 128-bit vector of [2 x i64] 546 /// containing the products. 547 /// 548 /// \headerfile <x86intrin.h> 549 /// 550 /// This intrinsic corresponds to the <c> VPMULDQ / PMULDQ </c> instruction. 551 /// 552 /// \param __V1 553 /// A 128-bit vector of [4 x i32]. 554 /// \param __V2 555 /// A 128-bit vector of [4 x i32]. 556 /// \returns A 128-bit vector of [2 x i64] containing the products of both 557 /// operands. 558 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epi32(__m128i __V1, 559 __m128i __V2) { 560 return (__m128i)__builtin_ia32_pmuldq128((__v4si)__V1, (__v4si)__V2); 561 } 562 563 /* SSE4 Floating Point Dot Product Instructions. */ 564 /// Computes the dot product of the two 128-bit vectors of [4 x float] 565 /// and returns it in the elements of the 128-bit result vector of 566 /// [4 x float]. 567 /// 568 /// The immediate integer operand controls which input elements 569 /// will contribute to the dot product, and where the final results are 570 /// returned. 571 /// 572 /// \headerfile <x86intrin.h> 573 /// 574 /// \code 575 /// __m128 _mm_dp_ps(__m128 X, __m128 Y, const int M); 576 /// \endcode 577 /// 578 /// This intrinsic corresponds to the <c> VDPPS / DPPS </c> instruction. 579 /// 580 /// \param X 581 /// A 128-bit vector of [4 x float]. 582 /// \param Y 583 /// A 128-bit vector of [4 x float]. 584 /// \param M 585 /// An immediate integer operand. Mask bits [7:4] determine which elements 586 /// of the input vectors are used, with bit [4] corresponding to the lowest 587 /// element and bit [7] corresponding to the highest element of each [4 x 588 /// float] vector. If a bit is set, the corresponding elements from the two 589 /// input vectors are used as an input for dot product; otherwise that input 590 /// is treated as zero. Bits [3:0] determine which elements of the result 591 /// will receive a copy of the final dot product, with bit [0] corresponding 592 /// to the lowest element and bit [3] corresponding to the highest element of 593 /// each [4 x float] subvector. If a bit is set, the dot product is returned 594 /// in the corresponding element; otherwise that element is set to zero. 595 /// \returns A 128-bit vector of [4 x float] containing the dot product. 596 #define _mm_dp_ps(X, Y, M) \ 597 ((__m128)__builtin_ia32_dpps((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (M))) 598 599 /// Computes the dot product of the two 128-bit vectors of [2 x double] 600 /// and returns it in the elements of the 128-bit result vector of 601 /// [2 x double]. 602 /// 603 /// The immediate integer operand controls which input 604 /// elements will contribute to the dot product, and where the final results 605 /// are returned. 606 /// 607 /// \headerfile <x86intrin.h> 608 /// 609 /// \code 610 /// __m128d _mm_dp_pd(__m128d X, __m128d Y, const int M); 611 /// \endcode 612 /// 613 /// This intrinsic corresponds to the <c> VDPPD / DPPD </c> instruction. 614 /// 615 /// \param X 616 /// A 128-bit vector of [2 x double]. 617 /// \param Y 618 /// A 128-bit vector of [2 x double]. 619 /// \param M 620 /// An immediate integer operand. Mask bits [5:4] determine which elements 621 /// of the input vectors are used, with bit [4] corresponding to the lowest 622 /// element and bit [5] corresponding to the highest element of each of [2 x 623 /// double] vector. If a bit is set, the corresponding elements from the two 624 /// input vectors are used as an input for dot product; otherwise that input 625 /// is treated as zero. Bits [1:0] determine which elements of the result 626 /// will receive a copy of the final dot product, with bit [0] corresponding 627 /// to the lowest element and bit [1] corresponding to the highest element of 628 /// each [2 x double] vector. If a bit is set, the dot product is returned in 629 /// the corresponding element; otherwise that element is set to zero. 630 #define _mm_dp_pd(X, Y, M) \ 631 ((__m128d)__builtin_ia32_dppd((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), \ 632 (M))) 633 634 /* SSE4 Streaming Load Hint Instruction. */ 635 /// Loads integer values from a 128-bit aligned memory location to a 636 /// 128-bit integer vector. 637 /// 638 /// \headerfile <x86intrin.h> 639 /// 640 /// This intrinsic corresponds to the <c> VMOVNTDQA / MOVNTDQA </c> instruction. 641 /// 642 /// \param __V 643 /// A pointer to a 128-bit aligned memory location that contains the integer 644 /// values. 645 /// \returns A 128-bit integer vector containing the data stored at the 646 /// specified memory location. 647 static __inline__ __m128i __DEFAULT_FN_ATTRS 648 _mm_stream_load_si128(__m128i const *__V) { 649 return (__m128i)__builtin_nontemporal_load((const __v2di *)__V); 650 } 651 652 /* SSE4 Packed Integer Min/Max Instructions. */ 653 /// Compares the corresponding elements of two 128-bit vectors of 654 /// [16 x i8] and returns a 128-bit vector of [16 x i8] containing the lesser 655 /// of the two values. 656 /// 657 /// \headerfile <x86intrin.h> 658 /// 659 /// This intrinsic corresponds to the <c> VPMINSB / PMINSB </c> instruction. 660 /// 661 /// \param __V1 662 /// A 128-bit vector of [16 x i8]. 663 /// \param __V2 664 /// A 128-bit vector of [16 x i8] 665 /// \returns A 128-bit vector of [16 x i8] containing the lesser values. 666 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi8(__m128i __V1, 667 __m128i __V2) { 668 return (__m128i)__builtin_elementwise_min((__v16qs)__V1, (__v16qs)__V2); 669 } 670 671 /// Compares the corresponding elements of two 128-bit vectors of 672 /// [16 x i8] and returns a 128-bit vector of [16 x i8] containing the 673 /// greater value of the two. 674 /// 675 /// \headerfile <x86intrin.h> 676 /// 677 /// This intrinsic corresponds to the <c> VPMAXSB / PMAXSB </c> instruction. 678 /// 679 /// \param __V1 680 /// A 128-bit vector of [16 x i8]. 681 /// \param __V2 682 /// A 128-bit vector of [16 x i8]. 683 /// \returns A 128-bit vector of [16 x i8] containing the greater values. 684 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi8(__m128i __V1, 685 __m128i __V2) { 686 return (__m128i)__builtin_elementwise_max((__v16qs)__V1, (__v16qs)__V2); 687 } 688 689 /// Compares the corresponding elements of two 128-bit vectors of 690 /// [8 x u16] and returns a 128-bit vector of [8 x u16] containing the lesser 691 /// value of the two. 692 /// 693 /// \headerfile <x86intrin.h> 694 /// 695 /// This intrinsic corresponds to the <c> VPMINUW / PMINUW </c> instruction. 696 /// 697 /// \param __V1 698 /// A 128-bit vector of [8 x u16]. 699 /// \param __V2 700 /// A 128-bit vector of [8 x u16]. 701 /// \returns A 128-bit vector of [8 x u16] containing the lesser values. 702 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu16(__m128i __V1, 703 __m128i __V2) { 704 return (__m128i)__builtin_elementwise_min((__v8hu)__V1, (__v8hu)__V2); 705 } 706 707 /// Compares the corresponding elements of two 128-bit vectors of 708 /// [8 x u16] and returns a 128-bit vector of [8 x u16] containing the 709 /// greater value of the two. 710 /// 711 /// \headerfile <x86intrin.h> 712 /// 713 /// This intrinsic corresponds to the <c> VPMAXUW / PMAXUW </c> instruction. 714 /// 715 /// \param __V1 716 /// A 128-bit vector of [8 x u16]. 717 /// \param __V2 718 /// A 128-bit vector of [8 x u16]. 719 /// \returns A 128-bit vector of [8 x u16] containing the greater values. 720 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu16(__m128i __V1, 721 __m128i __V2) { 722 return (__m128i)__builtin_elementwise_max((__v8hu)__V1, (__v8hu)__V2); 723 } 724 725 /// Compares the corresponding elements of two 128-bit vectors of 726 /// [4 x i32] and returns a 128-bit vector of [4 x i32] containing the lesser 727 /// value of the two. 728 /// 729 /// \headerfile <x86intrin.h> 730 /// 731 /// This intrinsic corresponds to the <c> VPMINSD / PMINSD </c> instruction. 732 /// 733 /// \param __V1 734 /// A 128-bit vector of [4 x i32]. 735 /// \param __V2 736 /// A 128-bit vector of [4 x i32]. 737 /// \returns A 128-bit vector of [4 x i32] containing the lesser values. 738 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi32(__m128i __V1, 739 __m128i __V2) { 740 return (__m128i)__builtin_elementwise_min((__v4si)__V1, (__v4si)__V2); 741 } 742 743 /// Compares the corresponding elements of two 128-bit vectors of 744 /// [4 x i32] and returns a 128-bit vector of [4 x i32] containing the 745 /// greater value of the two. 746 /// 747 /// \headerfile <x86intrin.h> 748 /// 749 /// This intrinsic corresponds to the <c> VPMAXSD / PMAXSD </c> instruction. 750 /// 751 /// \param __V1 752 /// A 128-bit vector of [4 x i32]. 753 /// \param __V2 754 /// A 128-bit vector of [4 x i32]. 755 /// \returns A 128-bit vector of [4 x i32] containing the greater values. 756 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi32(__m128i __V1, 757 __m128i __V2) { 758 return (__m128i)__builtin_elementwise_max((__v4si)__V1, (__v4si)__V2); 759 } 760 761 /// Compares the corresponding elements of two 128-bit vectors of 762 /// [4 x u32] and returns a 128-bit vector of [4 x u32] containing the lesser 763 /// value of the two. 764 /// 765 /// \headerfile <x86intrin.h> 766 /// 767 /// This intrinsic corresponds to the <c> VPMINUD / PMINUD </c> instruction. 768 /// 769 /// \param __V1 770 /// A 128-bit vector of [4 x u32]. 771 /// \param __V2 772 /// A 128-bit vector of [4 x u32]. 773 /// \returns A 128-bit vector of [4 x u32] containing the lesser values. 774 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu32(__m128i __V1, 775 __m128i __V2) { 776 return (__m128i)__builtin_elementwise_min((__v4su)__V1, (__v4su)__V2); 777 } 778 779 /// Compares the corresponding elements of two 128-bit vectors of 780 /// [4 x u32] and returns a 128-bit vector of [4 x u32] containing the 781 /// greater value of the two. 782 /// 783 /// \headerfile <x86intrin.h> 784 /// 785 /// This intrinsic corresponds to the <c> VPMAXUD / PMAXUD </c> instruction. 786 /// 787 /// \param __V1 788 /// A 128-bit vector of [4 x u32]. 789 /// \param __V2 790 /// A 128-bit vector of [4 x u32]. 791 /// \returns A 128-bit vector of [4 x u32] containing the greater values. 792 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu32(__m128i __V1, 793 __m128i __V2) { 794 return (__m128i)__builtin_elementwise_max((__v4su)__V1, (__v4su)__V2); 795 } 796 797 /* SSE4 Insertion and Extraction from XMM Register Instructions. */ 798 /// Takes the first argument \a X and inserts an element from the second 799 /// argument \a Y as selected by the third argument \a N. That result then 800 /// has elements zeroed out also as selected by the third argument \a N. The 801 /// resulting 128-bit vector of [4 x float] is then returned. 802 /// 803 /// \headerfile <x86intrin.h> 804 /// 805 /// \code 806 /// __m128 _mm_insert_ps(__m128 X, __m128 Y, const int N); 807 /// \endcode 808 /// 809 /// This intrinsic corresponds to the <c> VINSERTPS </c> instruction. 810 /// 811 /// \param X 812 /// A 128-bit vector source operand of [4 x float]. With the exception of 813 /// those bits in the result copied from parameter \a Y and zeroed by bits 814 /// [3:0] of \a N, all bits from this parameter are copied to the result. 815 /// \param Y 816 /// A 128-bit vector source operand of [4 x float]. One single-precision 817 /// floating-point element from this source, as determined by the immediate 818 /// parameter, is copied to the result. 819 /// \param N 820 /// Specifies which bits from operand \a Y will be copied, which bits in the 821 /// result they will be be copied to, and which bits in the result will be 822 /// cleared. The following assignments are made: \n 823 /// Bits [7:6] specify the bits to copy from operand \a Y: \n 824 /// 00: Selects bits [31:0] from operand \a Y. \n 825 /// 01: Selects bits [63:32] from operand \a Y. \n 826 /// 10: Selects bits [95:64] from operand \a Y. \n 827 /// 11: Selects bits [127:96] from operand \a Y. \n 828 /// Bits [5:4] specify the bits in the result to which the selected bits 829 /// from operand \a Y are copied: \n 830 /// 00: Copies the selected bits from \a Y to result bits [31:0]. \n 831 /// 01: Copies the selected bits from \a Y to result bits [63:32]. \n 832 /// 10: Copies the selected bits from \a Y to result bits [95:64]. \n 833 /// 11: Copies the selected bits from \a Y to result bits [127:96]. \n 834 /// Bits[3:0]: If any of these bits are set, the corresponding result 835 /// element is cleared. 836 /// \returns A 128-bit vector of [4 x float] containing the copied 837 /// single-precision floating point elements from the operands. 838 #define _mm_insert_ps(X, Y, N) __builtin_ia32_insertps128((X), (Y), (N)) 839 840 /// Extracts a 32-bit integer from a 128-bit vector of [4 x float] and 841 /// returns it, using the immediate value parameter \a N as a selector. 842 /// 843 /// \headerfile <x86intrin.h> 844 /// 845 /// \code 846 /// int _mm_extract_ps(__m128 X, const int N); 847 /// \endcode 848 /// 849 /// This intrinsic corresponds to the <c> VEXTRACTPS / EXTRACTPS </c> 850 /// instruction. 851 /// 852 /// \param X 853 /// A 128-bit vector of [4 x float]. 854 /// \param N 855 /// An immediate value. Bits [1:0] determines which bits from the argument 856 /// \a X are extracted and returned: \n 857 /// 00: Bits [31:0] of parameter \a X are returned. \n 858 /// 01: Bits [63:32] of parameter \a X are returned. \n 859 /// 10: Bits [95:64] of parameter \a X are returned. \n 860 /// 11: Bits [127:96] of parameter \a X are returned. 861 /// \returns A 32-bit integer containing the extracted 32 bits of float data. 862 #define _mm_extract_ps(X, N) \ 863 __builtin_bit_cast( \ 864 int, __builtin_ia32_vec_ext_v4sf((__v4sf)(__m128)(X), (int)(N))) 865 866 /* Miscellaneous insert and extract macros. */ 867 /* Extract a single-precision float from X at index N into D. */ 868 #define _MM_EXTRACT_FLOAT(D, X, N) \ 869 do { \ 870 (D) = __builtin_ia32_vec_ext_v4sf((__v4sf)(__m128)(X), (int)(N)); \ 871 } while (0) 872 873 /* Or together 2 sets of indexes (X and Y) with the zeroing bits (Z) to create 874 an index suitable for _mm_insert_ps. */ 875 #define _MM_MK_INSERTPS_NDX(X, Y, Z) (((X) << 6) | ((Y) << 4) | (Z)) 876 877 /* Extract a float from X at index N into the first index of the return. */ 878 #define _MM_PICK_OUT_PS(X, N) \ 879 _mm_insert_ps(_mm_setzero_ps(), (X), _MM_MK_INSERTPS_NDX((N), 0, 0x0e)) 880 881 /* Insert int into packed integer array at index. */ 882 /// Constructs a 128-bit vector of [16 x i8] by first making a copy of 883 /// the 128-bit integer vector parameter, and then inserting the lower 8 bits 884 /// of an integer parameter \a I into an offset specified by the immediate 885 /// value parameter \a N. 886 /// 887 /// \headerfile <x86intrin.h> 888 /// 889 /// \code 890 /// __m128i _mm_insert_epi8(__m128i X, int I, const int N); 891 /// \endcode 892 /// 893 /// This intrinsic corresponds to the <c> VPINSRB / PINSRB </c> instruction. 894 /// 895 /// \param X 896 /// A 128-bit integer vector of [16 x i8]. This vector is copied to the 897 /// result and then one of the sixteen elements in the result vector is 898 /// replaced by the lower 8 bits of \a I. 899 /// \param I 900 /// An integer. The lower 8 bits of this operand are written to the result 901 /// beginning at the offset specified by \a N. 902 /// \param N 903 /// An immediate value. Bits [3:0] specify the bit offset in the result at 904 /// which the lower 8 bits of \a I are written. \n 905 /// 0000: Bits [7:0] of the result are used for insertion. \n 906 /// 0001: Bits [15:8] of the result are used for insertion. \n 907 /// 0010: Bits [23:16] of the result are used for insertion. \n 908 /// 0011: Bits [31:24] of the result are used for insertion. \n 909 /// 0100: Bits [39:32] of the result are used for insertion. \n 910 /// 0101: Bits [47:40] of the result are used for insertion. \n 911 /// 0110: Bits [55:48] of the result are used for insertion. \n 912 /// 0111: Bits [63:56] of the result are used for insertion. \n 913 /// 1000: Bits [71:64] of the result are used for insertion. \n 914 /// 1001: Bits [79:72] of the result are used for insertion. \n 915 /// 1010: Bits [87:80] of the result are used for insertion. \n 916 /// 1011: Bits [95:88] of the result are used for insertion. \n 917 /// 1100: Bits [103:96] of the result are used for insertion. \n 918 /// 1101: Bits [111:104] of the result are used for insertion. \n 919 /// 1110: Bits [119:112] of the result are used for insertion. \n 920 /// 1111: Bits [127:120] of the result are used for insertion. 921 /// \returns A 128-bit integer vector containing the constructed values. 922 #define _mm_insert_epi8(X, I, N) \ 923 ((__m128i)__builtin_ia32_vec_set_v16qi((__v16qi)(__m128i)(X), (int)(I), \ 924 (int)(N))) 925 926 /// Constructs a 128-bit vector of [4 x i32] by first making a copy of 927 /// the 128-bit integer vector parameter, and then inserting the 32-bit 928 /// integer parameter \a I at the offset specified by the immediate value 929 /// parameter \a N. 930 /// 931 /// \headerfile <x86intrin.h> 932 /// 933 /// \code 934 /// __m128i _mm_insert_epi32(__m128i X, int I, const int N); 935 /// \endcode 936 /// 937 /// This intrinsic corresponds to the <c> VPINSRD / PINSRD </c> instruction. 938 /// 939 /// \param X 940 /// A 128-bit integer vector of [4 x i32]. This vector is copied to the 941 /// result and then one of the four elements in the result vector is 942 /// replaced by \a I. 943 /// \param I 944 /// A 32-bit integer that is written to the result beginning at the offset 945 /// specified by \a N. 946 /// \param N 947 /// An immediate value. Bits [1:0] specify the bit offset in the result at 948 /// which the integer \a I is written. \n 949 /// 00: Bits [31:0] of the result are used for insertion. \n 950 /// 01: Bits [63:32] of the result are used for insertion. \n 951 /// 10: Bits [95:64] of the result are used for insertion. \n 952 /// 11: Bits [127:96] of the result are used for insertion. 953 /// \returns A 128-bit integer vector containing the constructed values. 954 #define _mm_insert_epi32(X, I, N) \ 955 ((__m128i)__builtin_ia32_vec_set_v4si((__v4si)(__m128i)(X), (int)(I), \ 956 (int)(N))) 957 958 #ifdef __x86_64__ 959 /// Constructs a 128-bit vector of [2 x i64] by first making a copy of 960 /// the 128-bit integer vector parameter, and then inserting the 64-bit 961 /// integer parameter \a I, using the immediate value parameter \a N as an 962 /// insertion location selector. 963 /// 964 /// \headerfile <x86intrin.h> 965 /// 966 /// \code 967 /// __m128i _mm_insert_epi64(__m128i X, long long I, const int N); 968 /// \endcode 969 /// 970 /// This intrinsic corresponds to the <c> VPINSRQ / PINSRQ </c> instruction. 971 /// 972 /// \param X 973 /// A 128-bit integer vector of [2 x i64]. This vector is copied to the 974 /// result and then one of the two elements in the result vector is replaced 975 /// by \a I. 976 /// \param I 977 /// A 64-bit integer that is written to the result beginning at the offset 978 /// specified by \a N. 979 /// \param N 980 /// An immediate value. Bit [0] specifies the bit offset in the result at 981 /// which the integer \a I is written. \n 982 /// 0: Bits [63:0] of the result are used for insertion. \n 983 /// 1: Bits [127:64] of the result are used for insertion. \n 984 /// \returns A 128-bit integer vector containing the constructed values. 985 #define _mm_insert_epi64(X, I, N) \ 986 ((__m128i)__builtin_ia32_vec_set_v2di((__v2di)(__m128i)(X), (long long)(I), \ 987 (int)(N))) 988 #endif /* __x86_64__ */ 989 990 /* Extract int from packed integer array at index. This returns the element 991 * as a zero extended value, so it is unsigned. 992 */ 993 /// Extracts an 8-bit element from the 128-bit integer vector of 994 /// [16 x i8], using the immediate value parameter \a N as a selector. 995 /// 996 /// \headerfile <x86intrin.h> 997 /// 998 /// \code 999 /// int _mm_extract_epi8(__m128i X, const int N); 1000 /// \endcode 1001 /// 1002 /// This intrinsic corresponds to the <c> VPEXTRB / PEXTRB </c> instruction. 1003 /// 1004 /// \param X 1005 /// A 128-bit integer vector. 1006 /// \param N 1007 /// An immediate value. Bits [3:0] specify which 8-bit vector element from 1008 /// the argument \a X to extract and copy to the result. \n 1009 /// 0000: Bits [7:0] of parameter \a X are extracted. \n 1010 /// 0001: Bits [15:8] of the parameter \a X are extracted. \n 1011 /// 0010: Bits [23:16] of the parameter \a X are extracted. \n 1012 /// 0011: Bits [31:24] of the parameter \a X are extracted. \n 1013 /// 0100: Bits [39:32] of the parameter \a X are extracted. \n 1014 /// 0101: Bits [47:40] of the parameter \a X are extracted. \n 1015 /// 0110: Bits [55:48] of the parameter \a X are extracted. \n 1016 /// 0111: Bits [63:56] of the parameter \a X are extracted. \n 1017 /// 1000: Bits [71:64] of the parameter \a X are extracted. \n 1018 /// 1001: Bits [79:72] of the parameter \a X are extracted. \n 1019 /// 1010: Bits [87:80] of the parameter \a X are extracted. \n 1020 /// 1011: Bits [95:88] of the parameter \a X are extracted. \n 1021 /// 1100: Bits [103:96] of the parameter \a X are extracted. \n 1022 /// 1101: Bits [111:104] of the parameter \a X are extracted. \n 1023 /// 1110: Bits [119:112] of the parameter \a X are extracted. \n 1024 /// 1111: Bits [127:120] of the parameter \a X are extracted. 1025 /// \returns An unsigned integer, whose lower 8 bits are selected from the 1026 /// 128-bit integer vector parameter and the remaining bits are assigned 1027 /// zeros. 1028 #define _mm_extract_epi8(X, N) \ 1029 ((int)(unsigned char)__builtin_ia32_vec_ext_v16qi((__v16qi)(__m128i)(X), \ 1030 (int)(N))) 1031 1032 /// Extracts a 32-bit element from the 128-bit integer vector of 1033 /// [4 x i32], using the immediate value parameter \a N as a selector. 1034 /// 1035 /// \headerfile <x86intrin.h> 1036 /// 1037 /// \code 1038 /// int _mm_extract_epi32(__m128i X, const int N); 1039 /// \endcode 1040 /// 1041 /// This intrinsic corresponds to the <c> VPEXTRD / PEXTRD </c> instruction. 1042 /// 1043 /// \param X 1044 /// A 128-bit integer vector. 1045 /// \param N 1046 /// An immediate value. Bits [1:0] specify which 32-bit vector element from 1047 /// the argument \a X to extract and copy to the result. \n 1048 /// 00: Bits [31:0] of the parameter \a X are extracted. \n 1049 /// 01: Bits [63:32] of the parameter \a X are extracted. \n 1050 /// 10: Bits [95:64] of the parameter \a X are extracted. \n 1051 /// 11: Bits [127:96] of the parameter \a X are exracted. 1052 /// \returns An integer, whose lower 32 bits are selected from the 128-bit 1053 /// integer vector parameter and the remaining bits are assigned zeros. 1054 #define _mm_extract_epi32(X, N) \ 1055 ((int)__builtin_ia32_vec_ext_v4si((__v4si)(__m128i)(X), (int)(N))) 1056 1057 /// Extracts a 64-bit element from the 128-bit integer vector of 1058 /// [2 x i64], using the immediate value parameter \a N as a selector. 1059 /// 1060 /// \headerfile <x86intrin.h> 1061 /// 1062 /// \code 1063 /// long long _mm_extract_epi64(__m128i X, const int N); 1064 /// \endcode 1065 /// 1066 /// This intrinsic corresponds to the <c> VPEXTRQ / PEXTRQ </c> instruction 1067 /// in 64-bit mode. 1068 /// 1069 /// \param X 1070 /// A 128-bit integer vector. 1071 /// \param N 1072 /// An immediate value. Bit [0] specifies which 64-bit vector element from 1073 /// the argument \a X to return. \n 1074 /// 0: Bits [63:0] are returned. \n 1075 /// 1: Bits [127:64] are returned. \n 1076 /// \returns A 64-bit integer. 1077 #define _mm_extract_epi64(X, N) \ 1078 ((long long)__builtin_ia32_vec_ext_v2di((__v2di)(__m128i)(X), (int)(N))) 1079 1080 /* SSE4 128-bit Packed Integer Comparisons. */ 1081 /// Tests whether the specified bits in a 128-bit integer vector are all 1082 /// zeros. 1083 /// 1084 /// \headerfile <x86intrin.h> 1085 /// 1086 /// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction. 1087 /// 1088 /// \param __M 1089 /// A 128-bit integer vector containing the bits to be tested. 1090 /// \param __V 1091 /// A 128-bit integer vector selecting which bits to test in operand \a __M. 1092 /// \returns TRUE if the specified bits are all zeros; FALSE otherwise. 1093 static __inline__ int __DEFAULT_FN_ATTRS _mm_testz_si128(__m128i __M, 1094 __m128i __V) { 1095 return __builtin_ia32_ptestz128((__v2di)__M, (__v2di)__V); 1096 } 1097 1098 /// Tests whether the specified bits in a 128-bit integer vector are all 1099 /// ones. 1100 /// 1101 /// \headerfile <x86intrin.h> 1102 /// 1103 /// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction. 1104 /// 1105 /// \param __M 1106 /// A 128-bit integer vector containing the bits to be tested. 1107 /// \param __V 1108 /// A 128-bit integer vector selecting which bits to test in operand \a __M. 1109 /// \returns TRUE if the specified bits are all ones; FALSE otherwise. 1110 static __inline__ int __DEFAULT_FN_ATTRS _mm_testc_si128(__m128i __M, 1111 __m128i __V) { 1112 return __builtin_ia32_ptestc128((__v2di)__M, (__v2di)__V); 1113 } 1114 1115 /// Tests whether the specified bits in a 128-bit integer vector are 1116 /// neither all zeros nor all ones. 1117 /// 1118 /// \headerfile <x86intrin.h> 1119 /// 1120 /// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction. 1121 /// 1122 /// \param __M 1123 /// A 128-bit integer vector containing the bits to be tested. 1124 /// \param __V 1125 /// A 128-bit integer vector selecting which bits to test in operand \a __M. 1126 /// \returns TRUE if the specified bits are neither all zeros nor all ones; 1127 /// FALSE otherwise. 1128 static __inline__ int __DEFAULT_FN_ATTRS _mm_testnzc_si128(__m128i __M, 1129 __m128i __V) { 1130 return __builtin_ia32_ptestnzc128((__v2di)__M, (__v2di)__V); 1131 } 1132 1133 /// Tests whether the specified bits in a 128-bit integer vector are all 1134 /// ones. 1135 /// 1136 /// \headerfile <x86intrin.h> 1137 /// 1138 /// \code 1139 /// int _mm_test_all_ones(__m128i V); 1140 /// \endcode 1141 /// 1142 /// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction. 1143 /// 1144 /// \param V 1145 /// A 128-bit integer vector containing the bits to be tested. 1146 /// \returns TRUE if the bits specified in the operand are all set to 1; FALSE 1147 /// otherwise. 1148 #define _mm_test_all_ones(V) _mm_testc_si128((V), _mm_cmpeq_epi32((V), (V))) 1149 1150 /// Tests whether the specified bits in a 128-bit integer vector are 1151 /// neither all zeros nor all ones. 1152 /// 1153 /// \headerfile <x86intrin.h> 1154 /// 1155 /// \code 1156 /// int _mm_test_mix_ones_zeros(__m128i M, __m128i V); 1157 /// \endcode 1158 /// 1159 /// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction. 1160 /// 1161 /// \param M 1162 /// A 128-bit integer vector containing the bits to be tested. 1163 /// \param V 1164 /// A 128-bit integer vector selecting which bits to test in operand \a M. 1165 /// \returns TRUE if the specified bits are neither all zeros nor all ones; 1166 /// FALSE otherwise. 1167 #define _mm_test_mix_ones_zeros(M, V) _mm_testnzc_si128((M), (V)) 1168 1169 /// Tests whether the specified bits in a 128-bit integer vector are all 1170 /// zeros. 1171 /// 1172 /// \headerfile <x86intrin.h> 1173 /// 1174 /// \code 1175 /// int _mm_test_all_zeros(__m128i M, __m128i V); 1176 /// \endcode 1177 /// 1178 /// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction. 1179 /// 1180 /// \param M 1181 /// A 128-bit integer vector containing the bits to be tested. 1182 /// \param V 1183 /// A 128-bit integer vector selecting which bits to test in operand \a M. 1184 /// \returns TRUE if the specified bits are all zeros; FALSE otherwise. 1185 #define _mm_test_all_zeros(M, V) _mm_testz_si128((M), (V)) 1186 1187 /* SSE4 64-bit Packed Integer Comparisons. */ 1188 /// Compares each of the corresponding 64-bit values of the 128-bit 1189 /// integer vectors for equality. 1190 /// 1191 /// \headerfile <x86intrin.h> 1192 /// 1193 /// This intrinsic corresponds to the <c> VPCMPEQQ / PCMPEQQ </c> instruction. 1194 /// 1195 /// \param __V1 1196 /// A 128-bit integer vector. 1197 /// \param __V2 1198 /// A 128-bit integer vector. 1199 /// \returns A 128-bit integer vector containing the comparison results. 1200 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi64(__m128i __V1, 1201 __m128i __V2) { 1202 return (__m128i)((__v2di)__V1 == (__v2di)__V2); 1203 } 1204 1205 /* SSE4 Packed Integer Sign-Extension. */ 1206 /// Sign-extends each of the lower eight 8-bit integer elements of a 1207 /// 128-bit vector of [16 x i8] to 16-bit values and returns them in a 1208 /// 128-bit vector of [8 x i16]. The upper eight elements of the input vector 1209 /// are unused. 1210 /// 1211 /// \headerfile <x86intrin.h> 1212 /// 1213 /// This intrinsic corresponds to the <c> VPMOVSXBW / PMOVSXBW </c> instruction. 1214 /// 1215 /// \param __V 1216 /// A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are 1217 /// sign-extended to 16-bit values. 1218 /// \returns A 128-bit vector of [8 x i16] containing the sign-extended values. 1219 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi16(__m128i __V) { 1220 /* This function always performs a signed extension, but __v16qi is a char 1221 which may be signed or unsigned, so use __v16qs. */ 1222 return (__m128i) __builtin_convertvector( 1223 __builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3, 4, 5, 6, 1224 7), 1225 __v8hi); 1226 } 1227 1228 /// Sign-extends each of the lower four 8-bit integer elements of a 1229 /// 128-bit vector of [16 x i8] to 32-bit values and returns them in a 1230 /// 128-bit vector of [4 x i32]. The upper twelve elements of the input 1231 /// vector are unused. 1232 /// 1233 /// \headerfile <x86intrin.h> 1234 /// 1235 /// This intrinsic corresponds to the <c> VPMOVSXBD / PMOVSXBD </c> instruction. 1236 /// 1237 /// \param __V 1238 /// A 128-bit vector of [16 x i8]. The lower four 8-bit elements are 1239 /// sign-extended to 32-bit values. 1240 /// \returns A 128-bit vector of [4 x i32] containing the sign-extended values. 1241 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi32(__m128i __V) { 1242 /* This function always performs a signed extension, but __v16qi is a char 1243 which may be signed or unsigned, so use __v16qs. */ 1244 return (__m128i) __builtin_convertvector( 1245 __builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3), __v4si); 1246 } 1247 1248 /// Sign-extends each of the lower two 8-bit integer elements of a 1249 /// 128-bit integer vector of [16 x i8] to 64-bit values and returns them in 1250 /// a 128-bit vector of [2 x i64]. The upper fourteen elements of the input 1251 /// vector are unused. 1252 /// 1253 /// \headerfile <x86intrin.h> 1254 /// 1255 /// This intrinsic corresponds to the <c> VPMOVSXBQ / PMOVSXBQ </c> instruction. 1256 /// 1257 /// \param __V 1258 /// A 128-bit vector of [16 x i8]. The lower two 8-bit elements are 1259 /// sign-extended to 64-bit values. 1260 /// \returns A 128-bit vector of [2 x i64] containing the sign-extended values. 1261 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi64(__m128i __V) { 1262 /* This function always performs a signed extension, but __v16qi is a char 1263 which may be signed or unsigned, so use __v16qs. */ 1264 return (__m128i) __builtin_convertvector( 1265 __builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1), __v2di); 1266 } 1267 1268 /// Sign-extends each of the lower four 16-bit integer elements of a 1269 /// 128-bit integer vector of [8 x i16] to 32-bit values and returns them in 1270 /// a 128-bit vector of [4 x i32]. The upper four elements of the input 1271 /// vector are unused. 1272 /// 1273 /// \headerfile <x86intrin.h> 1274 /// 1275 /// This intrinsic corresponds to the <c> VPMOVSXWD / PMOVSXWD </c> instruction. 1276 /// 1277 /// \param __V 1278 /// A 128-bit vector of [8 x i16]. The lower four 16-bit elements are 1279 /// sign-extended to 32-bit values. 1280 /// \returns A 128-bit vector of [4 x i32] containing the sign-extended values. 1281 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi32(__m128i __V) { 1282 return (__m128i) __builtin_convertvector( 1283 __builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1, 2, 3), __v4si); 1284 } 1285 1286 /// Sign-extends each of the lower two 16-bit integer elements of a 1287 /// 128-bit integer vector of [8 x i16] to 64-bit values and returns them in 1288 /// a 128-bit vector of [2 x i64]. The upper six elements of the input 1289 /// vector are unused. 1290 /// 1291 /// \headerfile <x86intrin.h> 1292 /// 1293 /// This intrinsic corresponds to the <c> VPMOVSXWQ / PMOVSXWQ </c> instruction. 1294 /// 1295 /// \param __V 1296 /// A 128-bit vector of [8 x i16]. The lower two 16-bit elements are 1297 /// sign-extended to 64-bit values. 1298 /// \returns A 128-bit vector of [2 x i64] containing the sign-extended values. 1299 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi64(__m128i __V) { 1300 return (__m128i) __builtin_convertvector( 1301 __builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1), __v2di); 1302 } 1303 1304 /// Sign-extends each of the lower two 32-bit integer elements of a 1305 /// 128-bit integer vector of [4 x i32] to 64-bit values and returns them in 1306 /// a 128-bit vector of [2 x i64]. The upper two elements of the input vector 1307 /// are unused. 1308 /// 1309 /// \headerfile <x86intrin.h> 1310 /// 1311 /// This intrinsic corresponds to the <c> VPMOVSXDQ / PMOVSXDQ </c> instruction. 1312 /// 1313 /// \param __V 1314 /// A 128-bit vector of [4 x i32]. The lower two 32-bit elements are 1315 /// sign-extended to 64-bit values. 1316 /// \returns A 128-bit vector of [2 x i64] containing the sign-extended values. 1317 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi32_epi64(__m128i __V) { 1318 return (__m128i) __builtin_convertvector( 1319 __builtin_shufflevector((__v4si)__V, (__v4si)__V, 0, 1), __v2di); 1320 } 1321 1322 /* SSE4 Packed Integer Zero-Extension. */ 1323 /// Zero-extends each of the lower eight 8-bit integer elements of a 1324 /// 128-bit vector of [16 x i8] to 16-bit values and returns them in a 1325 /// 128-bit vector of [8 x i16]. The upper eight elements of the input vector 1326 /// are unused. 1327 /// 1328 /// \headerfile <x86intrin.h> 1329 /// 1330 /// This intrinsic corresponds to the <c> VPMOVZXBW / PMOVZXBW </c> instruction. 1331 /// 1332 /// \param __V 1333 /// A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are 1334 /// zero-extended to 16-bit values. 1335 /// \returns A 128-bit vector of [8 x i16] containing the zero-extended values. 1336 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi16(__m128i __V) { 1337 return (__m128i) __builtin_convertvector( 1338 __builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3, 4, 5, 6, 1339 7), 1340 __v8hi); 1341 } 1342 1343 /// Zero-extends each of the lower four 8-bit integer elements of a 1344 /// 128-bit vector of [16 x i8] to 32-bit values and returns them in a 1345 /// 128-bit vector of [4 x i32]. The upper twelve elements of the input 1346 /// vector are unused. 1347 /// 1348 /// \headerfile <x86intrin.h> 1349 /// 1350 /// This intrinsic corresponds to the <c> VPMOVZXBD / PMOVZXBD </c> instruction. 1351 /// 1352 /// \param __V 1353 /// A 128-bit vector of [16 x i8]. The lower four 8-bit elements are 1354 /// zero-extended to 32-bit values. 1355 /// \returns A 128-bit vector of [4 x i32] containing the zero-extended values. 1356 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi32(__m128i __V) { 1357 return (__m128i) __builtin_convertvector( 1358 __builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3), __v4si); 1359 } 1360 1361 /// Zero-extends each of the lower two 8-bit integer elements of a 1362 /// 128-bit integer vector of [16 x i8] to 64-bit values and returns them in 1363 /// a 128-bit vector of [2 x i64]. The upper fourteen elements of the input 1364 /// vector are unused. 1365 /// 1366 /// \headerfile <x86intrin.h> 1367 /// 1368 /// This intrinsic corresponds to the <c> VPMOVZXBQ / PMOVZXBQ </c> instruction. 1369 /// 1370 /// \param __V 1371 /// A 128-bit vector of [16 x i8]. The lower two 8-bit elements are 1372 /// zero-extended to 64-bit values. 1373 /// \returns A 128-bit vector of [2 x i64] containing the zero-extended values. 1374 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi64(__m128i __V) { 1375 return (__m128i) __builtin_convertvector( 1376 __builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1), __v2di); 1377 } 1378 1379 /// Zero-extends each of the lower four 16-bit integer elements of a 1380 /// 128-bit integer vector of [8 x i16] to 32-bit values and returns them in 1381 /// a 128-bit vector of [4 x i32]. The upper four elements of the input 1382 /// vector are unused. 1383 /// 1384 /// \headerfile <x86intrin.h> 1385 /// 1386 /// This intrinsic corresponds to the <c> VPMOVZXWD / PMOVZXWD </c> instruction. 1387 /// 1388 /// \param __V 1389 /// A 128-bit vector of [8 x i16]. The lower four 16-bit elements are 1390 /// zero-extended to 32-bit values. 1391 /// \returns A 128-bit vector of [4 x i32] containing the zero-extended values. 1392 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi32(__m128i __V) { 1393 return (__m128i) __builtin_convertvector( 1394 __builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1, 2, 3), __v4si); 1395 } 1396 1397 /// Zero-extends each of the lower two 16-bit integer elements of a 1398 /// 128-bit integer vector of [8 x i16] to 64-bit values and returns them in 1399 /// a 128-bit vector of [2 x i64]. The upper six elements of the input vector 1400 /// are unused. 1401 /// 1402 /// \headerfile <x86intrin.h> 1403 /// 1404 /// This intrinsic corresponds to the <c> VPMOVZXWQ / PMOVZXWQ </c> instruction. 1405 /// 1406 /// \param __V 1407 /// A 128-bit vector of [8 x i16]. The lower two 16-bit elements are 1408 /// zero-extended to 64-bit values. 1409 /// \returns A 128-bit vector of [2 x i64] containing the zero-extended values. 1410 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi64(__m128i __V) { 1411 return (__m128i) __builtin_convertvector( 1412 __builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1), __v2di); 1413 } 1414 1415 /// Zero-extends each of the lower two 32-bit integer elements of a 1416 /// 128-bit integer vector of [4 x i32] to 64-bit values and returns them in 1417 /// a 128-bit vector of [2 x i64]. The upper two elements of the input vector 1418 /// are unused. 1419 /// 1420 /// \headerfile <x86intrin.h> 1421 /// 1422 /// This intrinsic corresponds to the <c> VPMOVZXDQ / PMOVZXDQ </c> instruction. 1423 /// 1424 /// \param __V 1425 /// A 128-bit vector of [4 x i32]. The lower two 32-bit elements are 1426 /// zero-extended to 64-bit values. 1427 /// \returns A 128-bit vector of [2 x i64] containing the zero-extended values. 1428 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu32_epi64(__m128i __V) { 1429 return (__m128i) __builtin_convertvector( 1430 __builtin_shufflevector((__v4su)__V, (__v4su)__V, 0, 1), __v2di); 1431 } 1432 1433 /* SSE4 Pack with Unsigned Saturation. */ 1434 /// Converts 32-bit signed integers from both 128-bit integer vector 1435 /// operands into 16-bit unsigned integers, and returns the packed result. 1436 /// Values greater than 0xFFFF are saturated to 0xFFFF. Values less than 1437 /// 0x0000 are saturated to 0x0000. 1438 /// 1439 /// \headerfile <x86intrin.h> 1440 /// 1441 /// This intrinsic corresponds to the <c> VPACKUSDW / PACKUSDW </c> instruction. 1442 /// 1443 /// \param __V1 1444 /// A 128-bit vector of [4 x i32]. Each 32-bit element is treated as a 1445 /// signed integer and is converted to a 16-bit unsigned integer with 1446 /// saturation. Values greater than 0xFFFF are saturated to 0xFFFF. Values 1447 /// less than 0x0000 are saturated to 0x0000. The converted [4 x i16] values 1448 /// are written to the lower 64 bits of the result. 1449 /// \param __V2 1450 /// A 128-bit vector of [4 x i32]. Each 32-bit element is treated as a 1451 /// signed integer and is converted to a 16-bit unsigned integer with 1452 /// saturation. Values greater than 0xFFFF are saturated to 0xFFFF. Values 1453 /// less than 0x0000 are saturated to 0x0000. The converted [4 x i16] values 1454 /// are written to the higher 64 bits of the result. 1455 /// \returns A 128-bit vector of [8 x i16] containing the converted values. 1456 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi32(__m128i __V1, 1457 __m128i __V2) { 1458 return (__m128i)__builtin_ia32_packusdw128((__v4si)__V1, (__v4si)__V2); 1459 } 1460 1461 /* SSE4 Multiple Packed Sums of Absolute Difference. */ 1462 /// Subtracts 8-bit unsigned integer values and computes the absolute 1463 /// values of the differences to the corresponding bits in the destination. 1464 /// Then sums of the absolute differences are returned according to the bit 1465 /// fields in the immediate operand. 1466 /// 1467 /// \headerfile <x86intrin.h> 1468 /// 1469 /// \code 1470 /// __m128i _mm_mpsadbw_epu8(__m128i X, __m128i Y, const int M); 1471 /// \endcode 1472 /// 1473 /// This intrinsic corresponds to the <c> VMPSADBW / MPSADBW </c> instruction. 1474 /// 1475 /// \param X 1476 /// A 128-bit vector of [16 x i8]. 1477 /// \param Y 1478 /// A 128-bit vector of [16 x i8]. 1479 /// \param M 1480 /// An 8-bit immediate operand specifying how the absolute differences are to 1481 /// be calculated, according to the following algorithm: 1482 /// \code 1483 /// // M2 represents bit 2 of the immediate operand 1484 /// // M10 represents bits [1:0] of the immediate operand 1485 /// i = M2 * 4; 1486 /// j = M10 * 4; 1487 /// for (k = 0; k < 8; k = k + 1) { 1488 /// d0 = abs(X[i + k + 0] - Y[j + 0]); 1489 /// d1 = abs(X[i + k + 1] - Y[j + 1]); 1490 /// d2 = abs(X[i + k + 2] - Y[j + 2]); 1491 /// d3 = abs(X[i + k + 3] - Y[j + 3]); 1492 /// r[k] = d0 + d1 + d2 + d3; 1493 /// } 1494 /// \endcode 1495 /// \returns A 128-bit integer vector containing the sums of the sets of 1496 /// absolute differences between both operands. 1497 #define _mm_mpsadbw_epu8(X, Y, M) \ 1498 ((__m128i)__builtin_ia32_mpsadbw128((__v16qi)(__m128i)(X), \ 1499 (__v16qi)(__m128i)(Y), (M))) 1500 1501 /// Finds the minimum unsigned 16-bit element in the input 128-bit 1502 /// vector of [8 x u16] and returns it and along with its index. 1503 /// 1504 /// \headerfile <x86intrin.h> 1505 /// 1506 /// This intrinsic corresponds to the <c> VPHMINPOSUW / PHMINPOSUW </c> 1507 /// instruction. 1508 /// 1509 /// \param __V 1510 /// A 128-bit vector of [8 x u16]. 1511 /// \returns A 128-bit value where bits [15:0] contain the minimum value found 1512 /// in parameter \a __V, bits [18:16] contain the index of the minimum value 1513 /// and the remaining bits are set to 0. 1514 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_minpos_epu16(__m128i __V) { 1515 return (__m128i)__builtin_ia32_phminposuw128((__v8hi)__V); 1516 } 1517 1518 /* Handle the sse4.2 definitions here. */ 1519 1520 /* These definitions are normally in nmmintrin.h, but gcc puts them in here 1521 so we'll do the same. */ 1522 1523 #undef __DEFAULT_FN_ATTRS 1524 #define __DEFAULT_FN_ATTRS \ 1525 __attribute__((__always_inline__, __nodebug__, __target__("sse4.2"))) 1526 1527 /* These specify the type of data that we're comparing. */ 1528 #define _SIDD_UBYTE_OPS 0x00 1529 #define _SIDD_UWORD_OPS 0x01 1530 #define _SIDD_SBYTE_OPS 0x02 1531 #define _SIDD_SWORD_OPS 0x03 1532 1533 /* These specify the type of comparison operation. */ 1534 #define _SIDD_CMP_EQUAL_ANY 0x00 1535 #define _SIDD_CMP_RANGES 0x04 1536 #define _SIDD_CMP_EQUAL_EACH 0x08 1537 #define _SIDD_CMP_EQUAL_ORDERED 0x0c 1538 1539 /* These macros specify the polarity of the operation. */ 1540 #define _SIDD_POSITIVE_POLARITY 0x00 1541 #define _SIDD_NEGATIVE_POLARITY 0x10 1542 #define _SIDD_MASKED_POSITIVE_POLARITY 0x20 1543 #define _SIDD_MASKED_NEGATIVE_POLARITY 0x30 1544 1545 /* These macros are used in _mm_cmpXstri() to specify the return. */ 1546 #define _SIDD_LEAST_SIGNIFICANT 0x00 1547 #define _SIDD_MOST_SIGNIFICANT 0x40 1548 1549 /* These macros are used in _mm_cmpXstri() to specify the return. */ 1550 #define _SIDD_BIT_MASK 0x00 1551 #define _SIDD_UNIT_MASK 0x40 1552 1553 /* SSE4.2 Packed Comparison Intrinsics. */ 1554 /// Uses the immediate operand \a M to perform a comparison of string 1555 /// data with implicitly defined lengths that is contained in source operands 1556 /// \a A and \a B. Returns a 128-bit integer vector representing the result 1557 /// mask of the comparison. 1558 /// 1559 /// \headerfile <x86intrin.h> 1560 /// 1561 /// \code 1562 /// __m128i _mm_cmpistrm(__m128i A, __m128i B, const int M); 1563 /// \endcode 1564 /// 1565 /// This intrinsic corresponds to the <c> VPCMPISTRM / PCMPISTRM </c> 1566 /// instruction. 1567 /// 1568 /// \param A 1569 /// A 128-bit integer vector containing one of the source operands to be 1570 /// compared. 1571 /// \param B 1572 /// A 128-bit integer vector containing one of the source operands to be 1573 /// compared. 1574 /// \param M 1575 /// An 8-bit immediate operand specifying whether the characters are bytes or 1576 /// words, the type of comparison to perform, and the format of the return 1577 /// value. \n 1578 /// Bits [1:0]: Determine source data format. \n 1579 /// 00: 16 unsigned bytes \n 1580 /// 01: 8 unsigned words \n 1581 /// 10: 16 signed bytes \n 1582 /// 11: 8 signed words \n 1583 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1584 /// 00: Subset: Each character in \a B is compared for equality with all 1585 /// the characters in \a A. \n 1586 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1587 /// basis is greater than or equal for even-indexed elements in \a A, 1588 /// and less than or equal for odd-indexed elements in \a A. \n 1589 /// 10: Match: Compare each pair of corresponding characters in \a A and 1590 /// \a B for equality. \n 1591 /// 11: Substring: Search \a B for substring matches of \a A. \n 1592 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1593 /// mask of the comparison results. \n 1594 /// 00: No effect. \n 1595 /// 01: Negate the bit mask. \n 1596 /// 10: No effect. \n 1597 /// 11: Negate the bit mask only for bits with an index less than or equal 1598 /// to the size of \a A or \a B. \n 1599 /// Bit [6]: Determines whether the result is zero-extended or expanded to 16 1600 /// bytes. \n 1601 /// 0: The result is zero-extended to 16 bytes. \n 1602 /// 1: The result is expanded to 16 bytes (this expansion is performed by 1603 /// repeating each bit 8 or 16 times). 1604 /// \returns Returns a 128-bit integer vector representing the result mask of 1605 /// the comparison. 1606 #define _mm_cmpistrm(A, B, M) \ 1607 ((__m128i)__builtin_ia32_pcmpistrm128((__v16qi)(__m128i)(A), \ 1608 (__v16qi)(__m128i)(B), (int)(M))) 1609 1610 /// Uses the immediate operand \a M to perform a comparison of string 1611 /// data with implicitly defined lengths that is contained in source operands 1612 /// \a A and \a B. Returns an integer representing the result index of the 1613 /// comparison. 1614 /// 1615 /// \headerfile <x86intrin.h> 1616 /// 1617 /// \code 1618 /// int _mm_cmpistri(__m128i A, __m128i B, const int M); 1619 /// \endcode 1620 /// 1621 /// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c> 1622 /// instruction. 1623 /// 1624 /// \param A 1625 /// A 128-bit integer vector containing one of the source operands to be 1626 /// compared. 1627 /// \param B 1628 /// A 128-bit integer vector containing one of the source operands to be 1629 /// compared. 1630 /// \param M 1631 /// An 8-bit immediate operand specifying whether the characters are bytes or 1632 /// words, the type of comparison to perform, and the format of the return 1633 /// value. \n 1634 /// Bits [1:0]: Determine source data format. \n 1635 /// 00: 16 unsigned bytes \n 1636 /// 01: 8 unsigned words \n 1637 /// 10: 16 signed bytes \n 1638 /// 11: 8 signed words \n 1639 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1640 /// 00: Subset: Each character in \a B is compared for equality with all 1641 /// the characters in \a A. \n 1642 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1643 /// basis is greater than or equal for even-indexed elements in \a A, 1644 /// and less than or equal for odd-indexed elements in \a A. \n 1645 /// 10: Match: Compare each pair of corresponding characters in \a A and 1646 /// \a B for equality. \n 1647 /// 11: Substring: Search B for substring matches of \a A. \n 1648 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1649 /// mask of the comparison results. \n 1650 /// 00: No effect. \n 1651 /// 01: Negate the bit mask. \n 1652 /// 10: No effect. \n 1653 /// 11: Negate the bit mask only for bits with an index less than or equal 1654 /// to the size of \a A or \a B. \n 1655 /// Bit [6]: Determines whether the index of the lowest set bit or the 1656 /// highest set bit is returned. \n 1657 /// 0: The index of the least significant set bit. \n 1658 /// 1: The index of the most significant set bit. \n 1659 /// \returns Returns an integer representing the result index of the comparison. 1660 #define _mm_cmpistri(A, B, M) \ 1661 ((int)__builtin_ia32_pcmpistri128((__v16qi)(__m128i)(A), \ 1662 (__v16qi)(__m128i)(B), (int)(M))) 1663 1664 /// Uses the immediate operand \a M to perform a comparison of string 1665 /// data with explicitly defined lengths that is contained in source operands 1666 /// \a A and \a B. Returns a 128-bit integer vector representing the result 1667 /// mask of the comparison. 1668 /// 1669 /// \headerfile <x86intrin.h> 1670 /// 1671 /// \code 1672 /// __m128i _mm_cmpestrm(__m128i A, int LA, __m128i B, int LB, const int M); 1673 /// \endcode 1674 /// 1675 /// This intrinsic corresponds to the <c> VPCMPESTRM / PCMPESTRM </c> 1676 /// instruction. 1677 /// 1678 /// \param A 1679 /// A 128-bit integer vector containing one of the source operands to be 1680 /// compared. 1681 /// \param LA 1682 /// An integer that specifies the length of the string in \a A. 1683 /// \param B 1684 /// A 128-bit integer vector containing one of the source operands to be 1685 /// compared. 1686 /// \param LB 1687 /// An integer that specifies the length of the string in \a B. 1688 /// \param M 1689 /// An 8-bit immediate operand specifying whether the characters are bytes or 1690 /// words, the type of comparison to perform, and the format of the return 1691 /// value. \n 1692 /// Bits [1:0]: Determine source data format. \n 1693 /// 00: 16 unsigned bytes \n 1694 /// 01: 8 unsigned words \n 1695 /// 10: 16 signed bytes \n 1696 /// 11: 8 signed words \n 1697 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1698 /// 00: Subset: Each character in \a B is compared for equality with all 1699 /// the characters in \a A. \n 1700 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1701 /// basis is greater than or equal for even-indexed elements in \a A, 1702 /// and less than or equal for odd-indexed elements in \a A. \n 1703 /// 10: Match: Compare each pair of corresponding characters in \a A and 1704 /// \a B for equality. \n 1705 /// 11: Substring: Search \a B for substring matches of \a A. \n 1706 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1707 /// mask of the comparison results. \n 1708 /// 00: No effect. \n 1709 /// 01: Negate the bit mask. \n 1710 /// 10: No effect. \n 1711 /// 11: Negate the bit mask only for bits with an index less than or equal 1712 /// to the size of \a A or \a B. \n 1713 /// Bit [6]: Determines whether the result is zero-extended or expanded to 16 1714 /// bytes. \n 1715 /// 0: The result is zero-extended to 16 bytes. \n 1716 /// 1: The result is expanded to 16 bytes (this expansion is performed by 1717 /// repeating each bit 8 or 16 times). \n 1718 /// \returns Returns a 128-bit integer vector representing the result mask of 1719 /// the comparison. 1720 #define _mm_cmpestrm(A, LA, B, LB, M) \ 1721 ((__m128i)__builtin_ia32_pcmpestrm128((__v16qi)(__m128i)(A), (int)(LA), \ 1722 (__v16qi)(__m128i)(B), (int)(LB), \ 1723 (int)(M))) 1724 1725 /// Uses the immediate operand \a M to perform a comparison of string 1726 /// data with explicitly defined lengths that is contained in source operands 1727 /// \a A and \a B. Returns an integer representing the result index of the 1728 /// comparison. 1729 /// 1730 /// \headerfile <x86intrin.h> 1731 /// 1732 /// \code 1733 /// int _mm_cmpestri(__m128i A, int LA, __m128i B, int LB, const int M); 1734 /// \endcode 1735 /// 1736 /// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c> 1737 /// instruction. 1738 /// 1739 /// \param A 1740 /// A 128-bit integer vector containing one of the source operands to be 1741 /// compared. 1742 /// \param LA 1743 /// An integer that specifies the length of the string in \a A. 1744 /// \param B 1745 /// A 128-bit integer vector containing one of the source operands to be 1746 /// compared. 1747 /// \param LB 1748 /// An integer that specifies the length of the string in \a B. 1749 /// \param M 1750 /// An 8-bit immediate operand specifying whether the characters are bytes or 1751 /// words, the type of comparison to perform, and the format of the return 1752 /// value. \n 1753 /// Bits [1:0]: Determine source data format. \n 1754 /// 00: 16 unsigned bytes \n 1755 /// 01: 8 unsigned words \n 1756 /// 10: 16 signed bytes \n 1757 /// 11: 8 signed words \n 1758 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1759 /// 00: Subset: Each character in \a B is compared for equality with all 1760 /// the characters in \a A. \n 1761 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1762 /// basis is greater than or equal for even-indexed elements in \a A, 1763 /// and less than or equal for odd-indexed elements in \a A. \n 1764 /// 10: Match: Compare each pair of corresponding characters in \a A and 1765 /// \a B for equality. \n 1766 /// 11: Substring: Search B for substring matches of \a A. \n 1767 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1768 /// mask of the comparison results. \n 1769 /// 00: No effect. \n 1770 /// 01: Negate the bit mask. \n 1771 /// 10: No effect. \n 1772 /// 11: Negate the bit mask only for bits with an index less than or equal 1773 /// to the size of \a A or \a B. \n 1774 /// Bit [6]: Determines whether the index of the lowest set bit or the 1775 /// highest set bit is returned. \n 1776 /// 0: The index of the least significant set bit. \n 1777 /// 1: The index of the most significant set bit. \n 1778 /// \returns Returns an integer representing the result index of the comparison. 1779 #define _mm_cmpestri(A, LA, B, LB, M) \ 1780 ((int)__builtin_ia32_pcmpestri128((__v16qi)(__m128i)(A), (int)(LA), \ 1781 (__v16qi)(__m128i)(B), (int)(LB), \ 1782 (int)(M))) 1783 1784 /* SSE4.2 Packed Comparison Intrinsics and EFlag Reading. */ 1785 /// Uses the immediate operand \a M to perform a comparison of string 1786 /// data with implicitly defined lengths that is contained in source operands 1787 /// \a A and \a B. Returns 1 if the bit mask is zero and the length of the 1788 /// string in \a B is the maximum, otherwise, returns 0. 1789 /// 1790 /// \headerfile <x86intrin.h> 1791 /// 1792 /// \code 1793 /// int _mm_cmpistra(__m128i A, __m128i B, const int M); 1794 /// \endcode 1795 /// 1796 /// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c> 1797 /// instruction. 1798 /// 1799 /// \param A 1800 /// A 128-bit integer vector containing one of the source operands to be 1801 /// compared. 1802 /// \param B 1803 /// A 128-bit integer vector containing one of the source operands to be 1804 /// compared. 1805 /// \param M 1806 /// An 8-bit immediate operand specifying whether the characters are bytes or 1807 /// words and the type of comparison to perform. \n 1808 /// Bits [1:0]: Determine source data format. \n 1809 /// 00: 16 unsigned bytes \n 1810 /// 01: 8 unsigned words \n 1811 /// 10: 16 signed bytes \n 1812 /// 11: 8 signed words \n 1813 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1814 /// 00: Subset: Each character in \a B is compared for equality with all 1815 /// the characters in \a A. \n 1816 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1817 /// basis is greater than or equal for even-indexed elements in \a A, 1818 /// and less than or equal for odd-indexed elements in \a A. \n 1819 /// 10: Match: Compare each pair of corresponding characters in \a A and 1820 /// \a B for equality. \n 1821 /// 11: Substring: Search \a B for substring matches of \a A. \n 1822 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1823 /// mask of the comparison results. \n 1824 /// 00: No effect. \n 1825 /// 01: Negate the bit mask. \n 1826 /// 10: No effect. \n 1827 /// 11: Negate the bit mask only for bits with an index less than or equal 1828 /// to the size of \a A or \a B. \n 1829 /// \returns Returns 1 if the bit mask is zero and the length of the string in 1830 /// \a B is the maximum; otherwise, returns 0. 1831 #define _mm_cmpistra(A, B, M) \ 1832 ((int)__builtin_ia32_pcmpistria128((__v16qi)(__m128i)(A), \ 1833 (__v16qi)(__m128i)(B), (int)(M))) 1834 1835 /// Uses the immediate operand \a M to perform a comparison of string 1836 /// data with implicitly defined lengths that is contained in source operands 1837 /// \a A and \a B. Returns 1 if the bit mask is non-zero, otherwise, returns 1838 /// 0. 1839 /// 1840 /// \headerfile <x86intrin.h> 1841 /// 1842 /// \code 1843 /// int _mm_cmpistrc(__m128i A, __m128i B, const int M); 1844 /// \endcode 1845 /// 1846 /// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c> 1847 /// instruction. 1848 /// 1849 /// \param A 1850 /// A 128-bit integer vector containing one of the source operands to be 1851 /// compared. 1852 /// \param B 1853 /// A 128-bit integer vector containing one of the source operands to be 1854 /// compared. 1855 /// \param M 1856 /// An 8-bit immediate operand specifying whether the characters are bytes or 1857 /// words and the type of comparison to perform. \n 1858 /// Bits [1:0]: Determine source data format. \n 1859 /// 00: 16 unsigned bytes \n 1860 /// 01: 8 unsigned words \n 1861 /// 10: 16 signed bytes \n 1862 /// 11: 8 signed words \n 1863 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1864 /// 00: Subset: Each character in \a B is compared for equality with all 1865 /// the characters in \a A. \n 1866 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1867 /// basis is greater than or equal for even-indexed elements in \a A, 1868 /// and less than or equal for odd-indexed elements in \a A. \n 1869 /// 10: Match: Compare each pair of corresponding characters in \a A and 1870 /// \a B for equality. \n 1871 /// 11: Substring: Search B for substring matches of \a A. \n 1872 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1873 /// mask of the comparison results. \n 1874 /// 00: No effect. \n 1875 /// 01: Negate the bit mask. \n 1876 /// 10: No effect. \n 1877 /// 11: Negate the bit mask only for bits with an index less than or equal 1878 /// to the size of \a A or \a B. 1879 /// \returns Returns 1 if the bit mask is non-zero, otherwise, returns 0. 1880 #define _mm_cmpistrc(A, B, M) \ 1881 ((int)__builtin_ia32_pcmpistric128((__v16qi)(__m128i)(A), \ 1882 (__v16qi)(__m128i)(B), (int)(M))) 1883 1884 /// Uses the immediate operand \a M to perform a comparison of string 1885 /// data with implicitly defined lengths that is contained in source operands 1886 /// \a A and \a B. Returns bit 0 of the resulting bit mask. 1887 /// 1888 /// \headerfile <x86intrin.h> 1889 /// 1890 /// \code 1891 /// int _mm_cmpistro(__m128i A, __m128i B, const int M); 1892 /// \endcode 1893 /// 1894 /// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c> 1895 /// instruction. 1896 /// 1897 /// \param A 1898 /// A 128-bit integer vector containing one of the source operands to be 1899 /// compared. 1900 /// \param B 1901 /// A 128-bit integer vector containing one of the source operands to be 1902 /// compared. 1903 /// \param M 1904 /// An 8-bit immediate operand specifying whether the characters are bytes or 1905 /// words and the type of comparison to perform. \n 1906 /// Bits [1:0]: Determine source data format. \n 1907 /// 00: 16 unsigned bytes \n 1908 /// 01: 8 unsigned words \n 1909 /// 10: 16 signed bytes \n 1910 /// 11: 8 signed words \n 1911 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1912 /// 00: Subset: Each character in \a B is compared for equality with all 1913 /// the characters in \a A. \n 1914 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1915 /// basis is greater than or equal for even-indexed elements in \a A, 1916 /// and less than or equal for odd-indexed elements in \a A. \n 1917 /// 10: Match: Compare each pair of corresponding characters in \a A and 1918 /// \a B for equality. \n 1919 /// 11: Substring: Search B for substring matches of \a A. \n 1920 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1921 /// mask of the comparison results. \n 1922 /// 00: No effect. \n 1923 /// 01: Negate the bit mask. \n 1924 /// 10: No effect. \n 1925 /// 11: Negate the bit mask only for bits with an index less than or equal 1926 /// to the size of \a A or \a B. \n 1927 /// \returns Returns bit 0 of the resulting bit mask. 1928 #define _mm_cmpistro(A, B, M) \ 1929 ((int)__builtin_ia32_pcmpistrio128((__v16qi)(__m128i)(A), \ 1930 (__v16qi)(__m128i)(B), (int)(M))) 1931 1932 /// Uses the immediate operand \a M to perform a comparison of string 1933 /// data with implicitly defined lengths that is contained in source operands 1934 /// \a A and \a B. Returns 1 if the length of the string in \a A is less than 1935 /// the maximum, otherwise, returns 0. 1936 /// 1937 /// \headerfile <x86intrin.h> 1938 /// 1939 /// \code 1940 /// int _mm_cmpistrs(__m128i A, __m128i B, const int M); 1941 /// \endcode 1942 /// 1943 /// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c> 1944 /// instruction. 1945 /// 1946 /// \param A 1947 /// A 128-bit integer vector containing one of the source operands to be 1948 /// compared. 1949 /// \param B 1950 /// A 128-bit integer vector containing one of the source operands to be 1951 /// compared. 1952 /// \param M 1953 /// An 8-bit immediate operand specifying whether the characters are bytes or 1954 /// words and the type of comparison to perform. \n 1955 /// Bits [1:0]: Determine source data format. \n 1956 /// 00: 16 unsigned bytes \n 1957 /// 01: 8 unsigned words \n 1958 /// 10: 16 signed bytes \n 1959 /// 11: 8 signed words \n 1960 /// Bits [3:2]: Determine comparison type and aggregation method. \n 1961 /// 00: Subset: Each character in \a B is compared for equality with all 1962 /// the characters in \a A. \n 1963 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 1964 /// basis is greater than or equal for even-indexed elements in \a A, 1965 /// and less than or equal for odd-indexed elements in \a A. \n 1966 /// 10: Match: Compare each pair of corresponding characters in \a A and 1967 /// \a B for equality. \n 1968 /// 11: Substring: Search \a B for substring matches of \a A. \n 1969 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 1970 /// mask of the comparison results. \n 1971 /// 00: No effect. \n 1972 /// 01: Negate the bit mask. \n 1973 /// 10: No effect. \n 1974 /// 11: Negate the bit mask only for bits with an index less than or equal 1975 /// to the size of \a A or \a B. \n 1976 /// \returns Returns 1 if the length of the string in \a A is less than the 1977 /// maximum, otherwise, returns 0. 1978 #define _mm_cmpistrs(A, B, M) \ 1979 ((int)__builtin_ia32_pcmpistris128((__v16qi)(__m128i)(A), \ 1980 (__v16qi)(__m128i)(B), (int)(M))) 1981 1982 /// Uses the immediate operand \a M to perform a comparison of string 1983 /// data with implicitly defined lengths that is contained in source operands 1984 /// \a A and \a B. Returns 1 if the length of the string in \a B is less than 1985 /// the maximum, otherwise, returns 0. 1986 /// 1987 /// \headerfile <x86intrin.h> 1988 /// 1989 /// \code 1990 /// int _mm_cmpistrz(__m128i A, __m128i B, const int M); 1991 /// \endcode 1992 /// 1993 /// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c> 1994 /// instruction. 1995 /// 1996 /// \param A 1997 /// A 128-bit integer vector containing one of the source operands to be 1998 /// compared. 1999 /// \param B 2000 /// A 128-bit integer vector containing one of the source operands to be 2001 /// compared. 2002 /// \param M 2003 /// An 8-bit immediate operand specifying whether the characters are bytes or 2004 /// words and the type of comparison to perform. \n 2005 /// Bits [1:0]: Determine source data format. \n 2006 /// 00: 16 unsigned bytes \n 2007 /// 01: 8 unsigned words \n 2008 /// 10: 16 signed bytes \n 2009 /// 11: 8 signed words \n 2010 /// Bits [3:2]: Determine comparison type and aggregation method. \n 2011 /// 00: Subset: Each character in \a B is compared for equality with all 2012 /// the characters in \a A. \n 2013 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 2014 /// basis is greater than or equal for even-indexed elements in \a A, 2015 /// and less than or equal for odd-indexed elements in \a A. \n 2016 /// 10: Match: Compare each pair of corresponding characters in \a A and 2017 /// \a B for equality. \n 2018 /// 11: Substring: Search \a B for substring matches of \a A. \n 2019 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 2020 /// mask of the comparison results. \n 2021 /// 00: No effect. \n 2022 /// 01: Negate the bit mask. \n 2023 /// 10: No effect. \n 2024 /// 11: Negate the bit mask only for bits with an index less than or equal 2025 /// to the size of \a A or \a B. 2026 /// \returns Returns 1 if the length of the string in \a B is less than the 2027 /// maximum, otherwise, returns 0. 2028 #define _mm_cmpistrz(A, B, M) \ 2029 ((int)__builtin_ia32_pcmpistriz128((__v16qi)(__m128i)(A), \ 2030 (__v16qi)(__m128i)(B), (int)(M))) 2031 2032 /// Uses the immediate operand \a M to perform a comparison of string 2033 /// data with explicitly defined lengths that is contained in source operands 2034 /// \a A and \a B. Returns 1 if the bit mask is zero and the length of the 2035 /// string in \a B is the maximum, otherwise, returns 0. 2036 /// 2037 /// \headerfile <x86intrin.h> 2038 /// 2039 /// \code 2040 /// int _mm_cmpestra(__m128i A, int LA, __m128i B, int LB, const int M); 2041 /// \endcode 2042 /// 2043 /// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c> 2044 /// instruction. 2045 /// 2046 /// \param A 2047 /// A 128-bit integer vector containing one of the source operands to be 2048 /// compared. 2049 /// \param LA 2050 /// An integer that specifies the length of the string in \a A. 2051 /// \param B 2052 /// A 128-bit integer vector containing one of the source operands to be 2053 /// compared. 2054 /// \param LB 2055 /// An integer that specifies the length of the string in \a B. 2056 /// \param M 2057 /// An 8-bit immediate operand specifying whether the characters are bytes or 2058 /// words and the type of comparison to perform. \n 2059 /// Bits [1:0]: Determine source data format. \n 2060 /// 00: 16 unsigned bytes \n 2061 /// 01: 8 unsigned words \n 2062 /// 10: 16 signed bytes \n 2063 /// 11: 8 signed words \n 2064 /// Bits [3:2]: Determine comparison type and aggregation method. \n 2065 /// 00: Subset: Each character in \a B is compared for equality with all 2066 /// the characters in \a A. \n 2067 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 2068 /// basis is greater than or equal for even-indexed elements in \a A, 2069 /// and less than or equal for odd-indexed elements in \a A. \n 2070 /// 10: Match: Compare each pair of corresponding characters in \a A and 2071 /// \a B for equality. \n 2072 /// 11: Substring: Search \a B for substring matches of \a A. \n 2073 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 2074 /// mask of the comparison results. \n 2075 /// 00: No effect. \n 2076 /// 01: Negate the bit mask. \n 2077 /// 10: No effect. \n 2078 /// 11: Negate the bit mask only for bits with an index less than or equal 2079 /// to the size of \a A or \a B. 2080 /// \returns Returns 1 if the bit mask is zero and the length of the string in 2081 /// \a B is the maximum, otherwise, returns 0. 2082 #define _mm_cmpestra(A, LA, B, LB, M) \ 2083 ((int)__builtin_ia32_pcmpestria128((__v16qi)(__m128i)(A), (int)(LA), \ 2084 (__v16qi)(__m128i)(B), (int)(LB), \ 2085 (int)(M))) 2086 2087 /// Uses the immediate operand \a M to perform a comparison of string 2088 /// data with explicitly defined lengths that is contained in source operands 2089 /// \a A and \a B. Returns 1 if the resulting mask is non-zero, otherwise, 2090 /// returns 0. 2091 /// 2092 /// \headerfile <x86intrin.h> 2093 /// 2094 /// \code 2095 /// int _mm_cmpestrc(__m128i A, int LA, __m128i B, int LB, const int M); 2096 /// \endcode 2097 /// 2098 /// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c> 2099 /// instruction. 2100 /// 2101 /// \param A 2102 /// A 128-bit integer vector containing one of the source operands to be 2103 /// compared. 2104 /// \param LA 2105 /// An integer that specifies the length of the string in \a A. 2106 /// \param B 2107 /// A 128-bit integer vector containing one of the source operands to be 2108 /// compared. 2109 /// \param LB 2110 /// An integer that specifies the length of the string in \a B. 2111 /// \param M 2112 /// An 8-bit immediate operand specifying whether the characters are bytes or 2113 /// words and the type of comparison to perform. \n 2114 /// Bits [1:0]: Determine source data format. \n 2115 /// 00: 16 unsigned bytes \n 2116 /// 01: 8 unsigned words \n 2117 /// 10: 16 signed bytes \n 2118 /// 11: 8 signed words \n 2119 /// Bits [3:2]: Determine comparison type and aggregation method. \n 2120 /// 00: Subset: Each character in \a B is compared for equality with all 2121 /// the characters in \a A. \n 2122 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 2123 /// basis is greater than or equal for even-indexed elements in \a A, 2124 /// and less than or equal for odd-indexed elements in \a A. \n 2125 /// 10: Match: Compare each pair of corresponding characters in \a A and 2126 /// \a B for equality. \n 2127 /// 11: Substring: Search \a B for substring matches of \a A. \n 2128 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 2129 /// mask of the comparison results. \n 2130 /// 00: No effect. \n 2131 /// 01: Negate the bit mask. \n 2132 /// 10: No effect. \n 2133 /// 11: Negate the bit mask only for bits with an index less than or equal 2134 /// to the size of \a A or \a B. \n 2135 /// \returns Returns 1 if the resulting mask is non-zero, otherwise, returns 0. 2136 #define _mm_cmpestrc(A, LA, B, LB, M) \ 2137 ((int)__builtin_ia32_pcmpestric128((__v16qi)(__m128i)(A), (int)(LA), \ 2138 (__v16qi)(__m128i)(B), (int)(LB), \ 2139 (int)(M))) 2140 2141 /// Uses the immediate operand \a M to perform a comparison of string 2142 /// data with explicitly defined lengths that is contained in source operands 2143 /// \a A and \a B. Returns bit 0 of the resulting bit mask. 2144 /// 2145 /// \headerfile <x86intrin.h> 2146 /// 2147 /// \code 2148 /// int _mm_cmpestro(__m128i A, int LA, __m128i B, int LB, const int M); 2149 /// \endcode 2150 /// 2151 /// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c> 2152 /// instruction. 2153 /// 2154 /// \param A 2155 /// A 128-bit integer vector containing one of the source operands to be 2156 /// compared. 2157 /// \param LA 2158 /// An integer that specifies the length of the string in \a A. 2159 /// \param B 2160 /// A 128-bit integer vector containing one of the source operands to be 2161 /// compared. 2162 /// \param LB 2163 /// An integer that specifies the length of the string in \a B. 2164 /// \param M 2165 /// An 8-bit immediate operand specifying whether the characters are bytes or 2166 /// words and the type of comparison to perform. \n 2167 /// Bits [1:0]: Determine source data format. \n 2168 /// 00: 16 unsigned bytes \n 2169 /// 01: 8 unsigned words \n 2170 /// 10: 16 signed bytes \n 2171 /// 11: 8 signed words \n 2172 /// Bits [3:2]: Determine comparison type and aggregation method. \n 2173 /// 00: Subset: Each character in \a B is compared for equality with all 2174 /// the characters in \a A. \n 2175 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 2176 /// basis is greater than or equal for even-indexed elements in \a A, 2177 /// and less than or equal for odd-indexed elements in \a A. \n 2178 /// 10: Match: Compare each pair of corresponding characters in \a A and 2179 /// \a B for equality. \n 2180 /// 11: Substring: Search \a B for substring matches of \a A. \n 2181 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 2182 /// mask of the comparison results. \n 2183 /// 00: No effect. \n 2184 /// 01: Negate the bit mask. \n 2185 /// 10: No effect. \n 2186 /// 11: Negate the bit mask only for bits with an index less than or equal 2187 /// to the size of \a A or \a B. 2188 /// \returns Returns bit 0 of the resulting bit mask. 2189 #define _mm_cmpestro(A, LA, B, LB, M) \ 2190 ((int)__builtin_ia32_pcmpestrio128((__v16qi)(__m128i)(A), (int)(LA), \ 2191 (__v16qi)(__m128i)(B), (int)(LB), \ 2192 (int)(M))) 2193 2194 /// Uses the immediate operand \a M to perform a comparison of string 2195 /// data with explicitly defined lengths that is contained in source operands 2196 /// \a A and \a B. Returns 1 if the length of the string in \a A is less than 2197 /// the maximum, otherwise, returns 0. 2198 /// 2199 /// \headerfile <x86intrin.h> 2200 /// 2201 /// \code 2202 /// int _mm_cmpestrs(__m128i A, int LA, __m128i B, int LB, const int M); 2203 /// \endcode 2204 /// 2205 /// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c> 2206 /// instruction. 2207 /// 2208 /// \param A 2209 /// A 128-bit integer vector containing one of the source operands to be 2210 /// compared. 2211 /// \param LA 2212 /// An integer that specifies the length of the string in \a A. 2213 /// \param B 2214 /// A 128-bit integer vector containing one of the source operands to be 2215 /// compared. 2216 /// \param LB 2217 /// An integer that specifies the length of the string in \a B. 2218 /// \param M 2219 /// An 8-bit immediate operand specifying whether the characters are bytes or 2220 /// words and the type of comparison to perform. \n 2221 /// Bits [1:0]: Determine source data format. \n 2222 /// 00: 16 unsigned bytes \n 2223 /// 01: 8 unsigned words \n 2224 /// 10: 16 signed bytes \n 2225 /// 11: 8 signed words \n 2226 /// Bits [3:2]: Determine comparison type and aggregation method. \n 2227 /// 00: Subset: Each character in \a B is compared for equality with all 2228 /// the characters in \a A. \n 2229 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 2230 /// basis is greater than or equal for even-indexed elements in \a A, 2231 /// and less than or equal for odd-indexed elements in \a A. \n 2232 /// 10: Match: Compare each pair of corresponding characters in \a A and 2233 /// \a B for equality. \n 2234 /// 11: Substring: Search \a B for substring matches of \a A. \n 2235 /// Bits [5:4]: Determine whether to perform a one's complement in the bit 2236 /// mask of the comparison results. \n 2237 /// 00: No effect. \n 2238 /// 01: Negate the bit mask. \n 2239 /// 10: No effect. \n 2240 /// 11: Negate the bit mask only for bits with an index less than or equal 2241 /// to the size of \a A or \a B. \n 2242 /// \returns Returns 1 if the length of the string in \a A is less than the 2243 /// maximum, otherwise, returns 0. 2244 #define _mm_cmpestrs(A, LA, B, LB, M) \ 2245 ((int)__builtin_ia32_pcmpestris128((__v16qi)(__m128i)(A), (int)(LA), \ 2246 (__v16qi)(__m128i)(B), (int)(LB), \ 2247 (int)(M))) 2248 2249 /// Uses the immediate operand \a M to perform a comparison of string 2250 /// data with explicitly defined lengths that is contained in source operands 2251 /// \a A and \a B. Returns 1 if the length of the string in \a B is less than 2252 /// the maximum, otherwise, returns 0. 2253 /// 2254 /// \headerfile <x86intrin.h> 2255 /// 2256 /// \code 2257 /// int _mm_cmpestrz(__m128i A, int LA, __m128i B, int LB, const int M); 2258 /// \endcode 2259 /// 2260 /// This intrinsic corresponds to the <c> VPCMPESTRI </c> instruction. 2261 /// 2262 /// \param A 2263 /// A 128-bit integer vector containing one of the source operands to be 2264 /// compared. 2265 /// \param LA 2266 /// An integer that specifies the length of the string in \a A. 2267 /// \param B 2268 /// A 128-bit integer vector containing one of the source operands to be 2269 /// compared. 2270 /// \param LB 2271 /// An integer that specifies the length of the string in \a B. 2272 /// \param M 2273 /// An 8-bit immediate operand specifying whether the characters are bytes or 2274 /// words and the type of comparison to perform. \n 2275 /// Bits [1:0]: Determine source data format. \n 2276 /// 00: 16 unsigned bytes \n 2277 /// 01: 8 unsigned words \n 2278 /// 10: 16 signed bytes \n 2279 /// 11: 8 signed words \n 2280 /// Bits [3:2]: Determine comparison type and aggregation method. \n 2281 /// 00: Subset: Each character in \a B is compared for equality with all 2282 /// the characters in \a A. \n 2283 /// 01: Ranges: Each character in \a B is compared to \a A. The comparison 2284 /// basis is greater than or equal for even-indexed elements in \a A, 2285 /// and less than or equal for odd-indexed elements in \a A. \n 2286 /// 10: Match: Compare each pair of corresponding characters in \a A and 2287 /// \a B for equality. \n 2288 /// 11: Substring: Search \a B for substring matches of \a A. \n 2289 /// Bits [5:4]: Determine whether to perform a one's complement on the bit 2290 /// mask of the comparison results. \n 2291 /// 00: No effect. \n 2292 /// 01: Negate the bit mask. \n 2293 /// 10: No effect. \n 2294 /// 11: Negate the bit mask only for bits with an index less than or equal 2295 /// to the size of \a A or \a B. 2296 /// \returns Returns 1 if the length of the string in \a B is less than the 2297 /// maximum, otherwise, returns 0. 2298 #define _mm_cmpestrz(A, LA, B, LB, M) \ 2299 ((int)__builtin_ia32_pcmpestriz128((__v16qi)(__m128i)(A), (int)(LA), \ 2300 (__v16qi)(__m128i)(B), (int)(LB), \ 2301 (int)(M))) 2302 2303 /* SSE4.2 Compare Packed Data -- Greater Than. */ 2304 /// Compares each of the corresponding 64-bit values of the 128-bit 2305 /// integer vectors to determine if the values in the first operand are 2306 /// greater than those in the second operand. 2307 /// 2308 /// \headerfile <x86intrin.h> 2309 /// 2310 /// This intrinsic corresponds to the <c> VPCMPGTQ / PCMPGTQ </c> instruction. 2311 /// 2312 /// \param __V1 2313 /// A 128-bit integer vector. 2314 /// \param __V2 2315 /// A 128-bit integer vector. 2316 /// \returns A 128-bit integer vector containing the comparison results. 2317 static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi64(__m128i __V1, 2318 __m128i __V2) { 2319 return (__m128i)((__v2di)__V1 > (__v2di)__V2); 2320 } 2321 2322 #undef __DEFAULT_FN_ATTRS 2323 2324 #include <popcntintrin.h> 2325 2326 #include <crc32intrin.h> 2327 2328 #endif /* __SMMINTRIN_H */ 2329