Module typed_arch::x86
[−]
[src]
x86
intrinsics
Structs
CpuidResult 
[ Experimental ] Result of the 
Round 
Functions
__cpuid^{⚠} 
[ Experimental ] See 
__cpuid_count^{⚠} 
[ Experimental ] Returns the result of the 
__get_cpuid_max^{⚠} 
[ Experimental ] Returns the highestsupported 
__readeflags^{⚠} 
[ Experimental ] Reads EFLAGS. 
__writeeflags^{⚠} 
[ Experimental ] Write EFLAGS. 
_bswap^{⚠} 
[ Experimental ] Return an integer with the reversed byte order of x 
_mm256_add_pd^{⚠} 
Add 
_mm256_blendv_epi8^{⚠} 
Blend packed 8bit integers from 
_mm256_sqrt_pd^{⚠} 
Square root 
_mm_add_epi8^{⚠} 
Add 
_mm_add_epi16^{⚠} 
Add 
_mm_add_epi32^{⚠} 
Add 
_mm_add_epi64^{⚠} 
Add 
_mm_add_pd^{⚠} 
Add packed doubleprecision (64bit) floatingpoint elements in 
_mm_add_sd^{⚠} 
Return a new vector with the low element of 
_mm_add_si64^{⚠} 
[ Experimental ] Adds two signed or unsigned 64bit integer values, returning the lower 64 bits of the sum. 
_mm_adds_epi8^{⚠} 
Saturated add 
_mm_adds_epi16^{⚠} 
Saturated add 
_mm_adds_epu8^{⚠} 
Saturated add 
_mm_adds_epu16^{⚠} 
Saturated add 
_mm_addsub_pd^{⚠} 
Alternatively add and subtract packed doubleprecision (64bit)
floatingpoint elements in 
_mm_addsub_ps^{⚠} 
Alternatively add and subtract packed singleprecision (32bit)
floatingpoint elements in 
_mm_and_pd^{⚠} 
Compute the bitwise AND of packed doubleprecision (64bit) floatingpoint
elements in 
_mm_and_ps^{⚠} 
Bitwise AND of packed singleprecision (32bit) floatingpoint elements. 
_mm_and_si128^{⚠} 
[ Experimental ] Compute the bitwise AND of 128 bits (representing integer data) in 
_mm_andnot_pd^{⚠} 
Compute the bitwise NOT of 
_mm_andnot_si128^{⚠} 
[ Experimental ] Compute the bitwise NOT of 128 bits (representing integer data) in 
_mm_avg_epu8^{⚠} 
Average 
_mm_avg_epu16^{⚠} 
Average 
_mm_blendv_epi8^{⚠} 
Blend packed 8bit integers from 
_mm_bslli_si128^{⚠} 
[ Experimental ] Shift 
_mm_bsrli_si128^{⚠} 
[ Experimental ] Shift 
_mm_castpd_ps^{⚠} 
Casts a 128bit floatingpoint vector of [2 x double] into a 128bit floatingpoint vector of [4 x float]. 
_mm_castpd_si128^{⚠} 
Casts a 128bit floatingpoint vector of [2 x double] into a 128bit integer vector. 
_mm_castps_pd^{⚠} 
Casts a 128bit floatingpoint vector of [4 x float] into a 128bit floatingpoint vector of [2 x double]. 
_mm_castps_si128^{⚠} 
Casts a 128bit floatingpoint vector of [4 x float] into a 128bit integer vector. 
_mm_castsi128_pd^{⚠} 
Casts a 128bit integer vector into a 128bit floatingpoint vector of [2 x double]. 
_mm_castsi128_ps^{⚠} 
Casts a 128bit integer vector into a 128bit floatingpoint vector of [4 x float]. 
_mm_ceil_ps^{⚠} 
Round the elements in 
_mm_clflush^{⚠} 
[ Experimental ] Invalidate and flush the cache line that contains 
_mm_cmpeq_epi8^{⚠} 
Equal 
_mm_cmpeq_epi16^{⚠} 
Equal 
_mm_cmpeq_epi32^{⚠} 
Equal 
_mm_cmpeq_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpeq_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpge_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpge_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpgt_epi8^{⚠} 
Greaterthan 
_mm_cmpgt_epi16^{⚠} 
Greaterthan 
_mm_cmpgt_epi32^{⚠} 
Greaterthan 
_mm_cmpgt_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpgt_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmple_pd^{⚠} 
Compare corresponding elements in 
_mm_cmple_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmplt_epi8^{⚠} 
Lessthan 
_mm_cmplt_epi16^{⚠} 
Lessthan 
_mm_cmplt_epi32^{⚠} 
Lessthan 
_mm_cmplt_pd^{⚠} 
Compare corresponding elements in 
_mm_cmplt_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpneq_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpneq_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpnge_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpnge_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpngt_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpngt_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpnle_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpnle_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpnlt_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpnlt_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpord_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpord_sd^{⚠} 
Return a new vector with the low element of 
_mm_cmpunord_pd^{⚠} 
Compare corresponding elements in 
_mm_cmpunord_sd^{⚠} 
Return a new vector with the low element of 
_mm_comieq_sd^{⚠} 
Compare the lower element of 
_mm_comige_sd^{⚠} 
Compare the lower element of 
_mm_comigt_sd^{⚠} 
Compare the lower element of 
_mm_comile_sd^{⚠} 
Compare the lower element of 
_mm_comilt_sd^{⚠} 
Compare the lower element of 
_mm_comineq_sd^{⚠} 
Compare the lower element of 
_mm_cvtepi32_pd^{⚠} 
Converts lower two packed 32bit integers in 
_mm_cvtepi32_ps^{⚠} 
Conversion 
_mm_cvtepu8_epi16^{⚠} 
Zero extend packed unsigned 8bit integers in 
_mm_cvtpd_epi32^{⚠} 
Convert packed doubleprecision (64bit) floatingpoint elements in 
_mm_cvtpd_pi32^{⚠} 
Converts the two doubleprecision floatingpoint elements of a 128bit vector of [2 x double] into two signed 32bit integer values, returned in a 64bit vector of [2 x i32]. 
_mm_cvtpd_ps^{⚠} 
Convert packed doubleprecision (64bit) floatingpoint elements in "a" to packed singleprecision (32bit) floatingpoint elements 
_mm_cvtpi32_pd^{⚠} 
Converts the two signed 32bit integer elements of a 64bit vector of [2 x i32] into two doubleprecision floatingpoint values, returned in a 128bit vector of [2 x double]. 
_mm_cvtps_epi32^{⚠} 
Conversion 
_mm_cvtps_pd^{⚠} 
Convert packed singleprecision (32bit) floatingpoint elements in 
_mm_cvtsd_f64^{⚠} 
Return the lower doubleprecision (64bit) floatingpoint element of "a". 
_mm_cvtsd_si32^{⚠} 
Convert the lower doubleprecision (64bit) floatingpoint element in a to a 32bit integer. 
_mm_cvtsd_ss^{⚠} 
Convert the lower doubleprecision (64bit) floatingpoint element in 
_mm_cvtsi128_si32^{⚠} 
Extracts lowest element of 
_mm_cvtsi32_sd^{⚠} 
Replaces lower element of 
_mm_cvtsi32_si128^{⚠} 
Instantiates 
_mm_cvtss_sd^{⚠} 
Convert the lower singleprecision (32bit) floatingpoint element in 
_mm_cvttpd_epi32^{⚠} 
Convert packed doubleprecision (64bit) floatingpoint elements in 
_mm_cvttpd_pi32^{⚠} 
Converts the two doubleprecision floatingpoint elements of a 128bit vector of [2 x double] into two signed 32bit integer values, returned in a 64bit vector of [2 x i32]. If the result of either conversion is inexact, the result is truncated (rounded towards zero) regardless of the current MXCSR setting. 
_mm_cvttps_epi32^{⚠} 
Convert packed singleprecision (32bit) floatingpoint elements in 
_mm_cvttsd_si32^{⚠} 
Convert the lower doubleprecision (64bit) floatingpoint element in 
_mm_div_pd^{⚠} 
Divide packed doubleprecision (64bit) floatingpoint elements in 
_mm_div_sd^{⚠} 
Return a new vector with the low element of 
_mm_extract_epi16^{⚠} 
Return the 
_mm_floor_ps^{⚠} 
Round the elements in 
_mm_hadd_pd^{⚠} 
Horizontally add adjacent pairs of doubleprecision (64bit)
floatingpoint elements in 
_mm_hadd_ps^{⚠} 
Horizontally add adjacent pairs of singleprecision (32bit)
floatingpoint elements in 
_mm_hadds_epi16^{⚠} 
Horizontally add the adjacent pairs of values contained in 2 packed 128bit vectors of [8 x i16]. Positive sums greater than 7FFFh are saturated to 7FFFh. Negative sums less than 8000h are saturated to 8000h. 
_mm_hsub_pd^{⚠} 
Horizontally subtract adjacent pairs of doubleprecision (64bit)
floatingpoint elements in 
_mm_hsub_ps^{⚠} 
Horizontally add adjacent pairs of singleprecision (32bit)
floatingpoint elements in 
_mm_hsubs_epi16^{⚠} 
Horizontally subtract the adjacent pairs of values contained in 2 packed 128bit vectors of [8 x i16]. Positive differences greater than 7FFFh are saturated to 7FFFh. Negative differences less than 8000h are saturated to 8000h. 
_mm_insert_epi16^{⚠} 
Return a new vector where the 
_mm_lfence^{⚠} 
[ Experimental ] Perform a serializing operation on all loadfrommemory instructions that were issued prior to this instruction. 
_mm_load1_pd^{⚠} 
Load a doubleprecision (64bit) floatingpoint element from memory into both elements of returned vector. 
_mm_load_pd^{⚠} 
Load 128bits (composed of 2 packed doubleprecision (64bit)
floatingpoint elements) from memory into the returned vector.

_mm_load_pd1^{⚠} 
Load a doubleprecision (64bit) floatingpoint element from memory into both elements of returned vector. 
_mm_load_sd^{⚠} 
Loads a 64bit doubleprecision value to the low element of a 128bit integer vector and clears the upper element. 
_mm_load_si128^{⚠} 
[ Experimental ] Load 128bits of integer data from memory into a new vector. 
_mm_loadh_pd^{⚠} 
Loads a doubleprecision value into the highorder bits of a 128bit vector of [2 x double]. The loworder bits are copied from the loworder bits of the first operand. 
_mm_loadl_epi64^{⚠} 
Load 64bit integer from memory into first element of returned vector. 
_mm_loadl_pd^{⚠} 
Loads a doubleprecision value into the loworder bits of a 128bit vector of [2 x double]. The highorder bits are copied from the highorder bits of the first operand. 
_mm_loadr_pd^{⚠} 
Load 2 doubleprecision (64bit) floatingpoint elements from memory into
the returned vector in reverse order. 
_mm_loadu_pd^{⚠} 
Load 128bits (composed of 2 packed doubleprecision (64bit)
floatingpoint elements) from memory into the returned vector.

_mm_loadu_si128^{⚠} 
[ Experimental ] Load 128bits of integer data from memory into a new vector. 
_mm_madd_epi16^{⚠} 
Multiply and horizontally add 
_mm_maskmoveu_si128^{⚠} 
Conditionally store elements from 
_mm_max_epi16^{⚠} 
Max 
_mm_max_epu8^{⚠} 
Max 
_mm_max_pd^{⚠} 
Return a new vector with the maximum values from corresponding elements in

_mm_max_sd^{⚠} 
Return a new vector with the low element of 
_mm_mfence^{⚠} 
[ Experimental ] Perform a serializing operation on all loadfrommemory and storetomemory instructions that were issued prior to this instruction. 
_mm_min_epi16^{⚠} 
Min 
_mm_min_epu8^{⚠} 
Min 
_mm_min_pd^{⚠} 
Return a new vector with the minimum values from corresponding elements in

_mm_min_sd^{⚠} 
Return a new vector with the low element of 
_mm_move_epi64^{⚠} 
Instantiate vector with the low element extracted from 
_mm_move_sd^{⚠} 
Constructs a 128bit floatingpoint 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^{⚠} 
Return a mask of the most significant bit of each element in 
_mm_movemask_pd^{⚠} 
Return a mask of the most significant bit of each element in 
_mm_movepi64_pi64^{⚠} 
Returns the lower 64 bits of a 128bit integer vector as a 64bit integer. 
_mm_movpi64_epi64^{⚠} 
Moves the 64bit operand to a 128bit integer vector, zeroing the upper bits. 
_mm_mul_epu32^{⚠} 
Multiply the low unsigned 32bit integers from each packed 64bit element 
_mm_mul_pd^{⚠} 
Multiply packed doubleprecision (64bit) floatingpoint elements in 
_mm_mul_sd^{⚠} 
Return a new vector with the low element of 
_mm_mul_su32^{⚠} 
Multiplies 32bit unsigned integer values contained in the lower bits of the two 64bit integer vectors and returns the 64bit unsigned product. 
_mm_mulhi_epi16^{⚠} 
Multiply returning high 16 bits of the result. 
_mm_mulhi_epu16^{⚠} 
Multiply returning high 16 bits of the result. 
_mm_mullo_epi16^{⚠} 
Multiply returning low 16 bits of the result. 
_mm_or_pd^{⚠} 
Compute the bitwise OR of 
_mm_or_si128^{⚠} 
[ Experimental ] Compute the bitwise OR of 128 bits (representing integer data) in 
_mm_packs_epi16^{⚠} 
Convert elements of 
_mm_packs_epi32^{⚠} 
Convert elements of 
_mm_packus_epi16^{⚠} 
Convert elements of 
_mm_pause^{⚠} 
[ Experimental ] Provide a hint to the processor that the code sequence is a spinwait loop. 
_mm_rcp_ps^{⚠} 
Reciprocal (approximate) 
_mm_round_ps^{⚠} 
Round the elements in 
_mm_rsqrt_ps^{⚠} 
Reciprocal square root (approximate). 
_mm_sad_epu8^{⚠} 
Sum absolute differences 
_mm_set1_epi8^{⚠} 
Broadcast 
_mm_set1_epi16^{⚠} 
Broadcast 
_mm_set1_epi32^{⚠} 
Broadcast 
_mm_set1_epi64^{⚠} 
Initializes both values in a 128bit vector of [2 x i64] with the specified 64bit value. 
_mm_set1_epi64x^{⚠} 
Broadcast 
_mm_set1_pd^{⚠} 
Broadcast doubleprecision (64bit) floatingpoint value a to all elements of the return value. 
_mm_set_epi8^{⚠} 
Instantiate 
_mm_set_epi16^{⚠} 
Instantiate 
_mm_set_epi32^{⚠} 
Instantiate 
_mm_set_epi64^{⚠} 
Initializes both 64bit values in a 128bit vector of [2 x i64] with the specified 64bit integer values. 
_mm_set_epi64x^{⚠} 
Instantiate 
_mm_set_pd^{⚠} 
Set packed doubleprecision (64bit) floatingpoint elements in the return value with the supplied values. 
_mm_set_pd1^{⚠} 
Broadcast doubleprecision (64bit) floatingpoint value a to all elements of the return value. 
_mm_set_sd^{⚠} 
Copy doubleprecision (64bit) floatingpoint element 
_mm_setr_epi8^{⚠} 
Instantiate with values in reverse order 
_mm_setr_epi16^{⚠} 
Instantiate with values in reverse order 
_mm_setr_epi32^{⚠} 
Instantiate with values in reverse order 
_mm_setr_epi64^{⚠} 
Constructs a 128bit integer vector, initialized in reverse order with the specified 64bit integral values. 
_mm_setr_pd^{⚠} 
Set packed doubleprecision (64bit) floatingpoint elements in the return value with the supplied values in reverse order. 
_mm_setzero_pd^{⚠} 
Returns packed doubleprecision (64bit) floatingpoint elements with all zeros. 
_mm_setzero_si128^{⚠} 
[ Experimental ] Returns a vector with all elements set to zero. 
_mm_shuffle_epi8^{⚠} 
Shuffle bytes from 
_mm_shuffle_epi32^{⚠} 
Shuffle 
_mm_shuffle_pd^{⚠} 
Constructs a 128bit floatingpoint vector of [2 x double] from two
128bit vector parameters of [2 x double], using the 
_mm_shuffle_ps^{⚠} 
Shuffle elements in 
_mm_shufflehi_epi16^{⚠} 
Shuffle integers in the high 64 bits of 
_mm_shufflelo_epi16^{⚠} 
Shuffle integers in the low 64 bits of 
_mm_sll_epi16^{⚠} 
Left shift (shifting in zeros). 
_mm_sll_epi32^{⚠} 
Left shift (shifting in zeros). 
_mm_sll_epi64^{⚠} 
Left shift (shifting in zeros). 
_mm_slli_epi16^{⚠} 
Left shift by 
_mm_slli_epi32^{⚠} 
Left shift by 
_mm_slli_epi64^{⚠} 
Left shift by 
_mm_slli_si128^{⚠} 
[ Experimental ] Shift 
_mm_sqrt_pd^{⚠} 
Return a new vector with the square root of each of the values in 
_mm_sqrt_ps^{⚠} 
Square root. 
_mm_sqrt_sd^{⚠} 
Return a new vector with the low element of 
_mm_sra_epi16^{⚠} 
Right shift (shifting in sign bits). 
_mm_sra_epi32^{⚠} 
Right shift (shifting in sign bits). 
_mm_srai_epi16^{⚠} 
Right shift by 
_mm_srai_epi32^{⚠} 
Right shift by 
_mm_srl_epi16^{⚠} 
Right shift (shifting in zeros). 
_mm_srl_epi32^{⚠} 
Right shift (shifting in zeros). 
_mm_srl_epi64^{⚠} 
Right shift (shifting in zeros). 
_mm_srli_epi16^{⚠} 
Right shift by 
_mm_srli_epi32^{⚠} 
Right shift by 
_mm_srli_epi64^{⚠} 
Right shift by 
_mm_srli_si128^{⚠} 
[ Experimental ] Shift 
_mm_store1_pd^{⚠} 
Store the lower doubleprecision (64bit) floatingpoint element from 
_mm_store_pd^{⚠} 
Store 128bits (composed of 2 packed doubleprecision (64bit)
floatingpoint elements) from 
_mm_store_pd1^{⚠} 
Store the lower doubleprecision (64bit) floatingpoint element from 
_mm_store_sd^{⚠} 
Stores the lower 64 bits of a 128bit vector of [2 x double] to a memory location. 
_mm_store_si128^{⚠} 
[ Experimental ] Store 128bits of integer data from 
_mm_storeh_pd^{⚠} 
Stores the upper 64 bits of a 128bit vector of [2 x double] to a memory location. 
_mm_storel_epi64^{⚠} 
Store the lower integer of 
_mm_storel_pd^{⚠} 
Stores the lower 64 bits of a 128bit vector of [2 x double] to a memory location. 
_mm_storer_pd^{⚠} 
Store 2 doubleprecision (64bit) floatingpoint elements from 
_mm_storeu_pd^{⚠} 
Store 128bits (composed of 2 packed doubleprecision (64bit)
floatingpoint elements) from 
_mm_storeu_si128^{⚠} 
[ Experimental ] Store 128bits of integer data from 
_mm_stream_pd^{⚠} 
Stores a 128bit floating point vector of [2 x double] to a 128bit aligned memory location. To minimize caching, the data is flagged as nontemporal (unlikely to be used again soon). 
_mm_stream_si32^{⚠} 
[ Experimental ] Stores a 32bit integer value in the specified memory location. To minimize caching, the data is flagged as nontemporal (unlikely to be used again soon). 
_mm_stream_si128^{⚠} 
[ Experimental ] Stores a 128bit integer vector to a 128bit aligned memory location. To minimize caching, the data is flagged as nontemporal (unlikely to be used again soon). 
_mm_sub_epi8^{⚠} 
Subtract 
_mm_sub_epi16^{⚠} 
Subtract 
_mm_sub_epi32^{⚠} 
Subtract 
_mm_sub_epi64^{⚠} 
Subtract 
_mm_sub_pd^{⚠} 
Subtract packed doubleprecision (64bit) floatingpoint elements in 
_mm_sub_sd^{⚠} 
Return a new vector with the low element of 
_mm_sub_si64^{⚠} 
[ Experimental ] Subtracts signed or unsigned 64bit integer values and writes the difference to the corresponding bits in the destination. 
_mm_subs_epi8^{⚠} 
Saturated subtract 
_mm_subs_epi16^{⚠} 
Saturated subtract 
_mm_subs_epu8^{⚠} 
Saturated subtract 
_mm_subs_epu16^{⚠} 
Saturated subtract 
_mm_ucomieq_sd^{⚠} 
Compare the lower element of 
_mm_ucomige_sd^{⚠} 
Compare the lower element of 
_mm_ucomigt_sd^{⚠} 
Compare the lower element of 
_mm_ucomile_sd^{⚠} 
Compare the lower element of 
_mm_ucomilt_sd^{⚠} 
Compare the lower element of 
_mm_ucomineq_sd^{⚠} 
Compare the lower element of 
_mm_undefined_pd^{⚠} 
Return vector of type f64x2 with undefined elements. 
_mm_undefined_si128^{⚠} 
[ Experimental ] Return vector of type __m128i with undefined elements. 
_mm_unpackhi_epi8^{⚠} 
Unpack and interleave integers from the high half of 
_mm_unpackhi_epi16^{⚠} 
Unpack and interleave integers from the high half of 
_mm_unpackhi_epi32^{⚠} 
Unpack and interleave integers from the high half of 
_mm_unpackhi_epi64^{⚠} 
Unpack and interleave integers from the high half of 
_mm_unpackhi_pd^{⚠} 
The resulting 
_mm_unpacklo_epi8^{⚠} 
Unpack and interleave integers from the low half of 
_mm_unpacklo_epi16^{⚠} 
Unpack and interleave integers from the low half of 
_mm_unpacklo_epi32^{⚠} 
Unpack and interleave integers from the low half of 
_mm_unpacklo_epi64^{⚠} 
Unpack and interleave integers from the low half of 
_mm_unpacklo_pd^{⚠} 
The resulting 
_mm_xor_pd^{⚠} 
Compute the bitwise OR of 
_mm_xor_si128^{⚠} 
[ Experimental ] Compute the bitwise XOR of 128 bits (representing integer data) in 
_rdrand16_step^{⚠} 
Returns a hardware generated 16bit random value. 
_rdrand32_step^{⚠} 
Read a hardware generated 32bit random value. 
_rdseed16_step^{⚠} 
Returns a 16bit NIST SP80090B and SP80090C compliant random value. 
_rdseed32_step^{⚠} 
Returns a 32bit NIST SP80090B and SP80090C compliant random value. 
has_cpuid 
[ Experimental ] Does the host support the 