Module x86 

Modules

aesni 🔒

avx 🔒

avx2 🔒

avx512 🔒

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.

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.

permute 🔒

Shuffle elements in values across lanes using the corresponding index in indices, and store the results in dest.

permute2 🔒

Shuffle elements from two source registers (left and right) using the corresponding index in indices, and store the results in dest.

pmaddbw 🔒

Multiplies packed 8-bit unsigned integers from left and packed signed 8-bit integers from right into 16-bit signed integers. Then, the saturating sum of the products with indices 2*i and 2*i+1 produces the output at index i.

pmaddwd 🔒

Multiply packed signed 16-bit integers in left and right, producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in dest.

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.

psadbw 🔒

Compute the absolute differences of packed unsigned 8-bit integers in left and right, then horizontally sum each consecutive 8 differences to produce unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low 16 bits of 64-bit elements in dest.

pshufb 🔒

Shuffles bytes from left using right as pattern. Each 16-byte block is shuffled independently.

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

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.