smmintrin.h File Reference

#include <tmmintrin.h>
#include <popcntintrin.h>
#include <crc32intrin.h>

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 128-bit vector of [4 x float] to an integer and returns the rounded values in a 128-bit vector of [4 x float].
#define	_mm_ceil_pd(X)   _mm_round_pd((X), _MM_FROUND_CEIL)
	Rounds up each element of the 128-bit vector of [2 x double] to an integer and returns the rounded values in a 128-bit 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 128-bit vector operand to the corresponding three upper elements of the 128-bit 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 128-bit vector operand to the corresponding upper element of the 128-bit result vector of [2 x double].
#define	_mm_floor_ps(X)   _mm_round_ps((X), _MM_FROUND_FLOOR)
	Rounds down each element of the 128-bit vector of [4 x float] to an an integer and returns the rounded values in a 128-bit vector of [4 x float].
#define	_mm_floor_pd(X)   _mm_round_pd((X), _MM_FROUND_FLOOR)
	Rounds down each element of the 128-bit vector of [2 x double] to an integer and returns the rounded values in a 128-bit 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 128-bit vector operand to the corresponding three upper elements of the 128-bit 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 128-bit vector operand to the corresponding upper element of the 128-bit 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 128-bit 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 128-bit vector of [4 x float].
#define	_mm_round_ss(X, Y, M)
	Copies three upper elements of the first 128-bit vector operand to the corresponding three upper elements of the 128-bit 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 128-bit 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 128-bit vector of [2 x double].
#define	_mm_round_sd(X, Y, M)
	Copies the upper element of the first 128-bit vector operand to the corresponding upper element of the 128-bit result vector of [2 x double].
#define	_mm_blend_pd(V1, V2, M)
	Returns a 128-bit 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 128-bit 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 128-bit 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 128-bit vectors of [4 x float] and returns it in the elements of the 128-bit result vector of [4 x float].
#define	_mm_dp_pd(X, Y, M)
	Computes the dot product of the two 128-bit vectors of [2 x double] and returns it in the elements of the 128-bit 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 32-bit integer from a 128-bit 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 128-bit vector of [16 x i8] by first making a copy of the 128-bit 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 128-bit vector of [4 x i32] by first making a copy of the 128-bit integer vector parameter, and then inserting the 32-bit integer parameter I at the offset specified by the immediate value parameter N.
#define	_mm_extract_epi8(X, N)
	Extracts an 8-bit element from the 128-bit 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 32-bit element from the 128-bit 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 64-bit element from the 128-bit 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 128-bit 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 128-bit 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 128-bit integer vector are all zeros.
#define	_mm_mpsadbw_epu8(X, Y, M)
	Subtracts 8-bit 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 128-bit 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 128-bit 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 128-bit 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 128-bit vectors of [4 x i32] and returns the lower 32 bits of the each product in a 128-bit vector of [4 x i32].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_mul_epi32 (__m128i __V1, __m128i __V2)
	Multiplies corresponding even-indexed elements of two 128-bit vectors of [4 x i32] and returns a 128-bit 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 128-bit aligned memory location to a 128-bit integer vector.
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_min_epi8 (__m128i __V1, __m128i __V2)
	Compares the corresponding elements of two 128-bit vectors of [16 x i8] and returns a 128-bit vector 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 128-bit vectors of [16 x i8] and returns a 128-bit 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 128-bit vectors of [8 x u16] and returns a 128-bit 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 128-bit vectors of [8 x u16] and returns a 128-bit 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 128-bit vectors of [4 x i32] and returns a 128-bit 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 128-bit vectors of [4 x i32] and returns a 128-bit 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 128-bit vectors of [4 x u32] and returns a 128-bit 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 128-bit vectors of [4 x u32] and returns a 128-bit 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 128-bit 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 128-bit 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 128-bit 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 64-bit values of the 128-bit integer vectors for equality.
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepi8_epi16 (__m128i __V)
	Sign-extends each of the lower eight 8-bit integer elements of a 128-bit vector of [16 x i8] to 16-bit values and returns them in a 128-bit vector of [8 x i16].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepi8_epi32 (__m128i __V)
	Sign-extends each of the lower four 8-bit integer elements of a 128-bit vector of [16 x i8] to 32-bit values and returns them in a 128-bit vector of [4 x i32].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepi8_epi64 (__m128i __V)
	Sign-extends each of the lower two 8-bit integer elements of a 128-bit integer vector of [16 x i8] to 64-bit values and returns them in a 128-bit vector of [2 x i64].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepi16_epi32 (__m128i __V)
	Sign-extends each of the lower four 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 32-bit values and returns them in a 128-bit vector of [4 x i32].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepi16_epi64 (__m128i __V)
	Sign-extends each of the lower two 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 64-bit values and returns them in a 128-bit vector of [2 x i64].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepi32_epi64 (__m128i __V)
	Sign-extends each of the lower two 32-bit integer elements of a 128-bit integer vector of [4 x i32] to 64-bit values and returns them in a 128-bit vector of [2 x i64].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepu8_epi16 (__m128i __V)
	Zero-extends each of the lower eight 8-bit integer elements of a 128-bit vector of [16 x i8] to 16-bit values and returns them in a 128-bit vector of [8 x i16].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepu8_epi32 (__m128i __V)
	Zero-extends each of the lower four 8-bit integer elements of a 128-bit vector of [16 x i8] to 32-bit values and returns them in a 128-bit vector of [4 x i32].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepu8_epi64 (__m128i __V)
	Zero-extends each of the lower two 8-bit integer elements of a 128-bit integer vector of [16 x i8] to 64-bit values and returns them in a 128-bit vector of [2 x i64].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepu16_epi32 (__m128i __V)
	Zero-extends each of the lower four 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 32-bit values and returns them in a 128-bit vector of [4 x i32].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepu16_epi64 (__m128i __V)
	Zero-extends each of the lower two 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 64-bit values and returns them in a 128-bit vector of [2 x i64].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cvtepu32_epi64 (__m128i __V)
	Zero-extends each of the lower two 32-bit integer elements of a 128-bit integer vector of [4 x i32] to 64-bit values and returns them in a 128-bit vector of [2 x i64].
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_packus_epi32 (__m128i __V1, __m128i __V2)
	Converts, with saturation, 32-bit signed integers from both 128-bit integer vector operands into 16-bit unsigned integers, and returns the packed result.
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_minpos_epu16 (__m128i __V)
	Finds the minimum unsigned 16-bit element in the input 128-bit vector of [8 x u16] and returns it and along with its index.
static __inline__ __m128i __DEFAULT_FN_ATTRS	_mm_cmpgt_epi64 (__m128i __V1, __m128i __V2)
	Compares each of the corresponding 64-bit values of the 128-bit integer vectors to determine if the values in the first operand are greater than those in the second operand.

Macro Definition Documentation

__DEFAULT_FN_ATTRS [1/2]

#define __DEFAULT_FN_ATTRS

Value:

  __attribute__((__always_inline__, __nodebug__, __target__("sse4.1"),         \
                 __min_vector_width__(128)))

Definition at line 1528 of file smmintrin.h.

__DEFAULT_FN_ATTRS [2/2]

#define __DEFAULT_FN_ATTRS    __attribute__((__always_inline__, __nodebug__, __target__("sse4.2")))

Definition at line 1528 of file smmintrin.h.

_mm_blend_epi16

#define _mm_blend_epi16	(		V1,
			V2,
			M
	)

Value:

  ((__m128i)__builtin_ia32_pblendw128((__v8hi)(__m128i)(V1),                   \
                                      (__v8hi)(__m128i)(V2), (int)(M)))

Returns a 128-bit 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.

__m128i _mm_blend_epi16(__m128i V1, __m128i V2, const int M);

This intrinsic corresponds to the VPBLENDW / PBLENDW instruction.

Parameters

V1	A 128-bit vector of [8 x i16].
V2	A 128-bit 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 16-bit element in operand V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 16-bit element in operand V2 is copied to the same position in the result.

Returns

A 128-bit vector of [8 x i16] containing the copied values.

Definition at line 527 of file smmintrin.h.

_mm_blend_pd

#define _mm_blend_pd	(		V1,
			V2,
			M
	)

Value:

  ((__m128d)__builtin_ia32_blendpd((__v2df)(__m128d)(V1),                      \
                                   (__v2df)(__m128d)(V2), (int)(M)))

Returns a 128-bit 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.

__m128d _mm_blend_pd(__m128d V1, __m128d V2, const int M);

This intrinsic corresponds to the VBLENDPD / BLENDPD instruction.

Parameters

V1	A 128-bit vector of [2 x double].
V2	A 128-bit 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 64-bit element in operand V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 64-bit element in operand V2 is copied to the same position in the result.

Returns

A 128-bit vector of [2 x double] containing the copied values.

Definition at line 390 of file smmintrin.h.

_mm_blend_ps

#define _mm_blend_ps	(		V1,
			V2,
			M
	)

Value:

  ((__m128)__builtin_ia32_blendps((__v4sf)(__m128)(V1), (__v4sf)(__m128)(V2),  \
                                  (int)(M)))

Returns a 128-bit 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.

__m128 _mm_blend_ps(__m128 V1, __m128 V2, const int M);

This intrinsic corresponds to the VBLENDPS / BLENDPS instruction.

Parameters

V1	A 128-bit vector of [4 x float].
V2	A 128-bit 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 32-bit element in operand V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 32-bit element in operand V2 is copied to the same position in the result.

Returns

A 128-bit vector of [4 x float] containing the copied values.

Definition at line 418 of file smmintrin.h.

_mm_ceil_pd

#define _mm_ceil_pd

(

X

)

_mm_round_pd((X), _MM_FROUND_CEIL)

Rounds up each element of the 128-bit vector of [2 x double] to an integer and returns the rounded values in a 128-bit vector of [2 x double].

__m128d _mm_ceil_pd(__m128d X);

This intrinsic corresponds to the VROUNDPD / ROUNDPD instruction.

Parameters

X	A 128-bit vector of [2 x double] values to be rounded up.

Returns

A 128-bit vector of [2 x double] containing the rounded values.

Definition at line 79 of file smmintrin.h.

_mm_ceil_ps

#define _mm_ceil_ps

(

X

)

_mm_round_ps((X), _MM_FROUND_CEIL)

Rounds up each element of the 128-bit vector of [4 x float] to an integer and returns the rounded values in a 128-bit vector of [4 x float].

__m128 _mm_ceil_ps(__m128 X);

This intrinsic corresponds to the VROUNDPS / ROUNDPS instruction.

Parameters

X	A 128-bit vector of [4 x float] values to be rounded up.

Returns

A 128-bit vector of [4 x float] containing the rounded values.

Definition at line 62 of file smmintrin.h.

_mm_ceil_sd

#define _mm_ceil_sd	(		X,
			Y
	)		_mm_round_sd((X), (Y), _MM_FROUND_CEIL)

Copies the upper element of the first 128-bit vector operand to the corresponding upper element of the 128-bit result vector of [2 x double].

Rounds up the lower element of the second 128-bit vector operand to an integer and copies it to the lower element of the 128-bit result vector of [2 x double].

__m128d _mm_ceil_sd(__m128d X, __m128d Y);

This intrinsic corresponds to the VROUNDSD / ROUNDSD instruction.

Parameters

X	A 128-bit vector of [2 x double]. The value stored in bits [127:64] is copied to the corresponding bits of the result.
Y	A 128-bit 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.

Returns

A 128-bit vector of [2 x double] containing the copied and rounded values.

Definition at line 129 of file smmintrin.h.

_mm_ceil_ss

#define _mm_ceil_ss	(		X,
			Y
	)		_mm_round_ss((X), (Y), _MM_FROUND_CEIL)

Copies three upper elements of the first 128-bit vector operand to the corresponding three upper elements of the 128-bit result vector of [4 x float].

Rounds up the lowest element of the second 128-bit vector operand to an integer and copies it to the lowest element of the 128-bit result vector of [4 x float].

__m128 _mm_ceil_ss(__m128 X, __m128 Y);

This intrinsic corresponds to the VROUNDSS / ROUNDSS instruction.

Parameters

X	A 128-bit vector of [4 x float]. The values stored in bits [127:32] are copied to the corresponding bits of the result.
Y	A 128-bit 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.

Returns

A 128-bit vector of [4 x float] containing the copied and rounded values.

Definition at line 104 of file smmintrin.h.

_mm_cmpestra

#define _mm_cmpestra	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpestria128((__v16qi)(__m128i)(A), (int)(LA),         \
                                     (__v16qi)(__m128i)(B), (int)(LB),         \
                                     (int)(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.

int _mm_cmpestra(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the bit mask is zero and the length of the string in B is the maximum, otherwise, returns 0.

Definition at line 2086 of file smmintrin.h.

_mm_cmpestrc

#define _mm_cmpestrc	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpestric128((__v16qi)(__m128i)(A), (int)(LA),         \
                                     (__v16qi)(__m128i)(B), (int)(LB),         \
                                     (int)(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 non-zero, otherwise, returns 0.

int _mm_cmpestrc(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the resulting mask is non-zero, otherwise, returns 0.

Definition at line 2140 of file smmintrin.h.

_mm_cmpestri

#define _mm_cmpestri	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpestri128((__v16qi)(__m128i)(A), (int)(LA),          \
                                    (__v16qi)(__m128i)(B), (int)(LB),          \
                                    (int)(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.

int _mm_cmpestri(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns an integer representing the result index of the comparison.

Definition at line 1783 of file smmintrin.h.

_mm_cmpestrm

#define _mm_cmpestrm	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((__m128i)__builtin_ia32_pcmpestrm128((__v16qi)(__m128i)(A), (int)(LA),      \
                                        (__v16qi)(__m128i)(B), (int)(LB),      \
                                        (int)(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 128-bit integer vector representing the result mask of the comparison.

__m128i _mm_cmpestrm(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRM / PCMPESTRM instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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 zero-extended or expanded to 16 bytes. 0: The result is zero-extended to 16 bytes. 1: The result is expanded to 16 bytes (this expansion is performed by repeating each bit 8 or 16 times).

Returns

Returns a 128-bit integer vector representing the result mask of the comparison.

Definition at line 1724 of file smmintrin.h.

_mm_cmpestro

#define _mm_cmpestro	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpestrio128((__v16qi)(__m128i)(A), (int)(LA),         \
                                     (__v16qi)(__m128i)(B), (int)(LB),         \
                                     (int)(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.

int _mm_cmpestro(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns bit 0 of the resulting bit mask.

Definition at line 2193 of file smmintrin.h.

_mm_cmpestrs

#define _mm_cmpestrs	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpestris128((__v16qi)(__m128i)(A), (int)(LA),         \
                                     (__v16qi)(__m128i)(B), (int)(LB),         \
                                     (int)(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.

int _mm_cmpestrs(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRI / PCMPESTRI instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the length of the string in A is less than the maximum, otherwise, returns 0.

Definition at line 2248 of file smmintrin.h.

_mm_cmpestrz

#define _mm_cmpestrz	(		A,
			LA,
			B,
			LB,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpestriz128((__v16qi)(__m128i)(A), (int)(LA),         \
                                     (__v16qi)(__m128i)(B), (int)(LB),         \
                                     (int)(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.

int _mm_cmpestrz(__m128i A, int LA, __m128i B, int LB, const int M);

This intrinsic corresponds to the VPCMPESTRI instruction.

Parameters

A	A 128-bit 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 128-bit 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 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the length of the string in B is less than the maximum, otherwise, returns 0.

Definition at line 2302 of file smmintrin.h.

_mm_cmpistra

#define _mm_cmpistra	(		A,
			B,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpistria128((__v16qi)(__m128i)(A),                    \
                                     (__v16qi)(__m128i)(B), (int)(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.

int _mm_cmpistra(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the bit mask is zero and the length of the string in B is the maximum; otherwise, returns 0.

Definition at line 1835 of file smmintrin.h.

_mm_cmpistrc

#define _mm_cmpistrc	(		A,
			B,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpistric128((__v16qi)(__m128i)(A),                    \
                                     (__v16qi)(__m128i)(B), (int)(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 non-zero, otherwise, returns 0.

int _mm_cmpistrc(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the bit mask is non-zero, otherwise, returns 0.

Definition at line 1884 of file smmintrin.h.

_mm_cmpistri

#define _mm_cmpistri	(		A,
			B,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpistri128((__v16qi)(__m128i)(A),                     \
                                    (__v16qi)(__m128i)(B), (int)(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.

int _mm_cmpistri(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns an integer representing the result index of the comparison.

Definition at line 1664 of file smmintrin.h.

_mm_cmpistrm

#define _mm_cmpistrm	(		A,
			B,
			M
	)

Value:

  ((__m128i)__builtin_ia32_pcmpistrm128((__v16qi)(__m128i)(A),                 \
                                        (__v16qi)(__m128i)(B), (int)(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 128-bit integer vector representing the result mask of the comparison.

__m128i _mm_cmpistrm(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRM / PCMPISTRM instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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 zero-extended or expanded to 16 bytes. 0: The result is zero-extended to 16 bytes. 1: The result is expanded to 16 bytes (this expansion is performed by repeating each bit 8 or 16 times).

Returns

Returns a 128-bit integer vector representing the result mask of the comparison.

Definition at line 1610 of file smmintrin.h.

_mm_cmpistro

#define _mm_cmpistro	(		A,
			B,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpistrio128((__v16qi)(__m128i)(A),                    \
                                     (__v16qi)(__m128i)(B), (int)(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.

int _mm_cmpistro(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns bit 0 of the resulting bit mask.

Definition at line 1932 of file smmintrin.h.

_mm_cmpistrs

#define _mm_cmpistrs	(		A,
			B,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpistris128((__v16qi)(__m128i)(A),                    \
                                     (__v16qi)(__m128i)(B), (int)(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.

int _mm_cmpistrs(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the length of the string in A is less than the maximum, otherwise, returns 0.

Definition at line 1982 of file smmintrin.h.

_mm_cmpistrz

#define _mm_cmpistrz	(		A,
			B,
			M
	)

Value:

  ((int)__builtin_ia32_pcmpistriz128((__v16qi)(__m128i)(A),                    \
                                     (__v16qi)(__m128i)(B), (int)(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.

int _mm_cmpistrz(__m128i A, __m128i B, const int M);

This intrinsic corresponds to the VPCMPISTRI / PCMPISTRI instruction.

Parameters

A	A 128-bit integer vector containing one of the source operands to be compared.
B	A 128-bit integer vector containing one of the source operands to be compared.
M	An 8-bit 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 even-indexed elements in A, and less than or equal for odd-indexed 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.

Returns

Returns 1 if the length of the string in B is less than the maximum, otherwise, returns 0.

Definition at line 2032 of file smmintrin.h.

_mm_dp_pd

#define _mm_dp_pd	(		X,
			Y,
			M
	)

Value:

  ((__m128d)__builtin_ia32_dppd((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y),    \
                                (M)))

Computes the dot product of the two 128-bit vectors of [2 x double] and returns it in the elements of the 128-bit 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.

__m128d _mm_dp_pd(__m128d X, __m128d Y, const int M);

This intrinsic corresponds to the VDPPD / DPPD instruction.

Parameters

X	A 128-bit vector of [2 x double].
Y	A 128-bit 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 636 of file smmintrin.h.

_mm_dp_ps

#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 128-bit vectors of [4 x float] and returns it in the elements of the 128-bit 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.

__m128 _mm_dp_ps(__m128 X, __m128 Y, const int M);

This intrinsic corresponds to the VDPPS / DPPS instruction.

Parameters

X	A 128-bit vector of [4 x float].
Y	A 128-bit 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.

Returns

A 128-bit vector of [4 x float] containing the dot product.

Definition at line 602 of file smmintrin.h.

_mm_extract_epi32

#define _mm_extract_epi32	(		X,
			N
	)		((int)__builtin_ia32_vec_ext_v4si((__v4si)(__m128i)(X), (int)(N)))

Extracts a 32-bit element from the 128-bit integer vector of [4 x i32], using the immediate value parameter N as a selector.

int _mm_extract_epi32(__m128i X, const int N);

This intrinsic corresponds to the VPEXTRD / PEXTRD instruction.

Parameters

X	A 128-bit integer vector.
N	An immediate value. Bits [1:0] specify which 32-bit 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.

Returns

An integer, whose lower 32 bits are selected from the 128-bit integer vector parameter and the remaining bits are assigned zeros.

Definition at line 1060 of file smmintrin.h.

_mm_extract_epi64

#define _mm_extract_epi64	(		X,
			N
	)		((long long)__builtin_ia32_vec_ext_v2di((__v2di)(__m128i)(X), (int)(N)))

Extracts a 64-bit element from the 128-bit integer vector of [2 x i64], using the immediate value parameter N as a selector.

long long _mm_extract_epi64(__m128i X, const int N);

This intrinsic corresponds to the VPEXTRQ / PEXTRQ instruction in 64-bit mode.

Parameters

X	A 128-bit integer vector.
N	An immediate value. Bit [0] specifies which 64-bit vector element from the argument X to return. 0: Bits [63:0] are returned. 1: Bits [127:64] are returned.

Returns

A 64-bit integer.

Definition at line 1083 of file smmintrin.h.

_mm_extract_epi8

#define _mm_extract_epi8	(		X,
			N
	)

Value:

  ((int)(unsigned char)__builtin_ia32_vec_ext_v16qi((__v16qi)(__m128i)(X),     \
                                                    (int)(N)))

Extracts an 8-bit element from the 128-bit integer vector of [16 x i8], using the immediate value parameter N as a selector.

int _mm_extract_epi8(__m128i X, const int N);

This intrinsic corresponds to the VPEXTRB / PEXTRB instruction.

Parameters

X

A 128-bit integer vector.

N

An immediate value. Bits [3:0] specify which 8-bit 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.

Returns

An unsigned integer, whose lower 8 bits are selected from the 128-bit integer vector parameter and the remaining bits are assigned zeros.

Definition at line 1034 of file smmintrin.h.

_MM_EXTRACT_FLOAT

#define _MM_EXTRACT_FLOAT	(		D,
			X,
			N
	)

Value:

  do {                                                                         \
    (D) = __builtin_ia32_vec_ext_v4sf((__v4sf)(__m128)(X), (int)(N));          \
  } while (0)

Definition at line 874 of file smmintrin.h.

_mm_extract_ps

#define _mm_extract_ps	(		X,
			N
	)

Value:

  __builtin_bit_cast(                                                          \
      int, __builtin_ia32_vec_ext_v4sf((__v4sf)(__m128)(X), (int)(N)))

Extracts a 32-bit integer from a 128-bit vector of [4 x float] and returns it, using the immediate value parameter N as a selector.

int _mm_extract_ps(__m128 X, const int N);

This intrinsic corresponds to the VEXTRACTPS / EXTRACTPS instruction.

Parameters

X	A 128-bit 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.

Returns

A 32-bit integer containing the extracted 32 bits of float data.

Definition at line 868 of file smmintrin.h.

_mm_floor_pd

#define _mm_floor_pd

(

X

)

_mm_round_pd((X), _MM_FROUND_FLOOR)

Rounds down each element of the 128-bit vector of [2 x double] to an integer and returns the rounded values in a 128-bit vector of [2 x double].

__m128d _mm_floor_pd(__m128d X);

This intrinsic corresponds to the VROUNDPD / ROUNDPD instruction.

Parameters

X	A 128-bit vector of [2 x double].

Returns

A 128-bit vector of [2 x double] containing the rounded values.

Definition at line 163 of file smmintrin.h.

_mm_floor_ps

#define _mm_floor_ps

(

X

)

_mm_round_ps((X), _MM_FROUND_FLOOR)

Rounds down each element of the 128-bit vector of [4 x float] to an an integer and returns the rounded values in a 128-bit vector of [4 x float].

__m128 _mm_floor_ps(__m128 X);

This intrinsic corresponds to the VROUNDPS / ROUNDPS instruction.

Parameters

X	A 128-bit vector of [4 x float] values to be rounded down.

Returns

A 128-bit vector of [4 x float] containing the rounded values.

Definition at line 146 of file smmintrin.h.

_mm_floor_sd

#define _mm_floor_sd	(		X,
			Y
	)		_mm_round_sd((X), (Y), _MM_FROUND_FLOOR)

Copies the upper element of the first 128-bit vector operand to the corresponding upper element of the 128-bit result vector of [2 x double].

Rounds down the lower element of the second 128-bit vector operand to an integer and copies it to the lower element of the 128-bit result vector of [2 x double].

__m128d _mm_floor_sd(__m128d X, __m128d Y);

This intrinsic corresponds to the VROUNDSD / ROUNDSD instruction.

Parameters

X	A 128-bit vector of [2 x double]. The value stored in bits [127:64] is copied to the corresponding bits of the result.
Y	A 128-bit 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.

Returns

A 128-bit vector of [2 x double] containing the copied and rounded values.

Definition at line 213 of file smmintrin.h.

_mm_floor_ss

#define _mm_floor_ss	(		X,
			Y
	)		_mm_round_ss((X), (Y), _MM_FROUND_FLOOR)

Copies three upper elements of the first 128-bit vector operand to the corresponding three upper elements of the 128-bit result vector of [4 x float].

Rounds down the lowest element of the second 128-bit vector operand to an integer and copies it to the lowest element of the 128-bit result vector of [4 x float].

__m128 _mm_floor_ss(__m128 X, __m128 Y);

This intrinsic corresponds to the VROUNDSS / ROUNDSS instruction.

Parameters

X	A 128-bit vector of [4 x float]. The values stored in bits [127:32] are copied to the corresponding bits of the result.
Y	A 128-bit 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.

Returns

A 128-bit vector of [4 x float] containing the copied and rounded values.

Definition at line 188 of file smmintrin.h.

_MM_FROUND_CEIL

#define _MM_FROUND_CEIL   (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_POS_INF)

Definition at line 42 of file smmintrin.h.

_MM_FROUND_CUR_DIRECTION

#define _MM_FROUND_CUR_DIRECTION   0x04

Definition at line 35 of file smmintrin.h.

_MM_FROUND_FLOOR

#define _MM_FROUND_FLOOR   (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_NEG_INF)

Definition at line 41 of file smmintrin.h.

_MM_FROUND_NEARBYINT

#define _MM_FROUND_NEARBYINT   (_MM_FROUND_NO_EXC | _MM_FROUND_CUR_DIRECTION)

Definition at line 45 of file smmintrin.h.

_MM_FROUND_NINT

#define _MM_FROUND_NINT   (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_NEAREST_INT)

Definition at line 40 of file smmintrin.h.

_MM_FROUND_NO_EXC

#define _MM_FROUND_NO_EXC   0x08

Definition at line 38 of file smmintrin.h.

_MM_FROUND_RAISE_EXC

#define _MM_FROUND_RAISE_EXC   0x00

Definition at line 37 of file smmintrin.h.

_MM_FROUND_RINT

#define _MM_FROUND_RINT   (_MM_FROUND_RAISE_EXC | _MM_FROUND_CUR_DIRECTION)

Definition at line 44 of file smmintrin.h.

_MM_FROUND_TO_NEAREST_INT

#define _MM_FROUND_TO_NEAREST_INT   0x00

Definition at line 31 of file smmintrin.h.

_MM_FROUND_TO_NEG_INF

#define _MM_FROUND_TO_NEG_INF   0x01

Definition at line 32 of file smmintrin.h.

_MM_FROUND_TO_POS_INF

#define _MM_FROUND_TO_POS_INF   0x02

Definition at line 33 of file smmintrin.h.

_MM_FROUND_TO_ZERO

#define _MM_FROUND_TO_ZERO   0x03

Definition at line 34 of file smmintrin.h.

_MM_FROUND_TRUNC

#define _MM_FROUND_TRUNC   (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_ZERO)

Definition at line 43 of file smmintrin.h.

_mm_insert_epi32

#define _mm_insert_epi32	(		X,
			I,
			N
	)

Value:

  ((__m128i)__builtin_ia32_vec_set_v4si((__v4si)(__m128i)(X), (int)(I),        \
                                        (int)(N)))

Constructs a 128-bit vector of [4 x i32] by first making a copy of the 128-bit integer vector parameter, and then inserting the 32-bit integer parameter I at the offset specified by the immediate value parameter N.

__m128i _mm_insert_epi32(__m128i X, int I, const int N);

This intrinsic corresponds to the VPINSRD / PINSRD instruction.

Parameters

X	A 128-bit 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 32-bit 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.

Returns

A 128-bit integer vector containing the constructed values.

Definition at line 960 of file smmintrin.h.

_mm_insert_epi8

#define _mm_insert_epi8	(		X,
			I,
			N
	)

Value:

  ((__m128i)__builtin_ia32_vec_set_v16qi((__v16qi)(__m128i)(X), (int)(I),      \
                                         (int)(N)))

Constructs a 128-bit vector of [16 x i8] by first making a copy of the 128-bit 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.

__m128i _mm_insert_epi8(__m128i X, int I, const int N);

This intrinsic corresponds to the VPINSRB / PINSRB instruction.

Parameters

X	A 128-bit 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.

Returns

A 128-bit integer vector containing the constructed values.

Definition at line 928 of file smmintrin.h.

_mm_insert_ps

#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.

That result then has elements zeroed out also as selected by the third argument N. The resulting 128-bit vector of [4 x float] is then returned.

__m128 _mm_insert_ps(__m128 X, __m128 Y, const int N);

This intrinsic corresponds to the VINSERTPS instruction.

Parameters

X	A 128-bit 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 128-bit vector source operand of [4 x float]. One single-precision floating-point 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.

Returns

A 128-bit vector of [4 x float] containing the copied single-precision floating point elements from the operands.

Definition at line 844 of file smmintrin.h.

_MM_MK_INSERTPS_NDX

#define _MM_MK_INSERTPS_NDX	(		X,
			Y,
			Z
	)		(((X) << 6) | ((Y) << 4) | (Z))

Definition at line 881 of file smmintrin.h.

_mm_mpsadbw_epu8

#define _mm_mpsadbw_epu8	(		X,
			Y,
			M
	)

Value:

  ((__m128i)__builtin_ia32_mpsadbw128((__v16qi)(__m128i)(X),                   \
                                      (__v16qi)(__m128i)(Y), (M)))

Subtracts 8-bit 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.

__m128i _mm_mpsadbw_epu8(__m128i X, __m128i Y, const int M);

This intrinsic corresponds to the VMPSADBW / MPSADBW instruction.

Parameters

X	A 128-bit vector of [16 x i8].
Y	A 128-bit vector of [16 x i8].
M	An 8-bit 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) { d0 = abs(X[i + k + 0] - Y[j + 0]); d1 = abs(X[i + k + 1] - Y[j + 1]); d2 = abs(X[i + k + 2] - Y[j + 2]); d3 = abs(X[i + k + 3] - Y[j + 3]); r[k] = d0 + d1 + d2 + d3; }

Returns

A 128-bit integer vector containing the sums of the sets of absolute differences between both operands.

Definition at line 1501 of file smmintrin.h.

_MM_PICK_OUT_PS

#define _MM_PICK_OUT_PS	(		X,
			N
	)		_mm_insert_ps(_mm_setzero_ps(), (X), _MM_MK_INSERTPS_NDX((N), 0, 0x0e))

Definition at line 884 of file smmintrin.h.

_mm_round_pd

#define _mm_round_pd	(		X,
			M
	)		((__m128d)__builtin_ia32_roundpd((__v2df)(__m128d)(X), (M)))

Rounds each element of the 128-bit 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 128-bit vector of [2 x double].

__m128d _mm_round_pd(__m128d X, const int M);

This intrinsic corresponds to the VROUNDPD / ROUNDPD instruction.

Parameters

X

A 128-bit 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

Returns

A 128-bit vector of [2 x double] containing the rounded values.

Definition at line 320 of file smmintrin.h.

_mm_round_ps

#define _mm_round_ps	(		X,
			M
	)		((__m128)__builtin_ia32_roundps((__v4sf)(__m128)(X), (M)))

Rounds each element of the 128-bit 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 128-bit vector of [4 x float].

__m128 _mm_round_ps(__m128 X, const int M);

This intrinsic corresponds to the VROUNDPS / ROUNDPS instruction.

Parameters

X

A 128-bit 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

Returns

A 128-bit vector of [4 x float] containing the rounded values.

Definition at line 245 of file smmintrin.h.

_mm_round_sd

#define _mm_round_sd	(		X,
			Y,
			M
	)

Value:

  ((__m128d)__builtin_ia32_roundsd((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), \
                                   (M)))

Copies the upper element of the first 128-bit vector operand to the corresponding upper element of the 128-bit result vector of [2 x double].

Rounds the lower element of the second 128-bit 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 128-bit result vector of [2 x double].

__m128d _mm_round_sd(__m128d X, __m128d Y, const int M);

This intrinsic corresponds to the VROUNDSD / ROUNDSD instruction.

Parameters

X	A 128-bit vector of [2 x double]. The value stored in bits [127:64] is copied to the corresponding bits of the result.
Y	A 128-bit 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

Returns

A 128-bit vector of [2 x double] containing the copied and rounded values.

Definition at line 361 of file smmintrin.h.

_mm_round_ss

#define _mm_round_ss	(		X,
			Y,
			M
	)

Value:

  ((__m128)__builtin_ia32_roundss((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y),    \
                                  (M)))

Copies three upper elements of the first 128-bit vector operand to the corresponding three upper elements of the 128-bit result vector of [4 x float].

Rounds the lowest element of the second 128-bit 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 128-bit result vector of [4 x float].

__m128 _mm_round_ss(__m128 X, __m128 Y, const int M);

This intrinsic corresponds to the VROUNDSS / ROUNDSS instruction.

Parameters

X	A 128-bit vector of [4 x float]. The values stored in bits [127:32] are copied to the corresponding bits of the result.
Y	A 128-bit 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

Returns

A 128-bit vector of [4 x float] containing the copied and rounded values.

Definition at line 286 of file smmintrin.h.

_mm_test_all_ones

#define _mm_test_all_ones

(

V

)

_mm_testc_si128((V), _mm_set1_epi32(-1))

Tests whether the specified bits in a 128-bit integer vector are all ones.

int _mm_test_all_ones(__m128i V);

This intrinsic corresponds to the VPTEST / PTEST instruction.

Parameters

V	A 128-bit integer vector containing the bits to be tested.

Returns

TRUE if the bits specified in the operand are all set to 1; FALSE otherwise.

Definition at line 1154 of file smmintrin.h.

_mm_test_all_zeros

#define _mm_test_all_zeros	(		M,
			V
	)		_mm_testz_si128((M), (V))

Tests whether the specified bits in a 128-bit integer vector are all zeros.

int _mm_test_all_zeros(__m128i M, __m128i V);

This intrinsic corresponds to the VPTEST / PTEST instruction.

Parameters

M	A 128-bit integer vector containing the bits to be tested.
V	A 128-bit integer vector selecting which bits to test in operand M.

Returns

TRUE if the specified bits are all zeros; FALSE otherwise.

Definition at line 1191 of file smmintrin.h.

_mm_test_mix_ones_zeros

#define _mm_test_mix_ones_zeros	(		M,
			V
	)		_mm_testnzc_si128((M), (V))

Tests whether the specified bits in a 128-bit integer vector are neither all zeros nor all ones.

int _mm_test_mix_ones_zeros(__m128i M, __m128i V);

This intrinsic corresponds to the VPTEST / PTEST instruction.

Parameters

M	A 128-bit integer vector containing the bits to be tested.
V	A 128-bit integer vector selecting which bits to test in operand M.

Returns

TRUE if the specified bits are neither all zeros nor all ones; FALSE otherwise.

Definition at line 1173 of file smmintrin.h.

_SIDD_BIT_MASK

#define _SIDD_BIT_MASK   0x00

Definition at line 1554 of file smmintrin.h.

_SIDD_CMP_EQUAL_ANY

#define _SIDD_CMP_EQUAL_ANY   0x00

Definition at line 1538 of file smmintrin.h.

_SIDD_CMP_EQUAL_EACH

#define _SIDD_CMP_EQUAL_EACH   0x08

Definition at line 1540 of file smmintrin.h.

_SIDD_CMP_EQUAL_ORDERED

#define _SIDD_CMP_EQUAL_ORDERED   0x0c

Definition at line 1541 of file smmintrin.h.

_SIDD_CMP_RANGES

#define _SIDD_CMP_RANGES   0x04

Definition at line 1539 of file smmintrin.h.

_SIDD_LEAST_SIGNIFICANT

#define _SIDD_LEAST_SIGNIFICANT   0x00

Definition at line 1550 of file smmintrin.h.

_SIDD_MASKED_NEGATIVE_POLARITY

#define _SIDD_MASKED_NEGATIVE_POLARITY   0x30

Definition at line 1547 of file smmintrin.h.

_SIDD_MASKED_POSITIVE_POLARITY

#define _SIDD_MASKED_POSITIVE_POLARITY   0x20

Definition at line 1546 of file smmintrin.h.

_SIDD_MOST_SIGNIFICANT

#define _SIDD_MOST_SIGNIFICANT   0x40

Definition at line 1551 of file smmintrin.h.

_SIDD_NEGATIVE_POLARITY

#define _SIDD_NEGATIVE_POLARITY   0x10

Definition at line 1545 of file smmintrin.h.

_SIDD_POSITIVE_POLARITY

#define _SIDD_POSITIVE_POLARITY   0x00

Definition at line 1544 of file smmintrin.h.

_SIDD_SBYTE_OPS

#define _SIDD_SBYTE_OPS   0x02

Definition at line 1534 of file smmintrin.h.

_SIDD_SWORD_OPS

#define _SIDD_SWORD_OPS   0x03

Definition at line 1535 of file smmintrin.h.

_SIDD_UBYTE_OPS

#define _SIDD_UBYTE_OPS   0x00

Definition at line 1532 of file smmintrin.h.

_SIDD_UNIT_MASK

#define _SIDD_UNIT_MASK   0x40

Definition at line 1555 of file smmintrin.h.

_SIDD_UWORD_OPS

#define _SIDD_UWORD_OPS   0x01

Definition at line 1533 of file smmintrin.h.

Function Documentation

_mm_blendv_epi8()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_blendv_epi8 ( __m128i  __V1, __m128i  __V2, __m128i  __M  )

static

Returns a 128-bit 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.

Parameters

__V1	A 128-bit vector of [16 x i8].
__V2	A 128-bit vector of [16 x i8].
__M	A 128-bit 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 8-bit element in operand __V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 8-bit element in operand __V2 is copied to the same position in the result.

Returns

A 128-bit vector of [16 x i8] containing the copied values.

Definition at line 496 of file smmintrin.h.

_mm_blendv_pd()

static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_blendv_pd ( __m128d  __V1, __m128d  __V2, __m128d  __M  )

static

Returns a 128-bit 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.

Parameters

__V1	A 128-bit vector of [2 x double].
__V2	A 128-bit vector of [2 x double].
__M	A 128-bit 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 64-bit element in operand __V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 64-bit element in operand __V2 is copied to the same position in the result.

Returns

A 128-bit vector of [2 x double] containing the copied values.

Definition at line 442 of file smmintrin.h.

_mm_blendv_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_blendv_ps ( __m128  __V1, __m128  __V2, __m128  __M  )

static

Returns a 128-bit 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.

Parameters

__V1	A 128-bit vector of [4 x float].
__V2	A 128-bit vector of [4 x float].
__M	A 128-bit 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 32-bit element in operand __V1 is copied to the same position in the result. When a mask bit is 1, the corresponding 32-bit element in operand __V2 is copied to the same position in the result.

Returns

A 128-bit vector of [4 x float] containing the copied values.

Definition at line 469 of file smmintrin.h.

_mm_cmpeq_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi64 ( __m128i  __V1, __m128i  __V2  )

static

Compares each of the corresponding 64-bit values of the 128-bit integer vectors for equality.

Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.

This intrinsic corresponds to the VPCMPEQQ / PCMPEQQ instruction.

Parameters

__V1	A 128-bit integer vector.
__V2	A 128-bit integer vector.

Returns

A 128-bit integer vector containing the comparison results.

Definition at line 1208 of file smmintrin.h.

_mm_cmpgt_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi64 ( __m128i  __V1, __m128i  __V2  )

static

Compares each of the corresponding 64-bit values of the 128-bit 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.

Parameters

__V1	A 128-bit integer vector.
__V2	A 128-bit integer vector.

Returns

A 128-bit integer vector containing the comparison results.

Definition at line 2323 of file smmintrin.h.

_mm_cvtepi16_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi32 ( __m128i  __V )

static

Sign-extends each of the lower four 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 32-bit values and returns them in a 128-bit vector of [4 x i32].

The upper four elements of the input vector are unused.

This intrinsic corresponds to the VPMOVSXWD / PMOVSXWD instruction.

Parameters

__V	A 128-bit vector of [8 x i16]. The lower four 16-bit elements are sign-extended to 32-bit values.

Returns

A 128-bit vector of [4 x i32] containing the sign-extended values.

Definition at line 1289 of file smmintrin.h.

Referenced by _mm_mask_cvtepi16_epi32(), and _mm_maskz_cvtepi16_epi32().

_mm_cvtepi16_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi64 ( __m128i  __V )

static

Sign-extends each of the lower two 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 64-bit values and returns them in a 128-bit vector of [2 x i64].

The upper six elements of the input vector are unused.

This intrinsic corresponds to the VPMOVSXWQ / PMOVSXWQ instruction.

Parameters

__V	A 128-bit vector of [8 x i16]. The lower two 16-bit elements are sign-extended to 64-bit values.

Returns

A 128-bit vector of [2 x i64] containing the sign-extended values.

Definition at line 1307 of file smmintrin.h.

Referenced by _mm_mask_cvtepi16_epi64(), and _mm_maskz_cvtepi16_epi64().

_mm_cvtepi32_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi32_epi64 ( __m128i  __V )

static

Sign-extends each of the lower two 32-bit integer elements of a 128-bit integer vector of [4 x i32] to 64-bit values and returns them in a 128-bit vector of [2 x i64].

The upper two elements of the input vector are unused.

This intrinsic corresponds to the VPMOVSXDQ / PMOVSXDQ instruction.

Parameters

__V	A 128-bit vector of [4 x i32]. The lower two 32-bit elements are sign-extended to 64-bit values.

Returns

A 128-bit vector of [2 x i64] containing the sign-extended values.

Definition at line 1325 of file smmintrin.h.

Referenced by _mm_mask_cvtepi32_epi64(), and _mm_maskz_cvtepi32_epi64().

_mm_cvtepi8_epi16()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi16 ( __m128i  __V )

static

Sign-extends each of the lower eight 8-bit integer elements of a 128-bit vector of [16 x i8] to 16-bit values and returns them in a 128-bit vector of [8 x i16].

The upper eight elements of the input vector are unused.

This intrinsic corresponds to the VPMOVSXBW / PMOVSXBW instruction.

Parameters

__V	A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are sign-extended to 16-bit values.

Returns

A 128-bit vector of [8 x i16] containing the sign-extended values.

Definition at line 1227 of file smmintrin.h.

Referenced by _mm_mask_cvtepi8_epi16(), and _mm_maskz_cvtepi8_epi16().

_mm_cvtepi8_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi32 ( __m128i  __V )

static

Sign-extends each of the lower four 8-bit integer elements of a 128-bit vector of [16 x i8] to 32-bit values and returns them in a 128-bit vector of [4 x i32].

The upper twelve elements of the input vector are unused.

This intrinsic corresponds to the VPMOVSXBD / PMOVSXBD instruction.

Parameters

__V	A 128-bit vector of [16 x i8]. The lower four 8-bit elements are sign-extended to 32-bit values.

Returns

A 128-bit vector of [4 x i32] containing the sign-extended values.

Definition at line 1249 of file smmintrin.h.

Referenced by _mm_mask_cvtepi8_epi32(), and _mm_maskz_cvtepi8_epi32().

_mm_cvtepi8_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi64 ( __m128i  __V )

static

Sign-extends each of the lower two 8-bit integer elements of a 128-bit integer vector of [16 x i8] to 64-bit values and returns them in a 128-bit vector of [2 x i64].

The upper fourteen elements of the input vector are unused.

This intrinsic corresponds to the VPMOVSXBQ / PMOVSXBQ instruction.

Parameters

__V	A 128-bit vector of [16 x i8]. The lower two 8-bit elements are sign-extended to 64-bit values.

Returns

A 128-bit vector of [2 x i64] containing the sign-extended values.

Definition at line 1269 of file smmintrin.h.

Referenced by _mm_mask_cvtepi8_epi64(), and _mm_maskz_cvtepi8_epi64().

_mm_cvtepu16_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi32 ( __m128i  __V )

static

Zero-extends each of the lower four 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 32-bit values and returns them in a 128-bit vector of [4 x i32].

The upper four elements of the input vector are unused.

This intrinsic corresponds to the VPMOVZXWD / PMOVZXWD instruction.

Parameters

__V	A 128-bit vector of [8 x i16]. The lower four 16-bit elements are zero-extended to 32-bit values.

Returns

A 128-bit vector of [4 x i32] containing the zero-extended values.

Definition at line 1400 of file smmintrin.h.

Referenced by _mm_mask_cvtepu16_epi32(), and _mm_maskz_cvtepu16_epi32().

_mm_cvtepu16_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi64 ( __m128i  __V )

static

Zero-extends each of the lower two 16-bit integer elements of a 128-bit integer vector of [8 x i16] to 64-bit values and returns them in a 128-bit vector of [2 x i64].

The upper six elements of the input vector are unused.

This intrinsic corresponds to the VPMOVZXWQ / PMOVZXWQ instruction.

Parameters

__V	A 128-bit vector of [8 x i16]. The lower two 16-bit elements are zero-extended to 64-bit values.

Returns

A 128-bit vector of [2 x i64] containing the zero-extended values.

Definition at line 1418 of file smmintrin.h.

Referenced by _mm_mask_cvtepu16_epi64(), and _mm_maskz_cvtepu16_epi64().

_mm_cvtepu32_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu32_epi64 ( __m128i  __V )

static

Zero-extends each of the lower two 32-bit integer elements of a 128-bit integer vector of [4 x i32] to 64-bit values and returns them in a 128-bit vector of [2 x i64].

The upper two elements of the input vector are unused.

This intrinsic corresponds to the VPMOVZXDQ / PMOVZXDQ instruction.

Parameters

__V	A 128-bit vector of [4 x i32]. The lower two 32-bit elements are zero-extended to 64-bit values.

Returns

A 128-bit vector of [2 x i64] containing the zero-extended values.

Definition at line 1436 of file smmintrin.h.

Referenced by _mm_mask_cvtepu32_epi64(), and _mm_maskz_cvtepu32_epi64().

_mm_cvtepu8_epi16()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi16 ( __m128i  __V )

static

Zero-extends each of the lower eight 8-bit integer elements of a 128-bit vector of [16 x i8] to 16-bit values and returns them in a 128-bit vector of [8 x i16].

The upper eight elements of the input vector are unused.

This intrinsic corresponds to the VPMOVZXBW / PMOVZXBW instruction.

Parameters

__V	A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are zero-extended to 16-bit values.

Returns

A 128-bit vector of [8 x i16] containing the zero-extended values.

Definition at line 1344 of file smmintrin.h.

Referenced by _mm_mask_cvtepu8_epi16(), and _mm_maskz_cvtepu8_epi16().

_mm_cvtepu8_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi32 ( __m128i  __V )

static

Zero-extends each of the lower four 8-bit integer elements of a 128-bit vector of [16 x i8] to 32-bit values and returns them in a 128-bit vector of [4 x i32].

The upper twelve elements of the input vector are unused.

This intrinsic corresponds to the VPMOVZXBD / PMOVZXBD instruction.

Parameters

__V	A 128-bit vector of [16 x i8]. The lower four 8-bit elements are zero-extended to 32-bit values.

Returns

A 128-bit vector of [4 x i32] containing the zero-extended values.

Definition at line 1364 of file smmintrin.h.

Referenced by _mm_mask_cvtepu8_epi32(), and _mm_maskz_cvtepu8_epi32().

_mm_cvtepu8_epi64()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi64 ( __m128i  __V )

static

Zero-extends each of the lower two 8-bit integer elements of a 128-bit integer vector of [16 x i8] to 64-bit values and returns them in a 128-bit vector of [2 x i64].

The upper fourteen elements of the input vector are unused.

This intrinsic corresponds to the VPMOVZXBQ / PMOVZXBQ instruction.

Parameters

__V	A 128-bit vector of [16 x i8]. The lower two 8-bit elements are zero-extended to 64-bit values.

Returns

A 128-bit vector of [2 x i64] containing the zero-extended values.

Definition at line 1382 of file smmintrin.h.

Referenced by _mm_mask_cvtepu8_epi64(), and _mm_maskz_cvtepu8_epi64().

_mm_max_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi32 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [4 x i32] and returns a 128-bit vector of [4 x i32] containing the greater value of the two.

This intrinsic corresponds to the VPMAXSD / PMAXSD instruction.

Parameters

__V1	A 128-bit vector of [4 x i32].
__V2	A 128-bit vector of [4 x i32].

Returns

A 128-bit vector of [4 x i32] containing the greater values.

Definition at line 762 of file smmintrin.h.

Referenced by _mm_mask_max_epi32(), and _mm_maskz_max_epi32().

_mm_max_epi8()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi8 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [16 x i8] and returns a 128-bit vector of [16 x i8] containing the greater value of the two.

This intrinsic corresponds to the VPMAXSB / PMAXSB instruction.

Parameters

__V1	A 128-bit vector of [16 x i8].
__V2	A 128-bit vector of [16 x i8].

Returns

A 128-bit vector of [16 x i8] containing the greater values.

Definition at line 690 of file smmintrin.h.

Referenced by _mm_mask_max_epi8(), and _mm_maskz_max_epi8().

_mm_max_epu16()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu16 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [8 x u16] and returns a 128-bit vector of [8 x u16] containing the greater value of the two.

This intrinsic corresponds to the VPMAXUW / PMAXUW instruction.

Parameters

__V1	A 128-bit vector of [8 x u16].
__V2	A 128-bit vector of [8 x u16].

Returns

A 128-bit vector of [8 x u16] containing the greater values.

Definition at line 726 of file smmintrin.h.

Referenced by _mm_mask_max_epu16(), and _mm_maskz_max_epu16().

_mm_max_epu32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu32 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [4 x u32] and returns a 128-bit vector of [4 x u32] containing the greater value of the two.

This intrinsic corresponds to the VPMAXUD / PMAXUD instruction.

Parameters

__V1	A 128-bit vector of [4 x u32].
__V2	A 128-bit vector of [4 x u32].

Returns

A 128-bit vector of [4 x u32] containing the greater values.

Definition at line 798 of file smmintrin.h.

Referenced by _mm_mask_max_epu32(), and _mm_maskz_max_epu32().

_mm_min_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi32 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [4 x i32] and returns a 128-bit vector of [4 x i32] containing the lesser value of the two.

This intrinsic corresponds to the VPMINSD / PMINSD instruction.

Parameters

__V1	A 128-bit vector of [4 x i32].
__V2	A 128-bit vector of [4 x i32].

Returns

A 128-bit vector of [4 x i32] containing the lesser values.

Definition at line 744 of file smmintrin.h.

Referenced by _mm_mask_min_epi32(), and _mm_maskz_min_epi32().

_mm_min_epi8()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi8 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [16 x i8] and returns a 128-bit vector of [16 x i8] containing the lesser of the two values.

This intrinsic corresponds to the VPMINSB / PMINSB instruction.

Parameters

__V1	A 128-bit vector of [16 x i8].
__V2	A 128-bit vector of [16 x i8]

Returns

A 128-bit vector of [16 x i8] containing the lesser values.

Definition at line 672 of file smmintrin.h.

Referenced by _mm_mask_min_epi8(), and _mm_maskz_min_epi8().

_mm_min_epu16()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu16 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [8 x u16] and returns a 128-bit vector of [8 x u16] containing the lesser value of the two.

This intrinsic corresponds to the VPMINUW / PMINUW instruction.

Parameters

__V1	A 128-bit vector of [8 x u16].
__V2	A 128-bit vector of [8 x u16].

Returns

A 128-bit vector of [8 x u16] containing the lesser values.

Definition at line 708 of file smmintrin.h.

Referenced by _mm_mask_min_epu16(), and _mm_maskz_min_epu16().

_mm_min_epu32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu32 ( __m128i  __V1, __m128i  __V2  )

static

Compares the corresponding elements of two 128-bit vectors of [4 x u32] and returns a 128-bit vector of [4 x u32] containing the lesser value of the two.

This intrinsic corresponds to the VPMINUD / PMINUD instruction.

Parameters

__V1	A 128-bit vector of [4 x u32].
__V2	A 128-bit vector of [4 x u32].

Returns

A 128-bit vector of [4 x u32] containing the lesser values.

Definition at line 780 of file smmintrin.h.

Referenced by _mm_mask_min_epu32(), and _mm_maskz_min_epu32().

_mm_minpos_epu16()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_minpos_epu16 ( __m128i  __V )

static

Finds the minimum unsigned 16-bit element in the input 128-bit vector of [8 x u16] and returns it and along with its index.

This intrinsic corresponds to the VPHMINPOSUW / PHMINPOSUW instruction.

Parameters

__V	A 128-bit vector of [8 x u16].

Returns

A 128-bit value where bits [15:0] contain the minimum value found in parameter __V, bits [18:16] contain the index of the minimum value and the remaining bits are set to 0.

Definition at line 1518 of file smmintrin.h.

_mm_mul_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epi32 ( __m128i  __V1, __m128i  __V2  )

static

Multiplies corresponding even-indexed elements of two 128-bit vectors of [4 x i32] and returns a 128-bit vector of [2 x i64] containing the products.

This intrinsic corresponds to the VPMULDQ / PMULDQ instruction.

Parameters

__V1	A 128-bit vector of [4 x i32].
__V2	A 128-bit vector of [4 x i32].

Returns

A 128-bit vector of [2 x i64] containing the products of both operands.

Definition at line 564 of file smmintrin.h.

Referenced by _mm_mask_mul_epi32(), and _mm_maskz_mul_epi32().

_mm_mullo_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi32 ( __m128i  __V1, __m128i  __V2  )

static

Multiples corresponding elements of two 128-bit vectors of [4 x i32] and returns the lower 32 bits of the each product in a 128-bit vector of [4 x i32].

This intrinsic corresponds to the VPMULLD / PMULLD instruction.

Parameters

__V1	A 128-bit integer vector.
__V2	A 128-bit integer vector.

Returns

A 128-bit integer vector containing the products of both operands.

Definition at line 545 of file smmintrin.h.

Referenced by _mm_mask_mullo_epi32(), and _mm_maskz_mullo_epi32().

_mm_packus_epi32()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi32 ( __m128i  __V1, __m128i  __V2  )

static

Converts, with saturation, 32-bit signed integers from both 128-bit integer vector operands into 16-bit 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.

Parameters

__V1	A 128-bit vector of [4 x i32]. The converted [4 x i16] values are written to the lower 64 bits of the result.
__V2	A 128-bit vector of [4 x i32]. The converted [4 x i16] values are written to the higher 64 bits of the result.

Returns

A 128-bit vector of [8 x i16] containing the converted values.

Definition at line 1460 of file smmintrin.h.

Referenced by _mm_mask_packus_epi32(), and _mm_maskz_packus_epi32().

_mm_stream_load_si128()

static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_stream_load_si128 ( const void *  __V )

static

Loads integer values from a 128-bit aligned memory location to a 128-bit integer vector.

This intrinsic corresponds to the VMOVNTDQA / MOVNTDQA instruction.

Parameters

__V	A pointer to a 128-bit aligned memory location that contains the integer values.

Returns

A 128-bit integer vector containing the data stored at the specified memory location.

Definition at line 654 of file smmintrin.h.

_mm_testc_si128()

static __inline__ int __DEFAULT_FN_ATTRS _mm_testc_si128 ( __m128i  __M, __m128i  __V  )

static

Tests whether the specified bits in a 128-bit integer vector are all ones.

This intrinsic corresponds to the VPTEST / PTEST instruction.

Parameters

__M	A 128-bit integer vector containing the bits to be tested.
__V	A 128-bit integer vector selecting which bits to test in operand __M.

Returns

TRUE if the specified bits are all ones; FALSE otherwise.

Definition at line 1116 of file smmintrin.h.

_mm_testnzc_si128()

static __inline__ int __DEFAULT_FN_ATTRS _mm_testnzc_si128 ( __m128i  __M, __m128i  __V  )

static

Tests whether the specified bits in a 128-bit integer vector are neither all zeros nor all ones.

This intrinsic corresponds to the VPTEST / PTEST instruction.

Parameters

__M	A 128-bit integer vector containing the bits to be tested.
__V	A 128-bit integer vector selecting which bits to test in operand __M.

Returns

TRUE if the specified bits are neither all zeros nor all ones; FALSE otherwise.

Definition at line 1134 of file smmintrin.h.

_mm_testz_si128()

static __inline__ int __DEFAULT_FN_ATTRS _mm_testz_si128 ( __m128i  __M, __m128i  __V  )

static

Tests whether the specified bits in a 128-bit integer vector are all zeros.

This intrinsic corresponds to the VPTEST / PTEST instruction.

Parameters

__M	A 128-bit integer vector containing the bits to be tested.
__V	A 128-bit integer vector selecting which bits to test in operand __M.

Returns

TRUE if the specified bits are all zeros; FALSE otherwise.

Definition at line 1099 of file smmintrin.h.