#include <mmintrin.h>

Macros
#define	__DEFAULT_FN_ATTRS

#define	__DEFAULT_FN_ATTRS_SSE2

#define	__DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS

#define	__DEFAULT_FN_ATTRS_SSE2_CONSTEXPR __DEFAULT_FN_ATTRS_SSE2

#define	__trunc64(x) (__m64) __builtin_shufflevector((__v2di)(x), __extension__(__v2di){}, 0)

#define	__zext128(x)

#define	__anyext128(x)

#define	__zeroupper64(x)

#define	_mm_load_ps1(p) _mm_load1_ps(p)

#define	_MM_HINT_ET0 7

#define	_MM_HINT_ET1 6

#define	_MM_HINT_T0 3

#define	_MM_HINT_T1 2

#define	_MM_HINT_T2 1

#define	_MM_HINT_NTA 0

#define	_mm_prefetch(a, sel)
	Loads one cache line of data from the specified address to a location closer to the processor.

#define	_mm_extract_pi16(a, n) ((int)(unsigned short)__builtin_ia32_vec_ext_v4hi((__v4hi)a, (int)n))
	Extracts 16-bit element from a 64-bit vector of [4 x i16] and returns it, as specified by the immediate integer operand.

#define	_mm_insert_pi16(a, d, n) ((__m64)__builtin_ia32_vec_set_v4hi((__v4hi)a, (int)d, (int)n))
	Copies data from the 64-bit vector of [4 x i16] to the destination, and inserts the lower 16-bits of an integer operand at the 16-bit offset specified by the immediate operand n.

#define	_mm_shuffle_pi16(a, n)
	Shuffles the 4 16-bit integers from a 64-bit integer vector to the destination, as specified by the immediate value operand.

#define	_mm_shuffle_ps(a, b, mask)
	Selects 4 float values from the 128-bit operands of [4 x float], as specified by the immediate value operand.

#define	_CMP_EQ_OQ 0x00 /* Equal (ordered, non-signaling) */

#define	_CMP_LT_OS 0x01 /* Less-than (ordered, signaling) */

#define	_CMP_LE_OS 0x02 /* Less-than-or-equal (ordered, signaling) */

#define	_CMP_UNORD_Q 0x03 /* Unordered (non-signaling) */

#define	_CMP_NEQ_UQ 0x04 /* Not-equal (unordered, non-signaling) */

#define	_CMP_NLT_US 0x05 /* Not-less-than (unordered, signaling) */

#define	_CMP_NLE_US 0x06 /* Not-less-than-or-equal (unordered, signaling) */

#define	_CMP_ORD_Q 0x07 /* Ordered (non-signaling) */

#define	_mm_cmp_ps(a, b, c) ((__m128)__builtin_ia32_cmpps((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), (c)))
	Compares each of the corresponding values of two 128-bit vectors of [4 x float], using the operation specified by the immediate integer operand.

#define	_mm_cmp_ss(a, b, c) ((__m128)__builtin_ia32_cmpss((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), (c)))
	Compares each of the corresponding scalar values of two 128-bit vectors of [4 x float], using the operation specified by the immediate integer operand.

#define	_MM_ALIGN16 __attribute__((aligned(16)))

#define	_MM_SHUFFLE(z, y, x, w) (((z) << 6) \| ((y) << 4) \| ((x) << 2) \| (w))

#define	_MM_EXCEPT_INVALID (0x0001U)

#define	_MM_EXCEPT_DENORM (0x0002U)

#define	_MM_EXCEPT_DIV_ZERO (0x0004U)

#define	_MM_EXCEPT_OVERFLOW (0x0008U)

#define	_MM_EXCEPT_UNDERFLOW (0x0010U)

#define	_MM_EXCEPT_INEXACT (0x0020U)

#define	_MM_EXCEPT_MASK (0x003fU)

#define	_MM_MASK_INVALID (0x0080U)

#define	_MM_MASK_DENORM (0x0100U)

#define	_MM_MASK_DIV_ZERO (0x0200U)

#define	_MM_MASK_OVERFLOW (0x0400U)

#define	_MM_MASK_UNDERFLOW (0x0800U)

#define	_MM_MASK_INEXACT (0x1000U)

#define	_MM_MASK_MASK (0x1f80U)

#define	_MM_ROUND_NEAREST (0x0000U)

#define	_MM_ROUND_DOWN (0x2000U)

#define	_MM_ROUND_UP (0x4000U)

#define	_MM_ROUND_TOWARD_ZERO (0x6000U)

#define	_MM_ROUND_MASK (0x6000U)

#define	_MM_FLUSH_ZERO_MASK (0x8000U)

#define	_MM_FLUSH_ZERO_ON (0x8000U)

#define	_MM_FLUSH_ZERO_OFF (0x0000U)

#define	_MM_GET_EXCEPTION_MASK() (_mm_getcsr() & _MM_MASK_MASK)

#define	_MM_GET_EXCEPTION_STATE() (_mm_getcsr() & _MM_EXCEPT_MASK)

#define	_MM_GET_FLUSH_ZERO_MODE() (_mm_getcsr() & _MM_FLUSH_ZERO_MASK)

#define	_MM_GET_ROUNDING_MODE() (_mm_getcsr() & _MM_ROUND_MASK)

#define	_MM_SET_EXCEPTION_MASK(x) (_mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) \| (x)))

#define	_MM_SET_EXCEPTION_STATE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) \| (x)))

#define	_MM_SET_FLUSH_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) \| (x)))

#define	_MM_SET_ROUNDING_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) \| (x)))

#define	_MM_TRANSPOSE4_PS(row0, row1, row2, row3)

#define	_m_pextrw _mm_extract_pi16

#define	_m_pinsrw _mm_insert_pi16

#define	_m_pmaxsw _mm_max_pi16

#define	_m_pmaxub _mm_max_pu8

#define	_m_pminsw _mm_min_pi16

#define	_m_pminub _mm_min_pu8

#define	_m_pmovmskb _mm_movemask_pi8

#define	_m_pmulhuw _mm_mulhi_pu16

#define	_m_pshufw _mm_shuffle_pi16

#define	_m_maskmovq _mm_maskmove_si64

#define	_m_pavgb _mm_avg_pu8

#define	_m_pavgw _mm_avg_pu16

#define	_m_psadbw _mm_sad_pu8

#define	_m_ _mm_

Typedefs
typedef int __v4si	__attribute__((__vector_size__(16)))

Functions
static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_add_ss (__m128 __a, __m128 __b)
	Adds the 32-bit float values in the low-order bits of the operands.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_add_ps (__m128 __a, __m128 __b)
	Adds two 128-bit vectors of [4 x float], and returns the results of the addition.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_sub_ss (__m128 __a, __m128 __b)
	Subtracts the 32-bit float value in the low-order bits of the second operand from the corresponding value in the first operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_sub_ps (__m128 __a, __m128 __b)
	Subtracts each of the values of the second operand from the first operand, both of which are 128-bit vectors of [4 x float] and returns the results of the subtraction.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_mul_ss (__m128 __a, __m128 __b)
	Multiplies two 32-bit float values in the low-order bits of the operands.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_mul_ps (__m128 __a, __m128 __b)
	Multiplies two 128-bit vectors of [4 x float] and returns the results of the multiplication.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_div_ss (__m128 __a, __m128 __b)
	Divides the value in the low-order 32 bits of the first operand by the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_div_ps (__m128 __a, __m128 __b)
	Divides two 128-bit vectors of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_sqrt_ss (__m128 __a)
	Calculates the square root of the value stored in the low-order bits of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_sqrt_ps (__m128 __a)
	Calculates the square roots of the values stored in a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_rcp_ss (__m128 __a)
	Calculates the approximate reciprocal of the value stored in the low-order bits of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_rcp_ps (__m128 __a)
	Calculates the approximate reciprocals of the values stored in a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_rsqrt_ss (__m128 __a)
	Calculates the approximate reciprocal of the square root of the value stored in the low-order bits of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_rsqrt_ps (__m128 __a)
	Calculates the approximate reciprocals of the square roots of the values stored in a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_min_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands and returns the lesser value in the low-order bits of the vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_min_ps (__m128 __a, __m128 __b)
	Compares two 128-bit vectors of [4 x float] and returns the lesser of each pair of values.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_max_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands and returns the greater value in the low-order bits of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_max_ps (__m128 __a, __m128 __b)
	Compares two 128-bit vectors of [4 x float] and returns the greater of each pair of values.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_and_ps (__m128 __a, __m128 __b)
	Performs a bitwise AND of two 128-bit vectors of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_andnot_ps (__m128 __a, __m128 __b)
	Performs a bitwise AND of two 128-bit vectors of [4 x float], using the one's complement of the values contained in the first source operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_or_ps (__m128 __a, __m128 __b)
	Performs a bitwise OR of two 128-bit vectors of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_xor_ps (__m128 __a, __m128 __b)
	Performs a bitwise exclusive OR of two 128-bit vectors of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpeq_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands for equality.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpeq_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] for equality.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmplt_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is less than the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmplt_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are less than those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmple_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is less than or equal to the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmple_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are less than or equal to those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpgt_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is greater than the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpgt_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are greater than those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpge_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is greater than or equal to the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpge_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are greater than or equal to those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpneq_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands for inequality.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpneq_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] for inequality.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpnlt_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not less than the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpnlt_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not less than those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpnle_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not less than or equal to the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpnle_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not less than or equal to those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpngt_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not greater than the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpngt_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not greater than those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpnge_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not greater than or equal to the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpnge_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not greater than or equal to those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpord_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is ordered with respect to the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpord_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are ordered with respect to those in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpunord_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is unordered with respect to the corresponding value in the second operand.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_cmpunord_ps (__m128 __a, __m128 __b)
	Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are unordered with respect to those in the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_comieq_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands for equality.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_comilt_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is less than the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_comile_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is less than or equal to the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_comigt_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is greater than the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_comige_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is greater than or equal to the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_comineq_ss (__m128 __a, __m128 __b)
	Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is not equal to the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_ucomieq_ss (__m128 __a, __m128 __b)
	Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine equality.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_ucomilt_ss (__m128 __a, __m128 __b)
	Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is less than the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_ucomile_ss (__m128 __a, __m128 __b)
	Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is less than or equal to the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_ucomigt_ss (__m128 __a, __m128 __b)
	Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is greater than the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_ucomige_ss (__m128 __a, __m128 __b)
	Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is greater than or equal to the second operand.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_ucomineq_ss (__m128 __a, __m128 __b)
	Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine inequality.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_cvtss_si32 (__m128 __a)
	Converts a float value contained in the lower 32 bits of a vector of [4 x float] into a 32-bit integer.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_cvt_ss2si (__m128 __a)
	Converts a float value contained in the lower 32 bits of a vector of [4 x float] into a 32-bit integer.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtps_pi32 (__m128 __a)
	Converts two low-order float values in a 128-bit vector of [4 x float] into a 64-bit vector of [2 x i32].

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_cvt_ps2pi (__m128 __a)
	Converts two low-order float values in a 128-bit vector of [4 x float] into a 64-bit vector of [2 x i32].

static __inline__ int __DEFAULT_FN_ATTRS	_mm_cvttss_si32 (__m128 __a)
	Converts the lower (first) element of a vector of [4 x float] into a signed truncated (rounded toward zero) 32-bit integer.

static __inline__ int __DEFAULT_FN_ATTRS	_mm_cvtt_ss2si (__m128 __a)
	Converts the lower (first) element of a vector of [4 x float] into a signed truncated (rounded toward zero) 32-bit integer.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_cvttps_pi32 (__m128 __a)
	Converts the lower (first) two elements of a 128-bit vector of [4 x float] into two signed truncated (rounded toward zero) 32-bit integers, returned in a 64-bit vector of [2 x i32].

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtt_ps2pi (__m128 __a)
	Converts the lower (first) two elements of a 128-bit vector of [4 x float] into two signed truncated (rounded toward zero) 64-bit integers, returned in a 64-bit vector of [2 x i32].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_cvtsi32_ss (__m128 __a, int __b)
	Converts a 32-bit signed integer value into a floating point value and writes it to the lower 32 bits of the destination.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_cvt_si2ss (__m128 __a, int __b)
	Converts a 32-bit signed integer value into a floating point value and writes it to the lower 32 bits of the destination.

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtpi32_ps (__m128 __a, __m64 __b)
	Converts two elements of a 64-bit vector of [2 x i32] into two floating point values and writes them to the lower 64-bits of the destination.

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvt_pi2ps (__m128 __a, __m64 __b)
	Converts two elements of a 64-bit vector of [2 x i32] into two floating point values and writes them to the lower 64-bits of the destination.

static __inline__ float __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_cvtss_f32 (__m128 __a)
	Extracts a float value contained in the lower 32 bits of a vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_loadh_pi (__m128 __a, const __m64 *__p)
	Loads two packed float values from the address __p into the high-order bits of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_loadl_pi (__m128 __a, const __m64 *__p)
	Loads two packed float values from the address __p into the low-order bits of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_load_ss (const float *__p)
	Constructs a 128-bit floating-point vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_load1_ps (const float *__p)
	Loads a 32-bit float value and duplicates it to all four vector elements of a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_load_ps (const float *__p)
	Loads a 128-bit floating-point vector of [4 x float] from an aligned memory location.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_loadu_ps (const float *__p)
	Loads a 128-bit floating-point vector of [4 x float] from an unaligned memory location.

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_loadr_ps (const float *__p)
	Loads four packed float values, in reverse order, from an aligned memory location to 32-bit elements in a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS	_mm_undefined_ps (void)
	Create a 128-bit vector of [4 x float] with undefined values.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_set_ss (float __w)
	Constructs a 128-bit floating-point vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_set1_ps (float __w)
	Constructs a 128-bit floating-point vector of [4 x float], with each of the four single-precision floating-point vector elements set to the specified single-precision floating-point value.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_set_ps1 (float __w)
	Constructs a 128-bit floating-point vector of [4 x float], with each of the four single-precision floating-point vector elements set to the specified single-precision floating-point value.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_set_ps (float __z, float __y, float __x, float __w)
	Constructs a 128-bit floating-point vector of [4 x float] initialized with the specified single-precision floating-point values.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_setr_ps (float __z, float __y, float __x, float __w)
	Constructs a 128-bit floating-point vector of [4 x float], initialized in reverse order with the specified 32-bit single-precision float-point values.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_setzero_ps (void)
	Constructs a 128-bit floating-point vector of [4 x float] initialized to zero.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_storeh_pi (__m64 *__p, __m128 __a)
	Stores the upper 64 bits of a 128-bit vector of [4 x float] to a memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_storel_pi (__m64 *__p, __m128 __a)
	Stores the lower 64 bits of a 128-bit vector of [4 x float] to a memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_store_ss (float *__p, __m128 __a)
	Stores the lower 32 bits of a 128-bit vector of [4 x float] to a memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_storeu_ps (float *__p, __m128 __a)
	Stores a 128-bit vector of [4 x float] to an unaligned memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_store_ps (float *__p, __m128 __a)
	Stores a 128-bit vector of [4 x float] into an aligned memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_store1_ps (float *__p, __m128 __a)
	Stores the lower 32 bits of a 128-bit vector of [4 x float] into four contiguous elements in an aligned memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_store_ps1 (float *__p, __m128 __a)
	Stores the lower 32 bits of a 128-bit vector of [4 x float] into four contiguous elements in an aligned memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_storer_ps (float *__p, __m128 __a)
	Stores float values from a 128-bit vector of [4 x float] to an aligned memory location in reverse order.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_stream_pi (void *__p, __m64 __a)
	Stores a 64-bit integer in the specified aligned memory location.

static __inline__ void __DEFAULT_FN_ATTRS	_mm_stream_ps (void *__p, __m128 __a)
	Moves packed float values from a 128-bit vector of [4 x float] to a 128-bit aligned memory location.

void	_mm_sfence (void)
	Forces strong memory ordering (serialization) between store instructions preceding this instruction and store instructions following this instruction, ensuring the system completes all previous stores before executing subsequent stores.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_max_pi16 (__m64 __a, __m64 __b)
	Compares each of the corresponding packed 16-bit integer values of the 64-bit integer vectors, and writes the greater value to the corresponding bits in the destination.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_max_pu8 (__m64 __a, __m64 __b)
	Compares each of the corresponding packed 8-bit unsigned integer values of the 64-bit integer vectors, and writes the greater value to the corresponding bits in the destination.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_min_pi16 (__m64 __a, __m64 __b)
	Compares each of the corresponding packed 16-bit integer values of the 64-bit integer vectors, and writes the lesser value to the corresponding bits in the destination.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_min_pu8 (__m64 __a, __m64 __b)
	Compares each of the corresponding packed 8-bit unsigned integer values of the 64-bit integer vectors, and writes the lesser value to the corresponding bits in the destination.

static __inline__ int __DEFAULT_FN_ATTRS_SSE2	_mm_movemask_pi8 (__m64 __a)
	Takes the most significant bit from each 8-bit element in a 64-bit integer vector to create an 8-bit mask value.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_mulhi_pu16 (__m64 __a, __m64 __b)
	Multiplies packed 16-bit unsigned integer values and writes the high-order 16 bits of each 32-bit product to the corresponding bits in the destination.

static __inline__ void __DEFAULT_FN_ATTRS_SSE2	_mm_maskmove_si64 (__m64 __d, __m64 __n, char *__p)
	Conditionally copies the values from each 8-bit element in the first 64-bit integer vector operand to the specified memory location, as specified by the most significant bit in the corresponding element in the second 64-bit integer vector operand.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_avg_pu8 (__m64 __a, __m64 __b)
	Computes the rounded averages of the packed unsigned 8-bit integer values and writes the averages to the corresponding bits in the destination.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_avg_pu16 (__m64 __a, __m64 __b)
	Computes the rounded averages of the packed unsigned 16-bit integer values and writes the averages to the corresponding bits in the destination.

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_sad_pu8 (__m64 __a, __m64 __b)
	Subtracts the corresponding 8-bit unsigned integer values of the two 64-bit vector operands and computes the absolute value for each of the difference.

unsigned int	_mm_getcsr (void)
	Returns the contents of the MXCSR register as a 32-bit unsigned integer value.

void	_mm_setcsr (unsigned int __i)
	Sets the MXCSR register with the 32-bit unsigned integer value.

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_unpackhi_ps (__m128 __a, __m128 __b)
	Unpacks the high-order (index 2,3) values from two 128-bit vectors of [4 x float] and interleaves them into a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_unpacklo_ps (__m128 __a, __m128 __b)
	Unpacks the low-order (index 0,1) values from two 128-bit vectors of [4 x float] and interleaves them into a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_move_ss (__m128 __a, __m128 __b)
	Constructs a 128-bit floating-point vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_movehl_ps (__m128 __a, __m128 __b)
	Constructs a 128-bit floating-point vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR	_mm_movelh_ps (__m128 __a, __m128 __b)
	Constructs a 128-bit floating-point vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtpi16_ps (__m64 __a)
	Converts a 64-bit vector of [4 x i16] into a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtpu16_ps (__m64 __a)
	Converts a 64-bit vector of 16-bit unsigned integer values into a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtpi8_ps (__m64 __a)
	Converts the lower four 8-bit values from a 64-bit vector of [8 x i8] into a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtpu8_ps (__m64 __a)
	Converts the lower four unsigned 8-bit integer values from a 64-bit vector of [8 x u8] into a 128-bit vector of [4 x float].

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtpi32x2_ps (__m64 __a, __m64 __b)
	Converts the two 32-bit signed integer values from each 64-bit vector operand of [2 x i32] into a 128-bit vector of [4 x float].

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtps_pi16 (__m128 __a)
	Converts each single-precision floating-point element of a 128-bit floating-point vector of [4 x float] into a 16-bit signed integer, and packs the results into a 64-bit integer vector of [4 x i16].

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2	_mm_cvtps_pi8 (__m128 __a)
	Converts each single-precision floating-point element of a 128-bit floating-point vector of [4 x float] into an 8-bit signed integer, and packs the results into the lower 32 bits of a 64-bit integer vector of [8 x i8].

static __inline__ int __DEFAULT_FN_ATTRS	_mm_movemask_ps (__m128 __a)
	Extracts the sign bits from each single-precision floating-point element of a 128-bit floating-point vector of [4 x float] and returns the sign bits in bits [0:3] of the result.

Macro Definition Documentation

◆ __anyext128

#define __anyext128 ( x )

Value:

(__m128i) __builtin_shufflevector((__v2si)(x), __extension__(__v2si){}, 0, \

1, -1, -1)

Definition at line 64 of file xmmintrin.h.

◆ __DEFAULT_FN_ATTRS

#define __DEFAULT_FN_ATTRS

Value:

__attribute__((__always_inline__, __nodebug__, __target__("sse"), \

__min_vector_width__(128)))

__attribute__

_Float16 __2f16 __attribute__((ext_vector_type(2)))

Zeroes the upper 128 bits (bits 255:128) of all YMM registers.

Definition: __clang_hip_libdevice_declares.h:293

Definition at line 43 of file xmmintrin.h.

◆ __DEFAULT_FN_ATTRS_CONSTEXPR

#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS

Definition at line 55 of file xmmintrin.h.

◆ __DEFAULT_FN_ATTRS_SSE2

#define __DEFAULT_FN_ATTRS_SSE2

Value:

__attribute__((__always_inline__, __nodebug__, __target__("sse2"), \

__min_vector_width__(128)))

Definition at line 46 of file xmmintrin.h.

◆ __DEFAULT_FN_ATTRS_SSE2_CONSTEXPR

#define __DEFAULT_FN_ATTRS_SSE2_CONSTEXPR __DEFAULT_FN_ATTRS_SSE2

Definition at line 56 of file xmmintrin.h.

◆ __trunc64

#define __trunc64 ( x ) (__m64) __builtin_shufflevector((__v2di)(x), __extension__(__v2di){}, 0)

Definition at line 59 of file xmmintrin.h.

◆ __zeroupper64

#define __zeroupper64 ( x )

Value:

(__m128i) __builtin_shufflevector((__v4si)(x), __extension__(__v4si){}, 0, \

1, 4, 5)

Definition at line 67 of file xmmintrin.h.

◆ __zext128

#define __zext128 ( x )

Value:

(__m128i) __builtin_shufflevector((__v2si)(x), __extension__(__v2si){}, 0, \

1, 2, 3)

Definition at line 61 of file xmmintrin.h.

◆ _CMP_EQ_OQ

#define _CMP_EQ_OQ 0x00 /* Equal (ordered, non-signaling) */

Definition at line 3038 of file xmmintrin.h.

◆ _CMP_LE_OS

#define _CMP_LE_OS 0x02 /* Less-than-or-equal (ordered, signaling) */

Definition at line 3040 of file xmmintrin.h.

◆ _CMP_LT_OS

#define _CMP_LT_OS 0x01 /* Less-than (ordered, signaling) */

Definition at line 3039 of file xmmintrin.h.

◆ _CMP_NEQ_UQ

#define _CMP_NEQ_UQ 0x04 /* Not-equal (unordered, non-signaling) */

Definition at line 3042 of file xmmintrin.h.

◆ _CMP_NLE_US

#define _CMP_NLE_US 0x06 /* Not-less-than-or-equal (unordered, signaling) */

Definition at line 3044 of file xmmintrin.h.

◆ _CMP_NLT_US

#define _CMP_NLT_US 0x05 /* Not-less-than (unordered, signaling) */

Definition at line 3043 of file xmmintrin.h.

◆ _CMP_ORD_Q

#define _CMP_ORD_Q 0x07 /* Ordered (non-signaling) */

Definition at line 3045 of file xmmintrin.h.

◆ _CMP_UNORD_Q

#define _CMP_UNORD_Q 0x03 /* Unordered (non-signaling) */

Definition at line 3041 of file xmmintrin.h.

◆ _m_

#define _m_ _mm_

Definition at line 3184 of file xmmintrin.h.

◆ _m_maskmovq

#define _m_maskmovq _mm_maskmove_si64

Definition at line 3180 of file xmmintrin.h.

◆ _m_pavgb

#define _m_pavgb _mm_avg_pu8

Definition at line 3181 of file xmmintrin.h.

◆ _m_pavgw

#define _m_pavgw _mm_avg_pu16

Definition at line 3182 of file xmmintrin.h.

◆ _m_pextrw

#define _m_pextrw _mm_extract_pi16

Definition at line 3171 of file xmmintrin.h.

◆ _m_pinsrw

#define _m_pinsrw _mm_insert_pi16

Definition at line 3172 of file xmmintrin.h.

◆ _m_pmaxsw

#define _m_pmaxsw _mm_max_pi16

Definition at line 3173 of file xmmintrin.h.

◆ _m_pmaxub

#define _m_pmaxub _mm_max_pu8

Definition at line 3174 of file xmmintrin.h.

◆ _m_pminsw

#define _m_pminsw _mm_min_pi16

Definition at line 3175 of file xmmintrin.h.

◆ _m_pminub

#define _m_pminub _mm_min_pu8

Definition at line 3176 of file xmmintrin.h.

◆ _m_pmovmskb

#define _m_pmovmskb _mm_movemask_pi8

Definition at line 3177 of file xmmintrin.h.

◆ _m_pmulhuw

#define _m_pmulhuw _mm_mulhi_pu16

Definition at line 3178 of file xmmintrin.h.

◆ _m_psadbw

#define _m_psadbw _mm_sad_pu8

Definition at line 3183 of file xmmintrin.h.

◆ _m_pshufw

#define _m_pshufw _mm_shuffle_pi16

Definition at line 3179 of file xmmintrin.h.

◆ _MM_ALIGN16

#define _MM_ALIGN16 __attribute__((aligned(16)))

Definition at line 3117 of file xmmintrin.h.

◆ _mm_cmp_ps

#define _mm_cmp_ps	(	a,
		b,
		c
	)	((__m128)__builtin_ia32_cmpps((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), (c)))

Compares each of the corresponding values of two 128-bit vectors of [4 x float], using the operation specified by the immediate integer operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, comparisons that are ordered return false, and comparisons that are unordered return true.

__m128 _mm_cmp_ps(__m128 a, __m128 b, const int c);

b

__device__ __2f16 b

Definition: __clang_hip_libdevice_declares.h:303

c

__device__ __2f16 float c

Definition: __clang_hip_libdevice_declares.h:304

_mm_cmp_ps

#define _mm_cmp_ps(a, b, c)

Compares each of the corresponding values of two 128-bit vectors of [4 x float], using the operation ...

Definition: xmmintrin.h:3079

This intrinsic corresponds to the (V)CMPPS instruction.

Parameters

a	A 128-bit vector of [4 x float].
b	A 128-bit vector of [4 x float].
c	An immediate integer operand, with bits [4:0] specifying which comparison operation to use: 0x00: Equal (ordered, non-signaling) 0x01: Less-than (ordered, signaling) 0x02: Less-than-or-equal (ordered, signaling) 0x03: Unordered (non-signaling) 0x04: Not-equal (unordered, non-signaling) 0x05: Not-less-than (unordered, signaling) 0x06: Not-less-than-or-equal (unordered, signaling) 0x07: Ordered (non-signaling)

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 3079 of file xmmintrin.h.

◆ _mm_cmp_ss

#define _mm_cmp_ss	(	a,
		b,
		c
	)	((__m128)__builtin_ia32_cmpss((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), (c)))

Compares each of the corresponding scalar values of two 128-bit vectors of [4 x float], using the operation specified by the immediate integer operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, comparisons that are ordered return false, and comparisons that are unordered return true.

__m128 _mm_cmp_ss(__m128 a, __m128 b, const int c);

_mm_cmp_ss

#define _mm_cmp_ss(a, b, c)

Compares each of the corresponding scalar values of two 128-bit vectors of [4 x float],...

Definition: xmmintrin.h:3114

This intrinsic corresponds to the (V)CMPSS instruction.

Parameters

a	A 128-bit vector of [4 x float].
b	A 128-bit vector of [4 x float].
c	An immediate integer operand, with bits [4:0] specifying which comparison operation to use: 0x00: Equal (ordered, non-signaling) 0x01: Less-than (ordered, signaling) 0x02: Less-than-or-equal (ordered, signaling) 0x03: Unordered (non-signaling) 0x04: Not-equal (unordered, non-signaling) 0x05: Not-less-than (unordered, signaling) 0x06: Not-less-than-or-equal (unordered, signaling) 0x07: Ordered (non-signaling)

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 3114 of file xmmintrin.h.

◆ _MM_EXCEPT_DENORM

#define _MM_EXCEPT_DENORM (0x0002U)

Definition at line 3122 of file xmmintrin.h.

◆ _MM_EXCEPT_DIV_ZERO

#define _MM_EXCEPT_DIV_ZERO (0x0004U)

Definition at line 3123 of file xmmintrin.h.

◆ _MM_EXCEPT_INEXACT

#define _MM_EXCEPT_INEXACT (0x0020U)

Definition at line 3126 of file xmmintrin.h.

◆ _MM_EXCEPT_INVALID

#define _MM_EXCEPT_INVALID (0x0001U)

Definition at line 3121 of file xmmintrin.h.

◆ _MM_EXCEPT_MASK

#define _MM_EXCEPT_MASK (0x003fU)

Definition at line 3127 of file xmmintrin.h.

◆ _MM_EXCEPT_OVERFLOW

#define _MM_EXCEPT_OVERFLOW (0x0008U)

Definition at line 3124 of file xmmintrin.h.

◆ _MM_EXCEPT_UNDERFLOW

#define _MM_EXCEPT_UNDERFLOW (0x0010U)

Definition at line 3125 of file xmmintrin.h.

◆ _mm_extract_pi16

#define _mm_extract_pi16	(	a,
		n
	)	((int)(unsigned short)__builtin_ia32_vec_ext_v4hi((__v4hi)a, (int)n))

Extracts 16-bit element from a 64-bit vector of [4 x i16] and returns it, as specified by the immediate integer operand.

int _mm_extract_pi16(__m64 a, int n);

_mm_extract_pi16

#define _mm_extract_pi16(a, n)

Extracts 16-bit element from a 64-bit vector of [4 x i16] and returns it, as specified by the immedia...

Definition: xmmintrin.h:2308

This intrinsic corresponds to the VPEXTRW / PEXTRW instruction.

Parameters

a	A 64-bit vector of [4 x i16].
n	An immediate integer operand that determines which bits are extracted: 0: Bits [15:0] are copied to the destination. 1: Bits [31:16] are copied to the destination. 2: Bits [47:32] are copied to the destination. 3: Bits [63:48] are copied to the destination.

Returns: A 16-bit integer containing the extracted 16 bits of packed data.

Definition at line 2308 of file xmmintrin.h.

◆ _MM_FLUSH_ZERO_MASK

#define _MM_FLUSH_ZERO_MASK (0x8000U)

Definition at line 3143 of file xmmintrin.h.

◆ _MM_FLUSH_ZERO_OFF

#define _MM_FLUSH_ZERO_OFF (0x0000U)

Definition at line 3145 of file xmmintrin.h.

◆ _MM_FLUSH_ZERO_ON

#define _MM_FLUSH_ZERO_ON (0x8000U)

Definition at line 3144 of file xmmintrin.h.

◆ _MM_GET_EXCEPTION_MASK

#define _MM_GET_EXCEPTION_MASK ( ) (_mm_getcsr() & _MM_MASK_MASK)

Definition at line 3147 of file xmmintrin.h.

◆ _MM_GET_EXCEPTION_STATE

#define _MM_GET_EXCEPTION_STATE ( ) (_mm_getcsr() & _MM_EXCEPT_MASK)

Definition at line 3148 of file xmmintrin.h.

◆ _MM_GET_FLUSH_ZERO_MODE

#define _MM_GET_FLUSH_ZERO_MODE ( ) (_mm_getcsr() & _MM_FLUSH_ZERO_MASK)

Definition at line 3149 of file xmmintrin.h.

◆ _MM_GET_ROUNDING_MODE

#define _MM_GET_ROUNDING_MODE ( ) (_mm_getcsr() & _MM_ROUND_MASK)

Definition at line 3150 of file xmmintrin.h.

◆ _MM_HINT_ET0

#define _MM_HINT_ET0 7

Definition at line 2193 of file xmmintrin.h.

◆ _MM_HINT_ET1

#define _MM_HINT_ET1 6

Definition at line 2194 of file xmmintrin.h.

◆ _MM_HINT_NTA

#define _MM_HINT_NTA 0

Definition at line 2198 of file xmmintrin.h.

◆ _MM_HINT_T0

#define _MM_HINT_T0 3

Definition at line 2195 of file xmmintrin.h.

◆ _MM_HINT_T1

#define _MM_HINT_T1 2

Definition at line 2196 of file xmmintrin.h.

◆ _MM_HINT_T2

#define _MM_HINT_T2 1

Definition at line 2197 of file xmmintrin.h.

◆ _mm_insert_pi16

#define _mm_insert_pi16	(	a,
		d,
		n
	)	((__m64)__builtin_ia32_vec_set_v4hi((__v4hi)a, (int)d, (int)n))

Copies data from the 64-bit vector of [4 x i16] to the destination, and inserts the lower 16-bits of an integer operand at the 16-bit offset specified by the immediate operand n.

__m64 _mm_insert_pi16(__m64 a, int d, int n);

_mm_insert_pi16

#define _mm_insert_pi16(a, d, n)

Copies data from the 64-bit vector of [4 x i16] to the destination, and inserts the lower 16-bits of ...

Definition: xmmintrin.h:2339

This intrinsic corresponds to the PINSRW instruction.

Parameters

a	A 64-bit vector of [4 x i16].
d	An integer. The lower 16-bit value from this operand is written to the destination at the offset specified by operand n.
n	An immediate integer operant that determines which the bits to be used in the destination. 0: Bits [15:0] are copied to the destination. 1: Bits [31:16] are copied to the destination. 2: Bits [47:32] are copied to the destination. 3: Bits [63:48] are copied to the destination. The remaining bits in the destination are copied from the corresponding bits in operand a.

Returns: A 64-bit integer vector containing the copied packed data from the operands.

Definition at line 2339 of file xmmintrin.h.

◆ _mm_load_ps1

#define _mm_load_ps1 ( p ) _mm_load1_ps(p)

Definition at line 1840 of file xmmintrin.h.

◆ _MM_MASK_DENORM

#define _MM_MASK_DENORM (0x0100U)

Definition at line 3130 of file xmmintrin.h.

◆ _MM_MASK_DIV_ZERO

#define _MM_MASK_DIV_ZERO (0x0200U)

Definition at line 3131 of file xmmintrin.h.

◆ _MM_MASK_INEXACT

#define _MM_MASK_INEXACT (0x1000U)

Definition at line 3134 of file xmmintrin.h.

◆ _MM_MASK_INVALID

#define _MM_MASK_INVALID (0x0080U)

Definition at line 3129 of file xmmintrin.h.

◆ _MM_MASK_MASK

#define _MM_MASK_MASK (0x1f80U)

Definition at line 3135 of file xmmintrin.h.

◆ _MM_MASK_OVERFLOW

#define _MM_MASK_OVERFLOW (0x0400U)

Definition at line 3132 of file xmmintrin.h.

◆ _MM_MASK_UNDERFLOW

#define _MM_MASK_UNDERFLOW (0x0800U)

Definition at line 3133 of file xmmintrin.h.

◆ _mm_prefetch

#define _mm_prefetch	(	a,
		sel
	)

Value:

(__builtin_prefetch((const void *)(a), \

((sel) >> 2) & 1, (sel) & 0x3))

Loads one cache line of data from the specified address to a location closer to the processor.

void _mm_prefetch(const void *a, const int sel);

_mm_prefetch

#define _mm_prefetch(a, sel)

Loads one cache line of data from the specified address to a location closer to the processor.

Definition: xmmintrin.h:2228

This intrinsic corresponds to the PREFETCHNTA instruction.

Parameters

a A pointer to a memory location containing a cache line of data.

sel A predefined integer constant specifying the type of prefetch operation:
_MM_HINT_NTA: Move data using the non-temporal access (NTA) hint. The PREFETCHNTA instruction will be generated.
_MM_HINT_T0: Move data using the T0 hint. The PREFETCHT0 instruction will be generated.
_MM_HINT_T1: Move data using the T1 hint. The PREFETCHT1 instruction will be generated.
_MM_HINT_T2: Move data using the T2 hint. The PREFETCHT2 instruction will be generated.

Definition at line 2228 of file xmmintrin.h.

◆ _MM_ROUND_DOWN

#define _MM_ROUND_DOWN (0x2000U)

Definition at line 3138 of file xmmintrin.h.

◆ _MM_ROUND_MASK

#define _MM_ROUND_MASK (0x6000U)

Definition at line 3141 of file xmmintrin.h.

◆ _MM_ROUND_NEAREST

#define _MM_ROUND_NEAREST (0x0000U)

Definition at line 3137 of file xmmintrin.h.

◆ _MM_ROUND_TOWARD_ZERO

#define _MM_ROUND_TOWARD_ZERO (0x6000U)

Definition at line 3140 of file xmmintrin.h.

◆ _MM_ROUND_UP

#define _MM_ROUND_UP (0x4000U)

Definition at line 3139 of file xmmintrin.h.

◆ _MM_SET_EXCEPTION_MASK

#define _MM_SET_EXCEPTION_MASK ( x ) (_mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | (x)))

Definition at line 3152 of file xmmintrin.h.

◆ _MM_SET_EXCEPTION_STATE

#define _MM_SET_EXCEPTION_STATE ( x ) (_mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | (x)))

Definition at line 3153 of file xmmintrin.h.

◆ _MM_SET_FLUSH_ZERO_MODE

#define _MM_SET_FLUSH_ZERO_MODE ( x ) (_mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | (x)))

Definition at line 3154 of file xmmintrin.h.

◆ _MM_SET_ROUNDING_MODE

#define _MM_SET_ROUNDING_MODE ( x ) (_mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | (x)))

Definition at line 3155 of file xmmintrin.h.

◆ _MM_SHUFFLE

#define _MM_SHUFFLE	(	z,
		y,
		x,
		w
	)	(((z) << 6) \| ((y) << 4) \| ((x) << 2) \| (w))

Definition at line 3119 of file xmmintrin.h.

◆ _mm_shuffle_pi16

#define _mm_shuffle_pi16	(	a,
		n
	)

Value:

  ((__m64)__builtin_shufflevector((__v4hi)(__m64)(a), __extension__(__v4hi){}, \
                                  (n) & 0x3, ((n) >> 2) & 0x3,                 \
                                  ((n) >> 4) & 0x3, ((n) >> 6) & 0x3))

Shuffles the 4 16-bit integers from a 64-bit integer vector to the destination, as specified by the immediate value operand.

__m64 _mm_shuffle_pi16(__m64 a, const int n);

_mm_shuffle_pi16

#define _mm_shuffle_pi16(a, n)

Shuffles the 4 16-bit integers from a 64-bit integer vector to the destination, as specified by the i...

Definition: xmmintrin.h:2490

This intrinsic corresponds to the PSHUFW instruction.

Parameters

a A 64-bit integer vector containing the values to be shuffled.

n An immediate value containing an 8-bit value specifying which elements to copy from a. The destinations within the 64-bit destination are assigned values as follows:
Bits [1:0] are used to assign values to bits [15:0] in the destination.
Bits [3:2] are used to assign values to bits [31:16] in the destination.
Bits [5:4] are used to assign values to bits [47:32] in the destination.
Bits [7:6] are used to assign values to bits [63:48] in the destination.
Bit value assignments:
00: assigned from bits [15:0] of a.
01: assigned from bits [31:16] of a.
10: assigned from bits [47:32] of a.
11: assigned from bits [63:48] of a.
Note: To generate a mask, you can use the _MM_SHUFFLE macro. _MM_SHUFFLE(b6, b4, b2, b0) can create an 8-bit mask of the form [b6, b4, b2, b0].

Returns: A 64-bit integer vector containing the shuffled values.

Definition at line 2490 of file xmmintrin.h.

◆ _mm_shuffle_ps

#define _mm_shuffle_ps	(	a,
		b,
		mask
	)

Value:

((__m128)__builtin_ia32_shufps((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), \

(int)(mask)))

Selects 4 float values from the 128-bit operands of [4 x float], as specified by the immediate value operand.

__m128 _mm_shuffle_ps(__m128 a, __m128 b, const int mask);

_mm_shuffle_ps

#define _mm_shuffle_ps(a, b, mask)

Selects 4 float values from the 128-bit operands of [4 x float], as specified by the immediate value ...

Definition: xmmintrin.h:2755

This intrinsic corresponds to the VSHUFPS / SHUFPS instruction.

Parameters

a	A 128-bit vector of [4 x float].
b	A 128-bit vector of [4 x float].
mask	An immediate value containing an 8-bit value specifying which elements to copy from a and b. Bits [3:0] specify the values copied from operand a. Bits [7:4] specify the values copied from operand b. The destinations within the 128-bit destination are assigned values as follows: Bits [1:0] are used to assign values to bits [31:0] in the destination. Bits [3:2] are used to assign values to bits [63:32] in the destination. Bits [5:4] are used to assign values to bits [95:64] in the destination. Bits [7:6] are used to assign values to bits [127:96] in the destination. Bit value assignments: 00: Bits [31:0] copied from the specified operand. 01: Bits [63:32] copied from the specified operand. 10: Bits [95:64] copied from the specified operand. 11: Bits [127:96] copied from the specified operand. Note: To generate a mask, you can use the `_MM_SHUFFLE` macro. `_MM_SHUFFLE(b6, b4, b2, b0)` can create an 8-bit mask of the form `[b6, b4, b2, b0]`.

Returns: A 128-bit vector of [4 x float] containing the shuffled values.

Definition at line 2755 of file xmmintrin.h.

◆ _MM_TRANSPOSE4_PS

#define _MM_TRANSPOSE4_PS	(	row0,
		row1,
		row2,
		row3
	)

Value:

do { \
  __m128 tmp3, tmp2, tmp1, tmp0; \
  tmp0 = _mm_unpacklo_ps((row0), (row1)); \
  tmp2 = _mm_unpacklo_ps((row2), (row3)); \
  tmp1 = _mm_unpackhi_ps((row0), (row1)); \
  tmp3 = _mm_unpackhi_ps((row2), (row3)); \
  (row0) = _mm_movelh_ps(tmp0, tmp2); \
  (row1) = _mm_movehl_ps(tmp2, tmp0); \
  (row2) = _mm_movelh_ps(tmp1, tmp3); \
  (row3) = _mm_movehl_ps(tmp3, tmp1); \
} while (0)

Definition at line 3157 of file xmmintrin.h.

Typedef Documentation

◆ attribute

typedef unsigned int __v4su __attribute__((__vector_size__(16)))

Definition at line 19 of file xmmintrin.h.

Function Documentation

◆ _mm_add_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_add_ps	(	__m128	__a,
		__m128	__b
	)

static

Adds two 128-bit vectors of [4 x float], and returns the results of the addition.

This intrinsic corresponds to the VADDPS / ADDPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the source operands.
__b	A 128-bit vector of [4 x float] containing one of the source operands.

Returns: A 128-bit vector of [4 x float] containing the sums of both operands.

Definition at line 106 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_add_ps(), and _mm_maskz_add_ps().

◆ _mm_add_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_add_ss	(	__m128	__a,
		__m128	__b
	)

static

Adds the 32-bit float values in the low-order bits of the operands.

This intrinsic corresponds to the VADDSS / ADDSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the source operands. The lower 32 bits of this operand are used in the calculation.
__b	A 128-bit vector of [4 x float] containing one of the source operands. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] whose lower 32 bits contain the sum of the lower 32 bits of both operands. The upper 96 bits are copied from the upper 96 bits of the first source operand.

Definition at line 87 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_add_ss(), and _mm_maskz_add_ss().

◆ _mm_and_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_and_ps	(	__m128	__a,
		__m128	__b
	)

static

Performs a bitwise AND of two 128-bit vectors of [4 x float].

This intrinsic corresponds to the VANDPS / ANDPS instructions.

Parameters

__a	A 128-bit vector containing one of the source operands.
__b	A 128-bit vector containing one of the source operands.

Returns: A 128-bit vector of [4 x float] containing the bitwise AND of the values between both operands.

Definition at line 441 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_and_ps(), and _mm_maskz_and_ps().

◆ _mm_andnot_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_andnot_ps	(	__m128	__a,
		__m128	__b
	)

static

Performs a bitwise AND of two 128-bit vectors of [4 x float], using the one's complement of the values contained in the first source operand.

This intrinsic corresponds to the VANDNPS / ANDNPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing the first source operand. The one's complement of this value is used in the bitwise AND.
__b	A 128-bit vector of [4 x float] containing the second source operand.

Returns: A 128-bit vector of [4 x float] containing the bitwise AND of the one's complement of the first operand and the values in the second operand.

Definition at line 462 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_andnot_ps(), and _mm_maskz_andnot_ps().

◆ _mm_avg_pu16()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_avg_pu16	(	__m64	__a,
		__m64	__b
	)

static

Computes the rounded averages of the packed unsigned 16-bit integer values and writes the averages to the corresponding bits in the destination.

This intrinsic corresponds to the PAVGW instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the averages of both operands.

Definition at line 2573 of file xmmintrin.h.

References __a, __anyext128, __b, and __trunc64.

◆ _mm_avg_pu8()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_avg_pu8	(	__m64	__a,
		__m64	__b
	)

static

Computes the rounded averages of the packed unsigned 8-bit integer values and writes the averages to the corresponding bits in the destination.

This intrinsic corresponds to the PAVGB instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the averages of both operands.

Definition at line 2553 of file xmmintrin.h.

References __a, __anyext128, __b, and __trunc64.

◆ _mm_cmpeq_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpeq_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] for equality.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPEQPS / CMPEQPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 542 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpeq_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpeq_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands for equality.

The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector [4 x float]. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPEQSS / CMPEQSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 521 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpge_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpge_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are greater than or equal to those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLEPS / CMPLEPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 738 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpge_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpge_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is greater than or equal to the corresponding value in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLESS / CMPLESS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 714 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpgt_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpgt_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are greater than those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLTPS / CMPLTPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 688 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpgt_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpgt_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is greater than the corresponding value in the second operand.

The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLTSS / CMPLTSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 664 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmple_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmple_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are less than or equal to those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLEPS / CMPLEPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 638 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmple_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmple_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is less than or equal to the corresponding value in the second operand.

The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLESS / CMPLESS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 616 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmplt_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmplt_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are less than those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLTPS / CMPLTPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 590 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmplt_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmplt_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is less than the corresponding value in the second operand.

The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns false.

This intrinsic corresponds to the VCMPLTSS / CMPLTSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 568 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpneq_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpneq_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] for inequality.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNEQPS / CMPNEQPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 786 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpneq_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpneq_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands for inequality.

The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNEQSS / CMPNEQSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 764 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpnge_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnge_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not greater than or equal to those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLEPS / CMPNLEPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 990 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpnge_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnge_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not greater than or equal to the corresponding value in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLESS / CMPNLESS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 965 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpngt_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpngt_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not greater than those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLTPS / CMPNLTPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 938 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpngt_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpngt_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not greater than the corresponding value in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLTSS / CMPNLTSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 913 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpnle_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnle_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not less than or equal to those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLEPS / CMPNLEPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 886 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpnle_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnle_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not less than or equal to the corresponding value in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLESS / CMPNLESS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 863 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpnlt_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnlt_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are not less than those in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLTPS / CMPNLTPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 836 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpnlt_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpnlt_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is not less than the corresponding value in the second operand.

Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the low-order bits of a vector of [4 x float]. If either value in a comparison is NaN, returns true.

This intrinsic corresponds to the VCMPNLTSS / CMPNLTSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 813 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpord_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpord_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are ordered with respect to those in the second operand.

A pair of floating-point values are ordered with respect to each other if neither value is a NaN. Each comparison returns 0x0 for false, 0xFFFFFFFF for true.

This intrinsic corresponds to the VCMPORDPS / CMPORDPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 1041 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpord_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpord_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is ordered with respect to the corresponding value in the second operand.

A pair of floating-point values are ordered with respect to each other if neither value is a NaN. Each comparison returns 0x0 for false, 0xFFFFFFFF for true.

This intrinsic corresponds to the VCMPORDSS / CMPORDSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 1017 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpunord_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpunord_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares each of the corresponding 32-bit float values of the 128-bit vectors of [4 x float] to determine if the values in the first operand are unordered with respect to those in the second operand.

A pair of double-precision values are unordered with respect to each other if one or both values are NaN. Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.

This intrinsic corresponds to the VCMPUNORDPS / CMPUNORDPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the comparison results.

Definition at line 1092 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cmpunord_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cmpunord_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the value in the first operand is unordered with respect to the corresponding value in the second operand.

A pair of double-precision values are unordered with respect to each other if one or both values are NaN. Each comparison returns 0x0 for false, 0xFFFFFFFF for true.

This intrinsic corresponds to the VCMPUNORDSS / CMPUNORDSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] containing the comparison results in the low-order bits.

Definition at line 1068 of file xmmintrin.h.

References __a, and __b.

◆ _mm_comieq_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands for equality.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VCOMISS / COMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1116 of file xmmintrin.h.

References __a, and __b.

◆ _mm_comige_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is greater than or equal to the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VCOMISS / COMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1213 of file xmmintrin.h.

References __a, and __b.

◆ _mm_comigt_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is greater than the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VCOMISS / COMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1189 of file xmmintrin.h.

References __a, and __b.

◆ _mm_comile_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is less than or equal to the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VCOMISS / COMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1165 of file xmmintrin.h.

References __a, and __b.

◆ _mm_comilt_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is less than the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VCOMISS / COMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1141 of file xmmintrin.h.

References __a, and __b.

◆ _mm_comineq_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_comineq_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands to determine if the first operand is not equal to the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 1.

This intrinsic corresponds to the VCOMISS / COMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1237 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cvt_pi2ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvt_pi2ps	(	__m128	__a,
		__m64	__b
	)

static

Converts two elements of a 64-bit vector of [2 x i32] into two floating point values and writes them to the lower 64-bits of the destination.

The remaining higher order elements of the destination are copied from the corresponding elements in the first operand.

This intrinsic corresponds to the CVTPI2PS instruction.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 64-bit vector of [2 x i32]. The elements in this vector are converted and written to the corresponding low-order elements in the destination.

Returns: A 128-bit vector of [4 x float] whose lower 64 bits contain the converted value from the second operand. The upper 64 bits are copied from the upper 64 bits of the first operand.

Definition at line 1718 of file xmmintrin.h.

References __a, __b, and _mm_cvtpi32_ps().

◆ _mm_cvt_ps2pi()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_cvt_ps2pi ( __m128 __a )

static

Converts two low-order float values in a 128-bit vector of [4 x float] into a 64-bit vector of [2 x i32].

If a converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the CVTPS2PI instruction.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 64-bit integer vector containing the converted values.

Definition at line 1489 of file xmmintrin.h.

References __a, and _mm_cvtps_pi32().

◆ _mm_cvt_si2ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_cvt_si2ss	(	__m128	__a,
		int	__b
	)

static

Converts a 32-bit signed integer value into a floating point value and writes it to the lower 32 bits of the destination.

The remaining higher order elements of the destination are copied from the corresponding elements in the first operand.

This intrinsic corresponds to the VCVTSI2SS / CVTSI2SS instruction.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 32-bit signed integer operand containing the value to be converted.

Returns: A 128-bit vector of [4 x float] whose lower 32 bits contain the converted value of the second operand. The upper 96 bits are copied from the upper 96 bits of the first operand.

Definition at line 1643 of file xmmintrin.h.

References __a, __b, and _mm_cvtsi32_ss().

◆ _mm_cvt_ss2si()

static __inline__ int __DEFAULT_FN_ATTRS _mm_cvt_ss2si ( __m128 __a )

static

Converts a float value contained in the lower 32 bits of a vector of [4 x float] into a 32-bit integer.

If the converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the VCVTSS2SI / CVTSS2SI instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the conversion.

Returns: A 32-bit integer containing the converted value.

Definition at line 1423 of file xmmintrin.h.

References __a, and _mm_cvtss_si32().

◆ _mm_cvtpi16_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtpi16_ps ( __m64 __a )

static

Converts a 64-bit vector of [4 x i16] into a 128-bit vector of [4 x float].

This intrinsic corresponds to the CVTPI2PS + COMPOSITE instruction.

Parameters

__a	A 64-bit vector of [4 x i16]. The elements of the destination are copied from the corresponding elements in this operand.

Returns: A 128-bit vector of [4 x float] containing the copied and converted values from the operand.

Definition at line 2876 of file xmmintrin.h.

References __a.

◆ _mm_cvtpi32_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtpi32_ps	(	__m128	__a,
		__m64	__b
	)

static

Converts two elements of a 64-bit vector of [2 x i32] into two floating point values and writes them to the lower 64-bits of the destination.

The remaining higher order elements of the destination are copied from the corresponding elements in the first operand.

This intrinsic corresponds to the CVTPI2PS instruction.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 64-bit vector of [2 x i32]. The elements in this vector are converted and written to the corresponding low-order elements in the destination.

Returns: A 128-bit vector of [4 x float] whose lower 64 bits contain the converted value of the second operand. The upper 64 bits are copied from the upper 64 bits of the first operand.

Definition at line 1692 of file xmmintrin.h.

References __a, __b, and __zext128.

Referenced by _mm_cvt_pi2ps().

◆ _mm_cvtpi32x2_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtpi32x2_ps	(	__m64	__a,
		__m64	__b
	)

static

Converts the two 32-bit signed integer values from each 64-bit vector operand of [2 x i32] into a 128-bit vector of [4 x float].

This intrinsic corresponds to the CVTPI2PS + COMPOSITE instruction.

Parameters

__a	A 64-bit vector of [2 x i32]. The lower elements of the destination are copied from the elements in this operand.
__b	A 64-bit vector of [2 x i32]. The upper elements of the destination are copied from the elements in this operand.

Returns: A 128-bit vector of [4 x float] whose lower 64 bits contain the copied and converted values from the first operand. The upper 64 bits contain the copied and converted values from the second operand.

Definition at line 2957 of file xmmintrin.h.

References __a, and __b.

◆ _mm_cvtpi8_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtpi8_ps ( __m64 __a )

static

Converts the lower four 8-bit values from a 64-bit vector of [8 x i8] into a 128-bit vector of [4 x float].

This intrinsic corresponds to the CVTPI2PS + COMPOSITE instruction.

Parameters

__a	A 64-bit vector of [8 x i8]. The elements of the destination are copied from the corresponding lower 4 elements in this operand.

Returns: A 128-bit vector of [4 x float] containing the copied and converted values from the operand.

Definition at line 2912 of file xmmintrin.h.

References __a.

◆ _mm_cvtps_pi16()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtps_pi16 ( __m128 __a )

static

Converts each single-precision floating-point element of a 128-bit floating-point vector of [4 x float] into a 16-bit signed integer, and packs the results into a 64-bit integer vector of [4 x i16].

If the floating-point element is NaN or infinity, or if the floating-point element is greater than 0x7FFFFFFF or less than -0x8000, it is converted to 0x8000. Otherwise if the floating-point element is greater than 0x7FFF, it is converted to 0x7FFF.

This intrinsic corresponds to the CVTPS2PI + COMPOSITE instruction.

Parameters

__a	A 128-bit floating-point vector of [4 x float].

Returns: A 64-bit integer vector of [4 x i16] containing the converted values.

Definition at line 2982 of file xmmintrin.h.

References __a, __trunc64, and _mm_setzero_ps().

Referenced by _mm_cvtps_pi8().

◆ _mm_cvtps_pi32()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtps_pi32 ( __m128 __a )

static

Converts two low-order float values in a 128-bit vector of [4 x float] into a 64-bit vector of [2 x i32].

If a converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the CVTPS2PI instruction.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 64-bit integer vector containing the converted values.

Definition at line 1469 of file xmmintrin.h.

References __a, __trunc64, and __zeroupper64.

Referenced by _mm_cvt_ps2pi().

◆ _mm_cvtps_pi8()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtps_pi8 ( __m128 __a )

static

Converts each single-precision floating-point element of a 128-bit floating-point vector of [4 x float] into an 8-bit signed integer, and packs the results into the lower 32 bits of a 64-bit integer vector of [8 x i8].

The upper 32 bits of the vector are set to 0.

If the floating-point element is NaN or infinity, or if the floating-point element is greater than 0x7FFFFFFF or less than -0x80, it is converted to 0x80. Otherwise if the floating-point element is greater than 0x7F, it is converted to 0x7F.

This intrinsic corresponds to the CVTPS2PI + COMPOSITE instruction.

Parameters

__a	128-bit floating-point vector of [4 x float].

Returns: A 64-bit integer vector of [8 x i8]. The lower 32 bits contain the converted values and the uppper 32 bits are set to zero.

Definition at line 3007 of file xmmintrin.h.

References __a, __b, __c, _mm_cvtps_pi16(), _mm_packs_pi16(), and _mm_setzero_si64().

◆ _mm_cvtpu16_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtpu16_ps ( __m64 __a )

static

Converts a 64-bit vector of 16-bit unsigned integer values into a 128-bit vector of [4 x float].

This intrinsic corresponds to the CVTPI2PS + COMPOSITE instruction.

Parameters

__a	A 64-bit vector of 16-bit unsigned integer values. The elements of the destination are copied from the corresponding elements in this operand.

Returns: A 128-bit vector of [4 x float] containing the copied and converted values from the operand.

Definition at line 2894 of file xmmintrin.h.

References __a.

◆ _mm_cvtpu8_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtpu8_ps ( __m64 __a )

static

Converts the lower four unsigned 8-bit integer values from a 64-bit vector of [8 x u8] into a 128-bit vector of [4 x float].

This intrinsic corresponds to the CVTPI2PS + COMPOSITE instruction.

Parameters

__a	A 64-bit vector of unsigned 8-bit integer values. The elements of the destination are copied from the corresponding lower 4 elements in this operand.

Returns: A 128-bit vector of [4 x float] containing the copied and converted values from the source operand.

Definition at line 2933 of file xmmintrin.h.

References __a.

◆ _mm_cvtsi32_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_cvtsi32_ss	(	__m128	__a,
		int	__b
	)

static

Converts a 32-bit signed integer value into a floating point value and writes it to the lower 32 bits of the destination.

The remaining higher order elements of the destination vector are copied from the corresponding elements in the first operand.

This intrinsic corresponds to the VCVTSI2SS / CVTSI2SS instruction.

Parameters

__a	A 128-bit vector of [4 x float].
__b	A 32-bit signed integer operand containing the value to be converted.

Returns: A 128-bit vector of [4 x float] whose lower 32 bits contain the converted value of the second operand. The upper 96 bits are copied from the upper 96 bits of the first operand.

Definition at line 1621 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_cvt_si2ss().

◆ _mm_cvtss_f32()

static __inline__ float __DEFAULT_FN_ATTRS_CONSTEXPR _mm_cvtss_f32 ( __m128 __a )

static

Extracts a float value contained in the lower 32 bits of a vector of [4 x float].

This intrinsic has no corresponding instruction.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the extraction.

Returns: A 32-bit float containing the extracted value.

Definition at line 1735 of file xmmintrin.h.

References __a.

◆ _mm_cvtss_si32()

static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtss_si32 ( __m128 __a )

static

Converts a float value contained in the lower 32 bits of a vector of [4 x float] into a 32-bit integer.

If the converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the VCVTSS2SI / CVTSS2SI instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the conversion.

Returns: A 32-bit integer containing the converted value.

Definition at line 1401 of file xmmintrin.h.

References __a.

Referenced by _mm_cvt_ss2si().

◆ _mm_cvtt_ps2pi()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_cvtt_ps2pi ( __m128 __a )

static

Converts the lower (first) two elements of a 128-bit vector of [4 x float] into two signed truncated (rounded toward zero) 64-bit integers, returned in a 64-bit vector of [2 x i32].

If a converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the CVTTPS2PI instruction.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 64-bit integer vector containing the converted values.

Definition at line 1600 of file xmmintrin.h.

References __a, and _mm_cvttps_pi32().

◆ _mm_cvtt_ss2si()

static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtt_ss2si ( __m128 __a )

static

Converts the lower (first) element of a vector of [4 x float] into a signed truncated (rounded toward zero) 32-bit integer.

If the converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the VCVTTSS2SI / CVTTSS2SI instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the conversion.

Returns: A 32-bit integer containing the converted value.

Definition at line 1533 of file xmmintrin.h.

References __a, and _mm_cvttss_si32().

◆ _mm_cvttps_pi32()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_cvttps_pi32 ( __m128 __a )

static

Converts the lower (first) two elements of a 128-bit vector of [4 x float] into two signed truncated (rounded toward zero) 32-bit integers, returned in a 64-bit vector of [2 x i32].

If a converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the CVTTPS2PI / VTTPS2PI instructions.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 64-bit integer vector containing the converted values.

Definition at line 1579 of file xmmintrin.h.

References __a, __trunc64, and __zeroupper64.

Referenced by _mm_cvtt_ps2pi().

◆ _mm_cvttss_si32()

static __inline__ int __DEFAULT_FN_ATTRS _mm_cvttss_si32 ( __m128 __a )

static

Converts the lower (first) element of a vector of [4 x float] into a signed truncated (rounded toward zero) 32-bit integer.

If the converted value does not fit in a 32-bit integer, raises a floating-point invalid exception. If the exception is masked, returns the most negative integer.

This intrinsic corresponds to the VCVTTSS2SI / CVTTSS2SI instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the conversion.

Returns: A 32-bit integer containing the converted value.

Definition at line 1511 of file xmmintrin.h.

References __a.

Referenced by _mm_cvtt_ss2si().

◆ _mm_div_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_div_ps	(	__m128	__a,
		__m128	__b
	)

static

Divides two 128-bit vectors of [4 x float].

This intrinsic corresponds to the VDIVPS / DIVPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing the dividend.
__b	A 128-bit vector of [4 x float] containing the divisor.

Returns: A 128-bit vector of [4 x float] containing the quotients of both operands.

Definition at line 226 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_div_ps(), and _mm_maskz_div_ps().

◆ _mm_div_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_div_ss	(	__m128	__a,
		__m128	__b
	)

static

Divides the value in the low-order 32 bits of the first operand by the corresponding value in the second operand.

This intrinsic corresponds to the VDIVSS / DIVSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing the dividend. The lower 32 bits of this operand are used in the calculation.
__b	A 128-bit vector of [4 x float] containing the divisor. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] containing the quotients of the lower 32 bits of both operands. The upper 96 bits are copied from the upper 96 bits of the first source operand.

Definition at line 208 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_div_ss(), and _mm_maskz_div_ss().

◆ _mm_getcsr()

unsigned int _mm_getcsr ( void )

Returns the contents of the MXCSR register as a 32-bit unsigned integer value.

There are several groups of macros associated with this intrinsic, including:

For checking exception states: _MM_EXCEPT_INVALID, _MM_EXCEPT_DIV_ZERO, _MM_EXCEPT_DENORM, _MM_EXCEPT_OVERFLOW, _MM_EXCEPT_UNDERFLOW, _MM_EXCEPT_INEXACT. There is a convenience wrapper _MM_GET_EXCEPTION_STATE().
For checking exception masks: _MM_MASK_UNDERFLOW, _MM_MASK_OVERFLOW, _MM_MASK_INVALID, _MM_MASK_DENORM, _MM_MASK_DIV_ZERO, _MM_MASK_INEXACT. There is a convenience wrapper _MM_GET_EXCEPTION_MASK().
For checking rounding modes: _MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO. There is a convenience wrapper _MM_GET_ROUNDING_MODE().
For checking flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF. There is a convenience wrapper _MM_GET_FLUSH_ZERO_MODE().
For checking denormals-are-zero mode: _MM_DENORMALS_ZERO_ON, _MM_DENORMALS_ZERO_OFF. There is a convenience wrapper _MM_GET_DENORMALS_ZERO_MODE().

For example, the following expression checks if an overflow exception has occurred:

( _mm_getcsr() & _MM_EXCEPT_OVERFLOW )

_MM_EXCEPT_OVERFLOW

#define _MM_EXCEPT_OVERFLOW

Definition: xmmintrin.h:3124

_mm_getcsr

unsigned int _mm_getcsr(void)

Returns the contents of the MXCSR register as a 32-bit unsigned integer value.

The following expression gets the current rounding mode:

_MM_GET_ROUNDING_MODE()

_MM_GET_ROUNDING_MODE

#define _MM_GET_ROUNDING_MODE()

Definition: xmmintrin.h:3150

This intrinsic corresponds to the VSTMXCSR / STMXCSR instruction.

Returns: A 32-bit unsigned integer containing the contents of the MXCSR register.

◆ _mm_load1_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_load1_ps ( const float * __p )

static

Loads a 32-bit float value and duplicates it to all four vector elements of a 128-bit vector of [4 x float].

This intrinsic corresponds to the VBROADCASTSS / MOVSS + shuffling instruction.

Parameters

__p	A pointer to a float value to be loaded and duplicated.

Returns: A 128-bit vector of [4 x float] containing the loaded and duplicated values.

Definition at line 1831 of file xmmintrin.h.

References __p.

◆ _mm_load_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_load_ps ( const float * __p )

static

Loads a 128-bit floating-point vector of [4 x float] from an aligned memory location.

This intrinsic corresponds to the VMOVAPS / MOVAPS instruction.

Parameters

__p	A pointer to a 128-bit memory location. The address of the memory location has to be 128-bit aligned.

Returns: A 128-bit vector of [4 x float] containing the loaded values.

Definition at line 1854 of file xmmintrin.h.

References __p.

Referenced by _mm_loadr_ps().

◆ _mm_load_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_load_ss ( const float * __p )

static

Constructs a 128-bit floating-point vector of [4 x float].

The lower 32 bits of the vector are initialized with the single-precision floating-point value loaded from a specified memory location. The upper 96 bits are set to zero.

This intrinsic corresponds to the VMOVSS / MOVSS instruction.

Parameters

__p	A pointer to a 32-bit memory location containing a single-precision floating-point value.

Returns: An initialized 128-bit floating-point vector of [4 x float]. The lower 32 bits contain the value loaded from the memory location. The upper 96 bits are set to zero.

Definition at line 1809 of file xmmintrin.h.

References __p.

◆ _mm_loadh_pi()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadh_pi	(	__m128	__a,
		const __m64 *	__p
	)

static

Loads two packed float values from the address __p into the high-order bits of a 128-bit vector of [4 x float].

The low-order bits are copied from the low-order bits of the first operand.

This intrinsic corresponds to the VMOVHPD / MOVHPD instruction.

Parameters

__a	A 128-bit vector of [4 x float]. Bits [63:0] are written to bits [63:0] of the destination.
__p	A pointer to two packed float values. Bits [63:0] are written to bits [127:64] of the destination.

Returns: A 128-bit vector of [4 x float] containing the moved values.

Definition at line 1755 of file xmmintrin.h.

References __a, __b, and __p.

◆ _mm_loadl_pi()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadl_pi	(	__m128	__a,
		const __m64 *	__p
	)

static

Loads two packed float values from the address __p into the low-order bits of a 128-bit vector of [4 x float].

The high-order bits are copied from the high-order bits of the first operand.

This intrinsic corresponds to the VMOVLPD / MOVLPD instruction.

Parameters

__a	A 128-bit vector of [4 x float]. Bits [127:64] are written to bits [127:64] of the destination.
__p	A pointer to two packed float values. Bits [63:0] are written to bits [63:0] of the destination.

Returns: A 128-bit vector of [4 x float] containing the moved values.

Definition at line 1782 of file xmmintrin.h.

References __a, __b, and __p.

◆ _mm_loadr_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadr_ps ( const float * __p )

static

Loads four packed float values, in reverse order, from an aligned memory location to 32-bit elements in a 128-bit vector of [4 x float].

This intrinsic corresponds to the VMOVAPS / MOVAPS + shuffling instruction.

Parameters

__p	A pointer to a 128-bit memory location. The address of the memory location has to be 128-bit aligned.

Returns: A 128-bit vector of [4 x float] containing the moved values, loaded in reverse order.

Definition at line 1893 of file xmmintrin.h.

References __a, __p, and _mm_load_ps().

◆ _mm_loadu_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_loadu_ps ( const float * __p )

static

Loads a 128-bit floating-point vector of [4 x float] from an unaligned memory location.

This intrinsic corresponds to the VMOVUPS / MOVUPS instruction.

Parameters

__p	A pointer to a 128-bit memory location. The address of the memory location does not have to be aligned.

Returns: A 128-bit vector of [4 x float] containing the loaded values.

Definition at line 1871 of file xmmintrin.h.

References __p, and __v.

Referenced by _mm256_broadcast_ps(), and _mm256_loadu2_m128().

◆ _mm_maskmove_si64()

static __inline__ void __DEFAULT_FN_ATTRS_SSE2 _mm_maskmove_si64	(	__m64	__d,
		__m64	__n,
		char *	__p
	)

static

Conditionally copies the values from each 8-bit element in the first 64-bit integer vector operand to the specified memory location, as specified by the most significant bit in the corresponding element in the second 64-bit integer vector operand.

To minimize caching, the data is flagged as non-temporal (unlikely to be used again soon).

This intrinsic corresponds to the MASKMOVQ instruction.

Parameters

__d	A 64-bit integer vector containing the values with elements to be copied.
__n	A 64-bit integer vector operand. The most significant bit from each 8-bit element determines whether the corresponding element in operand __d is copied. If the most significant bit of a given element is 1, the corresponding element in operand __d is copied.
__p	A pointer to a 64-bit memory location that will receive the conditionally copied integer values. The address of the memory location does not have to be aligned.

Definition at line 2519 of file xmmintrin.h.

References __anyext128, __p, and __zext128.

◆ _mm_max_pi16()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_max_pi16	(	__m64	__a,
		__m64	__b
	)

static

Compares each of the corresponding packed 16-bit integer values of the 64-bit integer vectors, and writes the greater value to the corresponding bits in the destination.

This intrinsic corresponds to the PMAXSW instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the comparison results.

Definition at line 2356 of file xmmintrin.h.

References __a, and __b.

◆ _mm_max_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_max_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares two 128-bit vectors of [4 x float] and returns the greater of each pair of values.

If either value in a comparison is NaN, returns the value from __b.

This intrinsic corresponds to the VMAXPS / MAXPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands.
__b	A 128-bit vector of [4 x float] containing one of the operands.

Returns: A 128-bit vector of [4 x float] containing the maximum values between both operands.

Definition at line 423 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_max_ps(), and _mm_maskz_max_ps().

◆ _mm_max_pu8()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_max_pu8	(	__m64	__a,
		__m64	__b
	)

static

Compares each of the corresponding packed 8-bit unsigned integer values of the 64-bit integer vectors, and writes the greater value to the corresponding bits in the destination.

This intrinsic corresponds to the PMAXUB instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the comparison results.

Definition at line 2375 of file xmmintrin.h.

References __a, and __b.

◆ _mm_max_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_max_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands and returns the greater value in the low-order bits of a 128-bit vector of [4 x float].

If either value in a comparison is NaN, returns the value from __b.

This intrinsic corresponds to the VMAXSS / MAXSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] whose lower 32 bits contain the maximum value between both operands. The upper 96 bits are copied from the upper 96 bits of the first source operand.

Definition at line 402 of file xmmintrin.h.

References __a, and __b.

◆ _mm_min_pi16()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_min_pi16	(	__m64	__a,
		__m64	__b
	)

static

Compares each of the corresponding packed 16-bit integer values of the 64-bit integer vectors, and writes the lesser value to the corresponding bits in the destination.

This intrinsic corresponds to the PMINSW instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the comparison results.

Definition at line 2394 of file xmmintrin.h.

References __a, and __b.

◆ _mm_min_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_min_ps	(	__m128	__a,
		__m128	__b
	)

static

Compares two 128-bit vectors of [4 x float] and returns the lesser of each pair of values.

If either value in a comparison is NaN, returns the value from __b.

This intrinsic corresponds to the VMINPS / MINPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands.
__b	A 128-bit vector of [4 x float] containing one of the operands.

Returns: A 128-bit vector of [4 x float] containing the minimum values between both operands.

Definition at line 377 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_min_ps(), and _mm_maskz_min_ps().

◆ _mm_min_pu8()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_min_pu8	(	__m64	__a,
		__m64	__b
	)

static

Compares each of the corresponding packed 8-bit unsigned integer values of the 64-bit integer vectors, and writes the lesser value to the corresponding bits in the destination.

This intrinsic corresponds to the PMINUB instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the comparison results.

Definition at line 2413 of file xmmintrin.h.

References __a, and __b.

◆ _mm_min_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_min_ss	(	__m128	__a,
		__m128	__b
	)

static

Compares two 32-bit float values in the low-order bits of both operands and returns the lesser value in the low-order bits of the vector of [4 x float].

If either value in a comparison is NaN, returns the value from __b.

This intrinsic corresponds to the VMINSS / MINSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float] containing one of the operands. The lower 32 bits of this operand are used in the comparison.

Returns: A 128-bit vector of [4 x float] whose lower 32 bits contain the minimum value between both operands. The upper 96 bits are copied from the upper 96 bits of the first source operand.

Definition at line 356 of file xmmintrin.h.

References __a, and __b.

◆ _mm_move_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_move_ss	(	__m128	__a,
		__m128	__b
	)

static

Constructs a 128-bit floating-point vector of [4 x float].

The lower 32 bits are set to the lower 32 bits of the second parameter. The upper 96 bits are set to the upper 96 bits of the first parameter.

This intrinsic corresponds to the VBLENDPS / BLENDPS / MOVSS instruction.

Parameters

__a	A 128-bit floating-point vector of [4 x float]. The upper 96 bits are written to the upper 96 bits of the result.
__b	A 128-bit floating-point vector of [4 x float]. The lower 32 bits are written to the lower 32 bits of the result.

Returns: A 128-bit floating-point vector of [4 x float].

Definition at line 2818 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_move_ss(), and _mm_maskz_move_ss().

◆ _mm_movehl_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_movehl_ps	(	__m128	__a,
		__m128	__b
	)

static

Constructs a 128-bit floating-point vector of [4 x float].

The lower 64 bits are set to the upper 64 bits of the second parameter. The upper 64 bits are set to the upper 64 bits of the first parameter.

This intrinsic corresponds to the VUNPCKHPD / UNPCKHPD instruction.

Parameters

__a	A 128-bit floating-point vector of [4 x float]. The upper 64 bits are written to the upper 64 bits of the result.
__b	A 128-bit floating-point vector of [4 x float]. The upper 64 bits are written to the lower 64 bits of the result.

Returns: A 128-bit floating-point vector of [4 x float].

Definition at line 2839 of file xmmintrin.h.

References __a, and __b.

◆ _mm_movelh_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_movelh_ps	(	__m128	__a,
		__m128	__b
	)

static

Constructs a 128-bit floating-point vector of [4 x float].

The lower 64 bits are set to the lower 64 bits of the first parameter. The upper 64 bits are set to the lower 64 bits of the second parameter.

This intrinsic corresponds to the VUNPCKLPD / UNPCKLPD instruction.

Parameters

__a	A 128-bit floating-point vector of [4 x float]. The lower 64 bits are written to the lower 64 bits of the result.
__b	A 128-bit floating-point vector of [4 x float]. The lower 64 bits are written to the upper 64 bits of the result.

Returns: A 128-bit floating-point vector of [4 x float].

Definition at line 2859 of file xmmintrin.h.

References __a, and __b.

◆ _mm_movemask_pi8()

static __inline__ int __DEFAULT_FN_ATTRS_SSE2 _mm_movemask_pi8 ( __m64 __a )

static

Takes the most significant bit from each 8-bit element in a 64-bit integer vector to create an 8-bit mask value.

Zero-extends the value to 32-bit integer and writes it to the destination.

This intrinsic corresponds to the PMOVMSKB instruction.

Parameters

__a	A 64-bit integer vector containing the values with bits to be extracted.

Returns: The most significant bit from each 8-bit element in __a, written to bits [7:0].

Definition at line 2431 of file xmmintrin.h.

References __a, and __zext128.

◆ _mm_movemask_ps()

static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_ps ( __m128 __a )

static

Extracts the sign bits from each single-precision floating-point element of a 128-bit floating-point vector of [4 x float] and returns the sign bits in bits [0:3] of the result.

Bits [31:4] of the result are set to zero.

This intrinsic corresponds to the VMOVMSKPS / MOVMSKPS instruction.

Parameters

__a	A 128-bit floating-point vector of [4 x float].

Returns: A 32-bit integer value. Bits [3:0] contain the sign bits from each single-precision floating-point element of the parameter. Bits [31:4] are set to zero.

Definition at line 3032 of file xmmintrin.h.

References __a.

◆ _mm_mul_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_mul_ps	(	__m128	__a,
		__m128	__b
	)

static

Multiplies two 128-bit vectors of [4 x float] and returns the results of the multiplication.

This intrinsic corresponds to the VMULPS / MULPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the source operands.
__b	A 128-bit vector of [4 x float] containing one of the source operands.

Returns: A 128-bit vector of [4 x float] containing the products of both operands.

Definition at line 187 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_mul_ps(), and _mm_maskz_mul_ps().

◆ _mm_mul_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_mul_ss	(	__m128	__a,
		__m128	__b
	)

static

Multiplies two 32-bit float values in the low-order bits of the operands.

This intrinsic corresponds to the VMULSS / MULSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the source operands. The lower 32 bits of this operand are used in the calculation.
__b	A 128-bit vector of [4 x float] containing one of the source operands. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] containing the product of the lower 32 bits of both operands. The upper 96 bits are copied from the upper 96 bits of the first source operand.

Definition at line 168 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_mul_ss(), and _mm_maskz_mul_ss().

◆ _mm_mulhi_pu16()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_mulhi_pu16	(	__m64	__a,
		__m64	__b
	)

static

Multiplies packed 16-bit unsigned integer values and writes the high-order 16 bits of each 32-bit product to the corresponding bits in the destination.

This intrinsic corresponds to the PMULHUW instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector containing the products of both operands.

Definition at line 2450 of file xmmintrin.h.

References __a, __anyext128, __b, and __trunc64.

◆ _mm_or_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_or_ps	(	__m128	__a,
		__m128	__b
	)

static

Performs a bitwise OR of two 128-bit vectors of [4 x float].

This intrinsic corresponds to the VORPS / ORPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the source operands.
__b	A 128-bit vector of [4 x float] containing one of the source operands.

Returns: A 128-bit vector of [4 x float] containing the bitwise OR of the values between both operands.

Definition at line 479 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_or_ps(), and _mm_maskz_or_ps().

◆ _mm_rcp_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rcp_ps ( __m128 __a )

static

Calculates the approximate reciprocals of the values stored in a 128-bit vector of [4 x float].

This intrinsic corresponds to the VRCPPS / RCPPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the approximate reciprocals of the values in the operand.

Definition at line 295 of file xmmintrin.h.

References __a.

◆ _mm_rcp_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rcp_ss ( __m128 __a )

static

Calculates the approximate reciprocal of the value stored in the low-order bits of a 128-bit vector of [4 x float].

This intrinsic corresponds to the VRCPSS / RCPSS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] containing the approximate reciprocal of the value in the low-order bits of the operand.

Definition at line 278 of file xmmintrin.h.

References __a.

◆ _mm_rsqrt_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rsqrt_ps ( __m128 __a )

static

Calculates the approximate reciprocals of the square roots of the values stored in a 128-bit vector of [4 x float].

This intrinsic corresponds to the VRSQRTPS / RSQRTPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the approximate reciprocals of the square roots of the values in the operand.

Definition at line 331 of file xmmintrin.h.

References __a.

◆ _mm_rsqrt_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_rsqrt_ss ( __m128 __a )

static

Calculates the approximate reciprocal of the square root of the value stored in the low-order bits of a 128-bit vector of [4 x float].

This intrinsic corresponds to the VRSQRTSS / RSQRTSS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] containing the approximate reciprocal of the square root of the value in the low-order bits of the operand.

Definition at line 314 of file xmmintrin.h.

References __a.

◆ _mm_sad_pu8()

static __inline__ __m64 __DEFAULT_FN_ATTRS_SSE2 _mm_sad_pu8	(	__m64	__a,
		__m64	__b
	)

static

Subtracts the corresponding 8-bit unsigned integer values of the two 64-bit vector operands and computes the absolute value for each of the difference.

Then sum of the 8 absolute differences is written to the bits [15:0] of the destination; the remaining bits [63:16] are cleared.

This intrinsic corresponds to the PSADBW instruction.

Parameters

__a	A 64-bit integer vector containing one of the source operands.
__b	A 64-bit integer vector containing one of the source operands.

Returns: A 64-bit integer vector whose lower 16 bits contain the sums of the sets of absolute differences between both operands. The upper bits are cleared.

Definition at line 2596 of file xmmintrin.h.

References __a, __b, __trunc64, and __zext128.

◆ _mm_set1_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_set1_ps ( float __w )

static

Constructs a 128-bit floating-point vector of [4 x float], with each of the four single-precision floating-point vector elements set to the specified single-precision floating-point value.

This intrinsic corresponds to the VPERMILPS / PERMILPS instruction.

Parameters

__w	A single-precision floating-point value used to initialize each vector element of the result.

Returns: An initialized 128-bit floating-point vector of [4 x float].

Definition at line 1944 of file xmmintrin.h.

Referenced by _mm_set_ps1().

◆ _mm_set_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_set_ps	(	float	__z,
		float	__y,
		float	__x,
		float	__w
	)

static

Constructs a 128-bit floating-point vector of [4 x float] initialized with the specified single-precision floating-point values.

This intrinsic is a utility function and does not correspond to a specific instruction.

Parameters

__z	A single-precision floating-point value used to initialize bits [127:96] of the result.
__y	A single-precision floating-point value used to initialize bits [95:64] of the result.
__x	A single-precision floating-point value used to initialize bits [63:32] of the result.
__w	A single-precision floating-point value used to initialize bits [31:0] of the result.

Returns: An initialized 128-bit floating-point vector of [4 x float].

Definition at line 1988 of file xmmintrin.h.

References __y.

◆ _mm_set_ps1()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_set_ps1 ( float __w )

static

Constructs a 128-bit floating-point vector of [4 x float], with each of the four single-precision floating-point vector elements set to the specified single-precision floating-point value.

This intrinsic corresponds to the VPERMILPS / PERMILPS instruction.

Parameters

__w	A single-precision floating-point value used to initialize each vector element of the result.

Returns: An initialized 128-bit floating-point vector of [4 x float].

Definition at line 1962 of file xmmintrin.h.

References _mm_set1_ps().

◆ _mm_set_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_set_ss ( float __w )

static

Constructs a 128-bit floating-point vector of [4 x float].

The lower 32 bits of the vector are initialized with the specified single-precision floating-point value. The upper 96 bits are set to zero.

This intrinsic corresponds to the VMOVSS / MOVSS instruction.

Parameters

__w	A single-precision floating-point value used to initialize the lower 32 bits of the result.

Returns: An initialized 128-bit floating-point vector of [4 x float]. The lower 32 bits contain the value provided in the source operand. The upper 96 bits are set to zero.

Definition at line 1927 of file xmmintrin.h.

◆ _mm_setcsr()

void _mm_setcsr ( unsigned int __i )

Sets the MXCSR register with the 32-bit unsigned integer value.

There are several groups of macros associated with this intrinsic, including:

For setting exception states: _MM_EXCEPT_INVALID, _MM_EXCEPT_DIV_ZERO, _MM_EXCEPT_DENORM, _MM_EXCEPT_OVERFLOW, _MM_EXCEPT_UNDERFLOW, _MM_EXCEPT_INEXACT. There is a convenience wrapper _MM_SET_EXCEPTION_STATE(x) where x is one of these macros.
For setting exception masks: _MM_MASK_UNDERFLOW, _MM_MASK_OVERFLOW, _MM_MASK_INVALID, _MM_MASK_DENORM, _MM_MASK_DIV_ZERO, _MM_MASK_INEXACT. There is a convenience wrapper _MM_SET_EXCEPTION_MASK(x) where x is one of these macros.
For setting rounding modes: _MM_ROUND_NEAREST, _MM_ROUND_DOWN, _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO. There is a convenience wrapper _MM_SET_ROUNDING_MODE(x) where x is one of these macros.
For setting flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF. There is a convenience wrapper _MM_SET_FLUSH_ZERO_MODE(x) where x is one of these macros.
For setting denormals-are-zero mode: _MM_DENORMALS_ZERO_ON, _MM_DENORMALS_ZERO_OFF. There is a convenience wrapper _MM_SET_DENORMALS_ZERO_MODE(x) where x is one of these macros.

For example, the following expression causes subsequent floating-point operations to round up: _mm_setcsr(_mm_getcsr() | _MM_ROUND_UP)

The following example sets the DAZ and FTZ flags:

void setFlags() {
  _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
  _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
}

This intrinsic corresponds to the VLDMXCSR / LDMXCSR instruction.

Parameters

__i	A 32-bit unsigned integer value to be written to the MXCSR register.

◆ _mm_setr_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_setr_ps	(	float	__z,
		float	__y,
		float	__x,
		float	__w
	)

static

Constructs a 128-bit floating-point vector of [4 x float], initialized in reverse order with the specified 32-bit single-precision float-point values.

This intrinsic is a utility function and does not correspond to a specific instruction.

Parameters

__z	A single-precision floating-point value used to initialize bits [31:0] of the result.
__y	A single-precision floating-point value used to initialize bits [63:32] of the result.
__x	A single-precision floating-point value used to initialize bits [95:64] of the result.
__w	A single-precision floating-point value used to initialize bits [127:96] of the result.

Returns: An initialized 128-bit floating-point vector of [4 x float].

Definition at line 2015 of file xmmintrin.h.

References __y.

◆ _mm_setzero_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_setzero_ps ( void )

static

Constructs a 128-bit floating-point vector of [4 x float] initialized to zero.

This intrinsic corresponds to the VXORPS / XORPS instruction.

Returns: An initialized 128-bit floating-point vector of [4 x float] with all elements set to zero.

Definition at line 2029 of file xmmintrin.h.

Referenced by _mm256_maskz_cvtepi64_ps(), _mm256_maskz_cvtepu64_ps(), _mm256_maskz_cvtpd_ps(), _mm256_zextps128_ps256(), _mm512_zextps128_ps512(), _mm_cvtepi64_ps(), _mm_cvtepu64_ps(), _mm_cvtps_pi16(), _mm_getexp_ps(), _mm_getexp_ss(), _mm_mask_load_ss(), _mm_maskz_add_ps(), _mm_maskz_add_ss(), _mm_maskz_and_ps(), _mm_maskz_andnot_ps(), _mm_maskz_broadcastss_ps(), _mm_maskz_compress_ps(), _mm_maskz_cvtepi32_ps(), _mm_maskz_cvtepi64_ps(), _mm_maskz_cvtepu32_ps(), _mm_maskz_cvtepu64_ps(), _mm_maskz_cvtpd_ps(), _mm_maskz_cvtph_ps(), _mm_maskz_cvtsd_ss(), _mm_maskz_div_ps(), _mm_maskz_div_ss(), _mm_maskz_expand_ps(), _mm_maskz_expandloadu_ps(), _mm_maskz_fmadd_ps(), _mm_maskz_fmaddsub_ps(), _mm_maskz_fmsub_ps(), _mm_maskz_fmsubadd_ps(), _mm_maskz_fnmadd_ps(), _mm_maskz_fnmsub_ps(), _mm_maskz_getexp_ps(), _mm_maskz_getexp_ss(), _mm_maskz_load_ps(), _mm_maskz_load_ss(), _mm_maskz_loadu_ps(), _mm_maskz_max_ps(), _mm_maskz_max_ss(), _mm_maskz_min_ps(), _mm_maskz_min_ss(), _mm_maskz_mov_ps(), _mm_maskz_move_ss(), _mm_maskz_movehdup_ps(), _mm_maskz_moveldup_ps(), _mm_maskz_mul_ps(), _mm_maskz_mul_ss(), _mm_maskz_or_ps(), _mm_maskz_permutevar_ps(), _mm_maskz_permutex2var_ps(), _mm_maskz_rcp14_ps(), _mm_maskz_rcp14_ss(), _mm_maskz_rsqrt14_ps(), _mm_maskz_rsqrt14_ss(), _mm_maskz_scalef_ps(), _mm_maskz_scalef_ss(), _mm_maskz_sqrt_ps(), _mm_maskz_sqrt_ss(), _mm_maskz_sub_ps(), _mm_maskz_sub_ss(), _mm_maskz_unpackhi_ps(), _mm_maskz_unpacklo_ps(), _mm_maskz_xor_ps(), _mm_rcp14_ps(), _mm_rcp14_ss(), _mm_rsqrt14_ps(), _mm_rsqrt14_ss(), _mm_scalef_ps(), and _mm_scalef_ss().

◆ _mm_sfence()

void _mm_sfence ( void )

Forces strong memory ordering (serialization) between store instructions preceding this instruction and store instructions following this instruction, ensuring the system completes all previous stores before executing subsequent stores.

This intrinsic corresponds to the SFENCE instruction.

◆ _mm_sqrt_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_sqrt_ps ( __m128 __a )

static

Calculates the square roots of the values stored in a 128-bit vector of [4 x float].

This intrinsic corresponds to the VSQRTPS / SQRTPS instructions.

Parameters

__a	A 128-bit vector of [4 x float].

Returns: A 128-bit vector of [4 x float] containing the square roots of the values in the operand.

Definition at line 260 of file xmmintrin.h.

References __a.

Referenced by _mm_mask_sqrt_ps(), and _mm_maskz_sqrt_ps().

◆ _mm_sqrt_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_sqrt_ss ( __m128 __a )

static

Calculates the square root of the value stored in the low-order bits of a 128-bit vector of [4 x float].

This intrinsic corresponds to the VSQRTSS / SQRTSS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] containing the square root of the value in the low-order bits of the operand.

Definition at line 243 of file xmmintrin.h.

References __a.

◆ _mm_store1_ps()

static __inline__ void __DEFAULT_FN_ATTRS _mm_store1_ps	(	float *	__p,
		__m128	__a
	)

static

Stores the lower 32 bits of a 128-bit vector of [4 x float] into four contiguous elements in an aligned memory location.

This intrinsic corresponds to VMOVAPS / MOVAPS + shuffling instruction.

Parameters

__p	A pointer to a 128-bit memory location.
__a	A 128-bit vector of [4 x float] whose lower 32 bits are stored to each of the four contiguous elements pointed by __p.

Definition at line 2148 of file xmmintrin.h.

References __a, __p, and _mm_store_ps().

Referenced by _mm_store_ps1().

◆ _mm_store_ps()

static __inline__ void __DEFAULT_FN_ATTRS _mm_store_ps	(	float *	__p,
		__m128	__a
	)

static

Stores a 128-bit vector of [4 x float] into an aligned memory location.

This intrinsic corresponds to the VMOVAPS / MOVAPS instruction.

Parameters

__p	A pointer to a 128-bit memory location. The address of the memory location has to be 16-byte aligned.
__a	A 128-bit vector of [4 x float] containing the values to be stored.

Definition at line 2129 of file xmmintrin.h.

References __a, and __p.

Referenced by _mm_store1_ps(), and _mm_storer_ps().

◆ _mm_store_ps1()

static __inline__ void __DEFAULT_FN_ATTRS _mm_store_ps1	(	float *	__p,
		__m128	__a
	)

static

Stores the lower 32 bits of a 128-bit vector of [4 x float] into four contiguous elements in an aligned memory location.

This intrinsic corresponds to VMOVAPS / MOVAPS + shuffling instruction.

Parameters

__p	A pointer to a 128-bit memory location.
__a	A 128-bit vector of [4 x float] whose lower 32 bits are stored to each of the four contiguous elements pointed by __p.

Definition at line 2168 of file xmmintrin.h.

References __a, __p, and _mm_store1_ps().

◆ _mm_store_ss()

static __inline__ void __DEFAULT_FN_ATTRS _mm_store_ss	(	float *	__p,
		__m128	__a
	)

static

Stores the lower 32 bits of a 128-bit vector of [4 x float] to a memory location.

This intrinsic corresponds to the VMOVSS / MOVSS instruction.

Parameters

__p	A pointer to a 32-bit memory location.
__a	A 128-bit vector of [4 x float] containing the value to be stored.

Definition at line 2087 of file xmmintrin.h.

References __a, and __p.

◆ _mm_storeh_pi()

static __inline__ void __DEFAULT_FN_ATTRS _mm_storeh_pi	(	__m64 *	__p,
		__m128	__a
	)

static

Stores the upper 64 bits of a 128-bit vector of [4 x float] to a memory location.

This intrinsic corresponds to the VPEXTRQ / PEXTRQ instruction.

Parameters

__p	A pointer to a 64-bit memory location.
__a	A 128-bit vector of [4 x float] containing the values to be stored.

Definition at line 2045 of file xmmintrin.h.

References __a, and __p.

◆ _mm_storel_pi()

static __inline__ void __DEFAULT_FN_ATTRS _mm_storel_pi	(	__m64 *	__p,
		__m128	__a
	)

static

Stores the lower 64 bits of a 128-bit vector of [4 x float] to a memory location.

This intrinsic corresponds to the VMOVLPS / MOVLPS instruction.

Parameters

__p	A pointer to a memory location that will receive the float values.
__a	A 128-bit vector of [4 x float] containing the values to be stored.

Definition at line 2066 of file xmmintrin.h.

References __a, and __p.

◆ _mm_storer_ps()

static __inline__ void __DEFAULT_FN_ATTRS _mm_storer_ps	(	float *	__p,
		__m128	__a
	)

static

Stores float values from a 128-bit vector of [4 x float] to an aligned memory location in reverse order.

This intrinsic corresponds to the VMOVAPS / MOVAPS + shuffling instruction.

Parameters

__p	A pointer to a 128-bit memory location. The address of the memory location has to be 128-bit aligned.
__a	A 128-bit vector of [4 x float] containing the values to be stored.

Definition at line 2187 of file xmmintrin.h.

References __a, __p, and _mm_store_ps().

◆ _mm_storeu_ps()

static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_ps	(	float *	__p,
		__m128	__a
	)

static

Stores a 128-bit vector of [4 x float] to an unaligned memory location.

This intrinsic corresponds to the VMOVUPS / MOVUPS instruction.

Parameters

__p	A pointer to a 128-bit memory location. The address of the memory location does not have to be aligned.
__a	A 128-bit vector of [4 x float] containing the values to be stored.

Definition at line 2108 of file xmmintrin.h.

References __a, __p, and __v.

Referenced by _mm256_storeu2_m128().

◆ _mm_stream_pi()

static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_pi	(	void *	__p,
		__m64	__a
	)

static

Stores a 64-bit integer in the specified aligned memory location.

To minimize caching, the data is flagged as non-temporal (unlikely to be used again soon).

This intrinsic corresponds to the MOVNTQ instruction.

Parameters

__p	A pointer to an aligned memory location used to store the register value.
__a	A 64-bit integer containing the value to be stored.

Definition at line 2245 of file xmmintrin.h.

References __a, and __p.

◆ _mm_stream_ps()

static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_ps	(	void *	__p,
		__m128	__a
	)

static

Moves packed float values from a 128-bit vector of [4 x float] to a 128-bit aligned memory location.

To minimize caching, the data is flagged as non-temporal (unlikely to be used again soon).

This intrinsic corresponds to the VMOVNTPS / MOVNTPS instruction.

Parameters

__p	A pointer to a 128-bit aligned memory location that will receive the single-precision floating-point values.
__a	A 128-bit vector of [4 x float] containing the values to be moved.

Definition at line 2264 of file xmmintrin.h.

References __a, and __p.

◆ _mm_sub_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_sub_ps	(	__m128	__a,
		__m128	__b
	)

static

Subtracts each of the values of the second operand from the first operand, both of which are 128-bit vectors of [4 x float] and returns the results of the subtraction.

This intrinsic corresponds to the VSUBPS / SUBPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing the minuend.
__b	A 128-bit vector of [4 x float] containing the subtrahend.

Returns: A 128-bit vector of [4 x float] containing the differences between both operands.

Definition at line 147 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_sub_ps(), and _mm_maskz_sub_ps().

◆ _mm_sub_ss()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_sub_ss	(	__m128	__a,
		__m128	__b
	)

static

Subtracts the 32-bit float value in the low-order bits of the second operand from the corresponding value in the first operand.

This intrinsic corresponds to the VSUBSS / SUBSS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing the minuend. The lower 32 bits of this operand are used in the calculation.
__b	A 128-bit vector of [4 x float] containing the subtrahend. The lower 32 bits of this operand are used in the calculation.

Returns: A 128-bit vector of [4 x float] whose lower 32 bits contain the difference of the lower 32 bits of both operands. The upper 96 bits are copied from the upper 96 bits of the first source operand.

Definition at line 127 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_sub_ss(), and _mm_maskz_sub_ss().

◆ _mm_ucomieq_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_ss	(	__m128	__a,
		__m128	__b
	)

static

Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine equality.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VUCOMISS / UCOMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1260 of file xmmintrin.h.

References __a, and __b.

◆ _mm_ucomige_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_ss	(	__m128	__a,
		__m128	__b
	)

static

Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is greater than or equal to the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VUCOMISS / UCOMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1356 of file xmmintrin.h.

References __a, and __b.

◆ _mm_ucomigt_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_ss	(	__m128	__a,
		__m128	__b
	)

static

Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is greater than the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VUCOMISS / UCOMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1332 of file xmmintrin.h.

References __a, and __b.

◆ _mm_ucomile_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_ss	(	__m128	__a,
		__m128	__b
	)

static

Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is less than or equal to the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VUCOMISS / UCOMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1308 of file xmmintrin.h.

References __a, and __b.

◆ _mm_ucomilt_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_ss	(	__m128	__a,
		__m128	__b
	)

static

Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine if the first operand is less than the second operand.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VUCOMISS / UCOMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1284 of file xmmintrin.h.

References __a, and __b.

◆ _mm_ucomineq_ss()

static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomineq_ss	(	__m128	__a,
		__m128	__b
	)

static

Performs an unordered comparison of two 32-bit float values using the low-order bits of both operands to determine inequality.

The comparison returns 0 for false, 1 for true. If either value in a comparison is NaN, returns 0.

This intrinsic corresponds to the VUCOMISS / UCOMISS instructions.

Parameters

__a	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.
__b	A 128-bit vector of [4 x float]. The lower 32 bits of this operand are used in the comparison.

Returns: An integer containing the comparison results.

Definition at line 1379 of file xmmintrin.h.

References __a, and __b.

◆ _mm_undefined_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_undefined_ps ( void )

static

Create a 128-bit vector of [4 x float] with undefined values.

This intrinsic has no corresponding instruction.

Returns: A 128-bit vector of [4 x float] containing undefined values.

Definition at line 1907 of file xmmintrin.h.

◆ _mm_unpackhi_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_unpackhi_ps	(	__m128	__a,
		__m128	__b
	)

static

Unpacks the high-order (index 2,3) values from two 128-bit vectors of [4 x float] and interleaves them into a 128-bit vector of [4 x float].

This intrinsic corresponds to the VUNPCKHPS / UNPCKHPS instruction.

Parameters

__a	A 128-bit vector of [4 x float]. Bits [95:64] are written to bits [31:0] of the destination. Bits [127:96] are written to bits [95:64] of the destination.
__b	A 128-bit vector of [4 x float]. Bits [95:64] are written to bits [63:32] of the destination. Bits [127:96] are written to bits [127:96] of the destination.

Returns: A 128-bit vector of [4 x float] containing the interleaved values.

Definition at line 2776 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_unpackhi_ps(), and _mm_maskz_unpackhi_ps().

◆ _mm_unpacklo_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_unpacklo_ps	(	__m128	__a,
		__m128	__b
	)

static

Unpacks the low-order (index 0,1) values from two 128-bit vectors of [4 x float] and interleaves them into a 128-bit vector of [4 x float].

This intrinsic corresponds to the VUNPCKLPS / UNPCKLPS instruction.

Parameters

__a	A 128-bit vector of [4 x float]. Bits [31:0] are written to bits [31:0] of the destination. Bits [63:32] are written to bits [95:64] of the destination.
__b	A 128-bit vector of [4 x float]. Bits [31:0] are written to bits [63:32] of the destination. Bits [63:32] are written to bits [127:96] of the destination.

Returns: A 128-bit vector of [4 x float] containing the interleaved values.

Definition at line 2797 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_unpacklo_ps(), and _mm_maskz_unpacklo_ps().

◆ _mm_xor_ps()

static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR _mm_xor_ps	(	__m128	__a,
		__m128	__b
	)

static

Performs a bitwise exclusive OR of two 128-bit vectors of [4 x float].

This intrinsic corresponds to the VXORPS / XORPS instructions.

Parameters

__a	A 128-bit vector of [4 x float] containing one of the source operands.
__b	A 128-bit vector of [4 x float] containing one of the source operands.

Returns: A 128-bit vector of [4 x float] containing the bitwise exclusive OR of the values between both operands.

Definition at line 497 of file xmmintrin.h.

References __a, and __b.

Referenced by _mm_mask_xor_ps(), and _mm_maskz_xor_ps().

Macros

Typedefs

Functions

Macro Definition Documentation

◆ __anyext128

◆ __DEFAULT_FN_ATTRS

◆ __DEFAULT_FN_ATTRS_CONSTEXPR

◆ __DEFAULT_FN_ATTRS_SSE2

◆ __DEFAULT_FN_ATTRS_SSE2_CONSTEXPR

◆ __trunc64

◆ __zeroupper64

◆ __zext128

◆ _CMP_EQ_OQ

◆ _CMP_LE_OS

◆ _CMP_LT_OS

◆ _CMP_NEQ_UQ

◆ _CMP_NLE_US

◆ _CMP_NLT_US

◆ _CMP_ORD_Q

◆ _CMP_UNORD_Q

◆ _m_

◆ _m_maskmovq

◆ _m_pavgb

◆ _m_pavgw

◆ _m_pextrw

◆ _m_pinsrw

◆ _m_pmaxsw

◆ _m_pmaxub

◆ _m_pminsw

◆ _m_pminub

◆ _m_pmovmskb

◆ _m_pmulhuw

◆ _m_psadbw

◆ _m_pshufw

◆ _MM_ALIGN16

◆ _mm_cmp_ps

◆ _mm_cmp_ss

◆ _MM_EXCEPT_DENORM

◆ _MM_EXCEPT_DIV_ZERO

◆ _MM_EXCEPT_INEXACT

◆ _MM_EXCEPT_INVALID

◆ _MM_EXCEPT_MASK

◆ _MM_EXCEPT_OVERFLOW

◆ _MM_EXCEPT_UNDERFLOW

◆ _mm_extract_pi16

◆ _MM_FLUSH_ZERO_MASK

◆ _MM_FLUSH_ZERO_OFF

◆ _MM_FLUSH_ZERO_ON

◆ _MM_GET_EXCEPTION_MASK

◆ _MM_GET_EXCEPTION_STATE

◆ _MM_GET_FLUSH_ZERO_MODE

◆ _MM_GET_ROUNDING_MODE

◆ _MM_HINT_ET0

◆ _MM_HINT_ET1

◆ _MM_HINT_NTA

◆ _MM_HINT_T0

◆ _MM_HINT_T1

◆ _MM_HINT_T2

◆ _mm_insert_pi16

◆ _mm_load_ps1

◆ _MM_MASK_DENORM

◆ _MM_MASK_DIV_ZERO

◆ _MM_MASK_INEXACT

◆ _MM_MASK_INVALID

◆ _MM_MASK_MASK

◆ _MM_MASK_OVERFLOW

◆ _MM_MASK_UNDERFLOW

◆ _mm_prefetch

◆ _MM_ROUND_DOWN

◆ _MM_ROUND_MASK

◆ _MM_ROUND_NEAREST

◆ _MM_ROUND_TOWARD_ZERO

◆ _MM_ROUND_UP

◆ _MM_SET_EXCEPTION_MASK

◆ _MM_SET_EXCEPTION_STATE

◆ _MM_SET_FLUSH_ZERO_MODE

◆ _MM_SET_ROUNDING_MODE

◆ _MM_SHUFFLE

◆ _mm_shuffle_pi16

◆ _mm_shuffle_ps

◆ attribute