clang  16.0.0git
smmintrin.h
Go to the documentation of this file.
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 */
_mm_blendv_pd
static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_blendv_pd(__m128d __V1, __m128d __V2, __m128d __M)
Returns a 128-bit vector of [2 x double] where the values are selected from either the first or secon...
Definition: smmintrin.h:436
_mm_max_epu32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu32(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [4 x u32] and returns a 128-bit vector ...
Definition: smmintrin.h:792
_mm_cvtepu8_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi32(__m128i __V)
Zero-extends each of the lower four 8-bit integer elements of a 128-bit vector of [16 x i8] to 32-bit...
Definition: smmintrin.h:1356
_mm_max_epu16
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu16(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [8 x u16] and returns a 128-bit vector ...
Definition: smmintrin.h:720
_mm_min_epu32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu32(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [4 x u32] and returns a 128-bit vector ...
Definition: smmintrin.h:774
_mm_max_epi8
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi8(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [16 x i8] and returns a 128-bit vector ...
Definition: smmintrin.h:684
_mm_blendv_epi8
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_blendv_epi8(__m128i __V1, __m128i __V2, __m128i __M)
Returns a 128-bit vector of [16 x i8] where the values are selected from either of the first or secon...
Definition: smmintrin.h:490
_mm_cvtepi8_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi64(__m128i __V)
Sign-extends each of the lower two 8-bit integer elements of a 128-bit integer vector of [16 x i8] to...
Definition: smmintrin.h:1261
_mm_cvtepu16_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi32(__m128i __V)
Zero-extends each of the lower four 16-bit integer elements of a 128-bit integer vector of [8 x i16] ...
Definition: smmintrin.h:1392
_mm_cvtepu16_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi64(__m128i __V)
Zero-extends each of the lower two 16-bit integer elements of a 128-bit integer vector of [8 x i16] t...
Definition: smmintrin.h:1410
_mm_blendv_ps
static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_blendv_ps(__m128 __V1, __m128 __V2, __m128 __M)
Returns a 128-bit vector of [4 x float] where the values are selected from either the first or second...
Definition: smmintrin.h:463
_mm_stream_load_si128
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_stream_load_si128(__m128i const *__V)
Loads integer values from a 128-bit aligned memory location to a 128-bit integer vector.
Definition: smmintrin.h:648
_mm_testz_si128
static __inline__ int __DEFAULT_FN_ATTRS _mm_testz_si128(__m128i __M, __m128i __V)
Tests whether the specified bits in a 128-bit integer vector are all zeros.
Definition: smmintrin.h:1093
_mm_cvtepi32_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi32_epi64(__m128i __V)
Sign-extends each of the lower two 32-bit integer elements of a 128-bit integer vector of [4 x i32] t...
Definition: smmintrin.h:1317
_mm_cvtepi8_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi32(__m128i __V)
Sign-extends each of the lower four 8-bit integer elements of a 128-bit vector of [16 x i8] to 32-bit...
Definition: smmintrin.h:1241
tmmintrin.h
_mm_cvtepu32_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu32_epi64(__m128i __V)
Zero-extends each of the lower two 32-bit integer elements of a 128-bit integer vector of [4 x i32] t...
Definition: smmintrin.h:1428
_mm_min_epu16
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu16(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [8 x u16] and returns a 128-bit vector ...
Definition: smmintrin.h:702
_mm_cvtepi8_epi16
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi16(__m128i __V)
Sign-extends each of the lower eight 8-bit integer elements of a 128-bit vector of [16 x i8] to 16-bi...
Definition: smmintrin.h:1219
__DEFAULT_FN_ATTRS
#define __DEFAULT_FN_ATTRS
Definition: smmintrin.h:1524
crc32intrin.h
_mm_packus_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi32(__m128i __V1, __m128i __V2)
Converts 32-bit signed integers from both 128-bit integer vector operands into 16-bit unsigned intege...
Definition: smmintrin.h:1456
_mm_cvtepu8_epi16
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi16(__m128i __V)
Zero-extends each of the lower eight 8-bit integer elements of a 128-bit vector of [16 x i8] to 16-bi...
Definition: smmintrin.h:1336
_mm_min_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi32(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [4 x i32] and returns a 128-bit vector ...
Definition: smmintrin.h:738
_mm_minpos_epu16
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_minpos_epu16(__m128i __V)
Finds the minimum unsigned 16-bit element in the input 128-bit vector of [8 x u16] and returns it and...
Definition: smmintrin.h:1514
_mm_cvtepi16_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi32(__m128i __V)
Sign-extends each of the lower four 16-bit integer elements of a 128-bit integer vector of [8 x i16] ...
Definition: smmintrin.h:1281
_mm_testnzc_si128
static __inline__ int __DEFAULT_FN_ATTRS _mm_testnzc_si128(__m128i __M, __m128i __V)
Tests whether the specified bits in a 128-bit integer vector are neither all zeros nor all ones.
Definition: smmintrin.h:1128
_mm_mullo_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi32(__m128i __V1, __m128i __V2)
Multiples corresponding elements of two 128-bit vectors of [4 x i32] and returns the lower 32 bits of...
Definition: smmintrin.h:539
_mm_cvtepu8_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi64(__m128i __V)
Zero-extends each of the lower two 8-bit integer elements of a 128-bit integer vector of [16 x i8] to...
Definition: smmintrin.h:1374
_mm_testc_si128
static __inline__ int __DEFAULT_FN_ATTRS _mm_testc_si128(__m128i __M, __m128i __V)
Tests whether the specified bits in a 128-bit integer vector are all ones.
Definition: smmintrin.h:1110
popcntintrin.h
_mm_min_epi8
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi8(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [16 x i8] and returns a 128-bit vector ...
Definition: smmintrin.h:666
_mm_max_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi32(__m128i __V1, __m128i __V2)
Compares the corresponding elements of two 128-bit vectors of [4 x i32] and returns a 128-bit vector ...
Definition: smmintrin.h:756
_mm_mul_epi32
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epi32(__m128i __V1, __m128i __V2)
Multiplies corresponding even-indexed elements of two 128-bit vectors of [4 x i32] and returns a 128-...
Definition: smmintrin.h:558
_mm_cvtepi16_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi64(__m128i __V)
Sign-extends each of the lower two 16-bit integer elements of a 128-bit integer vector of [8 x i16] t...
Definition: smmintrin.h:1299
_mm_cmpgt_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi64(__m128i __V1, __m128i __V2)
Compares each of the corresponding 64-bit values of the 128-bit integer vectors to determine if the v...
Definition: smmintrin.h:2317
_mm_cmpeq_epi64
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi64(__m128i __V1, __m128i __V2)
Compares each of the corresponding 64-bit values of the 128-bit integer vectors for equality.
Definition: smmintrin.h:1200