Module sse2

Available on x86 or x86-64 only.

Streaming SIMD Extensions 2 (SSE2)

Functions

_mm_add_epi8^⚠sse2

Adds packed 8-bit integers in a and b.

_mm_add_epi16^⚠sse2

Adds packed 16-bit integers in a and b.

_mm_add_epi32^⚠sse2

Adds packed 32-bit integers in a and b.

_mm_add_epi64^⚠sse2

Adds packed 64-bit integers in a and b.

_mm_add_pd^⚠sse2

Adds packed double-precision (64-bit) floating-point elements in a and b.

_mm_add_sd^⚠sse2

Returns a new vector with the low element of a replaced by the sum of the low elements of a and b.

_mm_adds_epi8^⚠sse2

Adds packed 8-bit integers in a and b using saturation.

_mm_adds_epi16^⚠sse2

Adds packed 16-bit integers in a and b using saturation.

_mm_adds_epu8^⚠sse2

Adds packed unsigned 8-bit integers in a and b using saturation.

_mm_adds_epu16^⚠sse2

Adds packed unsigned 16-bit integers in a and b using saturation.

_mm_and_pd^⚠sse2

Computes the bitwise AND of packed double-precision (64-bit) floating-point elements in a and b.

_mm_and_si128^⚠sse2

Computes the bitwise AND of 128 bits (representing integer data) in a and b.

_mm_andnot_pd^⚠sse2

Computes the bitwise NOT of a and then AND with b.

_mm_andnot_si128^⚠sse2

Computes the bitwise NOT of 128 bits (representing integer data) in a and then AND with b.

_mm_avg_epu8^⚠sse2

Averages packed unsigned 8-bit integers in a and b.

_mm_avg_epu16^⚠sse2

Averages packed unsigned 16-bit integers in a and b.

_mm_bslli_si128^⚠sse2

Shifts a left by IMM8 bytes while shifting in zeros.

_mm_bsrli_si128^⚠sse2

Shifts a right by IMM8 bytes while shifting in zeros.

_mm_castpd_ps^⚠sse2

Casts a 128-bit floating-point vector of [2 x double] into a 128-bit floating-point vector of [4 x float].

_mm_castpd_si128^⚠sse2

Casts a 128-bit floating-point vector of [2 x double] into a 128-bit integer vector.

_mm_castps_pd^⚠sse2

Casts a 128-bit floating-point vector of [4 x float] into a 128-bit floating-point vector of [2 x double].

_mm_castps_si128^⚠sse2

Casts a 128-bit floating-point vector of [4 x float] into a 128-bit integer vector.

_mm_castsi128_pd^⚠sse2

Casts a 128-bit integer vector into a 128-bit floating-point vector of [2 x double].

_mm_castsi128_ps^⚠sse2

Casts a 128-bit integer vector into a 128-bit floating-point vector of [4 x float].

_mm_clflush^⚠sse2

Invalidates and flushes the cache line that contains p from all levels of the cache hierarchy.

_mm_cmpeq_epi8^⚠sse2

Compares packed 8-bit integers in a and b for equality.

_mm_cmpeq_epi16^⚠sse2

Compares packed 16-bit integers in a and b for equality.

_mm_cmpeq_epi32^⚠sse2

Compares packed 32-bit integers in a and b for equality.

_mm_cmpeq_pd^⚠sse2

Compares corresponding elements in a and b for equality.

_mm_cmpeq_sd^⚠sse2

Returns a new vector with the low element of a replaced by the equality comparison of the lower elements of a and b.

_mm_cmpge_pd^⚠sse2

Compares corresponding elements in a and b for greater-than-or-equal.

_mm_cmpge_sd^⚠sse2

Returns a new vector with the low element of a replaced by the greater-than-or-equal comparison of the lower elements of a and b.

_mm_cmpgt_epi8^⚠sse2

Compares packed 8-bit integers in a and b for greater-than.

_mm_cmpgt_epi16^⚠sse2

Compares packed 16-bit integers in a and b for greater-than.

_mm_cmpgt_epi32^⚠sse2

Compares packed 32-bit integers in a and b for greater-than.

_mm_cmpgt_pd^⚠sse2

Compares corresponding elements in a and b for greater-than.

_mm_cmpgt_sd^⚠sse2

Returns a new vector with the low element of a replaced by the greater-than comparison of the lower elements of a and b.

_mm_cmple_pd^⚠sse2

Compares corresponding elements in a and b for less-than-or-equal

_mm_cmple_sd^⚠sse2

Returns a new vector with the low element of a replaced by the less-than-or-equal comparison of the lower elements of a and b.

_mm_cmplt_epi8^⚠sse2

Compares packed 8-bit integers in a and b for less-than.

_mm_cmplt_epi16^⚠sse2

Compares packed 16-bit integers in a and b for less-than.

_mm_cmplt_epi32^⚠sse2

Compares packed 32-bit integers in a and b for less-than.

_mm_cmplt_pd^⚠sse2

Compares corresponding elements in a and b for less-than.

_mm_cmplt_sd^⚠sse2

Returns a new vector with the low element of a replaced by the less-than comparison of the lower elements of a and b.

_mm_cmpneq_pd^⚠sse2

Compares corresponding elements in a and b for not-equal.

_mm_cmpneq_sd^⚠sse2

Returns a new vector with the low element of a replaced by the not-equal comparison of the lower elements of a and b.

_mm_cmpnge_pd^⚠sse2

Compares corresponding elements in a and b for not-greater-than-or-equal.

_mm_cmpnge_sd^⚠sse2

Returns a new vector with the low element of a replaced by the not-greater-than-or-equal comparison of the lower elements of a and b.

_mm_cmpngt_pd^⚠sse2

Compares corresponding elements in a and b for not-greater-than.

_mm_cmpngt_sd^⚠sse2

Returns a new vector with the low element of a replaced by the not-greater-than comparison of the lower elements of a and b.

_mm_cmpnle_pd^⚠sse2

Compares corresponding elements in a and b for not-less-than-or-equal.

_mm_cmpnle_sd^⚠sse2

Returns a new vector with the low element of a replaced by the not-less-than-or-equal comparison of the lower elements of a and b.

_mm_cmpnlt_pd^⚠sse2

Compares corresponding elements in a and b for not-less-than.

_mm_cmpnlt_sd^⚠sse2

Returns a new vector with the low element of a replaced by the not-less-than comparison of the lower elements of a and b.

_mm_cmpord_pd^⚠sse2

Compares corresponding elements in a and b to see if neither is NaN.

_mm_cmpord_sd^⚠sse2

Returns a new vector with the low element of a replaced by the result of comparing both of the lower elements of a and b to NaN. If neither are equal to NaN then 0xFFFFFFFFFFFFFFFF is used and 0 otherwise.

_mm_cmpunord_pd^⚠sse2

Compares corresponding elements in a and b to see if either is NaN.

_mm_cmpunord_sd^⚠sse2

Returns a new vector with the low element of a replaced by the result of comparing both of the lower elements of a and b to NaN. If either is equal to NaN then 0xFFFFFFFFFFFFFFFF is used and 0 otherwise.

_mm_comieq_sd^⚠sse2

Compares the lower element of a and b for equality.

_mm_comige_sd^⚠sse2

Compares the lower element of a and b for greater-than-or-equal.

_mm_comigt_sd^⚠sse2

Compares the lower element of a and b for greater-than.

_mm_comile_sd^⚠sse2

Compares the lower element of a and b for less-than-or-equal.

_mm_comilt_sd^⚠sse2

Compares the lower element of a and b for less-than.

_mm_comineq_sd^⚠sse2

Compares the lower element of a and b for not-equal.

_mm_cvtepi32_pd^⚠sse2

Converts the lower two packed 32-bit integers in a to packed double-precision (64-bit) floating-point elements.

_mm_cvtepi32_ps^⚠sse2

Converts packed 32-bit integers in a to packed single-precision (32-bit) floating-point elements.

_mm_cvtpd_epi32^⚠sse2

Converts packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers.

_mm_cvtpd_ps^⚠sse2

Converts packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements

_mm_cvtps_epi32^⚠sse2

Converts packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers.

_mm_cvtps_pd^⚠sse2

Converts packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements.

_mm_cvtsd_f64^⚠sse2

Returns the lower double-precision (64-bit) floating-point element of a.

_mm_cvtsd_si32^⚠sse2

Converts the lower double-precision (64-bit) floating-point element in a to a 32-bit integer.

_mm_cvtsd_ss^⚠sse2

Converts the lower double-precision (64-bit) floating-point element in b to a single-precision (32-bit) floating-point element, store the result in the lower element of the return value, and copies the upper element from a to the upper element the return value.

_mm_cvtsi32_sd^⚠sse2

Returns a with its lower element replaced by b after converting it to an f64.

_mm_cvtsi32_si128^⚠sse2

Returns a vector whose lowest element is a and all higher elements are 0.

_mm_cvtsi128_si32^⚠sse2

Returns the lowest element of a.

_mm_cvtss_sd^⚠sse2

Converts the lower single-precision (32-bit) floating-point element in b to a double-precision (64-bit) floating-point element, store the result in the lower element of the return value, and copies the upper element from a to the upper element the return value.

_mm_cvttpd_epi32^⚠sse2

Converts packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation.

_mm_cvttps_epi32^⚠sse2

Converts packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation.

_mm_cvttsd_si32^⚠sse2

Converts the lower double-precision (64-bit) floating-point element in a to a 32-bit integer with truncation.

_mm_div_pd^⚠sse2

Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b.

_mm_div_sd^⚠sse2

Returns a new vector with the low element of a replaced by the result of diving the lower element of a by the lower element of b.

_mm_extract_epi16^⚠sse2

Returns the imm8 element of a.

_mm_insert_epi16^⚠sse2

Returns a new vector where the imm8 element of a is replaced with i.

_mm_lfence^⚠sse2

Performs a serializing operation on all load-from-memory instructions that were issued prior to this instruction.

_mm_load1_pd^⚠sse2

Loads a double-precision (64-bit) floating-point element from memory into both elements of returned vector.

_mm_load_pd^⚠sse2

Loads 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from memory into the returned vector. mem_addr must be aligned on a 16-byte boundary or a general-protection exception may be generated.

_mm_load_pd1^⚠sse2

Loads a double-precision (64-bit) floating-point element from memory into both elements of returned vector.

_mm_load_sd^⚠sse2

Loads a 64-bit double-precision value to the low element of a 128-bit integer vector and clears the upper element.

_mm_load_si128^⚠sse2

Loads 128-bits of integer data from memory into a new vector.

_mm_loadh_pd^⚠sse2

Loads a double-precision value into the high-order bits of a 128-bit vector of [2 x double]. The low-order bits are copied from the low-order bits of the first operand.

_mm_loadl_epi64^⚠sse2

Loads 64-bit integer from memory into first element of returned vector.

_mm_loadl_pd^⚠sse2

Loads a double-precision value into the low-order bits of a 128-bit vector of [2 x double]. The high-order bits are copied from the high-order bits of the first operand.

_mm_loadr_pd^⚠sse2

Loads 2 double-precision (64-bit) floating-point elements from memory into the returned vector in reverse order. mem_addr must be aligned on a 16-byte boundary or a general-protection exception may be generated.

_mm_loadu_pd^⚠sse2

Loads 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from memory into the returned vector. mem_addr does not need to be aligned on any particular boundary.

_mm_loadu_si16^⚠sse2

Loads unaligned 16-bits of integer data from memory into new vector.

_mm_loadu_si32^⚠sse2

Loads unaligned 32-bits of integer data from memory into new vector.

_mm_loadu_si64^⚠sse2

Loads unaligned 64-bits of integer data from memory into new vector.

_mm_loadu_si128^⚠sse2

Loads 128-bits of integer data from memory into a new vector.

_mm_madd_epi16^⚠sse2

Multiplies and then horizontally add signed 16 bit integers in a and b.

_mm_maskmoveu_si128^⚠sse2

Conditionally store 8-bit integer elements from a into memory using mask.

_mm_max_epi16^⚠sse2

Compares packed 16-bit integers in a and b, and returns the packed maximum values.

_mm_max_epu8^⚠sse2

Compares packed unsigned 8-bit integers in a and b, and returns the packed maximum values.

_mm_max_pd^⚠sse2

Returns a new vector with the maximum values from corresponding elements in a and b.

_mm_max_sd^⚠sse2

Returns a new vector with the low element of a replaced by the maximum of the lower elements of a and b.

_mm_mfence^⚠sse2

Performs a serializing operation on all load-from-memory and store-to-memory instructions that were issued prior to this instruction.

_mm_min_epi16^⚠sse2

Compares packed 16-bit integers in a and b, and returns the packed minimum values.

_mm_min_epu8^⚠sse2

Compares packed unsigned 8-bit integers in a and b, and returns the packed minimum values.

_mm_min_pd^⚠sse2

Returns a new vector with the minimum values from corresponding elements in a and b.

_mm_min_sd^⚠sse2

Returns a new vector with the low element of a replaced by the minimum of the lower elements of a and b.

_mm_move_epi64^⚠sse2

Returns a vector where the low element is extracted from a and its upper element is zero.

_mm_move_sd^⚠sse2

Constructs a 128-bit floating-point vector of [2 x double]. The lower 64 bits are set to the lower 64 bits of the second parameter. The upper 64 bits are set to the upper 64 bits of the first parameter.

_mm_movemask_epi8^⚠sse2

Returns a mask of the most significant bit of each element in a.

_mm_movemask_pd^⚠sse2

Returns a mask of the most significant bit of each element in a.

_mm_mul_epu32^⚠sse2

Multiplies the low unsigned 32-bit integers from each packed 64-bit element in a and b.

_mm_mul_pd^⚠sse2

Multiplies packed double-precision (64-bit) floating-point elements in a and b.

_mm_mul_sd^⚠sse2

Returns a new vector with the low element of a replaced by multiplying the low elements of a and b.

_mm_mulhi_epi16^⚠sse2

Multiplies the packed 16-bit integers in a and b.

_mm_mulhi_epu16^⚠sse2

Multiplies the packed unsigned 16-bit integers in a and b.

_mm_mullo_epi16^⚠sse2

Multiplies the packed 16-bit integers in a and b.

_mm_or_pd^⚠sse2

Computes the bitwise OR of a and b.

_mm_or_si128^⚠sse2

Computes the bitwise OR of 128 bits (representing integer data) in a and b.

_mm_packs_epi16^⚠sse2

Converts packed 16-bit integers from a and b to packed 8-bit integers using signed saturation.

_mm_packs_epi32^⚠sse2

Converts packed 32-bit integers from a and b to packed 16-bit integers using signed saturation.

_mm_packus_epi16^⚠sse2

Converts packed 16-bit integers from a and b to packed 8-bit integers using unsigned saturation.

_mm_pause^⚠

Provides a hint to the processor that the code sequence is a spin-wait loop.

_mm_sad_epu8^⚠sse2

Sum the absolute differences of packed unsigned 8-bit integers.

_mm_set1_epi8^⚠sse2

Broadcasts 8-bit integer a to all elements.

_mm_set1_epi16^⚠sse2

Broadcasts 16-bit integer a to all elements.

_mm_set1_epi32^⚠sse2

Broadcasts 32-bit integer a to all elements.

_mm_set1_epi64x^⚠sse2

Broadcasts 64-bit integer a to all elements.

_mm_set1_pd^⚠sse2

Broadcasts double-precision (64-bit) floating-point value a to all elements of the return value.

_mm_set_epi8^⚠sse2

Sets packed 8-bit integers with the supplied values.

_mm_set_epi16^⚠sse2

Sets packed 16-bit integers with the supplied values.

_mm_set_epi32^⚠sse2

Sets packed 32-bit integers with the supplied values.

_mm_set_epi64x^⚠sse2

Sets packed 64-bit integers with the supplied values, from highest to lowest.

_mm_set_pd^⚠sse2

Sets packed double-precision (64-bit) floating-point elements in the return value with the supplied values.

_mm_set_pd1^⚠sse2

Broadcasts double-precision (64-bit) floating-point value a to all elements of the return value.

_mm_set_sd^⚠sse2

Copies double-precision (64-bit) floating-point element a to the lower element of the packed 64-bit return value.

_mm_setr_epi8^⚠sse2

Sets packed 8-bit integers with the supplied values in reverse order.

_mm_setr_epi16^⚠sse2

Sets packed 16-bit integers with the supplied values in reverse order.

_mm_setr_epi32^⚠sse2

Sets packed 32-bit integers with the supplied values in reverse order.

_mm_setr_pd^⚠sse2

Sets packed double-precision (64-bit) floating-point elements in the return value with the supplied values in reverse order.

_mm_setzero_pd^⚠sse2

Returns packed double-precision (64-bit) floating-point elements with all zeros.

_mm_setzero_si128^⚠sse2

Returns a vector with all elements set to zero.

_mm_shuffle_epi32^⚠sse2

Shuffles 32-bit integers in a using the control in IMM8.

_mm_shuffle_pd^⚠sse2

Constructs a 128-bit floating-point vector of [2 x double] from two 128-bit vector parameters of [2 x double], using the immediate-value parameter as a specifier.

_mm_shufflehi_epi16^⚠sse2

Shuffles 16-bit integers in the high 64 bits of a using the control in IMM8.

_mm_shufflelo_epi16^⚠sse2

Shuffles 16-bit integers in the low 64 bits of a using the control in IMM8.

_mm_sll_epi16^⚠sse2

Shifts packed 16-bit integers in a left by count while shifting in zeros.

_mm_sll_epi32^⚠sse2

Shifts packed 32-bit integers in a left by count while shifting in zeros.

_mm_sll_epi64^⚠sse2

Shifts packed 64-bit integers in a left by count while shifting in zeros.

_mm_slli_epi16^⚠sse2

Shifts packed 16-bit integers in a left by IMM8 while shifting in zeros.

_mm_slli_epi32^⚠sse2

Shifts packed 32-bit integers in a left by IMM8 while shifting in zeros.

_mm_slli_epi64^⚠sse2

Shifts packed 64-bit integers in a left by IMM8 while shifting in zeros.

_mm_slli_si128^⚠sse2

Shifts a left by IMM8 bytes while shifting in zeros.

_mm_slli_si128_impl 🔒 ^⚠sse2

Implementation detail: converts the immediate argument of the _mm_slli_si128 intrinsic into a compile-time constant.

_mm_sqrt_pd^⚠sse2

Returns a new vector with the square root of each of the values in a.

_mm_sqrt_sd^⚠sse2

Returns a new vector with the low element of a replaced by the square root of the lower element b.

_mm_sra_epi16^⚠sse2

Shifts packed 16-bit integers in a right by count while shifting in sign bits.

_mm_sra_epi32^⚠sse2

Shifts packed 32-bit integers in a right by count while shifting in sign bits.

_mm_srai_epi16^⚠sse2

Shifts packed 16-bit integers in a right by IMM8 while shifting in sign bits.

_mm_srai_epi32^⚠sse2

Shifts packed 32-bit integers in a right by IMM8 while shifting in sign bits.

_mm_srl_epi16^⚠sse2

Shifts packed 16-bit integers in a right by count while shifting in zeros.

_mm_srl_epi32^⚠sse2

Shifts packed 32-bit integers in a right by count while shifting in zeros.

_mm_srl_epi64^⚠sse2

Shifts packed 64-bit integers in a right by count while shifting in zeros.

_mm_srli_epi16^⚠sse2

Shifts packed 16-bit integers in a right by IMM8 while shifting in zeros.

_mm_srli_epi32^⚠sse2

Shifts packed 32-bit integers in a right by IMM8 while shifting in zeros.

_mm_srli_epi64^⚠sse2

Shifts packed 64-bit integers in a right by IMM8 while shifting in zeros.

_mm_srli_si128^⚠sse2

Shifts a right by IMM8 bytes while shifting in zeros.

_mm_srli_si128_impl 🔒 ^⚠sse2

Implementation detail: converts the immediate argument of the _mm_srli_si128 intrinsic into a compile-time constant.

_mm_store1_pd^⚠sse2

Stores the lower double-precision (64-bit) floating-point element from a into 2 contiguous elements in memory. mem_addr must be aligned on a 16-byte boundary or a general-protection exception may be generated.

_mm_store_pd^⚠sse2

Stores 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from a into memory. mem_addr must be aligned on a 16-byte boundary or a general-protection exception may be generated.

_mm_store_pd1^⚠sse2

Stores the lower double-precision (64-bit) floating-point element from a into 2 contiguous elements in memory. mem_addr must be aligned on a 16-byte boundary or a general-protection exception may be generated.

_mm_store_sd^⚠sse2

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

_mm_store_si128^⚠sse2

Stores 128-bits of integer data from a into memory.

_mm_storeh_pd^⚠sse2

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

_mm_storel_epi64^⚠sse2

Stores the lower 64-bit integer a to a memory location.

_mm_storel_pd^⚠sse2

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

_mm_storer_pd^⚠sse2

Stores 2 double-precision (64-bit) floating-point elements from a into memory in reverse order. mem_addr must be aligned on a 16-byte boundary or a general-protection exception may be generated.

_mm_storeu_pd^⚠sse2

Stores 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from a into memory. mem_addr does not need to be aligned on any particular boundary.

_mm_storeu_si16^⚠sse2

Store 16-bit integer from the first element of a into memory.

_mm_storeu_si32^⚠sse2

Store 32-bit integer from the first element of a into memory.

_mm_storeu_si64^⚠sse2

Store 64-bit integer from the first element of a into memory.

_mm_storeu_si128^⚠sse2

Stores 128-bits of integer data from a into memory.

_mm_stream_pd^⚠sse2

Stores a 128-bit floating point vector of [2 x double] to a 128-bit aligned memory location. To minimize caching, the data is flagged as non-temporal (unlikely to be used again soon).

_mm_stream_si32^⚠sse2

Stores a 32-bit integer value in the specified memory location. To minimize caching, the data is flagged as non-temporal (unlikely to be used again soon).

_mm_stream_si128^⚠sse2

Stores a 128-bit integer vector to a 128-bit aligned memory location. To minimize caching, the data is flagged as non-temporal (unlikely to be used again soon).

_mm_sub_epi8^⚠sse2

Subtracts packed 8-bit integers in b from packed 8-bit integers in a.

_mm_sub_epi16^⚠sse2

Subtracts packed 16-bit integers in b from packed 16-bit integers in a.

_mm_sub_epi32^⚠sse2

Subtract packed 32-bit integers in b from packed 32-bit integers in a.

_mm_sub_epi64^⚠sse2

Subtract packed 64-bit integers in b from packed 64-bit integers in a.

_mm_sub_pd^⚠sse2

Subtract packed double-precision (64-bit) floating-point elements in b from a.

_mm_sub_sd^⚠sse2

Returns a new vector with the low element of a replaced by subtracting the low element by b from the low element of a.

_mm_subs_epi8^⚠sse2

Subtract packed 8-bit integers in b from packed 8-bit integers in a using saturation.

_mm_subs_epi16^⚠sse2

Subtract packed 16-bit integers in b from packed 16-bit integers in a using saturation.

_mm_subs_epu8^⚠sse2

Subtract packed unsigned 8-bit integers in b from packed unsigned 8-bit integers in a using saturation.

_mm_subs_epu16^⚠sse2

Subtract packed unsigned 16-bit integers in b from packed unsigned 16-bit integers in a using saturation.

_mm_ucomieq_sd^⚠sse2

Compares the lower element of a and b for equality.

_mm_ucomige_sd^⚠sse2

Compares the lower element of a and b for greater-than-or-equal.

_mm_ucomigt_sd^⚠sse2

Compares the lower element of a and b for greater-than.

_mm_ucomile_sd^⚠sse2

Compares the lower element of a and b for less-than-or-equal.

_mm_ucomilt_sd^⚠sse2

Compares the lower element of a and b for less-than.

_mm_ucomineq_sd^⚠sse2

Compares the lower element of a and b for not-equal.

_mm_undefined_pd^⚠sse2

Returns vector of type __m128d with indeterminate elements.with indetermination elements. Despite using the word “undefined” (following Intel’s naming scheme), this non-deterministically picks some valid value and is not equivalent to mem::MaybeUninit. In practice, this is typically equivalent to mem::zeroed.

_mm_undefined_si128^⚠sse2

Returns vector of type __m128i with indeterminate elements.with indetermination elements. Despite using the word “undefined” (following Intel’s naming scheme), this non-deterministically picks some valid value and is not equivalent to mem::MaybeUninit. In practice, this is typically equivalent to mem::zeroed.

_mm_unpackhi_epi8^⚠sse2

Unpacks and interleave 8-bit integers from the high half of a and b.

_mm_unpackhi_epi16^⚠sse2

Unpacks and interleave 16-bit integers from the high half of a and b.

_mm_unpackhi_epi32^⚠sse2

Unpacks and interleave 32-bit integers from the high half of a and b.

_mm_unpackhi_epi64^⚠sse2

Unpacks and interleave 64-bit integers from the high half of a and b.

_mm_unpackhi_pd^⚠sse2

The resulting __m128d element is composed by the low-order values of the two __m128d interleaved input elements, i.e.:

_mm_unpacklo_epi8^⚠sse2

Unpacks and interleave 8-bit integers from the low half of a and b.

_mm_unpacklo_epi16^⚠sse2

Unpacks and interleave 16-bit integers from the low half of a and b.

_mm_unpacklo_epi32^⚠sse2

Unpacks and interleave 32-bit integers from the low half of a and b.

_mm_unpacklo_epi64^⚠sse2

Unpacks and interleave 64-bit integers from the low half of a and b.

_mm_unpacklo_pd^⚠sse2

The resulting __m128d element is composed by the high-order values of the two __m128d interleaved input elements, i.e.:

_mm_xor_pd^⚠sse2

Computes the bitwise XOR of a and b.

_mm_xor_si128^⚠sse2

Computes the bitwise XOR of 128 bits (representing integer data) in a and b.

clflush 🔒 ^⚠

cmppd 🔒 ^⚠

cmpsd 🔒 ^⚠

comieqsd 🔒 ^⚠

comigesd 🔒 ^⚠

comigtsd 🔒 ^⚠

comilesd 🔒 ^⚠

comiltsd 🔒 ^⚠

comineqsd 🔒 ^⚠

cvtpd2dq 🔒 ^⚠

cvtps2dq 🔒 ^⚠

cvtsd2si 🔒 ^⚠

cvtsd2ss 🔒 ^⚠

cvtss2sd 🔒 ^⚠

cvttpd2dq 🔒 ^⚠

cvttps2dq 🔒 ^⚠

cvttsd2si 🔒 ^⚠

lfence 🔒 ^⚠

maskmovdqu 🔒 ^⚠

maxpd 🔒 ^⚠

maxsd 🔒 ^⚠

mfence 🔒 ^⚠

minpd 🔒 ^⚠

minsd 🔒 ^⚠

packssdw 🔒 ^⚠

packsswb 🔒 ^⚠

packuswb 🔒 ^⚠

pause 🔒 ^⚠

pmaddwd 🔒 ^⚠

psadbw 🔒 ^⚠

pslld 🔒 ^⚠

psllq 🔒 ^⚠

psllw 🔒 ^⚠

psrad 🔒 ^⚠

psraw 🔒 ^⚠

psrld 🔒 ^⚠

psrlq 🔒 ^⚠

psrlw 🔒 ^⚠

ucomieqsd 🔒 ^⚠

ucomigesd 🔒 ^⚠

ucomigtsd 🔒 ^⚠

ucomilesd 🔒 ^⚠

ucomiltsd 🔒 ^⚠

ucomineqsd 🔒 ^⚠