Module x86

Modules

aesni 🔒

avx 🔒

avx2 🔒

bmi 🔒

gfni 🔒

sha 🔒

Implements sha256 SIMD instructions of x86 targets

sse 🔒

sse2 🔒

sse3 🔒

sse41 🔒

sse42 🔒

ssse3 🔒

Enums

FloatBinOp 🔒

FloatUnaryOp 🔒

ShiftOp 🔒

Traits

EvalContextExt 🔒

Functions

bin_op_float 🔒

Performs which scalar operation on left and right and returns the result.

bin_op_simd_float_all 🔒

Performs which operation on each component of left and right, storing the result is stored in dest.

bin_op_simd_float_first 🔒

Performs which operation on the first component of left and right and copies the other components from left. The result is stored in dest.

carrying_add 🔒

Calcultates either a + b + cb_in or a - b - cb_in depending on the value of op and returns both the sum and the overflow bit. op is expected to be either one of mir::BinOp::AddWithOverflow and mir::BinOp::SubWithOverflow.

conditional_dot_product 🔒

Conditionally multiplies the packed floating-point elements in left and right using the high 4 bits in imm, sums the calculated products (up to 4), and conditionally stores the sum in dest using the low 4 bits of imm.

convert_float_to_int 🔒

Converts each element of op from floating point to signed integer.

extract_first_u64 🔒

Takes a 128-bit vector, transmutes it to [u64; 2] and extracts the first value.

horizontal_bin_op 🔒

Horizontally performs which operation on adjacent values of left and right SIMD vectors and stores the result in dest. “Horizontal” means that the i-th output element is calculated from the elements 2i and 2i+1 of the concatenation of left and right.

int_abs 🔒

Calculates absolute value of integers in op and stores the result in dest.

mask_load 🔒

Conditionally loads from ptr according the high bit of each element of mask. ptr does not need to be aligned.

mask_store 🔒

Conditionally stores into ptr according the high bit of each element of mask. ptr does not need to be aligned.

mpsadbw 🔒

Compute the sum of absolute differences of quadruplets of unsigned 8-bit integers in left and right, and store the 16-bit results in right. Quadruplets are selected from left and right with offsets specified in imm.

pack_generic 🔒

Packs two N-bit integer vectors to a single N/2-bit integers.

packssdw 🔒

Converts two 32-bit integer vectors to a single 16-bit integer vector with signed saturation.

packsswb 🔒

Converts two 16-bit integer vectors to a single 8-bit integer vector with signed saturation.

packusdw 🔒

Converts two 32-bit integer vectors to a single 16-bit integer vector with unsigned saturation.

packuswb 🔒

Converts two 16-bit signed integer vectors to a single 8-bit unsigned integer vector with saturation.

pclmulqdq 🔒

Perform a carry-less multiplication of two 64-bit integers, selected from left and right according to imm8, and store the results in dst.

pmulhrsw 🔒

Multiplies packed 16-bit signed integer values, truncates the 32-bit product to the 18 most significant bits by right-shifting, and then divides the 18-bit value by 2 (rounding to nearest) by first adding 1 and then taking the bits 1..=16.

psign 🔒

Negates elements from left when the corresponding element in right is negative. If an element from right is zero, zero is written to the corresponding output element. In other words, multiplies left with right.signum().

round_all 🔒

round_first 🔒

rounding_from_imm 🔒

Gets equivalent rustc_apfloat::Round from rounding mode immediate of round.{ss,sd,ps,pd} intrinsics.

shift_simd_by_scalar 🔒

Shifts each element of left by a scalar amount. The shift amount is determined by the lowest 64 bits of right (which is a 128-bit vector).

shift_simd_by_simd 🔒

Shifts each element of left by the corresponding element of right.

split_simd_to_128bit_chunks 🔒

Splits op (which must be a SIMD vector) into 128-bit chunks.

test_bits_masked 🔒

Calculates two booleans.

test_high_bits_masked 🔒

Calculates two booleans.

unary_op_f32 🔒

Performs which scalar operation on op and returns the result.

unary_op_ps 🔒

Performs which operation on each component of op, storing the result is stored in dest.

unary_op_ss 🔒

Performs which operation on the first component of op and copies the other components. The result is stored in dest.