clang 20.0.0git

Go to the source code of this file.
Macros  
#define  __DEFAULT_FN_ATTRS 
#define  _MM_FROUND_TO_NEAREST_INT 0x00 
#define  _MM_FROUND_TO_NEG_INF 0x01 
#define  _MM_FROUND_TO_POS_INF 0x02 
#define  _MM_FROUND_TO_ZERO 0x03 
#define  _MM_FROUND_CUR_DIRECTION 0x04 
#define  _MM_FROUND_RAISE_EXC 0x00 
#define  _MM_FROUND_NO_EXC 0x08 
#define  _MM_FROUND_NINT (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_NEAREST_INT) 
#define  _MM_FROUND_FLOOR (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_NEG_INF) 
#define  _MM_FROUND_CEIL (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_POS_INF) 
#define  _MM_FROUND_TRUNC (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_ZERO) 
#define  _MM_FROUND_RINT (_MM_FROUND_RAISE_EXC  _MM_FROUND_CUR_DIRECTION) 
#define  _MM_FROUND_NEARBYINT (_MM_FROUND_NO_EXC  _MM_FROUND_CUR_DIRECTION) 
#define  _mm_ceil_ps(X) _mm_round_ps((X), _MM_FROUND_CEIL) 
Rounds up each element of the 128bit vector of [4 x float] to an integer and returns the rounded values in a 128bit vector of [4 x float].  
#define  _mm_ceil_pd(X) _mm_round_pd((X), _MM_FROUND_CEIL) 
Rounds up each element of the 128bit vector of [2 x double] to an integer and returns the rounded values in a 128bit vector of [2 x double].  
#define  _mm_ceil_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_CEIL) 
Copies three upper elements of the first 128bit vector operand to the corresponding three upper elements of the 128bit result vector of [4 x float].  
#define  _mm_ceil_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_CEIL) 
Copies the upper element of the first 128bit vector operand to the corresponding upper element of the 128bit result vector of [2 x double].  
#define  _mm_floor_ps(X) _mm_round_ps((X), _MM_FROUND_FLOOR) 
Rounds down each element of the 128bit vector of [4 x float] to an an integer and returns the rounded values in a 128bit vector of [4 x float].  
#define  _mm_floor_pd(X) _mm_round_pd((X), _MM_FROUND_FLOOR) 
Rounds down each element of the 128bit vector of [2 x double] to an integer and returns the rounded values in a 128bit vector of [2 x double].  
#define  _mm_floor_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_FLOOR) 
Copies three upper elements of the first 128bit vector operand to the corresponding three upper elements of the 128bit result vector of [4 x float].  
#define  _mm_floor_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_FLOOR) 
Copies the upper element of the first 128bit vector operand to the corresponding upper element of the 128bit result vector of [2 x double].  
#define  _mm_round_ps(X, M) ((__m128)__builtin_ia32_roundps((__v4sf)(__m128)(X), (M))) 
Rounds each element of the 128bit vector of [4 x float] to an integer value according to the rounding control specified by the second argument and returns the rounded values in a 128bit vector of [4 x float].  
#define  _mm_round_ss(X, Y, M) 
Copies three upper elements of the first 128bit vector operand to the corresponding three upper elements of the 128bit result vector of [4 x float].  
#define  _mm_round_pd(X, M) ((__m128d)__builtin_ia32_roundpd((__v2df)(__m128d)(X), (M))) 
Rounds each element of the 128bit vector of [2 x double] to an integer value according to the rounding control specified by the second argument and returns the rounded values in a 128bit vector of [2 x double].  
#define  _mm_round_sd(X, Y, M) 
Copies the upper element of the first 128bit vector operand to the corresponding upper element of the 128bit result vector of [2 x double].  
#define  _mm_blend_pd(V1, V2, M) 
Returns a 128bit vector of [2 x double] where the values are selected from either the first or second operand as specified by the third operand, the control mask.  
#define  _mm_blend_ps(V1, V2, M) 
Returns a 128bit vector of [4 x float] where the values are selected from either the first or second operand as specified by the third operand, the control mask.  
#define  _mm_blend_epi16(V1, V2, M) 
Returns a 128bit vector of [8 x i16] where the values are selected from either of the first or second operand as specified by the third operand, the control mask.  
#define  _mm_dp_ps(X, Y, M) ((__m128)__builtin_ia32_dpps((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (M))) 
Computes the dot product of the two 128bit vectors of [4 x float] and returns it in the elements of the 128bit result vector of [4 x float].  
#define  _mm_dp_pd(X, Y, M) 
Computes the dot product of the two 128bit vectors of [2 x double] and returns it in the elements of the 128bit result vector of [2 x double].  
#define  _mm_insert_ps(X, Y, N) __builtin_ia32_insertps128((X), (Y), (N)) 
Takes the first argument X and inserts an element from the second argument Y as selected by the third argument N.  
#define  _mm_extract_ps(X, N) 
Extracts a 32bit integer from a 128bit vector of [4 x float] and returns it, using the immediate value parameter N as a selector.  
#define  _MM_EXTRACT_FLOAT(D, X, N) 
#define  _MM_MK_INSERTPS_NDX(X, Y, Z) (((X) << 6)  ((Y) << 4)  (Z)) 
#define  _MM_PICK_OUT_PS(X, N) _mm_insert_ps(_mm_setzero_ps(), (X), _MM_MK_INSERTPS_NDX((N), 0, 0x0e)) 
#define  _mm_insert_epi8(X, I, N) 
Constructs a 128bit vector of [16 x i8] by first making a copy of the 128bit integer vector parameter, and then inserting the lower 8 bits of an integer parameter I into an offset specified by the immediate value parameter N.  
#define  _mm_insert_epi32(X, I, N) 
Constructs a 128bit vector of [4 x i32] by first making a copy of the 128bit integer vector parameter, and then inserting the 32bit integer parameter I at the offset specified by the immediate value parameter N.  
#define  _mm_extract_epi8(X, N) 
Extracts an 8bit element from the 128bit integer vector of [16 x i8], using the immediate value parameter N as a selector.  
#define  _mm_extract_epi32(X, N) ((int)__builtin_ia32_vec_ext_v4si((__v4si)(__m128i)(X), (int)(N))) 
Extracts a 32bit element from the 128bit integer vector of [4 x i32], using the immediate value parameter N as a selector.  
#define  _mm_extract_epi64(X, N) ((long long)__builtin_ia32_vec_ext_v2di((__v2di)(__m128i)(X), (int)(N))) 
Extracts a 64bit element from the 128bit integer vector of [2 x i64], using the immediate value parameter N as a selector.  
#define  _mm_test_all_ones(V) _mm_testc_si128((V), _mm_set1_epi32(1)) 
Tests whether the specified bits in a 128bit integer vector are all ones.  
#define  _mm_test_mix_ones_zeros(M, V) _mm_testnzc_si128((M), (V)) 
Tests whether the specified bits in a 128bit integer vector are neither all zeros nor all ones.  
#define  _mm_test_all_zeros(M, V) _mm_testz_si128((M), (V)) 
Tests whether the specified bits in a 128bit integer vector are all zeros.  
#define  _mm_mpsadbw_epu8(X, Y, M) 
Subtracts 8bit unsigned integer values and computes the absolute values of the differences to the corresponding bits in the destination.  
#define  __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4.2"))) 
#define  _SIDD_UBYTE_OPS 0x00 
#define  _SIDD_UWORD_OPS 0x01 
#define  _SIDD_SBYTE_OPS 0x02 
#define  _SIDD_SWORD_OPS 0x03 
#define  _SIDD_CMP_EQUAL_ANY 0x00 
#define  _SIDD_CMP_RANGES 0x04 
#define  _SIDD_CMP_EQUAL_EACH 0x08 
#define  _SIDD_CMP_EQUAL_ORDERED 0x0c 
#define  _SIDD_POSITIVE_POLARITY 0x00 
#define  _SIDD_NEGATIVE_POLARITY 0x10 
#define  _SIDD_MASKED_POSITIVE_POLARITY 0x20 
#define  _SIDD_MASKED_NEGATIVE_POLARITY 0x30 
#define  _SIDD_LEAST_SIGNIFICANT 0x00 
#define  _SIDD_MOST_SIGNIFICANT 0x40 
#define  _SIDD_BIT_MASK 0x00 
#define  _SIDD_UNIT_MASK 0x40 
#define  _mm_cmpistrm(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpistri(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestrm(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestri(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpistra(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpistrc(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpistro(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpistrs(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpistrz(A, B, M) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestra(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestrc(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestro(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestrs(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
#define  _mm_cmpestrz(A, LA, B, LB, M) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.  
Functions  
static __inline__ __m128d __DEFAULT_FN_ATTRS  _mm_blendv_pd (__m128d __V1, __m128d __V2, __m128d __M) 
Returns a 128bit vector of [2 x double] where the values are selected from either the first or second operand as specified by the third operand, the control mask.  
static __inline__ __m128 __DEFAULT_FN_ATTRS  _mm_blendv_ps (__m128 __V1, __m128 __V2, __m128 __M) 
Returns a 128bit vector of [4 x float] where the values are selected from either the first or second operand as specified by the third operand, the control mask.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M) 
Returns a 128bit vector of [16 x i8] where the values are selected from either of the first or second operand as specified by the third operand, the control mask.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_mullo_epi32 (__m128i __V1, __m128i __V2) 
Multiples corresponding elements of two 128bit vectors of [4 x i32] and returns the lower 32 bits of the each product in a 128bit vector of [4 x i32].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_mul_epi32 (__m128i __V1, __m128i __V2) 
Multiplies corresponding evenindexed elements of two 128bit vectors of [4 x i32] and returns a 128bit vector of [2 x i64] containing the products.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_stream_load_si128 (const void *__V) 
Loads integer values from a 128bit aligned memory location to a 128bit integer vector.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_min_epi8 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [16 x i8] and returns a 128bit vector of [16 x i8] containing the lesser of the two values.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_max_epi8 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [16 x i8] and returns a 128bit vector of [16 x i8] containing the greater value of the two.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_min_epu16 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [8 x u16] and returns a 128bit vector of [8 x u16] containing the lesser value of the two.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_max_epu16 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [8 x u16] and returns a 128bit vector of [8 x u16] containing the greater value of the two.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_min_epi32 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [4 x i32] and returns a 128bit vector of [4 x i32] containing the lesser value of the two.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_max_epi32 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [4 x i32] and returns a 128bit vector of [4 x i32] containing the greater value of the two.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_min_epu32 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [4 x u32] and returns a 128bit vector of [4 x u32] containing the lesser value of the two.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_max_epu32 (__m128i __V1, __m128i __V2) 
Compares the corresponding elements of two 128bit vectors of [4 x u32] and returns a 128bit vector of [4 x u32] containing the greater value of the two.  
static __inline__ int __DEFAULT_FN_ATTRS  _mm_testz_si128 (__m128i __M, __m128i __V) 
Tests whether the specified bits in a 128bit integer vector are all zeros.  
static __inline__ int __DEFAULT_FN_ATTRS  _mm_testc_si128 (__m128i __M, __m128i __V) 
Tests whether the specified bits in a 128bit integer vector are all ones.  
static __inline__ int __DEFAULT_FN_ATTRS  _mm_testnzc_si128 (__m128i __M, __m128i __V) 
Tests whether the specified bits in a 128bit integer vector are neither all zeros nor all ones.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cmpeq_epi64 (__m128i __V1, __m128i __V2) 
Compares each of the corresponding 64bit values of the 128bit integer vectors for equality.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepi8_epi16 (__m128i __V) 
Signextends each of the lower eight 8bit integer elements of a 128bit vector of [16 x i8] to 16bit values and returns them in a 128bit vector of [8 x i16].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepi8_epi32 (__m128i __V) 
Signextends each of the lower four 8bit integer elements of a 128bit vector of [16 x i8] to 32bit values and returns them in a 128bit vector of [4 x i32].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepi8_epi64 (__m128i __V) 
Signextends each of the lower two 8bit integer elements of a 128bit integer vector of [16 x i8] to 64bit values and returns them in a 128bit vector of [2 x i64].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepi16_epi32 (__m128i __V) 
Signextends each of the lower four 16bit integer elements of a 128bit integer vector of [8 x i16] to 32bit values and returns them in a 128bit vector of [4 x i32].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepi16_epi64 (__m128i __V) 
Signextends each of the lower two 16bit integer elements of a 128bit integer vector of [8 x i16] to 64bit values and returns them in a 128bit vector of [2 x i64].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepi32_epi64 (__m128i __V) 
Signextends each of the lower two 32bit integer elements of a 128bit integer vector of [4 x i32] to 64bit values and returns them in a 128bit vector of [2 x i64].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepu8_epi16 (__m128i __V) 
Zeroextends each of the lower eight 8bit integer elements of a 128bit vector of [16 x i8] to 16bit values and returns them in a 128bit vector of [8 x i16].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepu8_epi32 (__m128i __V) 
Zeroextends each of the lower four 8bit integer elements of a 128bit vector of [16 x i8] to 32bit values and returns them in a 128bit vector of [4 x i32].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepu8_epi64 (__m128i __V) 
Zeroextends each of the lower two 8bit integer elements of a 128bit integer vector of [16 x i8] to 64bit values and returns them in a 128bit vector of [2 x i64].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepu16_epi32 (__m128i __V) 
Zeroextends each of the lower four 16bit integer elements of a 128bit integer vector of [8 x i16] to 32bit values and returns them in a 128bit vector of [4 x i32].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepu16_epi64 (__m128i __V) 
Zeroextends each of the lower two 16bit integer elements of a 128bit integer vector of [8 x i16] to 64bit values and returns them in a 128bit vector of [2 x i64].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cvtepu32_epi64 (__m128i __V) 
Zeroextends each of the lower two 32bit integer elements of a 128bit integer vector of [4 x i32] to 64bit values and returns them in a 128bit vector of [2 x i64].  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_packus_epi32 (__m128i __V1, __m128i __V2) 
Converts, with saturation, 32bit signed integers from both 128bit integer vector operands into 16bit unsigned integers, and returns the packed result.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_minpos_epu16 (__m128i __V) 
Finds the minimum unsigned 16bit element in the input 128bit vector of [8 x u16] and returns it and along with its index.  
static __inline__ __m128i __DEFAULT_FN_ATTRS  _mm_cmpgt_epi64 (__m128i __V1, __m128i __V2) 
Compares each of the corresponding 64bit values of the 128bit integer vectors to determine if the values in the first operand are greater than those in the second operand.  
#define __DEFAULT_FN_ATTRS 
Definition at line 1522 of file smmintrin.h.
#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4.2"))) 
Definition at line 1522 of file smmintrin.h.
#define _mm_blend_epi16  (  V1,  
V2,  
M  
) 
Returns a 128bit vector of [8 x i16] where the values are selected from either of the first or second operand as specified by the third operand, the control mask.
This intrinsic corresponds to the VPBLENDW / PBLENDW
instruction.
V1  A 128bit vector of [8 x i16]. 
V2  A 128bit vector of [8 x i16]. 
M  An immediate integer operand, with mask bits [7:0] specifying how the values are to be copied. The position of the mask bit corresponds to the index of a copied value. When a mask bit is 0, the corresponding 16bit element in operand V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 16bit element in operand V2 is copied to the same position in the result. 
Definition at line 521 of file smmintrin.h.
#define _mm_blend_pd  (  V1,  
V2,  
M  
) 
Returns a 128bit vector of [2 x double] where the values are selected from either the first or second operand as specified by the third operand, the control mask.
This intrinsic corresponds to the VBLENDPD / BLENDPD
instruction.
V1  A 128bit vector of [2 x double]. 
V2  A 128bit vector of [2 x double]. 
M  An immediate integer operand, with mask bits [1:0] specifying how the values are to be copied. The position of the mask bit corresponds to the index of a copied value. When a mask bit is 0, the corresponding 64bit element in operand V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 64bit element in operand V2 is copied to the same position in the result. 
Definition at line 384 of file smmintrin.h.
#define _mm_blend_ps  (  V1,  
V2,  
M  
) 
Returns a 128bit vector of [4 x float] where the values are selected from either the first or second operand as specified by the third operand, the control mask.
This intrinsic corresponds to the VBLENDPS / BLENDPS
instruction.
V1  A 128bit vector of [4 x float]. 
V2  A 128bit vector of [4 x float]. 
M  An immediate integer operand, with mask bits [3:0] specifying how the values are to be copied. The position of the mask bit corresponds to the index of a copied value. When a mask bit is 0, the corresponding 32bit element in operand V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 32bit element in operand V2 is copied to the same position in the result. 
Definition at line 412 of file smmintrin.h.
#define _mm_ceil_pd  (  X  )  _mm_round_pd((X), _MM_FROUND_CEIL) 
Rounds up each element of the 128bit vector of [2 x double] to an integer and returns the rounded values in a 128bit vector of [2 x double].
This intrinsic corresponds to the VROUNDPD / ROUNDPD
instruction.
X  A 128bit vector of [2 x double] values to be rounded up. 
Definition at line 73 of file smmintrin.h.
#define _mm_ceil_ps  (  X  )  _mm_round_ps((X), _MM_FROUND_CEIL) 
Rounds up each element of the 128bit vector of [4 x float] to an integer and returns the rounded values in a 128bit vector of [4 x float].
This intrinsic corresponds to the VROUNDPS / ROUNDPS
instruction.
X  A 128bit vector of [4 x float] values to be rounded up. 
Definition at line 56 of file smmintrin.h.
#define _mm_ceil_sd  (  X,  
Y  
)  _mm_round_sd((X), (Y), _MM_FROUND_CEIL) 
Copies the upper element of the first 128bit vector operand to the corresponding upper element of the 128bit result vector of [2 x double].
Rounds up the lower element of the second 128bit vector operand to an integer and copies it to the lower element of the 128bit result vector of [2 x double].
This intrinsic corresponds to the VROUNDSD / ROUNDSD
instruction.
X  A 128bit vector of [2 x double]. The value stored in bits [127:64] is copied to the corresponding bits of the result. 
Y  A 128bit vector of [2 x double]. The value stored in bits [63:0] is rounded up to the nearest integer and copied to the corresponding bits of the result. 
Definition at line 123 of file smmintrin.h.
#define _mm_ceil_ss  (  X,  
Y  
)  _mm_round_ss((X), (Y), _MM_FROUND_CEIL) 
Copies three upper elements of the first 128bit vector operand to the corresponding three upper elements of the 128bit result vector of [4 x float].
Rounds up the lowest element of the second 128bit vector operand to an integer and copies it to the lowest element of the 128bit result vector of [4 x float].
This intrinsic corresponds to the VROUNDSS / ROUNDSS
instruction.
X  A 128bit vector of [4 x float]. The values stored in bits [127:32] are copied to the corresponding bits of the result. 
Y  A 128bit vector of [4 x float]. The value stored in bits [31:0] is rounded up to the nearest integer and copied to the corresponding bits of the result. 
Definition at line 98 of file smmintrin.h.
#define _mm_cmpestra  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns 1 if the bit mask is zero and the length of the string in B is the maximum, otherwise, returns 0.
This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 2080 of file smmintrin.h.
#define _mm_cmpestrc  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns 1 if the resulting mask is nonzero, otherwise, returns 0.
This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 2134 of file smmintrin.h.
#define _mm_cmpestri  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns an integer representing the result index of the comparison.
This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words, the type of comparison to perform, and the format of the return value. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. Bit [6]: Determines whether the index of the lowest set bit or the highest set bit is returned. 0: The index of the least significant set bit. 1: The index of the most significant set bit. 
Definition at line 1777 of file smmintrin.h.
#define _mm_cmpestrm  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns a 128bit integer vector representing the result mask of the comparison.
This intrinsic corresponds to the VPCMPESTRM / PCMPESTRM
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words, the type of comparison to perform, and the format of the return value. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. Bit [6]: Determines whether the result is zeroextended or expanded to 16 bytes. 0: The result is zeroextended to 16 bytes. 1: The result is expanded to 16 bytes (this expansion is performed by repeating each bit 8 or 16 times). 
Definition at line 1718 of file smmintrin.h.
#define _mm_cmpestro  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns bit 0 of the resulting bit mask.
This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 2187 of file smmintrin.h.
#define _mm_cmpestrs  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns 1 if the length of the string in A is less than the maximum, otherwise, returns 0.
This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement in the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 2242 of file smmintrin.h.
#define _mm_cmpestrz  (  A,  
LA,  
B,  
LB,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with explicitly defined lengths that is contained in source operands A and B.
Returns 1 if the length of the string in B is less than the maximum, otherwise, returns 0.
This intrinsic corresponds to the VPCMPESTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
LA  An integer that specifies the length of the string in A. 
B  A 128bit integer vector containing one of the source operands to be compared. 
LB  An integer that specifies the length of the string in B. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 2296 of file smmintrin.h.
#define _mm_cmpistra  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns 1 if the bit mask is zero and the length of the string in B is the maximum, otherwise, returns 0.
This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 1829 of file smmintrin.h.
#define _mm_cmpistrc  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns 1 if the bit mask is nonzero, otherwise, returns 0.
This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 1878 of file smmintrin.h.
#define _mm_cmpistri  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns an integer representing the result index of the comparison.
This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words, the type of comparison to perform, and the format of the return value. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. Bit [6]: Determines whether the index of the lowest set bit or the highest set bit is returned. 0: The index of the least significant set bit. 1: The index of the most significant set bit. 
Definition at line 1658 of file smmintrin.h.
#define _mm_cmpistrm  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns a 128bit integer vector representing the result mask of the comparison.
This intrinsic corresponds to the VPCMPISTRM / PCMPISTRM
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words, the type of comparison to perform, and the format of the return value. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. Bit [6]: Determines whether the result is zeroextended or expanded to 16 bytes. 0: The result is zeroextended to 16 bytes. 1: The result is expanded to 16 bytes (this expansion is performed by repeating each bit 8 or 16 times). 
Definition at line 1604 of file smmintrin.h.
#define _mm_cmpistro  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns bit 0 of the resulting bit mask.
This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 1926 of file smmintrin.h.
#define _mm_cmpistrs  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns 1 if the length of the string in A is less than the maximum, otherwise, returns 0.
This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 1976 of file smmintrin.h.
#define _mm_cmpistrz  (  A,  
B,  
M  
) 
Uses the immediate operand M to perform a comparison of string data with implicitly defined lengths that is contained in source operands A and B.
Returns 1 if the length of the string in B is less than the maximum, otherwise, returns 0.
This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI
instruction.
A  A 128bit integer vector containing one of the source operands to be compared. 
B  A 128bit integer vector containing one of the source operands to be compared. 
M  An 8bit immediate operand specifying whether the characters are bytes or words and the type of comparison to perform. Bits [1:0]: Determine source data format. 00: 16 unsigned bytes 01: 8 unsigned words 10: 16 signed bytes 11: 8 signed words Bits [3:2]: Determine comparison type and aggregation method. 00: Subset: Each character in B is compared for equality with all the characters in A. 01: Ranges: Each character in B is compared to A. The comparison basis is greater than or equal for evenindexed elements in A, and less than or equal for oddindexed elements in A. 10: Match: Compare each pair of corresponding characters in A and B for equality. 11: Substring: Search B for substring matches of A. Bits [5:4]: Determine whether to perform a one's complement on the bit mask of the comparison results. 00: No effect. 01: Negate the bit mask. 10: No effect. 11: Negate the bit mask only for bits with an index less than or equal to the size of A or B. 
Definition at line 2026 of file smmintrin.h.
#define _mm_dp_pd  (  X,  
Y,  
M  
) 
Computes the dot product of the two 128bit vectors of [2 x double] and returns it in the elements of the 128bit result vector of [2 x double].
The immediate integer operand controls which input elements will contribute to the dot product, and where the final results are returned.
This intrinsic corresponds to the VDPPD / DPPD
instruction.
X  A 128bit vector of [2 x double]. 
Y  A 128bit vector of [2 x double]. 
M  An immediate integer operand. Mask bits [5:4] determine which elements of the input vectors are used, with bit [4] corresponding to the lowest element and bit [5] corresponding to the highest element of each of [2 x double] vector. If a bit is set, the corresponding elements from the two input vectors are used as an input for dot product; otherwise that input is treated as zero. Bits [1:0] determine which elements of the result will receive a copy of the final dot product, with bit [0] corresponding to the lowest element and bit [1] corresponding to the highest element of each [2 x double] vector. If a bit is set, the dot product is returned in the corresponding element; otherwise that element is set to zero. 
Definition at line 630 of file smmintrin.h.
#define _mm_dp_ps  (  X,  
Y,  
M  
)  ((__m128)__builtin_ia32_dpps((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (M))) 
Computes the dot product of the two 128bit vectors of [4 x float] and returns it in the elements of the 128bit result vector of [4 x float].
The immediate integer operand controls which input elements will contribute to the dot product, and where the final results are returned.
This intrinsic corresponds to the VDPPS / DPPS
instruction.
X  A 128bit vector of [4 x float]. 
Y  A 128bit vector of [4 x float]. 
M  An immediate integer operand. Mask bits [7:4] determine which elements of the input vectors are used, with bit [4] corresponding to the lowest element and bit [7] corresponding to the highest element of each [4 x float] vector. If a bit is set, the corresponding elements from the two input vectors are used as an input for dot product; otherwise that input is treated as zero. Bits [3:0] determine which elements of the result will receive a copy of the final dot product, with bit [0] corresponding to the lowest element and bit [3] corresponding to the highest element of each [4 x float] subvector. If a bit is set, the dot product is returned in the corresponding element; otherwise that element is set to zero. 
Definition at line 596 of file smmintrin.h.
#define _mm_extract_epi32  (  X,  
N  
)  ((int)__builtin_ia32_vec_ext_v4si((__v4si)(__m128i)(X), (int)(N))) 
Extracts a 32bit element from the 128bit integer vector of [4 x i32], using the immediate value parameter N as a selector.
This intrinsic corresponds to the VPEXTRD / PEXTRD
instruction.
X  A 128bit integer vector. 
N  An immediate value. Bits [1:0] specify which 32bit vector element from the argument X to extract and copy to the result. 00: Bits [31:0] of the parameter X are extracted. 01: Bits [63:32] of the parameter X are extracted. 10: Bits [95:64] of the parameter X are extracted. 11: Bits [127:96] of the parameter X are exracted. 
Definition at line 1054 of file smmintrin.h.
#define _mm_extract_epi64  (  X,  
N  
)  ((long long)__builtin_ia32_vec_ext_v2di((__v2di)(__m128i)(X), (int)(N))) 
Extracts a 64bit element from the 128bit integer vector of [2 x i64], using the immediate value parameter N as a selector.
This intrinsic corresponds to the VPEXTRQ / PEXTRQ
instruction in 64bit mode.
X  A 128bit integer vector. 
N  An immediate value. Bit [0] specifies which 64bit vector element from the argument X to return. 0: Bits [63:0] are returned. 1: Bits [127:64] are returned. 
Definition at line 1077 of file smmintrin.h.
#define _mm_extract_epi8  (  X,  
N  
) 
Extracts an 8bit element from the 128bit integer vector of [16 x i8], using the immediate value parameter N as a selector.
This intrinsic corresponds to the VPEXTRB / PEXTRB
instruction.
X  A 128bit integer vector. 
N  An immediate value. Bits [3:0] specify which 8bit vector element from the argument X to extract and copy to the result. 0000: Bits [7:0] of parameter X are extracted. 0001: Bits [15:8] of the parameter X are extracted. 0010: Bits [23:16] of the parameter X are extracted. 0011: Bits [31:24] of the parameter X are extracted. 0100: Bits [39:32] of the parameter X are extracted. 0101: Bits [47:40] of the parameter X are extracted. 0110: Bits [55:48] of the parameter X are extracted. 0111: Bits [63:56] of the parameter X are extracted. 1000: Bits [71:64] of the parameter X are extracted. 1001: Bits [79:72] of the parameter X are extracted. 1010: Bits [87:80] of the parameter X are extracted. 1011: Bits [95:88] of the parameter X are extracted. 1100: Bits [103:96] of the parameter X are extracted. 1101: Bits [111:104] of the parameter X are extracted. 1110: Bits [119:112] of the parameter X are extracted. 1111: Bits [127:120] of the parameter X are extracted. 
Definition at line 1028 of file smmintrin.h.
Definition at line 868 of file smmintrin.h.
#define _mm_extract_ps  (  X,  
N  
) 
Extracts a 32bit integer from a 128bit vector of [4 x float] and returns it, using the immediate value parameter N as a selector.
This intrinsic corresponds to the VEXTRACTPS / EXTRACTPS
instruction.
X  A 128bit vector of [4 x float]. 
N  An immediate value. Bits [1:0] determines which bits from the argument X are extracted and returned: 00: Bits [31:0] of parameter X are returned. 01: Bits [63:32] of parameter X are returned. 10: Bits [95:64] of parameter X are returned. 11: Bits [127:96] of parameter X are returned. 
Definition at line 862 of file smmintrin.h.
#define _mm_floor_pd  (  X  )  _mm_round_pd((X), _MM_FROUND_FLOOR) 
Rounds down each element of the 128bit vector of [2 x double] to an integer and returns the rounded values in a 128bit vector of [2 x double].
This intrinsic corresponds to the VROUNDPD / ROUNDPD
instruction.
X  A 128bit vector of [2 x double]. 
Definition at line 157 of file smmintrin.h.
#define _mm_floor_ps  (  X  )  _mm_round_ps((X), _MM_FROUND_FLOOR) 
Rounds down each element of the 128bit vector of [4 x float] to an an integer and returns the rounded values in a 128bit vector of [4 x float].
This intrinsic corresponds to the VROUNDPS / ROUNDPS
instruction.
X  A 128bit vector of [4 x float] values to be rounded down. 
Definition at line 140 of file smmintrin.h.
#define _mm_floor_sd  (  X,  
Y  
)  _mm_round_sd((X), (Y), _MM_FROUND_FLOOR) 
Copies the upper element of the first 128bit vector operand to the corresponding upper element of the 128bit result vector of [2 x double].
Rounds down the lower element of the second 128bit vector operand to an integer and copies it to the lower element of the 128bit result vector of [2 x double].
This intrinsic corresponds to the VROUNDSD / ROUNDSD
instruction.
X  A 128bit vector of [2 x double]. The value stored in bits [127:64] is copied to the corresponding bits of the result. 
Y  A 128bit vector of [2 x double]. The value stored in bits [63:0] is rounded down to the nearest integer and copied to the corresponding bits of the result. 
Definition at line 207 of file smmintrin.h.
#define _mm_floor_ss  (  X,  
Y  
)  _mm_round_ss((X), (Y), _MM_FROUND_FLOOR) 
Copies three upper elements of the first 128bit vector operand to the corresponding three upper elements of the 128bit result vector of [4 x float].
Rounds down the lowest element of the second 128bit vector operand to an integer and copies it to the lowest element of the 128bit result vector of [4 x float].
This intrinsic corresponds to the VROUNDSS / ROUNDSS
instruction.
X  A 128bit vector of [4 x float]. The values stored in bits [127:32] are copied to the corresponding bits of the result. 
Y  A 128bit vector of [4 x float]. The value stored in bits [31:0] is rounded down to the nearest integer and copied to the corresponding bits of the result. 
Definition at line 182 of file smmintrin.h.
#define _MM_FROUND_CEIL (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_POS_INF) 
Definition at line 36 of file smmintrin.h.
#define _MM_FROUND_CUR_DIRECTION 0x04 
Definition at line 29 of file smmintrin.h.
#define _MM_FROUND_FLOOR (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_NEG_INF) 
Definition at line 35 of file smmintrin.h.
#define _MM_FROUND_NEARBYINT (_MM_FROUND_NO_EXC  _MM_FROUND_CUR_DIRECTION) 
Definition at line 39 of file smmintrin.h.
#define _MM_FROUND_NINT (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_NEAREST_INT) 
Definition at line 34 of file smmintrin.h.
#define _MM_FROUND_NO_EXC 0x08 
Definition at line 32 of file smmintrin.h.
#define _MM_FROUND_RAISE_EXC 0x00 
Definition at line 31 of file smmintrin.h.
#define _MM_FROUND_RINT (_MM_FROUND_RAISE_EXC  _MM_FROUND_CUR_DIRECTION) 
Definition at line 38 of file smmintrin.h.
#define _MM_FROUND_TO_NEAREST_INT 0x00 
Definition at line 25 of file smmintrin.h.
#define _MM_FROUND_TO_NEG_INF 0x01 
Definition at line 26 of file smmintrin.h.
#define _MM_FROUND_TO_POS_INF 0x02 
Definition at line 27 of file smmintrin.h.
#define _MM_FROUND_TO_ZERO 0x03 
Definition at line 28 of file smmintrin.h.
#define _MM_FROUND_TRUNC (_MM_FROUND_RAISE_EXC  _MM_FROUND_TO_ZERO) 
Definition at line 37 of file smmintrin.h.
#define _mm_insert_epi32  (  X,  
I,  
N  
) 
Constructs a 128bit vector of [4 x i32] by first making a copy of the 128bit integer vector parameter, and then inserting the 32bit integer parameter I at the offset specified by the immediate value parameter N.
This intrinsic corresponds to the VPINSRD / PINSRD
instruction.
X  A 128bit integer vector of [4 x i32]. This vector is copied to the result and then one of the four elements in the result vector is replaced by I. 
I  A 32bit integer that is written to the result beginning at the offset specified by N. 
N  An immediate value. Bits [1:0] specify the bit offset in the result at which the integer I is written. 00: Bits [31:0] of the result are used for insertion. 01: Bits [63:32] of the result are used for insertion. 10: Bits [95:64] of the result are used for insertion. 11: Bits [127:96] of the result are used for insertion. 
Definition at line 954 of file smmintrin.h.
#define _mm_insert_epi8  (  X,  
I,  
N  
) 
Constructs a 128bit vector of [16 x i8] by first making a copy of the 128bit integer vector parameter, and then inserting the lower 8 bits of an integer parameter I into an offset specified by the immediate value parameter N.
This intrinsic corresponds to the VPINSRB / PINSRB
instruction.
X  A 128bit integer vector of [16 x i8]. This vector is copied to the result and then one of the sixteen elements in the result vector is replaced by the lower 8 bits of I. 
I  An integer. The lower 8 bits of this operand are written to the result beginning at the offset specified by N. 
N  An immediate value. Bits [3:0] specify the bit offset in the result at which the lower 8 bits of I are written. 0000: Bits [7:0] of the result are used for insertion. 0001: Bits [15:8] of the result are used for insertion. 0010: Bits [23:16] of the result are used for insertion. 0011: Bits [31:24] of the result are used for insertion. 0100: Bits [39:32] of the result are used for insertion. 0101: Bits [47:40] of the result are used for insertion. 0110: Bits [55:48] of the result are used for insertion. 0111: Bits [63:56] of the result are used for insertion. 1000: Bits [71:64] of the result are used for insertion. 1001: Bits [79:72] of the result are used for insertion. 1010: Bits [87:80] of the result are used for insertion. 1011: Bits [95:88] of the result are used for insertion. 1100: Bits [103:96] of the result are used for insertion. 1101: Bits [111:104] of the result are used for insertion. 1110: Bits [119:112] of the result are used for insertion. 1111: Bits [127:120] of the result are used for insertion. 
Definition at line 922 of file smmintrin.h.
Takes the first argument X and inserts an element from the second argument Y as selected by the third argument N.
That result then has elements zeroed out also as selected by the third argument N. The resulting 128bit vector of [4 x float] is then returned.
This intrinsic corresponds to the VINSERTPS
instruction.
X  A 128bit vector source operand of [4 x float]. With the exception of those bits in the result copied from parameter Y and zeroed by bits [3:0] of N, all bits from this parameter are copied to the result. 
Y  A 128bit vector source operand of [4 x float]. One singleprecision floatingpoint element from this source, as determined by the immediate parameter, is copied to the result. 
N  Specifies which bits from operand Y will be copied, which bits in the result they will be copied to, and which bits in the result will be cleared. The following assignments are made: Bits [7:6] specify the bits to copy from operand Y: 00: Selects bits [31:0] from operand Y. 01: Selects bits [63:32] from operand Y. 10: Selects bits [95:64] from operand Y. 11: Selects bits [127:96] from operand Y. Bits [5:4] specify the bits in the result to which the selected bits from operand Y are copied: 00: Copies the selected bits from Y to result bits [31:0]. 01: Copies the selected bits from Y to result bits [63:32]. 10: Copies the selected bits from Y to result bits [95:64]. 11: Copies the selected bits from Y to result bits [127:96]. Bits[3:0]: If any of these bits are set, the corresponding result element is cleared. 
Definition at line 838 of file smmintrin.h.
Definition at line 875 of file smmintrin.h.
#define _mm_mpsadbw_epu8  (  X,  
Y,  
M  
) 
Subtracts 8bit unsigned integer values and computes the absolute values of the differences to the corresponding bits in the destination.
Then sums of the absolute differences are returned according to the bit fields in the immediate operand.
This intrinsic corresponds to the VMPSADBW / MPSADBW
instruction.
X  A 128bit vector of [16 x i8]. 
Y  A 128bit vector of [16 x i8]. 
M  An 8bit immediate operand specifying how the absolute differences are to be calculated, according to the following algorithm: // M2 represents bit 2 of the immediate operand
// M10 represents bits [1:0] of the immediate operand
i = M2 * 4;
j = M10 * 4;
for (k = 0; k < 8; k = k + 1) {
r[k] = d0 + d1 + d2 + d3;
}

Definition at line 1495 of file smmintrin.h.
#define _MM_PICK_OUT_PS  (  X,  
N  
)  _mm_insert_ps(_mm_setzero_ps(), (X), _MM_MK_INSERTPS_NDX((N), 0, 0x0e)) 
Definition at line 878 of file smmintrin.h.
Rounds each element of the 128bit vector of [2 x double] to an integer value according to the rounding control specified by the second argument and returns the rounded values in a 128bit vector of [2 x double].
This intrinsic corresponds to the VROUNDPD / ROUNDPD
instruction.
X  A 128bit vector of [2 x double]. 
M  An integer value that specifies the rounding operation. Bits [7:4] are reserved. Bit [3] is a precision exception value: 0: A normal PE exception is used 1: The PE field is not updated Bit [2] is the rounding control source: 0: Use bits [1:0] of M 1: Use the current MXCSR setting Bits [1:0] contain the rounding control definition: 00: Nearest 01: Downward (toward negative infinity) 10: Upward (toward positive infinity) 11: Truncated 
Definition at line 314 of file smmintrin.h.
Rounds each element of the 128bit vector of [4 x float] to an integer value according to the rounding control specified by the second argument and returns the rounded values in a 128bit vector of [4 x float].
This intrinsic corresponds to the VROUNDPS / ROUNDPS
instruction.
X  A 128bit vector of [4 x float]. 
M  An integer value that specifies the rounding operation. Bits [7:4] are reserved. Bit [3] is a precision exception value: 0: A normal PE exception is used 1: The PE field is not updated Bit [2] is the rounding control source: 0: Use bits [1:0] of M 1: Use the current MXCSR setting Bits [1:0] contain the rounding control definition: 00: Nearest 01: Downward (toward negative infinity) 10: Upward (toward positive infinity) 11: Truncated 
Definition at line 239 of file smmintrin.h.
#define _mm_round_sd  (  X,  
Y,  
M  
) 
Copies the upper element of the first 128bit vector operand to the corresponding upper element of the 128bit result vector of [2 x double].
Rounds the lower element of the second 128bit vector operand to an integer value according to the rounding control specified by the third argument and copies it to the lower element of the 128bit result vector of [2 x double].
This intrinsic corresponds to the VROUNDSD / ROUNDSD
instruction.
X  A 128bit vector of [2 x double]. The value stored in bits [127:64] is copied to the corresponding bits of the result. 
Y  A 128bit vector of [2 x double]. The value stored in bits [63:0] is rounded to the nearest integer using the specified rounding control and copied to the corresponding bits of the result. 
M  An integer value that specifies the rounding operation. Bits [7:4] are reserved. Bit [3] is a precision exception value: 0: A normal PE exception is used 1: The PE field is not updated Bit [2] is the rounding control source: 0: Use bits [1:0] of M 1: Use the current MXCSR setting Bits [1:0] contain the rounding control definition: 00: Nearest 01: Downward (toward negative infinity) 10: Upward (toward positive infinity) 11: Truncated 
Definition at line 355 of file smmintrin.h.
#define _mm_round_ss  (  X,  
Y,  
M  
) 
Copies three upper elements of the first 128bit vector operand to the corresponding three upper elements of the 128bit result vector of [4 x float].
Rounds the lowest element of the second 128bit vector operand to an integer value according to the rounding control specified by the third argument and copies it to the lowest element of the 128bit result vector of [4 x float].
This intrinsic corresponds to the VROUNDSS / ROUNDSS
instruction.
X  A 128bit vector of [4 x float]. The values stored in bits [127:32] are copied to the corresponding bits of the result. 
Y  A 128bit vector of [4 x float]. The value stored in bits [31:0] is rounded to the nearest integer using the specified rounding control and copied to the corresponding bits of the result. 
M  An integer value that specifies the rounding operation. Bits [7:4] are reserved. Bit [3] is a precision exception value: 0: A normal PE exception is used 1: The PE field is not updated Bit [2] is the rounding control source: 0: Use bits [1:0] of M 1: Use the current MXCSR setting Bits [1:0] contain the rounding control definition: 00: Nearest 01: Downward (toward negative infinity) 10: Upward (toward positive infinity) 11: Truncated 
Definition at line 280 of file smmintrin.h.
#define _mm_test_all_ones  (  V  )  _mm_testc_si128((V), _mm_set1_epi32(1)) 
Tests whether the specified bits in a 128bit integer vector are all ones.
This intrinsic corresponds to the VPTEST / PTEST
instruction.
V  A 128bit integer vector containing the bits to be tested. 
Definition at line 1148 of file smmintrin.h.
#define _mm_test_all_zeros  (  M,  
V  
)  _mm_testz_si128((M), (V)) 
Tests whether the specified bits in a 128bit integer vector are all zeros.
This intrinsic corresponds to the VPTEST / PTEST
instruction.
M  A 128bit integer vector containing the bits to be tested. 
V  A 128bit integer vector selecting which bits to test in operand M. 
Definition at line 1185 of file smmintrin.h.
#define _mm_test_mix_ones_zeros  (  M,  
V  
)  _mm_testnzc_si128((M), (V)) 
Tests whether the specified bits in a 128bit integer vector are neither all zeros nor all ones.
This intrinsic corresponds to the VPTEST / PTEST
instruction.
M  A 128bit integer vector containing the bits to be tested. 
V  A 128bit integer vector selecting which bits to test in operand M. 
Definition at line 1167 of file smmintrin.h.
#define _SIDD_BIT_MASK 0x00 
Definition at line 1548 of file smmintrin.h.
#define _SIDD_CMP_EQUAL_ANY 0x00 
Definition at line 1532 of file smmintrin.h.
#define _SIDD_CMP_EQUAL_EACH 0x08 
Definition at line 1534 of file smmintrin.h.
#define _SIDD_CMP_EQUAL_ORDERED 0x0c 
Definition at line 1535 of file smmintrin.h.
#define _SIDD_CMP_RANGES 0x04 
Definition at line 1533 of file smmintrin.h.
#define _SIDD_LEAST_SIGNIFICANT 0x00 
Definition at line 1544 of file smmintrin.h.
#define _SIDD_MASKED_NEGATIVE_POLARITY 0x30 
Definition at line 1541 of file smmintrin.h.
#define _SIDD_MASKED_POSITIVE_POLARITY 0x20 
Definition at line 1540 of file smmintrin.h.
#define _SIDD_MOST_SIGNIFICANT 0x40 
Definition at line 1545 of file smmintrin.h.
#define _SIDD_NEGATIVE_POLARITY 0x10 
Definition at line 1539 of file smmintrin.h.
#define _SIDD_POSITIVE_POLARITY 0x00 
Definition at line 1538 of file smmintrin.h.
#define _SIDD_SBYTE_OPS 0x02 
Definition at line 1528 of file smmintrin.h.
#define _SIDD_SWORD_OPS 0x03 
Definition at line 1529 of file smmintrin.h.
#define _SIDD_UBYTE_OPS 0x00 
Definition at line 1526 of file smmintrin.h.
#define _SIDD_UNIT_MASK 0x40 
Definition at line 1549 of file smmintrin.h.
#define _SIDD_UWORD_OPS 0x01 
Definition at line 1527 of file smmintrin.h.

static 
Returns a 128bit vector of [16 x i8] where the values are selected from either of the first or second operand as specified by the third operand, the control mask.
This intrinsic corresponds to the VPBLENDVB / PBLENDVB
instruction.
__V1  A 128bit vector of [16 x i8]. 
__V2  A 128bit vector of [16 x i8]. 
__M  A 128bit vector operand, with mask bits 127, 119, 111...7 specifying how the values are to be copied. The position of the mask bit corresponds to the most significant bit of a copied value. When a mask bit is 0, the corresponding 8bit element in operand __V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 8bit element in operand __V2 is copied to the same position in the result. 
Definition at line 490 of file smmintrin.h.

static 
Returns a 128bit vector of [2 x double] where the values are selected from either the first or second operand as specified by the third operand, the control mask.
This intrinsic corresponds to the VBLENDVPD / BLENDVPD
instruction.
__V1  A 128bit vector of [2 x double]. 
__V2  A 128bit vector of [2 x double]. 
__M  A 128bit vector operand, with mask bits 127 and 63 specifying how the values are to be copied. The position of the mask bit corresponds to the most significant bit of a copied value. When a mask bit is 0, the corresponding 64bit element in operand __V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 64bit element in operand __V2 is copied to the same position in the result. 
Definition at line 436 of file smmintrin.h.

static 
Returns a 128bit vector of [4 x float] where the values are selected from either the first or second operand as specified by the third operand, the control mask.
This intrinsic corresponds to the VBLENDVPS / BLENDVPS
instruction.
__V1  A 128bit vector of [4 x float]. 
__V2  A 128bit vector of [4 x float]. 
__M  A 128bit vector operand, with mask bits 127, 95, 63, and 31 specifying how the values are to be copied. The position of the mask bit corresponds to the most significant bit of a copied value. When a mask bit is 0, the corresponding 32bit element in operand __V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 32bit element in operand __V2 is copied to the same position in the result. 
Definition at line 463 of file smmintrin.h.

static 
Compares each of the corresponding 64bit values of the 128bit integer vectors for equality.
Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
This intrinsic corresponds to the VPCMPEQQ / PCMPEQQ
instruction.
__V1  A 128bit integer vector. 
__V2  A 128bit integer vector. 
Definition at line 1202 of file smmintrin.h.

static 
Compares each of the corresponding 64bit values of the 128bit integer vectors to determine if the values in the first operand are greater than those in the second operand.
Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
This intrinsic corresponds to the VPCMPGTQ / PCMPGTQ
instruction.
__V1  A 128bit integer vector. 
__V2  A 128bit integer vector. 
Definition at line 2317 of file smmintrin.h.

static 
Signextends each of the lower four 16bit integer elements of a 128bit integer vector of [8 x i16] to 32bit values and returns them in a 128bit vector of [4 x i32].
The upper four elements of the input vector are unused.
This intrinsic corresponds to the VPMOVSXWD / PMOVSXWD
instruction.
__V  A 128bit vector of [8 x i16]. The lower four 16bit elements are signextended to 32bit values. 
Definition at line 1283 of file smmintrin.h.
Referenced by _mm_mask_cvtepi16_epi32(), and _mm_maskz_cvtepi16_epi32().

static 
Signextends each of the lower two 16bit integer elements of a 128bit integer vector of [8 x i16] to 64bit values and returns them in a 128bit vector of [2 x i64].
The upper six elements of the input vector are unused.
This intrinsic corresponds to the VPMOVSXWQ / PMOVSXWQ
instruction.
__V  A 128bit vector of [8 x i16]. The lower two 16bit elements are signextended to 64bit values. 
Definition at line 1301 of file smmintrin.h.
Referenced by _mm_mask_cvtepi16_epi64(), and _mm_maskz_cvtepi16_epi64().

static 
Signextends each of the lower two 32bit integer elements of a 128bit integer vector of [4 x i32] to 64bit values and returns them in a 128bit vector of [2 x i64].
The upper two elements of the input vector are unused.
This intrinsic corresponds to the VPMOVSXDQ / PMOVSXDQ
instruction.
__V  A 128bit vector of [4 x i32]. The lower two 32bit elements are signextended to 64bit values. 
Definition at line 1319 of file smmintrin.h.
Referenced by _mm_mask_cvtepi32_epi64(), and _mm_maskz_cvtepi32_epi64().

static 
Signextends each of the lower eight 8bit integer elements of a 128bit vector of [16 x i8] to 16bit values and returns them in a 128bit vector of [8 x i16].
The upper eight elements of the input vector are unused.
This intrinsic corresponds to the VPMOVSXBW / PMOVSXBW
instruction.
__V  A 128bit vector of [16 x i8]. The lower eight 8bit elements are signextended to 16bit values. 
Definition at line 1221 of file smmintrin.h.
Referenced by _mm_mask_cvtepi8_epi16(), and _mm_maskz_cvtepi8_epi16().

static 
Signextends each of the lower four 8bit integer elements of a 128bit vector of [16 x i8] to 32bit values and returns them in a 128bit vector of [4 x i32].
The upper twelve elements of the input vector are unused.
This intrinsic corresponds to the VPMOVSXBD / PMOVSXBD
instruction.
__V  A 128bit vector of [16 x i8]. The lower four 8bit elements are signextended to 32bit values. 
Definition at line 1243 of file smmintrin.h.
Referenced by _mm_mask_cvtepi8_epi32(), and _mm_maskz_cvtepi8_epi32().

static 
Signextends each of the lower two 8bit integer elements of a 128bit integer vector of [16 x i8] to 64bit values and returns them in a 128bit vector of [2 x i64].
The upper fourteen elements of the input vector are unused.
This intrinsic corresponds to the VPMOVSXBQ / PMOVSXBQ
instruction.
__V  A 128bit vector of [16 x i8]. The lower two 8bit elements are signextended to 64bit values. 
Definition at line 1263 of file smmintrin.h.
Referenced by _mm_mask_cvtepi8_epi64(), and _mm_maskz_cvtepi8_epi64().

static 
Zeroextends each of the lower four 16bit integer elements of a 128bit integer vector of [8 x i16] to 32bit values and returns them in a 128bit vector of [4 x i32].
The upper four elements of the input vector are unused.
This intrinsic corresponds to the VPMOVZXWD / PMOVZXWD
instruction.
__V  A 128bit vector of [8 x i16]. The lower four 16bit elements are zeroextended to 32bit values. 
Definition at line 1394 of file smmintrin.h.
Referenced by _mm_mask_cvtepu16_epi32(), and _mm_maskz_cvtepu16_epi32().

static 
Zeroextends each of the lower two 16bit integer elements of a 128bit integer vector of [8 x i16] to 64bit values and returns them in a 128bit vector of [2 x i64].
The upper six elements of the input vector are unused.
This intrinsic corresponds to the VPMOVZXWQ / PMOVZXWQ
instruction.
__V  A 128bit vector of [8 x i16]. The lower two 16bit elements are zeroextended to 64bit values. 
Definition at line 1412 of file smmintrin.h.
Referenced by _mm_mask_cvtepu16_epi64(), and _mm_maskz_cvtepu16_epi64().

static 
Zeroextends each of the lower two 32bit integer elements of a 128bit integer vector of [4 x i32] to 64bit values and returns them in a 128bit vector of [2 x i64].
The upper two elements of the input vector are unused.
This intrinsic corresponds to the VPMOVZXDQ / PMOVZXDQ
instruction.
__V  A 128bit vector of [4 x i32]. The lower two 32bit elements are zeroextended to 64bit values. 
Definition at line 1430 of file smmintrin.h.
Referenced by _mm_mask_cvtepu32_epi64(), and _mm_maskz_cvtepu32_epi64().

static 
Zeroextends each of the lower eight 8bit integer elements of a 128bit vector of [16 x i8] to 16bit values and returns them in a 128bit vector of [8 x i16].
The upper eight elements of the input vector are unused.
This intrinsic corresponds to the VPMOVZXBW / PMOVZXBW
instruction.
__V  A 128bit vector of [16 x i8]. The lower eight 8bit elements are zeroextended to 16bit values. 
Definition at line 1338 of file smmintrin.h.
Referenced by _mm_mask_cvtepu8_epi16(), and _mm_maskz_cvtepu8_epi16().

static 
Zeroextends each of the lower four 8bit integer elements of a 128bit vector of [16 x i8] to 32bit values and returns them in a 128bit vector of [4 x i32].
The upper twelve elements of the input vector are unused.
This intrinsic corresponds to the VPMOVZXBD / PMOVZXBD
instruction.
__V  A 128bit vector of [16 x i8]. The lower four 8bit elements are zeroextended to 32bit values. 
Definition at line 1358 of file smmintrin.h.
Referenced by _mm_mask_cvtepu8_epi32(), and _mm_maskz_cvtepu8_epi32().

static 
Zeroextends each of the lower two 8bit integer elements of a 128bit integer vector of [16 x i8] to 64bit values and returns them in a 128bit vector of [2 x i64].
The upper fourteen elements of the input vector are unused.
This intrinsic corresponds to the VPMOVZXBQ / PMOVZXBQ
instruction.
__V  A 128bit vector of [16 x i8]. The lower two 8bit elements are zeroextended to 64bit values. 
Definition at line 1376 of file smmintrin.h.
Referenced by _mm_mask_cvtepu8_epi64(), and _mm_maskz_cvtepu8_epi64().

static 
Compares the corresponding elements of two 128bit vectors of [4 x i32] and returns a 128bit vector of [4 x i32] containing the greater value of the two.
This intrinsic corresponds to the VPMAXSD / PMAXSD
instruction.
__V1  A 128bit vector of [4 x i32]. 
__V2  A 128bit vector of [4 x i32]. 
Definition at line 756 of file smmintrin.h.
Referenced by _mm_mask_max_epi32(), and _mm_maskz_max_epi32().

static 
Compares the corresponding elements of two 128bit vectors of [16 x i8] and returns a 128bit vector of [16 x i8] containing the greater value of the two.
This intrinsic corresponds to the VPMAXSB / PMAXSB
instruction.
__V1  A 128bit vector of [16 x i8]. 
__V2  A 128bit vector of [16 x i8]. 
Definition at line 684 of file smmintrin.h.
Referenced by _mm_mask_max_epi8(), and _mm_maskz_max_epi8().

static 
Compares the corresponding elements of two 128bit vectors of [8 x u16] and returns a 128bit vector of [8 x u16] containing the greater value of the two.
This intrinsic corresponds to the VPMAXUW / PMAXUW
instruction.
__V1  A 128bit vector of [8 x u16]. 
__V2  A 128bit vector of [8 x u16]. 
Definition at line 720 of file smmintrin.h.
Referenced by _mm_mask_max_epu16(), and _mm_maskz_max_epu16().

static 
Compares the corresponding elements of two 128bit vectors of [4 x u32] and returns a 128bit vector of [4 x u32] containing the greater value of the two.
This intrinsic corresponds to the VPMAXUD / PMAXUD
instruction.
__V1  A 128bit vector of [4 x u32]. 
__V2  A 128bit vector of [4 x u32]. 
Definition at line 792 of file smmintrin.h.
Referenced by _mm_mask_max_epu32(), and _mm_maskz_max_epu32().

static 
Compares the corresponding elements of two 128bit vectors of [4 x i32] and returns a 128bit vector of [4 x i32] containing the lesser value of the two.
This intrinsic corresponds to the VPMINSD / PMINSD
instruction.
__V1  A 128bit vector of [4 x i32]. 
__V2  A 128bit vector of [4 x i32]. 
Definition at line 738 of file smmintrin.h.
Referenced by _mm_mask_min_epi32(), and _mm_maskz_min_epi32().

static 
Compares the corresponding elements of two 128bit vectors of [16 x i8] and returns a 128bit vector of [16 x i8] containing the lesser of the two values.
This intrinsic corresponds to the VPMINSB / PMINSB
instruction.
__V1  A 128bit vector of [16 x i8]. 
__V2  A 128bit vector of [16 x i8] 
Definition at line 666 of file smmintrin.h.
Referenced by _mm_mask_min_epi8(), and _mm_maskz_min_epi8().

static 
Compares the corresponding elements of two 128bit vectors of [8 x u16] and returns a 128bit vector of [8 x u16] containing the lesser value of the two.
This intrinsic corresponds to the VPMINUW / PMINUW
instruction.
__V1  A 128bit vector of [8 x u16]. 
__V2  A 128bit vector of [8 x u16]. 
Definition at line 702 of file smmintrin.h.
Referenced by _mm_mask_min_epu16(), and _mm_maskz_min_epu16().

static 
Compares the corresponding elements of two 128bit vectors of [4 x u32] and returns a 128bit vector of [4 x u32] containing the lesser value of the two.
This intrinsic corresponds to the VPMINUD / PMINUD
instruction.
__V1  A 128bit vector of [4 x u32]. 
__V2  A 128bit vector of [4 x u32]. 
Definition at line 774 of file smmintrin.h.
Referenced by _mm_mask_min_epu32(), and _mm_maskz_min_epu32().

static 
Finds the minimum unsigned 16bit element in the input 128bit vector of [8 x u16] and returns it and along with its index.
This intrinsic corresponds to the VPHMINPOSUW / PHMINPOSUW
instruction.
__V  A 128bit vector of [8 x u16]. 
Definition at line 1512 of file smmintrin.h.

static 
Multiplies corresponding evenindexed elements of two 128bit vectors of [4 x i32] and returns a 128bit vector of [2 x i64] containing the products.
This intrinsic corresponds to the VPMULDQ / PMULDQ
instruction.
__V1  A 128bit vector of [4 x i32]. 
__V2  A 128bit vector of [4 x i32]. 
Definition at line 558 of file smmintrin.h.
Referenced by _mm_mask_mul_epi32(), and _mm_maskz_mul_epi32().

static 
Multiples corresponding elements of two 128bit vectors of [4 x i32] and returns the lower 32 bits of the each product in a 128bit vector of [4 x i32].
This intrinsic corresponds to the VPMULLD / PMULLD
instruction.
__V1  A 128bit integer vector. 
__V2  A 128bit integer vector. 
Definition at line 539 of file smmintrin.h.
Referenced by _mm_mask_mullo_epi32(), and _mm_maskz_mullo_epi32().

static 
Converts, with saturation, 32bit signed integers from both 128bit integer vector operands into 16bit unsigned integers, and returns the packed result.
Values greater than 0xFFFF are saturated to 0xFFFF. Values less than 0x0000 are saturated to 0x0000.
This intrinsic corresponds to the VPACKUSDW / PACKUSDW
instruction.
__V1  A 128bit vector of [4 x i32]. The converted [4 x i16] values are written to the lower 64 bits of the result. 
__V2  A 128bit vector of [4 x i32]. The converted [4 x i16] values are written to the higher 64 bits of the result. 
Definition at line 1454 of file smmintrin.h.
Referenced by _mm_mask_packus_epi32(), and _mm_maskz_packus_epi32().

static 
Loads integer values from a 128bit aligned memory location to a 128bit integer vector.
This intrinsic corresponds to the VMOVNTDQA / MOVNTDQA
instruction.
__V  A pointer to a 128bit aligned memory location that contains the integer values. 
Definition at line 648 of file smmintrin.h.

static 
Tests whether the specified bits in a 128bit integer vector are all ones.
This intrinsic corresponds to the VPTEST / PTEST
instruction.
__M  A 128bit integer vector containing the bits to be tested. 
__V  A 128bit integer vector selecting which bits to test in operand __M. 
Definition at line 1110 of file smmintrin.h.

static 
Tests whether the specified bits in a 128bit integer vector are neither all zeros nor all ones.
This intrinsic corresponds to the VPTEST / PTEST
instruction.
__M  A 128bit integer vector containing the bits to be tested. 
__V  A 128bit integer vector selecting which bits to test in operand __M. 
Definition at line 1128 of file smmintrin.h.

static 
Tests whether the specified bits in a 128bit integer vector are all zeros.
This intrinsic corresponds to the VPTEST / PTEST
instruction.
__M  A 128bit integer vector containing the bits to be tested. 
__V  A 128bit integer vector selecting which bits to test in operand __M. 
Definition at line 1093 of file smmintrin.h.