## ModulesΒ§

- aesni π
- avx π
- avx2 π
- bmi π
- sse π
- sse2 π
- sse3 π
- sse41 π
- sse42 π
- ssse3 π

## EnumsΒ§

- FloatBinOp π
- FloatUnaryOp π
- ShiftOp π

## TraitsΒ§

- EvalContextExt π

## FunctionsΒ§

- Disturbes a floating-point result by a relative error on the order of (-2^scale, 2^scale).
- bin_op_float πPerforms
`which`

scalar operation on`left`

and`right`

and returns the result. - Performs
`which`

operation on each component of`left`

and`right`

, storing the result is stored in`dest`

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

. - 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 2*i and 2*i+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`

. - Splits
`op`

(which must be a SIMD vector) into 128-bit chunks. - test_bits_masked πCalculates two booleans.
- 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`

.