1 /*===---- mmintrin.h - MMX intrinsics --------------------------------------===
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to deal
5 * in the Software without restriction, including without limitation the rights
6 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 * copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 *===-----------------------------------------------------------------------===
27 typedef long long __m64 __attribute__((__vector_size__(8)));
29 typedef long long __v1di __attribute__((__vector_size__(8)));
30 typedef int __v2si __attribute__((__vector_size__(8)));
31 typedef short __v4hi __attribute__((__vector_size__(8)));
32 typedef char __v8qi __attribute__((__vector_size__(8)));
34 /* Define the default attributes for the functions in this file. */
35 #define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("mmx"), __min_vector_width__(64)))
37 /// Clears the MMX state by setting the state of the x87 stack registers
40 /// \headerfile <x86intrin.h>
42 /// This intrinsic corresponds to the <c> EMMS </c> instruction.
44 static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("mmx")))
47 __builtin_ia32_emms();
50 /// Constructs a 64-bit integer vector, setting the lower 32 bits to the
51 /// value of the 32-bit integer parameter and setting the upper 32 bits to 0.
53 /// \headerfile <x86intrin.h>
55 /// This intrinsic corresponds to the <c> MOVD </c> instruction.
58 /// A 32-bit integer value.
59 /// \returns A 64-bit integer vector. The lower 32 bits contain the value of the
60 /// parameter. The upper 32 bits are set to 0.
61 static __inline__ __m64 __DEFAULT_FN_ATTRS
62 _mm_cvtsi32_si64(int __i)
64 return (__m64)__builtin_ia32_vec_init_v2si(__i, 0);
67 /// Returns the lower 32 bits of a 64-bit integer vector as a 32-bit
70 /// \headerfile <x86intrin.h>
72 /// This intrinsic corresponds to the <c> MOVD </c> instruction.
75 /// A 64-bit integer vector.
76 /// \returns A 32-bit signed integer value containing the lower 32 bits of the
78 static __inline__ int __DEFAULT_FN_ATTRS
79 _mm_cvtsi64_si32(__m64 __m)
81 return __builtin_ia32_vec_ext_v2si((__v2si)__m, 0);
84 /// Casts a 64-bit signed integer value into a 64-bit integer vector.
86 /// \headerfile <x86intrin.h>
88 /// This intrinsic corresponds to the <c> MOVQ </c> instruction.
91 /// A 64-bit signed integer.
92 /// \returns A 64-bit integer vector containing the same bitwise pattern as the
94 static __inline__ __m64 __DEFAULT_FN_ATTRS
95 _mm_cvtsi64_m64(long long __i)
100 /// Casts a 64-bit integer vector into a 64-bit signed integer value.
102 /// \headerfile <x86intrin.h>
104 /// This intrinsic corresponds to the <c> MOVQ </c> instruction.
107 /// A 64-bit integer vector.
108 /// \returns A 64-bit signed integer containing the same bitwise pattern as the
110 static __inline__ long long __DEFAULT_FN_ATTRS
111 _mm_cvtm64_si64(__m64 __m)
113 return (long long)__m;
116 /// Converts 16-bit signed integers from both 64-bit integer vector
117 /// parameters of [4 x i16] into 8-bit signed integer values, and constructs
118 /// a 64-bit integer vector of [8 x i8] as the result. Positive values
119 /// greater than 0x7F are saturated to 0x7F. Negative values less than 0x80
120 /// are saturated to 0x80.
122 /// \headerfile <x86intrin.h>
124 /// This intrinsic corresponds to the <c> PACKSSWB </c> instruction.
127 /// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
128 /// 16-bit signed integer and is converted to an 8-bit signed integer with
129 /// saturation. Positive values greater than 0x7F are saturated to 0x7F.
130 /// Negative values less than 0x80 are saturated to 0x80. The converted
131 /// [4 x i8] values are written to the lower 32 bits of the result.
133 /// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
134 /// 16-bit signed integer and is converted to an 8-bit signed integer with
135 /// saturation. Positive values greater than 0x7F are saturated to 0x7F.
136 /// Negative values less than 0x80 are saturated to 0x80. The converted
137 /// [4 x i8] values are written to the upper 32 bits of the result.
138 /// \returns A 64-bit integer vector of [8 x i8] containing the converted
140 static __inline__ __m64 __DEFAULT_FN_ATTRS
141 _mm_packs_pi16(__m64 __m1, __m64 __m2)
143 return (__m64)__builtin_ia32_packsswb((__v4hi)__m1, (__v4hi)__m2);
146 /// Converts 32-bit signed integers from both 64-bit integer vector
147 /// parameters of [2 x i32] into 16-bit signed integer values, and constructs
148 /// a 64-bit integer vector of [4 x i16] as the result. Positive values
149 /// greater than 0x7FFF are saturated to 0x7FFF. Negative values less than
150 /// 0x8000 are saturated to 0x8000.
152 /// \headerfile <x86intrin.h>
154 /// This intrinsic corresponds to the <c> PACKSSDW </c> instruction.
157 /// A 64-bit integer vector of [2 x i32]. Each 32-bit element is treated as a
158 /// 32-bit signed integer and is converted to a 16-bit signed integer with
159 /// saturation. Positive values greater than 0x7FFF are saturated to 0x7FFF.
160 /// Negative values less than 0x8000 are saturated to 0x8000. The converted
161 /// [2 x i16] values are written to the lower 32 bits of the result.
163 /// A 64-bit integer vector of [2 x i32]. Each 32-bit element is treated as a
164 /// 32-bit signed integer and is converted to a 16-bit signed integer with
165 /// saturation. Positive values greater than 0x7FFF are saturated to 0x7FFF.
166 /// Negative values less than 0x8000 are saturated to 0x8000. The converted
167 /// [2 x i16] values are written to the upper 32 bits of the result.
168 /// \returns A 64-bit integer vector of [4 x i16] containing the converted
170 static __inline__ __m64 __DEFAULT_FN_ATTRS
171 _mm_packs_pi32(__m64 __m1, __m64 __m2)
173 return (__m64)__builtin_ia32_packssdw((__v2si)__m1, (__v2si)__m2);
176 /// Converts 16-bit signed integers from both 64-bit integer vector
177 /// parameters of [4 x i16] into 8-bit unsigned integer values, and
178 /// constructs a 64-bit integer vector of [8 x i8] as the result. Values
179 /// greater than 0xFF are saturated to 0xFF. Values less than 0 are saturated
182 /// \headerfile <x86intrin.h>
184 /// This intrinsic corresponds to the <c> PACKUSWB </c> instruction.
187 /// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
188 /// 16-bit signed integer and is converted to an 8-bit unsigned integer with
189 /// saturation. Values greater than 0xFF are saturated to 0xFF. Values less
190 /// than 0 are saturated to 0. The converted [4 x i8] values are written to
191 /// the lower 32 bits of the result.
193 /// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
194 /// 16-bit signed integer and is converted to an 8-bit unsigned integer with
195 /// saturation. Values greater than 0xFF are saturated to 0xFF. Values less
196 /// than 0 are saturated to 0. The converted [4 x i8] values are written to
197 /// the upper 32 bits of the result.
198 /// \returns A 64-bit integer vector of [8 x i8] containing the converted
200 static __inline__ __m64 __DEFAULT_FN_ATTRS
201 _mm_packs_pu16(__m64 __m1, __m64 __m2)
203 return (__m64)__builtin_ia32_packuswb((__v4hi)__m1, (__v4hi)__m2);
206 /// Unpacks the upper 32 bits from two 64-bit integer vectors of [8 x i8]
207 /// and interleaves them into a 64-bit integer vector of [8 x i8].
209 /// \headerfile <x86intrin.h>
211 /// This intrinsic corresponds to the <c> PUNPCKHBW </c> instruction.
214 /// A 64-bit integer vector of [8 x i8]. \n
215 /// Bits [39:32] are written to bits [7:0] of the result. \n
216 /// Bits [47:40] are written to bits [23:16] of the result. \n
217 /// Bits [55:48] are written to bits [39:32] of the result. \n
218 /// Bits [63:56] are written to bits [55:48] of the result.
220 /// A 64-bit integer vector of [8 x i8].
221 /// Bits [39:32] are written to bits [15:8] of the result. \n
222 /// Bits [47:40] are written to bits [31:24] of the result. \n
223 /// Bits [55:48] are written to bits [47:40] of the result. \n
224 /// Bits [63:56] are written to bits [63:56] of the result.
225 /// \returns A 64-bit integer vector of [8 x i8] containing the interleaved
227 static __inline__ __m64 __DEFAULT_FN_ATTRS
228 _mm_unpackhi_pi8(__m64 __m1, __m64 __m2)
230 return (__m64)__builtin_ia32_punpckhbw((__v8qi)__m1, (__v8qi)__m2);
233 /// Unpacks the upper 32 bits from two 64-bit integer vectors of
234 /// [4 x i16] and interleaves them into a 64-bit integer vector of [4 x i16].
236 /// \headerfile <x86intrin.h>
238 /// This intrinsic corresponds to the <c> PUNPCKHWD </c> instruction.
241 /// A 64-bit integer vector of [4 x i16].
242 /// Bits [47:32] are written to bits [15:0] of the result. \n
243 /// Bits [63:48] are written to bits [47:32] of the result.
245 /// A 64-bit integer vector of [4 x i16].
246 /// Bits [47:32] are written to bits [31:16] of the result. \n
247 /// Bits [63:48] are written to bits [63:48] of the result.
248 /// \returns A 64-bit integer vector of [4 x i16] containing the interleaved
250 static __inline__ __m64 __DEFAULT_FN_ATTRS
251 _mm_unpackhi_pi16(__m64 __m1, __m64 __m2)
253 return (__m64)__builtin_ia32_punpckhwd((__v4hi)__m1, (__v4hi)__m2);
256 /// Unpacks the upper 32 bits from two 64-bit integer vectors of
257 /// [2 x i32] and interleaves them into a 64-bit integer vector of [2 x i32].
259 /// \headerfile <x86intrin.h>
261 /// This intrinsic corresponds to the <c> PUNPCKHDQ </c> instruction.
264 /// A 64-bit integer vector of [2 x i32]. The upper 32 bits are written to
265 /// the lower 32 bits of the result.
267 /// A 64-bit integer vector of [2 x i32]. The upper 32 bits are written to
268 /// the upper 32 bits of the result.
269 /// \returns A 64-bit integer vector of [2 x i32] containing the interleaved
271 static __inline__ __m64 __DEFAULT_FN_ATTRS
272 _mm_unpackhi_pi32(__m64 __m1, __m64 __m2)
274 return (__m64)__builtin_ia32_punpckhdq((__v2si)__m1, (__v2si)__m2);
277 /// Unpacks the lower 32 bits from two 64-bit integer vectors of [8 x i8]
278 /// and interleaves them into a 64-bit integer vector of [8 x i8].
280 /// \headerfile <x86intrin.h>
282 /// This intrinsic corresponds to the <c> PUNPCKLBW </c> instruction.
285 /// A 64-bit integer vector of [8 x i8].
286 /// Bits [7:0] are written to bits [7:0] of the result. \n
287 /// Bits [15:8] are written to bits [23:16] of the result. \n
288 /// Bits [23:16] are written to bits [39:32] of the result. \n
289 /// Bits [31:24] are written to bits [55:48] of the result.
291 /// A 64-bit integer vector of [8 x i8].
292 /// Bits [7:0] are written to bits [15:8] of the result. \n
293 /// Bits [15:8] are written to bits [31:24] of the result. \n
294 /// Bits [23:16] are written to bits [47:40] of the result. \n
295 /// Bits [31:24] are written to bits [63:56] of the result.
296 /// \returns A 64-bit integer vector of [8 x i8] containing the interleaved
298 static __inline__ __m64 __DEFAULT_FN_ATTRS
299 _mm_unpacklo_pi8(__m64 __m1, __m64 __m2)
301 return (__m64)__builtin_ia32_punpcklbw((__v8qi)__m1, (__v8qi)__m2);
304 /// Unpacks the lower 32 bits from two 64-bit integer vectors of
305 /// [4 x i16] and interleaves them into a 64-bit integer vector of [4 x i16].
307 /// \headerfile <x86intrin.h>
309 /// This intrinsic corresponds to the <c> PUNPCKLWD </c> instruction.
312 /// A 64-bit integer vector of [4 x i16].
313 /// Bits [15:0] are written to bits [15:0] of the result. \n
314 /// Bits [31:16] are written to bits [47:32] of the result.
316 /// A 64-bit integer vector of [4 x i16].
317 /// Bits [15:0] are written to bits [31:16] of the result. \n
318 /// Bits [31:16] are written to bits [63:48] of the result.
319 /// \returns A 64-bit integer vector of [4 x i16] containing the interleaved
321 static __inline__ __m64 __DEFAULT_FN_ATTRS
322 _mm_unpacklo_pi16(__m64 __m1, __m64 __m2)
324 return (__m64)__builtin_ia32_punpcklwd((__v4hi)__m1, (__v4hi)__m2);
327 /// Unpacks the lower 32 bits from two 64-bit integer vectors of
328 /// [2 x i32] and interleaves them into a 64-bit integer vector of [2 x i32].
330 /// \headerfile <x86intrin.h>
332 /// This intrinsic corresponds to the <c> PUNPCKLDQ </c> instruction.
335 /// A 64-bit integer vector of [2 x i32]. The lower 32 bits are written to
336 /// the lower 32 bits of the result.
338 /// A 64-bit integer vector of [2 x i32]. The lower 32 bits are written to
339 /// the upper 32 bits of the result.
340 /// \returns A 64-bit integer vector of [2 x i32] containing the interleaved
342 static __inline__ __m64 __DEFAULT_FN_ATTRS
343 _mm_unpacklo_pi32(__m64 __m1, __m64 __m2)
345 return (__m64)__builtin_ia32_punpckldq((__v2si)__m1, (__v2si)__m2);
348 /// Adds each 8-bit integer element of the first 64-bit integer vector
349 /// of [8 x i8] to the corresponding 8-bit integer element of the second
350 /// 64-bit integer vector of [8 x i8]. The lower 8 bits of the results are
351 /// packed into a 64-bit integer vector of [8 x i8].
353 /// \headerfile <x86intrin.h>
355 /// This intrinsic corresponds to the <c> PADDB </c> instruction.
358 /// A 64-bit integer vector of [8 x i8].
360 /// A 64-bit integer vector of [8 x i8].
361 /// \returns A 64-bit integer vector of [8 x i8] containing the sums of both
363 static __inline__ __m64 __DEFAULT_FN_ATTRS
364 _mm_add_pi8(__m64 __m1, __m64 __m2)
366 return (__m64)__builtin_ia32_paddb((__v8qi)__m1, (__v8qi)__m2);
369 /// Adds each 16-bit integer element of the first 64-bit integer vector
370 /// of [4 x i16] to the corresponding 16-bit integer element of the second
371 /// 64-bit integer vector of [4 x i16]. The lower 16 bits of the results are
372 /// packed into a 64-bit integer vector of [4 x i16].
374 /// \headerfile <x86intrin.h>
376 /// This intrinsic corresponds to the <c> PADDW </c> instruction.
379 /// A 64-bit integer vector of [4 x i16].
381 /// A 64-bit integer vector of [4 x i16].
382 /// \returns A 64-bit integer vector of [4 x i16] containing the sums of both
384 static __inline__ __m64 __DEFAULT_FN_ATTRS
385 _mm_add_pi16(__m64 __m1, __m64 __m2)
387 return (__m64)__builtin_ia32_paddw((__v4hi)__m1, (__v4hi)__m2);
390 /// Adds each 32-bit integer element of the first 64-bit integer vector
391 /// of [2 x i32] to the corresponding 32-bit integer element of the second
392 /// 64-bit integer vector of [2 x i32]. The lower 32 bits of the results are
393 /// packed into a 64-bit integer vector of [2 x i32].
395 /// \headerfile <x86intrin.h>
397 /// This intrinsic corresponds to the <c> PADDD </c> instruction.
400 /// A 64-bit integer vector of [2 x i32].
402 /// A 64-bit integer vector of [2 x i32].
403 /// \returns A 64-bit integer vector of [2 x i32] containing the sums of both
405 static __inline__ __m64 __DEFAULT_FN_ATTRS
406 _mm_add_pi32(__m64 __m1, __m64 __m2)
408 return (__m64)__builtin_ia32_paddd((__v2si)__m1, (__v2si)__m2);
411 /// Adds each 8-bit signed integer element of the first 64-bit integer
412 /// vector of [8 x i8] to the corresponding 8-bit signed integer element of
413 /// the second 64-bit integer vector of [8 x i8]. Positive sums greater than
414 /// 0x7F are saturated to 0x7F. Negative sums less than 0x80 are saturated to
415 /// 0x80. The results are packed into a 64-bit integer vector of [8 x i8].
417 /// \headerfile <x86intrin.h>
419 /// This intrinsic corresponds to the <c> PADDSB </c> instruction.
422 /// A 64-bit integer vector of [8 x i8].
424 /// A 64-bit integer vector of [8 x i8].
425 /// \returns A 64-bit integer vector of [8 x i8] containing the saturated sums
426 /// of both parameters.
427 static __inline__ __m64 __DEFAULT_FN_ATTRS
428 _mm_adds_pi8(__m64 __m1, __m64 __m2)
430 return (__m64)__builtin_ia32_paddsb((__v8qi)__m1, (__v8qi)__m2);
433 /// Adds each 16-bit signed integer element of the first 64-bit integer
434 /// vector of [4 x i16] to the corresponding 16-bit signed integer element of
435 /// the second 64-bit integer vector of [4 x i16]. Positive sums greater than
436 /// 0x7FFF are saturated to 0x7FFF. Negative sums less than 0x8000 are
437 /// saturated to 0x8000. The results are packed into a 64-bit integer vector
440 /// \headerfile <x86intrin.h>
442 /// This intrinsic corresponds to the <c> PADDSW </c> instruction.
445 /// A 64-bit integer vector of [4 x i16].
447 /// A 64-bit integer vector of [4 x i16].
448 /// \returns A 64-bit integer vector of [4 x i16] containing the saturated sums
449 /// of both parameters.
450 static __inline__ __m64 __DEFAULT_FN_ATTRS
451 _mm_adds_pi16(__m64 __m1, __m64 __m2)
453 return (__m64)__builtin_ia32_paddsw((__v4hi)__m1, (__v4hi)__m2);
456 /// Adds each 8-bit unsigned integer element of the first 64-bit integer
457 /// vector of [8 x i8] to the corresponding 8-bit unsigned integer element of
458 /// the second 64-bit integer vector of [8 x i8]. Sums greater than 0xFF are
459 /// saturated to 0xFF. The results are packed into a 64-bit integer vector of
462 /// \headerfile <x86intrin.h>
464 /// This intrinsic corresponds to the <c> PADDUSB </c> instruction.
467 /// A 64-bit integer vector of [8 x i8].
469 /// A 64-bit integer vector of [8 x i8].
470 /// \returns A 64-bit integer vector of [8 x i8] containing the saturated
471 /// unsigned sums of both parameters.
472 static __inline__ __m64 __DEFAULT_FN_ATTRS
473 _mm_adds_pu8(__m64 __m1, __m64 __m2)
475 return (__m64)__builtin_ia32_paddusb((__v8qi)__m1, (__v8qi)__m2);
478 /// Adds each 16-bit unsigned integer element of the first 64-bit integer
479 /// vector of [4 x i16] to the corresponding 16-bit unsigned integer element
480 /// of the second 64-bit integer vector of [4 x i16]. Sums greater than
481 /// 0xFFFF are saturated to 0xFFFF. The results are packed into a 64-bit
482 /// integer vector of [4 x i16].
484 /// \headerfile <x86intrin.h>
486 /// This intrinsic corresponds to the <c> PADDUSW </c> instruction.
489 /// A 64-bit integer vector of [4 x i16].
491 /// A 64-bit integer vector of [4 x i16].
492 /// \returns A 64-bit integer vector of [4 x i16] containing the saturated
493 /// unsigned sums of both parameters.
494 static __inline__ __m64 __DEFAULT_FN_ATTRS
495 _mm_adds_pu16(__m64 __m1, __m64 __m2)
497 return (__m64)__builtin_ia32_paddusw((__v4hi)__m1, (__v4hi)__m2);
500 /// Subtracts each 8-bit integer element of the second 64-bit integer
501 /// vector of [8 x i8] from the corresponding 8-bit integer element of the
502 /// first 64-bit integer vector of [8 x i8]. The lower 8 bits of the results
503 /// are packed into a 64-bit integer vector of [8 x i8].
505 /// \headerfile <x86intrin.h>
507 /// This intrinsic corresponds to the <c> PSUBB </c> instruction.
510 /// A 64-bit integer vector of [8 x i8] containing the minuends.
512 /// A 64-bit integer vector of [8 x i8] containing the subtrahends.
513 /// \returns A 64-bit integer vector of [8 x i8] containing the differences of
515 static __inline__ __m64 __DEFAULT_FN_ATTRS
516 _mm_sub_pi8(__m64 __m1, __m64 __m2)
518 return (__m64)__builtin_ia32_psubb((__v8qi)__m1, (__v8qi)__m2);
521 /// Subtracts each 16-bit integer element of the second 64-bit integer
522 /// vector of [4 x i16] from the corresponding 16-bit integer element of the
523 /// first 64-bit integer vector of [4 x i16]. The lower 16 bits of the
524 /// results are packed into a 64-bit integer vector of [4 x i16].
526 /// \headerfile <x86intrin.h>
528 /// This intrinsic corresponds to the <c> PSUBW </c> instruction.
531 /// A 64-bit integer vector of [4 x i16] containing the minuends.
533 /// A 64-bit integer vector of [4 x i16] containing the subtrahends.
534 /// \returns A 64-bit integer vector of [4 x i16] containing the differences of
536 static __inline__ __m64 __DEFAULT_FN_ATTRS
537 _mm_sub_pi16(__m64 __m1, __m64 __m2)
539 return (__m64)__builtin_ia32_psubw((__v4hi)__m1, (__v4hi)__m2);
542 /// Subtracts each 32-bit integer element of the second 64-bit integer
543 /// vector of [2 x i32] from the corresponding 32-bit integer element of the
544 /// first 64-bit integer vector of [2 x i32]. The lower 32 bits of the
545 /// results are packed into a 64-bit integer vector of [2 x i32].
547 /// \headerfile <x86intrin.h>
549 /// This intrinsic corresponds to the <c> PSUBD </c> instruction.
552 /// A 64-bit integer vector of [2 x i32] containing the minuends.
554 /// A 64-bit integer vector of [2 x i32] containing the subtrahends.
555 /// \returns A 64-bit integer vector of [2 x i32] containing the differences of
557 static __inline__ __m64 __DEFAULT_FN_ATTRS
558 _mm_sub_pi32(__m64 __m1, __m64 __m2)
560 return (__m64)__builtin_ia32_psubd((__v2si)__m1, (__v2si)__m2);
563 /// Subtracts each 8-bit signed integer element of the second 64-bit
564 /// integer vector of [8 x i8] from the corresponding 8-bit signed integer
565 /// element of the first 64-bit integer vector of [8 x i8]. Positive results
566 /// greater than 0x7F are saturated to 0x7F. Negative results less than 0x80
567 /// are saturated to 0x80. The results are packed into a 64-bit integer
568 /// vector of [8 x i8].
570 /// \headerfile <x86intrin.h>
572 /// This intrinsic corresponds to the <c> PSUBSB </c> instruction.
575 /// A 64-bit integer vector of [8 x i8] containing the minuends.
577 /// A 64-bit integer vector of [8 x i8] containing the subtrahends.
578 /// \returns A 64-bit integer vector of [8 x i8] containing the saturated
579 /// differences of both parameters.
580 static __inline__ __m64 __DEFAULT_FN_ATTRS
581 _mm_subs_pi8(__m64 __m1, __m64 __m2)
583 return (__m64)__builtin_ia32_psubsb((__v8qi)__m1, (__v8qi)__m2);
586 /// Subtracts each 16-bit signed integer element of the second 64-bit
587 /// integer vector of [4 x i16] from the corresponding 16-bit signed integer
588 /// element of the first 64-bit integer vector of [4 x i16]. Positive results
589 /// greater than 0x7FFF are saturated to 0x7FFF. Negative results less than
590 /// 0x8000 are saturated to 0x8000. The results are packed into a 64-bit
591 /// integer vector of [4 x i16].
593 /// \headerfile <x86intrin.h>
595 /// This intrinsic corresponds to the <c> PSUBSW </c> instruction.
598 /// A 64-bit integer vector of [4 x i16] containing the minuends.
600 /// A 64-bit integer vector of [4 x i16] containing the subtrahends.
601 /// \returns A 64-bit integer vector of [4 x i16] containing the saturated
602 /// differences of both parameters.
603 static __inline__ __m64 __DEFAULT_FN_ATTRS
604 _mm_subs_pi16(__m64 __m1, __m64 __m2)
606 return (__m64)__builtin_ia32_psubsw((__v4hi)__m1, (__v4hi)__m2);
609 /// Subtracts each 8-bit unsigned integer element of the second 64-bit
610 /// integer vector of [8 x i8] from the corresponding 8-bit unsigned integer
611 /// element of the first 64-bit integer vector of [8 x i8].
613 /// If an element of the first vector is less than the corresponding element
614 /// of the second vector, the result is saturated to 0. The results are
615 /// packed into a 64-bit integer vector of [8 x i8].
617 /// \headerfile <x86intrin.h>
619 /// This intrinsic corresponds to the <c> PSUBUSB </c> instruction.
622 /// A 64-bit integer vector of [8 x i8] containing the minuends.
624 /// A 64-bit integer vector of [8 x i8] containing the subtrahends.
625 /// \returns A 64-bit integer vector of [8 x i8] containing the saturated
626 /// differences of both parameters.
627 static __inline__ __m64 __DEFAULT_FN_ATTRS
628 _mm_subs_pu8(__m64 __m1, __m64 __m2)
630 return (__m64)__builtin_ia32_psubusb((__v8qi)__m1, (__v8qi)__m2);
633 /// Subtracts each 16-bit unsigned integer element of the second 64-bit
634 /// integer vector of [4 x i16] from the corresponding 16-bit unsigned
635 /// integer element of the first 64-bit integer vector of [4 x i16].
637 /// If an element of the first vector is less than the corresponding element
638 /// of the second vector, the result is saturated to 0. The results are
639 /// packed into a 64-bit integer vector of [4 x i16].
641 /// \headerfile <x86intrin.h>
643 /// This intrinsic corresponds to the <c> PSUBUSW </c> instruction.
646 /// A 64-bit integer vector of [4 x i16] containing the minuends.
648 /// A 64-bit integer vector of [4 x i16] containing the subtrahends.
649 /// \returns A 64-bit integer vector of [4 x i16] containing the saturated
650 /// differences of both parameters.
651 static __inline__ __m64 __DEFAULT_FN_ATTRS
652 _mm_subs_pu16(__m64 __m1, __m64 __m2)
654 return (__m64)__builtin_ia32_psubusw((__v4hi)__m1, (__v4hi)__m2);
657 /// Multiplies each 16-bit signed integer element of the first 64-bit
658 /// integer vector of [4 x i16] by the corresponding 16-bit signed integer
659 /// element of the second 64-bit integer vector of [4 x i16] and get four
660 /// 32-bit products. Adds adjacent pairs of products to get two 32-bit sums.
661 /// The lower 32 bits of these two sums are packed into a 64-bit integer
662 /// vector of [2 x i32].
664 /// For example, bits [15:0] of both parameters are multiplied, bits [31:16]
665 /// of both parameters are multiplied, and the sum of both results is written
666 /// to bits [31:0] of the result.
668 /// \headerfile <x86intrin.h>
670 /// This intrinsic corresponds to the <c> PMADDWD </c> instruction.
673 /// A 64-bit integer vector of [4 x i16].
675 /// A 64-bit integer vector of [4 x i16].
676 /// \returns A 64-bit integer vector of [2 x i32] containing the sums of
677 /// products of both parameters.
678 static __inline__ __m64 __DEFAULT_FN_ATTRS
679 _mm_madd_pi16(__m64 __m1, __m64 __m2)
681 return (__m64)__builtin_ia32_pmaddwd((__v4hi)__m1, (__v4hi)__m2);
684 /// Multiplies each 16-bit signed integer element of the first 64-bit
685 /// integer vector of [4 x i16] by the corresponding 16-bit signed integer
686 /// element of the second 64-bit integer vector of [4 x i16]. Packs the upper
687 /// 16 bits of the 32-bit products into a 64-bit integer vector of [4 x i16].
689 /// \headerfile <x86intrin.h>
691 /// This intrinsic corresponds to the <c> PMULHW </c> instruction.
694 /// A 64-bit integer vector of [4 x i16].
696 /// A 64-bit integer vector of [4 x i16].
697 /// \returns A 64-bit integer vector of [4 x i16] containing the upper 16 bits
698 /// of the products of both parameters.
699 static __inline__ __m64 __DEFAULT_FN_ATTRS
700 _mm_mulhi_pi16(__m64 __m1, __m64 __m2)
702 return (__m64)__builtin_ia32_pmulhw((__v4hi)__m1, (__v4hi)__m2);
705 /// Multiplies each 16-bit signed integer element of the first 64-bit
706 /// integer vector of [4 x i16] by the corresponding 16-bit signed integer
707 /// element of the second 64-bit integer vector of [4 x i16]. Packs the lower
708 /// 16 bits of the 32-bit products into a 64-bit integer vector of [4 x i16].
710 /// \headerfile <x86intrin.h>
712 /// This intrinsic corresponds to the <c> PMULLW </c> instruction.
715 /// A 64-bit integer vector of [4 x i16].
717 /// A 64-bit integer vector of [4 x i16].
718 /// \returns A 64-bit integer vector of [4 x i16] containing the lower 16 bits
719 /// of the products of both parameters.
720 static __inline__ __m64 __DEFAULT_FN_ATTRS
721 _mm_mullo_pi16(__m64 __m1, __m64 __m2)
723 return (__m64)__builtin_ia32_pmullw((__v4hi)__m1, (__v4hi)__m2);
726 /// Left-shifts each 16-bit signed integer element of the first
727 /// parameter, which is a 64-bit integer vector of [4 x i16], by the number
728 /// of bits specified by the second parameter, which is a 64-bit integer. The
729 /// lower 16 bits of the results are packed into a 64-bit integer vector of
732 /// \headerfile <x86intrin.h>
734 /// This intrinsic corresponds to the <c> PSLLW </c> instruction.
737 /// A 64-bit integer vector of [4 x i16].
739 /// A 64-bit integer vector interpreted as a single 64-bit integer.
740 /// \returns A 64-bit integer vector of [4 x i16] containing the left-shifted
741 /// values. If \a __count is greater or equal to 16, the result is set to all
743 static __inline__ __m64 __DEFAULT_FN_ATTRS
744 _mm_sll_pi16(__m64 __m, __m64 __count)
746 return (__m64)__builtin_ia32_psllw((__v4hi)__m, __count);
749 /// Left-shifts each 16-bit signed integer element of a 64-bit integer
750 /// vector of [4 x i16] by the number of bits specified by a 32-bit integer.
751 /// The lower 16 bits of the results are packed into a 64-bit integer vector
754 /// \headerfile <x86intrin.h>
756 /// This intrinsic corresponds to the <c> PSLLW </c> instruction.
759 /// A 64-bit integer vector of [4 x i16].
761 /// A 32-bit integer value.
762 /// \returns A 64-bit integer vector of [4 x i16] containing the left-shifted
763 /// values. If \a __count is greater or equal to 16, the result is set to all
765 static __inline__ __m64 __DEFAULT_FN_ATTRS
766 _mm_slli_pi16(__m64 __m, int __count)
768 return (__m64)__builtin_ia32_psllwi((__v4hi)__m, __count);
771 /// Left-shifts each 32-bit signed integer element of the first
772 /// parameter, which is a 64-bit integer vector of [2 x i32], by the number
773 /// of bits specified by the second parameter, which is a 64-bit integer. The
774 /// lower 32 bits of the results are packed into a 64-bit integer vector of
777 /// \headerfile <x86intrin.h>
779 /// This intrinsic corresponds to the <c> PSLLD </c> instruction.
782 /// A 64-bit integer vector of [2 x i32].
784 /// A 64-bit integer vector interpreted as a single 64-bit integer.
785 /// \returns A 64-bit integer vector of [2 x i32] containing the left-shifted
786 /// values. If \a __count is greater or equal to 32, the result is set to all
788 static __inline__ __m64 __DEFAULT_FN_ATTRS
789 _mm_sll_pi32(__m64 __m, __m64 __count)
791 return (__m64)__builtin_ia32_pslld((__v2si)__m, __count);
794 /// Left-shifts each 32-bit signed integer element of a 64-bit integer
795 /// vector of [2 x i32] by the number of bits specified by a 32-bit integer.
796 /// The lower 32 bits of the results are packed into a 64-bit integer vector
799 /// \headerfile <x86intrin.h>
801 /// This intrinsic corresponds to the <c> PSLLD </c> instruction.
804 /// A 64-bit integer vector of [2 x i32].
806 /// A 32-bit integer value.
807 /// \returns A 64-bit integer vector of [2 x i32] containing the left-shifted
808 /// values. If \a __count is greater or equal to 32, the result is set to all
810 static __inline__ __m64 __DEFAULT_FN_ATTRS
811 _mm_slli_pi32(__m64 __m, int __count)
813 return (__m64)__builtin_ia32_pslldi((__v2si)__m, __count);
816 /// Left-shifts the first 64-bit integer parameter by the number of bits
817 /// specified by the second 64-bit integer parameter. The lower 64 bits of
818 /// result are returned.
820 /// \headerfile <x86intrin.h>
822 /// This intrinsic corresponds to the <c> PSLLQ </c> instruction.
825 /// A 64-bit integer vector interpreted as a single 64-bit integer.
827 /// A 64-bit integer vector interpreted as a single 64-bit integer.
828 /// \returns A 64-bit integer vector containing the left-shifted value. If
829 /// \a __count is greater or equal to 64, the result is set to 0.
830 static __inline__ __m64 __DEFAULT_FN_ATTRS
831 _mm_sll_si64(__m64 __m, __m64 __count)
833 return (__m64)__builtin_ia32_psllq((__v1di)__m, __count);
836 /// Left-shifts the first parameter, which is a 64-bit integer, by the
837 /// number of bits specified by the second parameter, which is a 32-bit
838 /// integer. The lower 64 bits of result are returned.
840 /// \headerfile <x86intrin.h>
842 /// This intrinsic corresponds to the <c> PSLLQ </c> instruction.
845 /// A 64-bit integer vector interpreted as a single 64-bit integer.
847 /// A 32-bit integer value.
848 /// \returns A 64-bit integer vector containing the left-shifted value. If
849 /// \a __count is greater or equal to 64, the result is set to 0.
850 static __inline__ __m64 __DEFAULT_FN_ATTRS
851 _mm_slli_si64(__m64 __m, int __count)
853 return (__m64)__builtin_ia32_psllqi((__v1di)__m, __count);
856 /// Right-shifts each 16-bit integer element of the first parameter,
857 /// which is a 64-bit integer vector of [4 x i16], by the number of bits
858 /// specified by the second parameter, which is a 64-bit integer.
860 /// High-order bits are filled with the sign bit of the initial value of each
861 /// 16-bit element. The 16-bit results are packed into a 64-bit integer
862 /// vector of [4 x i16].
864 /// \headerfile <x86intrin.h>
866 /// This intrinsic corresponds to the <c> PSRAW </c> instruction.
869 /// A 64-bit integer vector of [4 x i16].
871 /// A 64-bit integer vector interpreted as a single 64-bit integer.
872 /// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
874 static __inline__ __m64 __DEFAULT_FN_ATTRS
875 _mm_sra_pi16(__m64 __m, __m64 __count)
877 return (__m64)__builtin_ia32_psraw((__v4hi)__m, __count);
880 /// Right-shifts each 16-bit integer element of a 64-bit integer vector
881 /// of [4 x i16] by the number of bits specified by a 32-bit integer.
883 /// High-order bits are filled with the sign bit of the initial value of each
884 /// 16-bit element. The 16-bit results are packed into a 64-bit integer
885 /// vector of [4 x i16].
887 /// \headerfile <x86intrin.h>
889 /// This intrinsic corresponds to the <c> PSRAW </c> instruction.
892 /// A 64-bit integer vector of [4 x i16].
894 /// A 32-bit integer value.
895 /// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
897 static __inline__ __m64 __DEFAULT_FN_ATTRS
898 _mm_srai_pi16(__m64 __m, int __count)
900 return (__m64)__builtin_ia32_psrawi((__v4hi)__m, __count);
903 /// Right-shifts each 32-bit integer element of the first parameter,
904 /// which is a 64-bit integer vector of [2 x i32], by the number of bits
905 /// specified by the second parameter, which is a 64-bit integer.
907 /// High-order bits are filled with the sign bit of the initial value of each
908 /// 32-bit element. The 32-bit results are packed into a 64-bit integer
909 /// vector of [2 x i32].
911 /// \headerfile <x86intrin.h>
913 /// This intrinsic corresponds to the <c> PSRAD </c> instruction.
916 /// A 64-bit integer vector of [2 x i32].
918 /// A 64-bit integer vector interpreted as a single 64-bit integer.
919 /// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
921 static __inline__ __m64 __DEFAULT_FN_ATTRS
922 _mm_sra_pi32(__m64 __m, __m64 __count)
924 return (__m64)__builtin_ia32_psrad((__v2si)__m, __count);
927 /// Right-shifts each 32-bit integer element of a 64-bit integer vector
928 /// of [2 x i32] by the number of bits specified by a 32-bit integer.
930 /// High-order bits are filled with the sign bit of the initial value of each
931 /// 32-bit element. The 32-bit results are packed into a 64-bit integer
932 /// vector of [2 x i32].
934 /// \headerfile <x86intrin.h>
936 /// This intrinsic corresponds to the <c> PSRAD </c> instruction.
939 /// A 64-bit integer vector of [2 x i32].
941 /// A 32-bit integer value.
942 /// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
944 static __inline__ __m64 __DEFAULT_FN_ATTRS
945 _mm_srai_pi32(__m64 __m, int __count)
947 return (__m64)__builtin_ia32_psradi((__v2si)__m, __count);
950 /// Right-shifts each 16-bit integer element of the first parameter,
951 /// which is a 64-bit integer vector of [4 x i16], by the number of bits
952 /// specified by the second parameter, which is a 64-bit integer.
954 /// High-order bits are cleared. The 16-bit results are packed into a 64-bit
955 /// integer vector of [4 x i16].
957 /// \headerfile <x86intrin.h>
959 /// This intrinsic corresponds to the <c> PSRLW </c> instruction.
962 /// A 64-bit integer vector of [4 x i16].
964 /// A 64-bit integer vector interpreted as a single 64-bit integer.
965 /// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
967 static __inline__ __m64 __DEFAULT_FN_ATTRS
968 _mm_srl_pi16(__m64 __m, __m64 __count)
970 return (__m64)__builtin_ia32_psrlw((__v4hi)__m, __count);
973 /// Right-shifts each 16-bit integer element of a 64-bit integer vector
974 /// of [4 x i16] by the number of bits specified by a 32-bit integer.
976 /// High-order bits are cleared. The 16-bit results are packed into a 64-bit
977 /// integer vector of [4 x i16].
979 /// \headerfile <x86intrin.h>
981 /// This intrinsic corresponds to the <c> PSRLW </c> instruction.
984 /// A 64-bit integer vector of [4 x i16].
986 /// A 32-bit integer value.
987 /// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
989 static __inline__ __m64 __DEFAULT_FN_ATTRS
990 _mm_srli_pi16(__m64 __m, int __count)
992 return (__m64)__builtin_ia32_psrlwi((__v4hi)__m, __count);
995 /// Right-shifts each 32-bit integer element of the first parameter,
996 /// which is a 64-bit integer vector of [2 x i32], by the number of bits
997 /// specified by the second parameter, which is a 64-bit integer.
999 /// High-order bits are cleared. The 32-bit results are packed into a 64-bit
1000 /// integer vector of [2 x i32].
1002 /// \headerfile <x86intrin.h>
1004 /// This intrinsic corresponds to the <c> PSRLD </c> instruction.
1007 /// A 64-bit integer vector of [2 x i32].
1009 /// A 64-bit integer vector interpreted as a single 64-bit integer.
1010 /// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
1012 static __inline__ __m64 __DEFAULT_FN_ATTRS
1013 _mm_srl_pi32(__m64 __m, __m64 __count)
1015 return (__m64)__builtin_ia32_psrld((__v2si)__m, __count);
1018 /// Right-shifts each 32-bit integer element of a 64-bit integer vector
1019 /// of [2 x i32] by the number of bits specified by a 32-bit integer.
1021 /// High-order bits are cleared. The 32-bit results are packed into a 64-bit
1022 /// integer vector of [2 x i32].
1024 /// \headerfile <x86intrin.h>
1026 /// This intrinsic corresponds to the <c> PSRLD </c> instruction.
1029 /// A 64-bit integer vector of [2 x i32].
1031 /// A 32-bit integer value.
1032 /// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
1034 static __inline__ __m64 __DEFAULT_FN_ATTRS
1035 _mm_srli_pi32(__m64 __m, int __count)
1037 return (__m64)__builtin_ia32_psrldi((__v2si)__m, __count);
1040 /// Right-shifts the first 64-bit integer parameter by the number of bits
1041 /// specified by the second 64-bit integer parameter.
1043 /// High-order bits are cleared.
1045 /// \headerfile <x86intrin.h>
1047 /// This intrinsic corresponds to the <c> PSRLQ </c> instruction.
1050 /// A 64-bit integer vector interpreted as a single 64-bit integer.
1052 /// A 64-bit integer vector interpreted as a single 64-bit integer.
1053 /// \returns A 64-bit integer vector containing the right-shifted value.
1054 static __inline__ __m64 __DEFAULT_FN_ATTRS
1055 _mm_srl_si64(__m64 __m, __m64 __count)
1057 return (__m64)__builtin_ia32_psrlq((__v1di)__m, __count);
1060 /// Right-shifts the first parameter, which is a 64-bit integer, by the
1061 /// number of bits specified by the second parameter, which is a 32-bit
1064 /// High-order bits are cleared.
1066 /// \headerfile <x86intrin.h>
1068 /// This intrinsic corresponds to the <c> PSRLQ </c> instruction.
1071 /// A 64-bit integer vector interpreted as a single 64-bit integer.
1073 /// A 32-bit integer value.
1074 /// \returns A 64-bit integer vector containing the right-shifted value.
1075 static __inline__ __m64 __DEFAULT_FN_ATTRS
1076 _mm_srli_si64(__m64 __m, int __count)
1078 return (__m64)__builtin_ia32_psrlqi((__v1di)__m, __count);
1081 /// Performs a bitwise AND of two 64-bit integer vectors.
1083 /// \headerfile <x86intrin.h>
1085 /// This intrinsic corresponds to the <c> PAND </c> instruction.
1088 /// A 64-bit integer vector.
1090 /// A 64-bit integer vector.
1091 /// \returns A 64-bit integer vector containing the bitwise AND of both
1093 static __inline__ __m64 __DEFAULT_FN_ATTRS
1094 _mm_and_si64(__m64 __m1, __m64 __m2)
1096 return __builtin_ia32_pand((__v1di)__m1, (__v1di)__m2);
1099 /// Performs a bitwise NOT of the first 64-bit integer vector, and then
1100 /// performs a bitwise AND of the intermediate result and the second 64-bit
1103 /// \headerfile <x86intrin.h>
1105 /// This intrinsic corresponds to the <c> PANDN </c> instruction.
1108 /// A 64-bit integer vector. The one's complement of this parameter is used
1109 /// in the bitwise AND.
1111 /// A 64-bit integer vector.
1112 /// \returns A 64-bit integer vector containing the bitwise AND of the second
1113 /// parameter and the one's complement of the first parameter.
1114 static __inline__ __m64 __DEFAULT_FN_ATTRS
1115 _mm_andnot_si64(__m64 __m1, __m64 __m2)
1117 return __builtin_ia32_pandn((__v1di)__m1, (__v1di)__m2);
1120 /// Performs a bitwise OR of two 64-bit integer vectors.
1122 /// \headerfile <x86intrin.h>
1124 /// This intrinsic corresponds to the <c> POR </c> instruction.
1127 /// A 64-bit integer vector.
1129 /// A 64-bit integer vector.
1130 /// \returns A 64-bit integer vector containing the bitwise OR of both
1132 static __inline__ __m64 __DEFAULT_FN_ATTRS
1133 _mm_or_si64(__m64 __m1, __m64 __m2)
1135 return __builtin_ia32_por((__v1di)__m1, (__v1di)__m2);
1138 /// Performs a bitwise exclusive OR of two 64-bit integer vectors.
1140 /// \headerfile <x86intrin.h>
1142 /// This intrinsic corresponds to the <c> PXOR </c> instruction.
1145 /// A 64-bit integer vector.
1147 /// A 64-bit integer vector.
1148 /// \returns A 64-bit integer vector containing the bitwise exclusive OR of both
1150 static __inline__ __m64 __DEFAULT_FN_ATTRS
1151 _mm_xor_si64(__m64 __m1, __m64 __m2)
1153 return __builtin_ia32_pxor((__v1di)__m1, (__v1di)__m2);
1156 /// Compares the 8-bit integer elements of two 64-bit integer vectors of
1157 /// [8 x i8] to determine if the element of the first vector is equal to the
1158 /// corresponding element of the second vector.
1160 /// The comparison yields 0 for false, 0xFF for true.
1162 /// \headerfile <x86intrin.h>
1164 /// This intrinsic corresponds to the <c> PCMPEQB </c> instruction.
1167 /// A 64-bit integer vector of [8 x i8].
1169 /// A 64-bit integer vector of [8 x i8].
1170 /// \returns A 64-bit integer vector of [8 x i8] containing the comparison
1172 static __inline__ __m64 __DEFAULT_FN_ATTRS
1173 _mm_cmpeq_pi8(__m64 __m1, __m64 __m2)
1175 return (__m64)__builtin_ia32_pcmpeqb((__v8qi)__m1, (__v8qi)__m2);
1178 /// Compares the 16-bit integer elements of two 64-bit integer vectors of
1179 /// [4 x i16] to determine if the element of the first vector is equal to the
1180 /// corresponding element of the second vector.
1182 /// The comparison yields 0 for false, 0xFFFF for true.
1184 /// \headerfile <x86intrin.h>
1186 /// This intrinsic corresponds to the <c> PCMPEQW </c> instruction.
1189 /// A 64-bit integer vector of [4 x i16].
1191 /// A 64-bit integer vector of [4 x i16].
1192 /// \returns A 64-bit integer vector of [4 x i16] containing the comparison
1194 static __inline__ __m64 __DEFAULT_FN_ATTRS
1195 _mm_cmpeq_pi16(__m64 __m1, __m64 __m2)
1197 return (__m64)__builtin_ia32_pcmpeqw((__v4hi)__m1, (__v4hi)__m2);
1200 /// Compares the 32-bit integer elements of two 64-bit integer vectors of
1201 /// [2 x i32] to determine if the element of the first vector is equal to the
1202 /// corresponding element of the second vector.
1204 /// The comparison yields 0 for false, 0xFFFFFFFF for true.
1206 /// \headerfile <x86intrin.h>
1208 /// This intrinsic corresponds to the <c> PCMPEQD </c> instruction.
1211 /// A 64-bit integer vector of [2 x i32].
1213 /// A 64-bit integer vector of [2 x i32].
1214 /// \returns A 64-bit integer vector of [2 x i32] containing the comparison
1216 static __inline__ __m64 __DEFAULT_FN_ATTRS
1217 _mm_cmpeq_pi32(__m64 __m1, __m64 __m2)
1219 return (__m64)__builtin_ia32_pcmpeqd((__v2si)__m1, (__v2si)__m2);
1222 /// Compares the 8-bit integer elements of two 64-bit integer vectors of
1223 /// [8 x i8] to determine if the element of the first vector is greater than
1224 /// the corresponding element of the second vector.
1226 /// The comparison yields 0 for false, 0xFF for true.
1228 /// \headerfile <x86intrin.h>
1230 /// This intrinsic corresponds to the <c> PCMPGTB </c> instruction.
1233 /// A 64-bit integer vector of [8 x i8].
1235 /// A 64-bit integer vector of [8 x i8].
1236 /// \returns A 64-bit integer vector of [8 x i8] containing the comparison
1238 static __inline__ __m64 __DEFAULT_FN_ATTRS
1239 _mm_cmpgt_pi8(__m64 __m1, __m64 __m2)
1241 return (__m64)__builtin_ia32_pcmpgtb((__v8qi)__m1, (__v8qi)__m2);
1244 /// Compares the 16-bit integer elements of two 64-bit integer vectors of
1245 /// [4 x i16] to determine if the element of the first vector is greater than
1246 /// the corresponding element of the second vector.
1248 /// The comparison yields 0 for false, 0xFFFF for true.
1250 /// \headerfile <x86intrin.h>
1252 /// This intrinsic corresponds to the <c> PCMPGTW </c> instruction.
1255 /// A 64-bit integer vector of [4 x i16].
1257 /// A 64-bit integer vector of [4 x i16].
1258 /// \returns A 64-bit integer vector of [4 x i16] containing the comparison
1260 static __inline__ __m64 __DEFAULT_FN_ATTRS
1261 _mm_cmpgt_pi16(__m64 __m1, __m64 __m2)
1263 return (__m64)__builtin_ia32_pcmpgtw((__v4hi)__m1, (__v4hi)__m2);
1266 /// Compares the 32-bit integer elements of two 64-bit integer vectors of
1267 /// [2 x i32] to determine if the element of the first vector is greater than
1268 /// the corresponding element of the second vector.
1270 /// The comparison yields 0 for false, 0xFFFFFFFF for true.
1272 /// \headerfile <x86intrin.h>
1274 /// This intrinsic corresponds to the <c> PCMPGTD </c> instruction.
1277 /// A 64-bit integer vector of [2 x i32].
1279 /// A 64-bit integer vector of [2 x i32].
1280 /// \returns A 64-bit integer vector of [2 x i32] containing the comparison
1282 static __inline__ __m64 __DEFAULT_FN_ATTRS
1283 _mm_cmpgt_pi32(__m64 __m1, __m64 __m2)
1285 return (__m64)__builtin_ia32_pcmpgtd((__v2si)__m1, (__v2si)__m2);
1288 /// Constructs a 64-bit integer vector initialized to zero.
1290 /// \headerfile <x86intrin.h>
1292 /// This intrinsic corresponds to the <c> PXOR </c> instruction.
1294 /// \returns An initialized 64-bit integer vector with all elements set to zero.
1295 static __inline__ __m64 __DEFAULT_FN_ATTRS
1296 _mm_setzero_si64(void)
1298 return __extension__ (__m64){ 0LL };
1301 /// Constructs a 64-bit integer vector initialized with the specified
1302 /// 32-bit integer values.
1304 /// \headerfile <x86intrin.h>
1306 /// This intrinsic is a utility function and does not correspond to a specific
1310 /// A 32-bit integer value used to initialize the upper 32 bits of the
1313 /// A 32-bit integer value used to initialize the lower 32 bits of the
1315 /// \returns An initialized 64-bit integer vector.
1316 static __inline__ __m64 __DEFAULT_FN_ATTRS
1317 _mm_set_pi32(int __i1, int __i0)
1319 return (__m64)__builtin_ia32_vec_init_v2si(__i0, __i1);
1322 /// Constructs a 64-bit integer vector initialized with the specified
1323 /// 16-bit integer values.
1325 /// \headerfile <x86intrin.h>
1327 /// This intrinsic is a utility function and does not correspond to a specific
1331 /// A 16-bit integer value used to initialize bits [63:48] of the result.
1333 /// A 16-bit integer value used to initialize bits [47:32] of the result.
1335 /// A 16-bit integer value used to initialize bits [31:16] of the result.
1337 /// A 16-bit integer value used to initialize bits [15:0] of the result.
1338 /// \returns An initialized 64-bit integer vector.
1339 static __inline__ __m64 __DEFAULT_FN_ATTRS
1340 _mm_set_pi16(short __s3, short __s2, short __s1, short __s0)
1342 return (__m64)__builtin_ia32_vec_init_v4hi(__s0, __s1, __s2, __s3);
1345 /// Constructs a 64-bit integer vector initialized with the specified
1346 /// 8-bit integer values.
1348 /// \headerfile <x86intrin.h>
1350 /// This intrinsic is a utility function and does not correspond to a specific
1354 /// An 8-bit integer value used to initialize bits [63:56] of the result.
1356 /// An 8-bit integer value used to initialize bits [55:48] of the result.
1358 /// An 8-bit integer value used to initialize bits [47:40] of the result.
1360 /// An 8-bit integer value used to initialize bits [39:32] of the result.
1362 /// An 8-bit integer value used to initialize bits [31:24] of the result.
1364 /// An 8-bit integer value used to initialize bits [23:16] of the result.
1366 /// An 8-bit integer value used to initialize bits [15:8] of the result.
1368 /// An 8-bit integer value used to initialize bits [7:0] of the result.
1369 /// \returns An initialized 64-bit integer vector.
1370 static __inline__ __m64 __DEFAULT_FN_ATTRS
1371 _mm_set_pi8(char __b7, char __b6, char __b5, char __b4, char __b3, char __b2,
1372 char __b1, char __b0)
1374 return (__m64)__builtin_ia32_vec_init_v8qi(__b0, __b1, __b2, __b3,
1375 __b4, __b5, __b6, __b7);
1378 /// Constructs a 64-bit integer vector of [2 x i32], with each of the
1379 /// 32-bit integer vector elements set to the specified 32-bit integer
1382 /// \headerfile <x86intrin.h>
1384 /// This intrinsic is a utility function and does not correspond to a specific
1388 /// A 32-bit integer value used to initialize each vector element of the
1390 /// \returns An initialized 64-bit integer vector of [2 x i32].
1391 static __inline__ __m64 __DEFAULT_FN_ATTRS
1392 _mm_set1_pi32(int __i)
1394 return _mm_set_pi32(__i, __i);
1397 /// Constructs a 64-bit integer vector of [4 x i16], with each of the
1398 /// 16-bit integer vector elements set to the specified 16-bit integer
1401 /// \headerfile <x86intrin.h>
1403 /// This intrinsic is a utility function and does not correspond to a specific
1407 /// A 16-bit integer value used to initialize each vector element of the
1409 /// \returns An initialized 64-bit integer vector of [4 x i16].
1410 static __inline__ __m64 __DEFAULT_FN_ATTRS
1411 _mm_set1_pi16(short __w)
1413 return _mm_set_pi16(__w, __w, __w, __w);
1416 /// Constructs a 64-bit integer vector of [8 x i8], with each of the
1417 /// 8-bit integer vector elements set to the specified 8-bit integer value.
1419 /// \headerfile <x86intrin.h>
1421 /// This intrinsic is a utility function and does not correspond to a specific
1425 /// An 8-bit integer value used to initialize each vector element of the
1427 /// \returns An initialized 64-bit integer vector of [8 x i8].
1428 static __inline__ __m64 __DEFAULT_FN_ATTRS
1429 _mm_set1_pi8(char __b)
1431 return _mm_set_pi8(__b, __b, __b, __b, __b, __b, __b, __b);
1434 /// Constructs a 64-bit integer vector, initialized in reverse order with
1435 /// the specified 32-bit integer values.
1437 /// \headerfile <x86intrin.h>
1439 /// This intrinsic is a utility function and does not correspond to a specific
1443 /// A 32-bit integer value used to initialize the lower 32 bits of the
1446 /// A 32-bit integer value used to initialize the upper 32 bits of the
1448 /// \returns An initialized 64-bit integer vector.
1449 static __inline__ __m64 __DEFAULT_FN_ATTRS
1450 _mm_setr_pi32(int __i0, int __i1)
1452 return _mm_set_pi32(__i1, __i0);
1455 /// Constructs a 64-bit integer vector, initialized in reverse order with
1456 /// the specified 16-bit integer values.
1458 /// \headerfile <x86intrin.h>
1460 /// This intrinsic is a utility function and does not correspond to a specific
1464 /// A 16-bit integer value used to initialize bits [15:0] of the result.
1466 /// A 16-bit integer value used to initialize bits [31:16] of the result.
1468 /// A 16-bit integer value used to initialize bits [47:32] of the result.
1470 /// A 16-bit integer value used to initialize bits [63:48] of the result.
1471 /// \returns An initialized 64-bit integer vector.
1472 static __inline__ __m64 __DEFAULT_FN_ATTRS
1473 _mm_setr_pi16(short __w0, short __w1, short __w2, short __w3)
1475 return _mm_set_pi16(__w3, __w2, __w1, __w0);
1478 /// Constructs a 64-bit integer vector, initialized in reverse order with
1479 /// the specified 8-bit integer values.
1481 /// \headerfile <x86intrin.h>
1483 /// This intrinsic is a utility function and does not correspond to a specific
1487 /// An 8-bit integer value used to initialize bits [7:0] of the result.
1489 /// An 8-bit integer value used to initialize bits [15:8] of the result.
1491 /// An 8-bit integer value used to initialize bits [23:16] of the result.
1493 /// An 8-bit integer value used to initialize bits [31:24] of the result.
1495 /// An 8-bit integer value used to initialize bits [39:32] of the result.
1497 /// An 8-bit integer value used to initialize bits [47:40] of the result.
1499 /// An 8-bit integer value used to initialize bits [55:48] of the result.
1501 /// An 8-bit integer value used to initialize bits [63:56] of the result.
1502 /// \returns An initialized 64-bit integer vector.
1503 static __inline__ __m64 __DEFAULT_FN_ATTRS
1504 _mm_setr_pi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5,
1505 char __b6, char __b7)
1507 return _mm_set_pi8(__b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
1510 #undef __DEFAULT_FN_ATTRS
1512 /* Aliases for compatibility. */
1513 #define _m_empty _mm_empty
1514 #define _m_from_int _mm_cvtsi32_si64
1515 #define _m_from_int64 _mm_cvtsi64_m64
1516 #define _m_to_int _mm_cvtsi64_si32
1517 #define _m_to_int64 _mm_cvtm64_si64
1518 #define _m_packsswb _mm_packs_pi16
1519 #define _m_packssdw _mm_packs_pi32
1520 #define _m_packuswb _mm_packs_pu16
1521 #define _m_punpckhbw _mm_unpackhi_pi8
1522 #define _m_punpckhwd _mm_unpackhi_pi16
1523 #define _m_punpckhdq _mm_unpackhi_pi32
1524 #define _m_punpcklbw _mm_unpacklo_pi8
1525 #define _m_punpcklwd _mm_unpacklo_pi16
1526 #define _m_punpckldq _mm_unpacklo_pi32
1527 #define _m_paddb _mm_add_pi8
1528 #define _m_paddw _mm_add_pi16
1529 #define _m_paddd _mm_add_pi32
1530 #define _m_paddsb _mm_adds_pi8
1531 #define _m_paddsw _mm_adds_pi16
1532 #define _m_paddusb _mm_adds_pu8
1533 #define _m_paddusw _mm_adds_pu16
1534 #define _m_psubb _mm_sub_pi8
1535 #define _m_psubw _mm_sub_pi16
1536 #define _m_psubd _mm_sub_pi32
1537 #define _m_psubsb _mm_subs_pi8
1538 #define _m_psubsw _mm_subs_pi16
1539 #define _m_psubusb _mm_subs_pu8
1540 #define _m_psubusw _mm_subs_pu16
1541 #define _m_pmaddwd _mm_madd_pi16
1542 #define _m_pmulhw _mm_mulhi_pi16
1543 #define _m_pmullw _mm_mullo_pi16
1544 #define _m_psllw _mm_sll_pi16
1545 #define _m_psllwi _mm_slli_pi16
1546 #define _m_pslld _mm_sll_pi32
1547 #define _m_pslldi _mm_slli_pi32
1548 #define _m_psllq _mm_sll_si64
1549 #define _m_psllqi _mm_slli_si64
1550 #define _m_psraw _mm_sra_pi16
1551 #define _m_psrawi _mm_srai_pi16
1552 #define _m_psrad _mm_sra_pi32
1553 #define _m_psradi _mm_srai_pi32
1554 #define _m_psrlw _mm_srl_pi16
1555 #define _m_psrlwi _mm_srli_pi16
1556 #define _m_psrld _mm_srl_pi32
1557 #define _m_psrldi _mm_srli_pi32
1558 #define _m_psrlq _mm_srl_si64
1559 #define _m_psrlqi _mm_srli_si64
1560 #define _m_pand _mm_and_si64
1561 #define _m_pandn _mm_andnot_si64
1562 #define _m_por _mm_or_si64
1563 #define _m_pxor _mm_xor_si64
1564 #define _m_pcmpeqb _mm_cmpeq_pi8
1565 #define _m_pcmpeqw _mm_cmpeq_pi16
1566 #define _m_pcmpeqd _mm_cmpeq_pi32
1567 #define _m_pcmpgtb _mm_cmpgt_pi8
1568 #define _m_pcmpgtw _mm_cmpgt_pi16
1569 #define _m_pcmpgtd _mm_cmpgt_pi32
1571 #endif /* __MMINTRIN_H */