[][src]Crate safe_arch

A crate that safely exposes arch intrinsics via #[cfg()].

safe_arch lets you safely use CPU intrinsics. Those things in the core::arch modules. It works purely via #[cfg()] and compile time CPU feature declaration. If you want to check for a feature at runtime and then call an intrinsic or use a fallback path based on that then this crate is sadly not for you.

SIMD register types are "newtype'd" so that better trait impls can be given to them, but the inner value is a pub field so feel free to just grab it out if you need to. Trait impls of the newtypes include: Default (zeroed), From/Into of appropriate data types, and appropriate operator overloading.

  • Most intrinsics (like addition and multiplication) are totally safe to use as long as the CPU feature is available. In this case, what you get is 1:1 with the actual intrinsic.
  • Some intrinsics take a pointer of an assumed minimum alignment and validity span. For these, the safe_arch function takes a reference of an appropriate type to uphold safety.
    • Try the bytemuck crate (and turn on the bytemuck feature of this crate) if you want help safely casting between reference types.
  • Some intrinsics are not safe unless you're very careful about how you use them, such as the streaming operations requiring you to use them in combination with an appropriate memory fence. Those operations aren't exposed here.
  • Some intrinsics mess with the processor state, such as changing the floating point flags, saving and loading special register state, and so on. LLVM doesn't really support you messing with that within a high level language, so those operations aren't exposed here. Use assembly or something if you want to do that.

Naming Conventions

The safe_arch crate does not simply use the "official" names for each intrinsic, because the official names are generally poor. Instead, the operations have been given better names that makes things hopefully easier to understand then you're reading the code.

For a full explanation of the naming used, see the Naming Conventions page.

Current Support

  • x86 / x86_64 (Intel, AMD, etc)
    • 128-bit: sse, sse2, sse3, ssse3, sse4.1, sse4.2
    • 256-bit: avx, avx2
    • Other: adx, aes, bmi1, bmi2, fma, lzcnt, pclmulqdq, popcnt, rdrand, rdseed

Compile Time CPU Target Features

At the time of me writing this, Rust enables the sse and sse2 CPU features by default for all i686 (x86) and x86_64 builds. Those CPU features are built into the design of x86_64, and you'd need a super old x86 CPU for it to not support at least sse and sse2, so they're a safe bet for the language to enable all the time. In fact, because the standard library is compiled with them enabled, simply trying to disable those features would actually cause ABI issues and fill your program with UB (link).

If you want additional CPU features available at compile time you'll have to enable them with an additional arg to rustc. For a feature named name you pass -C target-feature=+name, such as -C target-feature=+sse3 for sse3.

You can alternately enable all target features of the current CPU with -C target-cpu=native. This is primarily of use if you're building a program you'll only run on your own system.

It's sometimes hard to know if your target platform will support a given feature set, but the Steam Hardware Survey is generally taken as a guide to what you can expect people to have available. If you click "Other Settings" it'll expand into a list of CPU target features and how common they are. These days, it seems that sse3 can be safely assumed, and ssse3, sse4.1, and sse4.2 are pretty safe bets as well. The stuff above 128-bit isn't as common yet, give it another few years.

Please note that executing a program on a CPU that doesn't support the target features it was compiles for is Undefined Behavior.

Currently, Rust doesn't actually support an easy way for you to check that a feature enabled at compile time is actually available at runtime. There is the "feature_detected" family of macros, but if you enable a feature they will evaluate to a constant true instead of actually deferring the check for the feature to runtime. This means that, if you did want a check at the start of your program, to confirm that all the assumed features are present and error out when the assumptions don't hold, you can't use that macro. You gotta use CPUID and check manually. rip. Hopefully we can make that process easier in a future version of this crate.

A Note On Working With Cfg

There's two main ways to use cfg:

  • Via an attribute placed on an item, block, or expression:
    • #[cfg(debug_assertions)] println!("hello");
  • Via a macro used within an expression position:
    • if cfg!(debug_assertions) { println!("hello"); }

The difference might seem small but it's actually very important:

  • The attribute form will include code or not before deciding if all the items named and so forth really exist or not. This means that code that is configured via attribute can safely name things that don't always exist as long as the things they name do exist whenever that code is configured into the build.
  • The macro form will include the configured code no matter what, and then the macro resolves to a constant true or false and the compiler uses dead code elimination to cut out the path not taken.

This crate uses cfg via the attribute, so the functions it exposes don't exist at all when the appropriate CPU target features aren't enabled. Accordingly, if you plan to call this crate or not depending on what features are enabled in the build you'll also need to control your use of this crate via cfg attribute, not cfg macro.

Modules

naming_conventions

An explanation of the crate's naming conventions.

Macros

aes_key_gen_assist_m128iaes

?

blend_i32_m128iavx2

Blends the i32 lanes in $a and $b into a single value.

blend_imm_i16_m128i

Blends the i16 lanes according to the immediate mask.

blend_imm_i16_m256iavx2

Blends the i16 lanes according to the immediate value.

blend_imm_i32_m256iavx2

Blends the i32 lanes according to the immediate value.

blend_imm_m128d

Blends the lanes according to the immediate mask.

blend_imm_m128

Blends the lanes according to the immediate mask.

blend_imm_m256davx

Blends the f64 lanes according to the immediate mask.

blend_imm_m256avx

Blends the f32 lanes according to the immediate mask.

byte_shl_imm_u128_m128i

Shifts all bits in the entire register left by a number of bytes.

byte_shl_imm_u128_m256iavx2

Shifts each u128 lane left by a number of bytes.

byte_shr_imm_u128_m128i

Shifts all bits in the entire register right by a number of bytes.

byte_shr_imm_u128_m256iavx2

Shifts each u128 lane right by a number of bytes.

cmp_op_mask_m128avx

Compare f32 lanes according to the operation specified, mask output.

cmp_op_mask_m128_savx

Compare f32 lanes according to the operation specified, mask output.

cmp_op_mask_m128davx

Compare f64 lanes according to the operation specified, mask output.

cmp_op_mask_m128d_savx

Compare f64 lanes according to the operation specified, mask output.

cmp_op_mask_m256avx

Compare f32 lanes according to the operation specified, mask output.

cmp_op_mask_m256davx

Compare f64 lanes according to the operation specified, mask output.

combined_byte_shr_imm_m128i

Counts $a as the high bytes and $b as the low bytes then performs a byte shift to the right by the immediate value.

combined_byte_shr_imm_m256i

Works like combined_byte_shr_imm_m128i, but twice as wide.

comparison_operator_translationavx

Turns a comparison operator token to the correct constant value.

dot_product_m128d

Performs a dot product of two m128d registers.

dot_product_m128

Performs a dot product of two m128 registers.

dot_product_m256avx

This works like dot_product_m128, but twice as wide.

extract_f32_as_i32_bits_imm_m128

Gets the f32 lane requested. Returns as an i32 bit pattern.

extract_i16_as_i32_m128i

Gets an i16 value out of an m128i, returns as i32.

extract_i16_as_i32_m256iavx2

Gets an i16 value out of an m256i, returns as i32.

extract_i32_from_m256iavx

Extracts an i32 lane from m256i

extract_i32_imm_m128i

Gets the i32 lane requested. Only the lowest 2 bits are considered.

extract_i64_from_m256iavx

Extracts an i64 lane from m256i

extract_i64_imm_m128i

Gets the i64 lane requested. Only the lowest bit is considered.

extract_i8_as_i32_imm_m128i

Gets the i8 lane requested. Only the lowest 4 bits are considered.

extract_i8_as_i32_m256iavx2

Gets an i8 value out of an m256i, returns as i32.

extract_m128_from_m256avx

Extracts an m128 from m256

extract_m128d_from_m256davx

Extracts an m128d from m256d

extract_m128i_from_m256iavx

Extracts an m128i from m256i

extract_m128i_m256iavx2

Gets an m128i value out of an m256i.

insert_f32_imm_m128

Inserts a lane from $b into $a, optionally at a new position.

insert_i16_from_i32_m128i

Inserts the low 16 bits of an i32 value into an m128i.

insert_i16_to_m256iavx

Inserts an i16 to m256i

insert_i32_imm_m128i

Inserts a new value for the i32 lane specified.

insert_i32_to_m256iavx

Inserts an i32 to m256i

insert_i64_imm_m128i

Inserts a new value for the i64 lane specified.

insert_i64_to_m256iavx

Inserts an i64 to m256i

insert_i8_imm_m128i

Inserts a new value for the i64 lane specified.

insert_i8_to_m256iavx

Inserts an i8 to m256i

insert_m128_to_m256avx

Inserts an m128 to m256

insert_m128d_to_m256davx

Inserts an m128d to m256d

insert_m128i_to_m256i_slow_avxavx

Slowly inserts an m128i to m256i.

insert_m128i_to_m256iavx

Inserts an m128i to an m256i at the high or low position.

mul_i64_carryless_m128ipclmulqdq

Performs a "carryless" multiplication of two i64 values.

multi_packed_sum_abs_diff_u8_m128i

Computes eight u16 "sum of absolute difference" values according to the bytes selected.

multi_packed_sum_abs_diff_u8_m256iavx2

Computes eight u16 "sum of absolute difference" values according to the bytes selected.

round_m128d

Rounds each lane in the style specified.

round_m128d_s

Rounds $b low as specified, keeps $a high.

round_m128

Rounds each lane in the style specified.

round_m128_s

Rounds $b low as specified, other lanes use $a.

round_m256davx

Rounds each lane in the style specified.

round_m256avx

Rounds each lane in the style specified.

shl_imm_u16_m128i

Shifts all u16 lanes left by an immediate.

shl_imm_u16_m256iavx2

Shifts all u16 lanes left by an immediate.

shl_imm_u32_m128i

Shifts all u32 lanes left by an immediate.

shl_imm_u32_m256iavx2

Shifts all u32 lanes left by an immediate.

shl_imm_u64_m128i

Shifts both u64 lanes left by an immediate.

shl_imm_u64_m256iavx2

Shifts all u64 lanes left by an immediate.

shr_imm_i16_m128i

Shifts all i16 lanes right by an immediate.

shr_imm_i16_m256iavx2

Shifts all i16 lanes left by an immediate.

shr_imm_i32_m128i

Shifts all i32 lanes right by an immediate.

shr_imm_i32_m256iavx2

Shifts all i32 lanes left by an immediate.

shr_imm_u16_m128i

Shifts all u16 lanes right by an immediate.

shr_imm_u16_m256iavx2

Shifts all u16 lanes right by an immediate.

shr_imm_u32_m128i

Shifts all u32 lanes right by an immediate.

shr_imm_u32_m256iavx2

Shifts all u32 lanes right by an immediate.

shr_imm_u64_m128i

Shifts both u64 lanes right by an immediate.

shr_imm_u64_m256iavx2

Shifts all u64 lanes right by an immediate.

shuffle_abi_f128z_all_m256davx

Shuffle 128 bits of floating point data at a time from $a and $b using an immediate control value.

shuffle_abi_f128z_all_m256avx

Shuffle 128 bits of floating point data at a time from $a and $b using an immediate control value.

shuffle_abi_f128z_all_m256iavx

Slowly swizzle 128 bits of integer data from $a and $b using an immediate control value.

shuffle_abi_f32_all_m128sse

Shuffle the f32 lanes from $a and $b together using an immediate control value.

shuffle_abi_f32_half_m256avx

Shuffle the f32 lanes from $a and $b together using an immediate control value.

shuffle_abi_f64_all_m128d

Shuffle the f64 lanes from $a and $b together using an immediate control value.

shuffle_abi_f64_half_m256davx

Shuffle the f64 lanes from $a and $b together using an immediate control value.

shuffle_abi_i128z_all_m256iavx

Shuffle 128 bits of integer data from $a and $b using an immediate control value.

shuffle_ai_f32_all_m128i

Shuffle the i32 lanes in $a using an immediate control value.

shuffle_ai_f32_all_m128avx

Shuffle the f32 lanes from $a using an immediate control value.

shuffle_ai_f32_half_m256avx

Shuffle the f32 lanes in $a using an immediate control value.

shuffle_ai_f64_all_m128davx

Shuffle the f64 lanes in $a using an immediate control value.

shuffle_ai_f64_all_m256davx2

Shuffle the f64 lanes from $a using an immediate control value.

shuffle_ai_f64_half_m256davx

Shuffle the f64 lanes from $a and $b together using an immediate control value.

shuffle_ai_i16_h64all_m128i

Shuffle the high i16 lanes in $a using an immediate control value.

shuffle_ai_i16_h64half_m256iavx2

Shuffle the high i16 lanes in $a using an immediate control value.

shuffle_ai_i16_l64all_m128i

Shuffle the low i16 lanes in $a using an immediate control value.

shuffle_ai_i16_l64half_m256iavx2

Shuffle the low i16 lanes in $a using an immediate control value.

shuffle_ai_i32_half_m256iavx2

Shuffle the i32 lanes in $a using an immediate control value.

shuffle_ai_i64_all_m256iavx2

Shuffle the f64 lanes in $a using an immediate control value.

string_search_for_indexsse4.2

Looks for $needle in $haystack and gives the index of the either the first or last match.

string_search_for_masksse4.2

Looks for $needle in $haystack and gives the mask of where the matches were.

Structs

m128

The data for a 128-bit SSE register of four f32 lanes.

m128d

The data for a 128-bit SSE register of two f64 values.

m128i

The data for a 128-bit SSE register of integer data.

m256

The data for a 256-bit AVX register of eight f32 lanes.

m256d

The data for a 256-bit AVX register of four f64 values.

m256i

The data for a 256-bit AVX register of integer data.

Functions

abs_i16_m128issse3

Lanewise absolute value with lanes as i16.

abs_i16_m256iavx2

Absolute value of i16 lanes.

abs_i32_m128issse3

Lanewise absolute value with lanes as i32.

abs_i32_m256iavx2

Absolute value of i32 lanes.

abs_i8_m128issse3

Lanewise absolute value with lanes as i8.

abs_i8_m256iavx2

Absolute value of i8 lanes.

add_carry_u32adx

Add two u32 with a carry value.

add_carry_u64adx

Add two u64 with a carry value.

add_horizontal_i16_m128issse3

Add horizontal pairs of i16 values, pack the outputs as a then b.

add_horizontal_i16_m256iavx2

Horizontal a + b with lanes as i16.

add_horizontal_i32_m128issse3

Add horizontal pairs of i32 values, pack the outputs as a then b.

add_horizontal_i32_m256iavx2

Horizontal a + b with lanes as i32.

add_horizontal_m128dsse3

Add each lane horizontally, pack the outputs as a then b.

add_horizontal_m128sse3

Add each lane horizontally, pack the outputs as a then b.

add_horizontal_m256davx

Add adjacent f64 lanes.

add_horizontal_m256avx

Add adjacent f32 lanes.

add_horizontal_saturating_i16_m128issse3

Add horizontal pairs of i16 values, saturating, pack the outputs as a then b.

add_horizontal_saturating_i16_m256iavx2

Horizontal saturating a + b with lanes as i16.

add_i16_m128isse2

Lanewise a + b with lanes as i16.

add_i16_m256iavx2

Lanewise a + b with lanes as i16.

add_i32_m128isse2

Lanewise a + b with lanes as i32.

add_i32_m256iavx2

Lanewise a + b with lanes as i32.

add_i64_m128isse2

Lanewise a + b with lanes as i64.

add_i64_m256iavx2

Lanewise a + b with lanes as i64.

add_i8_m128isse2

Lanewise a + b with lanes as i8.

add_i8_m256iavx2

Lanewise a + b with lanes as i8.

add_m128sse

Lanewise a + b.

add_m128_ssse

Low lane a + b, other lanes unchanged.

add_m128dsse2

Lanewise a + b.

add_m128d_ssse2

Lowest lane a + b, high lane unchanged.

add_m256davx

Lanewise a + b with f64 lanes.

add_m256avx

Lanewise a + b with f32 lanes.

add_saturating_i16_m128isse2

Lanewise saturating a + b with lanes as i16.

add_saturating_i16_m256iavx2

Lanewise saturating a + b with lanes as i16.

add_saturating_i8_m128isse2

Lanewise saturating a + b with lanes as i8.

add_saturating_i8_m256iavx2

Lanewise saturating a + b with lanes as i8.

add_saturating_u16_m128isse2

Lanewise saturating a + b with lanes as u16.

add_saturating_u16_m256iavx2

Lanewise saturating a + b with lanes as u16.

add_saturating_u8_m128isse2

Lanewise saturating a + b with lanes as u8.

add_saturating_u8_m256iavx2

Lanewise saturating a + b with lanes as u8.

addsub_m128dsse3

Add the high lane and subtract the low lane.

addsub_m128sse3

Alternately, from the top, add a lane and then subtract a lane.

addsub_m256davx

Alternately, from the top, add f64 then sub f64.

addsub_m256avx

Alternately, from the top, add f32 then sub f32.

aes_decrypt_last_m128iaes

"Perform the last round of AES decryption flow on a using the round_key."

aes_decrypt_m128iaes

"Perform one round of AES decryption flow on a using the round_key."

aes_encrypt_last_m128iaes

"Perform the last round of AES encryption flow on a using the round_key."

aes_encrypt_m128iaes

"Perform one round of AES encryption flow on a using the round_key."

aes_inv_mix_columns_m128iaes

"Perform the InvMixColumns transform on a."

average_u16_m128isse2

Lanewise average of the u16 values.

average_u16_m256iavx2

Average u16 lanes.

average_u8_m128isse2

Lanewise average of the u8 values.

average_u8_m256iavx2

Average u8 lanes.

bit_extract2_u32bmi1

Extract a span of bits from the u32, control value style.

bit_extract2_u64bmi1

Extract a span of bits from the u64, control value style.

bit_extract_u32bmi1

Extract a span of bits from the u32, start and len style.

bit_extract_u64bmi1

Extract a span of bits from the u64, start and len style.

bit_lowest_set_mask_u32bmi1

Gets the mask of all bits up to and including the lowest set bit in a u32.

bit_lowest_set_mask_u64bmi1

Gets the mask of all bits up to and including the lowest set bit in a u64.

bit_lowest_set_reset_u32bmi1

Resets (clears) the lowest set bit.

bit_lowest_set_reset_u64bmi1

Resets (clears) the lowest set bit.

bit_lowest_set_value_u32bmi1

Gets the value of the lowest set bit in a u32.

bit_lowest_set_value_u64bmi1

Gets the value of the lowest set bit in a u64.

bit_zero_high_index_u32bmi2

Zero out all high bits in a u32 starting at the index given.

bit_zero_high_index_u64bmi2

Zero out all high bits in a u64 starting at the index given.

bitand_m128sse

Bitwise a & b.

bitand_m128dsse2

Bitwise a & b.

bitand_m128isse2

Bitwise a & b.

bitand_m256davx

Bitwise a & b.

bitand_m256avx

Bitwise a & b.

bitand_m256iavx2

Bitwise a & b.

bitandnot_m128sse

Bitwise (!a) & b.

bitandnot_m128dsse2

Bitwise (!a) & b.

bitandnot_m128isse2

Bitwise (!a) & b.

bitandnot_m256davx

Bitwise (!a) & b.

bitandnot_m256avx

Bitwise (!a) & b.

bitandnot_m256iavx2

Bitwise (!a) & b.

bitandnot_u32bmi1

Bitwise (!a) & b for u32

bitandnot_u64bmi1

Bitwise (!a) & b for u64

bitor_m128sse

Bitwise a | b.

bitor_m128dsse2

Bitwise a | b.

bitor_m128isse2

Bitwise a | b.

bitor_m256davx

Bitwise a | b.

bitor_m256avx

Bitwise a | b.

bitor_m256iavx2

Bitwise a | b

bitxor_m128sse

Bitwise a ^ b.

bitxor_m128dsse2

Bitwise a ^ b.

bitxor_m128isse2

Bitwise a ^ b.

bitxor_m256davx

Bitwise a ^ b.

bitxor_m256avx

Bitwise a ^ b.

bitxor_m256iavx2

Bitwise a ^ b.

blend_varying_i8_m128isse4.1

Blend the i8 lanes according to a runtime varying mask.

blend_varying_i8_m256iavx2

Blend i8 lanes according to a runtime varying mask.

blend_varying_m128dsse4.1

Blend the lanes according to a runtime varying mask.

blend_varying_m128sse4.1

Blend the lanes according to a runtime varying mask.

blend_varying_m256davx

Blend the lanes according to a runtime varying mask.

blend_varying_m256avx

Blend the lanes according to a runtime varying mask.

byte_swap_i32

Swap the bytes of the given 32-bit value.

byte_swap_i64

Swap the bytes of the given 64-bit value.

cast_to_m128_from_m128dsse2

Bit-preserving cast to m128 from m128d

cast_to_m128_from_m128isse2

Bit-preserving cast to m128 from m128i

cast_to_m128_from_m256avx

Bit-preserving cast to m128 from m256.

cast_to_m128d_from_m128sse2

Bit-preserving cast to m128d from m128

cast_to_m128d_from_m128isse2

Bit-preserving cast to m128d from m128i

cast_to_m128d_from_m256davx

Bit-preserving cast to m128d from m256d.

cast_to_m128i_from_m128dsse2

Bit-preserving cast to m128i from m128d

cast_to_m128i_from_m128sse2

Bit-preserving cast to m128i from m128

cast_to_m128i_from_m256iavx

Bit-preserving cast to m128i from m256i.

cast_to_m256_from_m256davx

Bit-preserving cast to m256 from m256d.

cast_to_m256_from_m256iavx

Bit-preserving cast to m256 from m256i.

cast_to_m256d_from_m256avx

Bit-preserving cast to m256i from m256.

cast_to_m256d_from_m256iavx

Bit-preserving cast to m256d from m256i.

cast_to_m256i_from_m256davx

Bit-preserving cast to m256i from m256d.

cast_to_m256i_from_m256avx

Bit-preserving cast to m256i from m256.

ceil_m128dsse4.1

Round each lane to a whole number, towards positive infinity

ceil_m128sse4.1

Round each lane to a whole number, towards positive infinity

ceil_m128d_ssse4.1

Round the low lane of b toward positive infinity, high lane is a.

ceil_m128_ssse4.1

Round the low lane of b toward positive infinity, other lanes a.

ceil_m256davx

Round f64 lanes towards positive infinity.

ceil_m256avx

Round f32 lanes towards positive infinity.

cmp_eq_i32_m128_ssse

Low lane equality.

cmp_eq_i32_m128d_ssse2

Low lane f64 equal to.

cmp_eq_mask_i16_m128isse2

Lanewise a == b with lanes as i16.

cmp_eq_mask_i16_m256iavx2

Compare i16 lanes for equality, mask output.

cmp_eq_mask_i32_m128isse2

Lanewise a == b with lanes as i32.

cmp_eq_mask_i32_m256iavx2

Compare i32 lanes for equality, mask output.

cmp_eq_mask_i64_m128isse4.1

Lanewise a == b with lanes as i64.

cmp_eq_mask_i64_m256iavx2

Compare i64 lanes for equality, mask output.

cmp_eq_mask_i8_m128isse2

Lanewise a == b with lanes as i8.

cmp_eq_mask_i8_m256iavx2

Compare i8 lanes for equality, mask output.

cmp_eq_mask_m128sse

Lanewise a == b.

cmp_eq_mask_m128_ssse

Low lane a == b, other lanes unchanged.

cmp_eq_mask_m128dsse2

Lanewise a == b, mask output.

cmp_eq_mask_m128d_ssse2

Low lane a == b, other lanes unchanged.

cmp_ge_i32_m128_ssse

Low lane greater than or equal to.

cmp_ge_i32_m128d_ssse2

Low lane f64 greater than or equal to.

cmp_ge_mask_m128sse

Lanewise a >= b.

cmp_ge_mask_m128_ssse

Low lane a >= b, other lanes unchanged.

cmp_ge_mask_m128dsse2

Lanewise a >= b.

cmp_ge_mask_m128d_ssse2

Low lane a >= b, other lanes unchanged.

cmp_gt_i32_m128_ssse

Low lane greater than.

cmp_gt_i32_m128d_ssse2

Low lane f64 greater than.

cmp_gt_mask_i16_m128isse2

Lanewise a > b with lanes as i16.

cmp_gt_mask_i16_m256iavx2

Compare i16 lanes for a > b, mask output.

cmp_gt_mask_i32_m128isse2

Lanewise a > b with lanes as i32.

cmp_gt_mask_i32_m256iavx2

Compare i32 lanes for a > b, mask output.

cmp_gt_mask_i64_m128isse4.2

Lanewise a > b with lanes as i64.

cmp_gt_mask_i64_m256iavx2

Compare i64 lanes for a > b, mask output.

cmp_gt_mask_i8_m128isse2

Lanewise a > b with lanes as i8.

cmp_gt_mask_i8_m256iavx2

Compare i8 lanes for a > b, mask output.

cmp_gt_mask_m128sse

Lanewise a > b.

cmp_gt_mask_m128_ssse

Low lane a > b, other lanes unchanged.

cmp_gt_mask_m128dsse2

Lanewise a > b.

cmp_gt_mask_m128d_ssse2

Low lane a > b, other lanes unchanged.

cmp_le_i32_m128_ssse

Low lane less than or equal to.

cmp_le_i32_m128d_ssse2

Low lane f64 less than or equal to.

cmp_le_mask_m128sse

Lanewise a <= b.

cmp_le_mask_m128_ssse

Low lane a <= b, other lanes unchanged.

cmp_le_mask_m128dsse2

Lanewise a <= b.

cmp_le_mask_m128d_ssse2

Low lane a <= b, other lanes unchanged.

cmp_lt_i32_m128_ssse

Low lane less than.

cmp_lt_i32_m128d_ssse2

Low lane f64 less than.

cmp_lt_mask_i16_m128isse2

Lanewise a < b with lanes as i16.

cmp_lt_mask_i32_m128isse2

Lanewise a < b with lanes as i32.

cmp_lt_mask_i8_m128isse2

Lanewise a < b with lanes as i8.

cmp_lt_mask_m128sse

Lanewise a < b.

cmp_lt_mask_m128_ssse

Low lane a < b, other lanes unchanged.

cmp_lt_mask_m128dsse2

Lanewise a < b.

cmp_lt_mask_m128d_ssse2

Low lane a < b, other lane unchanged.

cmp_neq_i32_m128_ssse

Low lane not equal to.

cmp_neq_i32_m128d_ssse2

Low lane f64 less than.

cmp_neq_mask_m128sse

Lanewise a != b.

cmp_neq_mask_m128_ssse

Low lane a != b, other lanes unchanged.

cmp_neq_mask_m128dsse2

Lanewise a != b.

cmp_neq_mask_m128d_ssse2

Low lane a != b, other lane unchanged.

cmp_nge_mask_m128sse

Lanewise !(a >= b).

cmp_nge_mask_m128_ssse

Low lane !(a >= b), other lanes unchanged.

cmp_nge_mask_m128dsse2

Lanewise !(a >= b).

cmp_nge_mask_m128d_ssse2

Low lane !(a >= b), other lane unchanged.

cmp_ngt_mask_m128sse

Lanewise !(a > b).

cmp_ngt_mask_m128_ssse

Low lane !(a > b), other lanes unchanged.

cmp_ngt_mask_m128dsse2

Lanewise !(a > b).

cmp_ngt_mask_m128d_ssse2

Low lane !(a > b), other lane unchanged.

cmp_nle_mask_m128sse

Lanewise !(a <= b).

cmp_nle_mask_m128_ssse

Low lane !(a <= b), other lanes unchanged.

cmp_nle_mask_m128dsse2

Lanewise !(a <= b).

cmp_nle_mask_m128d_ssse2

Low lane !(a <= b), other lane unchanged.

cmp_nlt_mask_m128sse

Lanewise !(a < b).

cmp_nlt_mask_m128_ssse

Low lane !(a < b), other lanes unchanged.

cmp_nlt_mask_m128dsse2

Lanewise !(a < b).

cmp_nlt_mask_m128d_ssse2

Low lane !(a < b), other lane unchanged.

cmp_ordinary_mask_m128sse

Lanewise (!a.is_nan()) & (!b.is_nan()).

cmp_ordinary_mask_m128_ssse

Low lane (!a.is_nan()) & (!b.is_nan()), other lanes unchanged.

cmp_ordinary_mask_m128dsse2

Lanewise (!a.is_nan()) & (!b.is_nan()).

cmp_ordinary_mask_m128d_ssse2

Low lane (!a.is_nan()) & (!b.is_nan()), other lane unchanged.

cmp_unord_mask_m128sse

Lanewise a.is_nan() | b.is_nan().

cmp_unord_mask_m128_ssse

Low lane a.is_nan() | b.is_nan(), other lanes unchanged.

cmp_unord_mask_m128dsse2

Lanewise a.is_nan() | b.is_nan().

cmp_unord_mask_m128d_ssse2

Low lane a.is_nan() | b.is_nan(), other lane unchanged.

convert_i32_replace_m128_ssse

Convert i32 to f32 and replace the low lane of the input.

convert_i32_replace_m128d_ssse2

Convert i32 to f64 and replace the low lane of the input.

convert_i64_replace_m128d_ssse2

Convert i64 to f64 and replace the low lane of the input.

convert_m128_s_replace_m128d_ssse2

Converts the lower f32 to f64 and replace the low lane of the input

convert_m128d_s_replace_m128_ssse2

Converts the low f64 to f32 and replaces the low lane of the input.

convert_to_f32_from_m256_savx

Convert the lowest f32 lane to a single f32.

convert_to_f64_from_m256d_savx

Convert the lowest f64 lane to a single f64.

convert_to_i16_m128i_from_lower2_i16_m128isse4.1

Convert the lower two i64 lanes to two i32 lanes.

convert_to_i16_m128i_from_lower8_i8_m128isse4.1

Convert the lower eight i8 lanes to eight i16 lanes.

convert_to_i16_m256i_from_i8_m128iavx2

Convert i8 values to i16 values.

convert_to_i16_m256i_from_lower4_u8_m128iavx2

Convert lower 4 u8 values to i16 values.

convert_to_i16_m256i_from_lower8_u8_m128iavx2

Convert lower 8 u8 values to i16 values.

convert_to_i16_m256i_from_u8_m128iavx2

Convert u8 values to i16 values.

convert_to_i32_from_m256i_savx

Convert the lowest i32 lane to a single i32.

convert_to_i32_m128i_from_lower4_i16_m128isse4.1

Convert the lower four i16 lanes to four i32 lanes.

convert_to_i32_m128i_from_lower4_i8_m128isse4.1

Convert the lower four i8 lanes to four i32 lanes.

convert_to_i32_m128i_from_m128dsse2

Rounds the two f64 lanes to the low two i32 lanes.

convert_to_i32_m128i_from_m128sse2

Rounds the f32 lanes to i32 lanes.

convert_to_i32_m128i_from_m256davx

Convert f64 lanes to be i32 lanes.

convert_to_i32_m256i_from_i16_m128iavx2

Convert i16 values to i32 values.

convert_to_i32_m256i_from_lower8_i8_m128iavx2

Convert the lower 8 i8 values to i32 values.

convert_to_i32_m256i_from_m256avx

Convert f32 lanes to be i32 lanes.

convert_to_i32_m256i_from_u16_m128iavx2

Convert u16 values to i32 values.

convert_to_i64_m128i_from_lower2_i32_m128isse4.1

Convert the lower two i32 lanes to two i64 lanes.

convert_to_i64_m128i_from_lower2_i8_m128isse4.1

Convert the lower two i8 lanes to two i64 lanes.

convert_to_i64_m256i_from_i32_m128iavx2

Convert i32 values to i64 values.

convert_to_i64_m256i_from_lower4_i16_m128iavx2

Convert i16 values to i64 values.

convert_to_i64_m256i_from_lower4_i8_m128iavx2

Convert the lower 4 i8 values to i64 values.

convert_to_i64_m256i_from_lower4_u16_m128iavx2

Convert u16 values to i64 values.

convert_to_i64_m256i_from_u32_m128iavx2

Convert u32 values to i64 values.

convert_to_m128_from_i32_m128isse2

Rounds the four i32 lanes to four f32 lanes.

convert_to_m128_from_m128dsse2

Rounds the two f64 lanes to the low two f32 lanes.

convert_to_m128_from_m256davx

Convert f64 lanes to be f32 lanes.

convert_to_m128d_from_lower2_i32_m128isse2

Rounds the lower two i32 lanes to two f64 lanes.

convert_to_m128d_from_lower2_m128sse2

Rounds the two f64 lanes to the low two f32 lanes.

convert_to_m256_from_i32_m256iavx

Convert i32 lanes to be f32 lanes.

convert_to_m256d_from_i32_m128iavx

Convert i32 lanes to be f64 lanes.

convert_to_m256d_from_m128avx

Convert f32 lanes to be f64 lanes.

convert_to_u16_m128i_from_lower8_u8_m128isse4.1

Convert the lower eight u8 lanes to eight u16 lanes.

convert_to_u32_m128i_from_lower4_u16_m128isse4.1

Convert the lower four u16 lanes to four u32 lanes.

convert_to_u32_m128i_from_lower4_u8_m128isse4.1

Convert the lower four u8 lanes to four u32 lanes.

convert_to_u64_m128i_from_lower2_u16_m128isse4.1

Convert the lower two u16 lanes to two u64 lanes.

convert_to_u64_m128i_from_lower2_u32_m128isse4.1

Convert the lower two u32 lanes to two u64 lanes.

convert_to_u64_m128i_from_lower2_u8_m128isse4.1

Convert the lower two u8 lanes to two u64 lanes.

convert_truncate_to_i32_m128i_from_m256davx

Convert f64 lanes to i32 lanes with truncation.

convert_truncate_to_i32_m256i_from_m256avx

Convert f32 lanes to i32 lanes with truncation.

copy_i64_m128i_ssse2

Copy the low i64 lane to a new register, upper bits 0.

copy_replace_low_f64_m128dsse2

Copies the a value and replaces the low lane with the low b value.

crc32_u8sse4.2

Accumulates the u8 into a running CRC32 value.

crc32_u16sse4.2

Accumulates the u16 into a running CRC32 value.

crc32_u32sse4.2

Accumulates the u32 into a running CRC32 value.

crc32_u64sse4.2

Accumulates the u64 into a running CRC32 value.

div_m128sse

Lanewise a / b.

div_m128_ssse

Low lane a / b, other lanes unchanged.

div_m128dsse2

Lanewise a / b.

div_m128d_ssse2

Lowest lane a / b, high lane unchanged.

div_m256davx

Lanewise a / b with f64.

div_m256avx

Lanewise a / b with f32.

duplicate_even_lanes_m128sse3

Duplicate the odd lanes to the even lanes.

duplicate_even_lanes_m256avx

Duplicate the even-indexed lanes to the odd lanes.

duplicate_low_lane_m128d_ssse3

Copy the low lane of the input to both lanes of the output.

duplicate_odd_lanes_m128sse3

Duplicate the odd lanes to the even lanes.

duplicate_odd_lanes_m256davx

Duplicate the odd-indexed lanes to the even lanes.

duplicate_odd_lanes_m256avx

Duplicate the odd-indexed lanes to the even lanes.

floor_m128dsse4.1

Round each lane to a whole number, towards negative infinity

floor_m128sse4.1

Round each lane to a whole number, towards negative infinity

floor_m128d_ssse4.1

Round the low lane of b toward negative infinity, high lane is a.

floor_m128_ssse4.1

Round the low lane of b toward negative infinity, other lanes a.

floor_m256davx

Round f64 lanes towards negative infinity.

floor_m256avx

Round f32 lanes towards negative infinity.

fused_mul_add_m128fma

Lanewise fused (a * b) + c

fused_mul_add_m128_sfma

Low lane fused (a * b) + c, other lanes unchanged

fused_mul_add_m128dfma

Lanewise fused (a * b) + c

fused_mul_add_m128d_sfma

Low lane fused (a * b) + c, other lanes unchanged

fused_mul_add_m256fma

Lanewise fused (a * b) + c

fused_mul_add_m256dfma

Lanewise fused (a * b) + c

fused_mul_addsub_m128fma

Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)

fused_mul_addsub_m128dfma

Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)

fused_mul_addsub_m256fma

Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)

fused_mul_addsub_m256dfma

Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)

fused_mul_neg_add_m128fma

Lanewise fused -(a * b) + c

fused_mul_neg_add_m128_sfma

Low lane -(a * b) + c, other lanes unchanged.

fused_mul_neg_add_m128dfma

Lanewise fused -(a * b) + c

fused_mul_neg_add_m128d_sfma

Low lane -(a * b) + c, other lanes unchanged.

fused_mul_neg_add_m256fma

Lanewise fused -(a * b) + c

fused_mul_neg_add_m256dfma

Lanewise fused -(a * b) + c

fused_mul_neg_sub_m128fma

Lanewise fused -(a * b) - c

fused_mul_neg_sub_m128_sfma

Low lane fused -(a * b) - c, other lanes unchanged.

fused_mul_neg_sub_m128dfma

Lanewise fused -(a * b) - c

fused_mul_neg_sub_m128d_sfma

Low lane fused -(a * b) - c, other lanes unchanged.

fused_mul_neg_sub_m256fma

Lanewise fused -(a * b) - c

fused_mul_neg_sub_m256dfma

Lanewise fused -(a * b) - c

fused_mul_sub_m128fma

Lanewise fused (a * b) - c

fused_mul_sub_m128_sfma

Low lane fused (a * b) - c, other lanes unchanged.

fused_mul_sub_m128dfma

Lanewise fused (a * b) - c

fused_mul_sub_m128d_sfma

Low lane fused (a * b) - c, other lanes unchanged.

fused_mul_sub_m256fma

Lanewise fused (a * b) - c

fused_mul_sub_m256dfma

Lanewise fused (a * b) - c

fused_mul_subadd_m128fma

Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)

fused_mul_subadd_m128dfma

Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)

fused_mul_subadd_m256fma

Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)

fused_mul_subadd_m256dfma

Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)

get_f32_from_m128_ssse

Gets the low lane as an individual f32 value.

get_f64_from_m128d_ssse2

Gets the lower lane as an f64 value.

get_i32_from_m128_ssse

Converts the low lane to i32 and extracts as an individual value.

get_i32_from_m128d_ssse2

Converts the lower lane to an i32 value.

get_i32_from_m128i_ssse2

Converts the lower lane to an i32 value.

get_i64_from_m128d_ssse2

Converts the lower lane to an i64 value.

get_i64_from_m128i_ssse2

Converts the lower lane to an i64 value.

leading_zero_count_u32lzcnt

Count the leading zeroes in a u32.

leading_zero_count_u64lzcnt

Count the leading zeroes in a u64.

load_f32_m128_ssse

Loads the f32 reference into the low lane of the register.

load_f32_splat_m128sse

Loads the f32 reference into all lanes of a register.

load_f32_splat_m256avx

Load an f32 and splat it to all lanes of an m256d

load_f64_m128d_ssse2

Loads the reference into the low lane of the register.

load_f64_splat_m128dsse2

Loads the f64 reference into all lanes of a register.

load_f64_splat_m256davx

Load an f64 and splat it to all lanes of an m256d

load_i64_m128i_ssse2

Loads the low i64 into a register.

load_m128sse

Loads the reference into a register.

load_m128dsse2

Loads the reference into a register.

load_m128isse2

Loads the reference into a register.

load_m256davx

Load data from memory into a register.

load_m256avx

Load data from memory into a register.

load_m256iavx

Load data from memory into a register.

load_m128_splat_m256avx

Load an m128 and splat it to the lower and upper half of an m256

load_m128d_splat_m256davx

Load an m128d and splat it to the lower and upper half of an m256d

load_masked_i32_m128iavx2

Loads the reference given and zeroes any i32 lanes not in the mask.

load_masked_i32_m256iavx2

Loads the reference given and zeroes any i32 lanes not in the mask.

load_masked_i64_m128iavx2

Loads the reference given and zeroes any i64 lanes not in the mask.

load_masked_i64_m256iavx2

Loads the reference given and zeroes any i64 lanes not in the mask.

load_masked_m128davx

Load data from memory into a register according to a mask.

load_masked_m128avx

Load data from memory into a register according to a mask.

load_masked_m256davx

Load data from memory into a register according to a mask.

load_masked_m256avx

Load data from memory into a register according to a mask.

load_replace_high_m128dsse2

Loads the reference into a register, replacing the high lane.

load_replace_low_m128dsse2

Loads the reference into a register, replacing the low lane.

load_reverse_m128sse

Loads the reference into a register with reversed order.

load_reverse_m128dsse2

Loads the reference into a register with reversed order.

load_unaligned_hi_lo_m256davx

Load data from memory into a register.

load_unaligned_hi_lo_m256avx

Load data from memory into a register.

load_unaligned_hi_lo_m256iavx

Load data from memory into a register.

load_unaligned_m128sse

Loads the reference into a register.

load_unaligned_m128dsse2

Loads the reference into a register.

load_unaligned_m128isse2

Loads the reference into a register.

load_unaligned_m256davx

Load data from memory into a register.

load_unaligned_m256avx

Load data from memory into a register.

load_unaligned_m256iavx

Load data from memory into a register.

max_i16_m128isse2

Lanewise max(a, b) with lanes as i16.

max_i16_m256iavx2

Lanewise max(a, b) with lanes as i16.

max_i32_m128isse4.1

Lanewise max(a, b) with lanes as i32.

max_i32_m256iavx2

Lanewise max(a, b) with lanes as i32.

max_i8_m128isse4.1

Lanewise max(a, b) with lanes as i8.

max_i8_m256iavx2

Lanewise max(a, b) with lanes as i8.

max_m128sse

Lanewise max(a, b).

max_m128_ssse

Low lane max(a, b), other lanes unchanged.

max_m128dsse2

Lanewise max(a, b).

max_m128d_ssse2

Low lane max(a, b), other lanes unchanged.

max_m256davx

Lanewise max(a, b).

max_m256avx

Lanewise max(a, b).

max_u16_m128isse4.1

Lanewise max(a, b) with lanes as u16.

max_u16_m256iavx2

Lanewise max(a, b) with lanes as u16.

max_u32_m128isse4.1

Lanewise max(a, b) with lanes as u32.

max_u32_m256iavx2

Lanewise max(a, b) with lanes as u32.

max_u8_m128isse2

Lanewise max(a, b) with lanes as u8.

max_u8_m256iavx2

Lanewise max(a, b) with lanes as u8.

min_i16_m128isse2

Lanewise min(a, b) with lanes as i16.

min_i16_m256iavx2

Lanewise min(a, b) with lanes as i16.

min_i32_m128isse4.1

Lanewise min(a, b) with lanes as i32.

min_i32_m256iavx2

Lanewise min(a, b) with lanes as i32.

min_i8_m128isse4.1

Lanewise min(a, b) with lanes as i8.

min_i8_m256iavx2

Lanewise min(a, b) with lanes as i8.

min_m128sse

Lanewise min(a, b).

min_m128_ssse

Low lane min(a, b), other lanes unchanged.

min_m128dsse2

Lanewise min(a, b).

min_m128d_ssse2

Low lane min(a, b), other lanes unchanged.

min_m256davx

Lanewise min(a, b).

min_m256avx

Lanewise min(a, b).

min_position_u16_m128isse4.1

Min u16 value, position, and other lanes zeroed.

min_u16_m128isse4.1

Lanewise min(a, b) with lanes as u16.

min_u16_m256iavx2

Lanewise min(a, b) with lanes as u16.

min_u32_m128isse4.1

Lanewise min(a, b) with lanes as u32.

min_u32_m256iavx2

Lanewise min(a, b) with lanes as u32.

min_u8_m128isse2

Lanewise min(a, b) with lanes as u8.

min_u8_m256iavx2

Lanewise min(a, b) with lanes as u8.

move_high_low_m128sse

Move the high lanes of b to the low lanes of a, other lanes unchanged.

move_low_high_m128sse

Move the low lanes of b to the high lanes of a, other lanes unchanged.

move_m128_ssse

Move the low lane of b to a, other lanes unchanged.

move_mask_i8_m128isse2

Gathers the i8 sign bit of each lane.

move_mask_m128sse

Gathers the sign bit of each lane.

move_mask_m128dsse2

Gathers the sign bit of each lane.

move_mask_m256davx

Collects the sign bit of each lane into a 4-bit value.

move_mask_m256avx

Collects the sign bit of each lane into a 4-bit value.

move_mask_m256iavx2

Create an i32 mask of each sign bit in the i8 lanes.

mul_extended_u32bmi2

Multiply two u32, outputting the low bits and storing the high bits in the reference.

mul_extended_u64bmi2

Multiply two u64, outputting the low bits and storing the high bits in the reference.

mul_i16_horizontal_add_m128isse2

Multiply i16 lanes producing i32 values, horizontal add pairs of i32 values to produce the final output.

mul_i16_horizontal_add_m256iavx2

Multiply i16 lanes producing i32 values, horizontal add pairs of i32 values to produce the final output.

mul_i16_keep_high_m128isse2

Lanewise a * b with lanes as i16, keep the high bits of the i32 intermediates.

mul_i16_keep_high_m256iavx2

Multiply the i16 lanes and keep the high half of each 32-bit output.

mul_i16_keep_low_m128isse2

Lanewise a * b with lanes as i16, keep the low bits of the i32 intermediates.

mul_i16_keep_low_m256iavx2

Multiply the i16 lanes and keep the low half of each 32-bit output.

mul_i16_scale_round_m128issse3

Multiply i16 lanes into i32 intermediates, keep the high 18 bits, round by adding 1, right shift by 1.

mul_i16_scale_round_m256iavx2

Multiply i16 lanes into i32 intermediates, keep the high 18 bits, round by adding 1, right shift by 1.

mul_i32_keep_low_m128isse4.1

Lanewise a * b with lanes as i32, keep the low bits of the i64 intermediates.

mul_i32_keep_low_m256iavx2

Multiply the i32 lanes and keep the low half of each 64-bit output.

mul_i64_low_bits_m256iavx2

Multiply the lower i32 within each i64 lane, i64 output.

mul_m128sse

Lanewise a * b.

mul_m128_ssse

Low lane a * b, other lanes unchanged.

mul_m128dsse2

Lanewise a * b.

mul_m128d_ssse2

Lowest lane a * b, high lane unchanged.

mul_m256davx

Lanewise a * b with f64 lanes.

mul_m256avx

Lanewise a * b with f32 lanes.

mul_u16_keep_high_m128isse2

Lanewise a * b with lanes as u16, keep the high bits of the u32 intermediates.

mul_u16_keep_high_m256iavx2

Multiply the u16 lanes and keep the high half of each 32-bit output.

mul_u64_low_bits_m256iavx2

Multiply the lower u32 within each u64 lane, u64 output.

mul_u8i8_add_horizontal_saturating_m128issse3

This is dumb and weird.

mul_u8i8_add_horizontal_saturating_m256iavx2

This is dumb and weird.

mul_widen_i32_odd_m128isse4.1

Multiplies the odd i32 lanes and gives the widened (i64) results.

mul_widen_u32_odd_m128isse2

Multiplies the odd u32 lanes and gives the widened (u64) results.

pack_i16_to_i8_m128isse2

Saturating convert i16 to i8, and pack the values.

pack_i16_to_i8_m256iavx2

Saturating convert i16 to i8, and pack the values.

pack_i16_to_u8_m128isse2

Saturating convert i16 to u8, and pack the values.

pack_i16_to_u8_m256iavx2

Saturating convert i16 to u8, and pack the values.

pack_i32_to_i16_m128isse2

Saturating convert i32 to i16, and pack the values.

pack_i32_to_i16_m256iavx2

Saturating convert i32 to i16, and pack the values.

pack_i32_to_u16_m128isse4.1

Saturating convert i32 to u16, and pack the values.

pack_i32_to_u16_m256iavx2

Saturating convert i32 to u16, and pack the values.

population_count_i32popcnt

Count the number of bits set within an i32

population_count_i64popcnt

Count the number of bits set within an i64

population_deposit_u32bmi2

Deposit contiguous low bits from a u32 according to a mask.

population_deposit_u64bmi2

Deposit contiguous low bits from a u64 according to a mask.

population_extract_u32bmi2

Extract bits from a u32 according to a mask.

population_extract_u64bmi2

Extract bits from a u64 according to a mask.

rdrand_u16rdrand

Try to obtain a random u16 from the hardware RNG.

rdrand_u32rdrand

Try to obtain a random u32 from the hardware RNG.

rdrand_u64rdrand

Try to obtain a random u64 from the hardware RNG.

rdseed_u16rdseed

Try to obtain a random u16 from the hardware RNG.

rdseed_u32rdseed

Try to obtain a random u32 from the hardware RNG.

rdseed_u64rdseed

Try to obtain a random u64 from the hardware RNG.

read_timestamp_counter

Reads the CPU's timestamp counter value.

read_timestamp_counter_p

Reads the CPU's timestamp counter value and store the processor signature.

reciprocal_m128sse

Lanewise 1.0 / a approximation.

reciprocal_m128_ssse

Low lane 1.0 / a approximation, other lanes unchanged.

reciprocal_m256avx

Reciprocal of f32 lanes.

reciprocal_sqrt_m128sse

Lanewise 1.0 / sqrt(a) approximation.

reciprocal_sqrt_m128_ssse

Low lane 1.0 / sqrt(a) approximation, other lanes unchanged.

reciprocal_sqrt_m256avx

Reciprocal of f32 lanes.

set_i16_m128isse2

Sets the args into an m128i, first arg is the high lane.

set_i16_m256iavx

Set i16 args into an m256i lane.

set_i32_m128i_ssse2

Set an i32 as the low 32-bit lane of an m128i, other lanes blank.

set_i32_m128isse2

Sets the args into an m128i, first arg is the high lane.

set_i32_m256iavx

Set i32 args into an m256i lane.

set_i64_m128i_ssse2

Set an i64 as the low 64-bit lane of an m128i, other lanes blank.

set_i64_m128isse2

Sets the args into an m128i, first arg is the high lane.

set_i8_m128isse2

Sets the args into an m128i, first arg is the high lane.

set_i8_m256iavx

Set i8 args into an m256i lane.

set_m128sse

Sets the args into an m128, first arg is the high lane.

set_m128_ssse

Sets the args into an m128, first arg is the high lane.

set_m128dsse2

Sets the args into an m128d, first arg is the high lane.

set_m128d_ssse2

Sets the args into the low lane of a m128d.

set_m256davx

Set f64 args into an m256d lane.

set_m256avx

Set f32 args into an m256 lane.

set_m128d_m256davx

Set m128d args into an m256d.

set_m128i_m256iavx

Set m128i args into an m256i.

set_reversed_i16_m128isse2

Sets the args into an m128i, first arg is the low lane.

set_reversed_i16_m256iavx

Set i16 args into an m256i lane.

set_reversed_i32_m128isse2

Sets the args into an m128i, first arg is the low lane.

set_reversed_i32_m256iavx

Set i32 args into an m256i lane.

set_reversed_i8_m128isse2

Sets the args into an m128i, first arg is the low lane.

set_reversed_i8_m256iavx

Set i8 args into an m256i lane.

set_reversed_m128sse

Sets the args into an m128, first arg is the low lane.

set_reversed_m128dsse2

Sets the args into an m128d, first arg is the low lane.

set_reversed_m256davx

Set f64 args into an m256d lane.

set_reversed_m256avx

Set f32 args into an m256 lane.

set_reversed_m128d_m256davx

Set m128d args into an m256d.

set_reversed_m128i_m256iavx

Set m128i args into an m256i.

set_splat_i16_m128isse2

Splats the i16 to all lanes of the m128i.

set_splat_i16_m256iavx

Splat an i16 arg into an m256i lane.

set_splat_i16_m128i_s_m256iavx2

Sets the lowest i16 lane of an m128i as all lanes of an m256i.

set_splat_i32_m128isse2

Splats the i32 to all lanes of the m128i.

set_splat_i32_m256iavx

Splat an i32 arg into an m256i lane.

set_splat_i32_m128i_s_m256iavx2

Sets the lowest i32 lane of an m128i as all lanes of an m256i.

set_splat_i64_m128isse2

Splats the i64 to both lanes of the m128i.

set_splat_i64_m128i_s_m256iavx2

Sets the lowest i64 lane of an m128i as all lanes of an m256i.

set_splat_i8_m128isse2

Splats the i8 to all lanes of the m128i.

set_splat_i8_m256iavx

Splat an i8 arg into an m256i lane.

set_splat_i8_m128i_s_m256iavx2

Sets the lowest i8 lane of an m128i as all lanes of an m256i.

set_splat_m128sse

Splats the value to all lanes.

set_splat_m128dsse2

Splats the args into both lanes of the m128d.

set_splat_m256davx

Splat an f64 arg into an m256d lane.

set_splat_m256avx

Splat an f32 arg into an m256 lane.

set_splat_m128_s_m256avx2

Sets the lowest lane of an m128 as all lanes of an m256.

set_splat_m128d_s_m256davx2

Sets the lowest lane of an m128d as all lanes of an m256d.

shl_all_u16_m128isse2

Shift all u16 lanes to the left by the count in the lower u64 lane.

shl_all_u16_m256iavx2

Lanewise u16 shift left by the lower u64 lane of count.

shl_all_u32_m128isse2

Shift all u32 lanes to the left by the count in the lower u64 lane.

shl_all_u32_m256iavx2

Shift all u32 lanes left by the lower u64 lane of count.

shl_all_u64_m128isse2

Shift all u64 lanes to the left by the count in the lower u64 lane.

shl_all_u64_m256iavx2

Shift all u64 lanes left by the lower u64 lane of count.

shl_each_u32_m128iavx2

Shift u32 values to the left by count bits.

shl_each_u32_m256iavx2

Lanewise u32 shift left by the matching i32 lane in count.

shl_each_u64_m128iavx2

Shift u64 values to the left by count bits.

shl_each_u64_m256iavx2

Lanewise u64 shift left by the matching u64 lane in count.

shr_all_i16_m128isse2

Shift each i16 lane to the right by the count in the lower i64 lane.

shr_all_i16_m256iavx2

Lanewise i16 shift right by the lower i64 lane of count.

shr_all_i32_m128isse2

Shift each i32 lane to the right by the count in the lower i64 lane.

shr_all_i32_m256iavx2

Lanewise i32 shift right by the lower i64 lane of count.

shr_all_u16_m128isse2

Shift each u16 lane to the right by the count in the lower u64 lane.

shr_all_u16_m256iavx2

Lanewise u16 shift right by the lower u64 lane of count.

shr_all_u32_m128isse2

Shift each u32 lane to the right by the count in the lower u64 lane.

shr_all_u32_m256iavx2

Lanewise u32 shift right by the lower u64 lane of count.

shr_all_u64_m128isse2

Shift each u64 lane to the right by the count in the lower u64 lane.

shr_all_u64_m256iavx2

Lanewise u64 shift right by the lower u64 lane of count.

shr_each_i32_m128iavx2

Shift i32 values to the right by count bits.

shr_each_i32_m256iavx2

Lanewise i32 shift right by the matching i32 lane in count.

shr_each_u32_m128iavx2

Shift u32 values to the left by count bits.

shr_each_u32_m256iavx2

Lanewise u32 shift right by the matching u32 lane in count.

shr_each_u64_m128iavx2

Shift u64 values to the left by count bits.

shr_each_u64_m256iavx2

Lanewise u64 shift right by the matching i64 lane in count.

shuffle_av_f32_all_m128avx

Shuffle f32 values in a using i32 values in v.

shuffle_av_f32_half_m256avx

Shuffle f32 values in a using i32 values in v.

shuffle_av_f64_all_m128davx

Shuffle f64 lanes in a using bit 1 of the i64 lanes in v

shuffle_av_f64_half_m256davx

Shuffle f64 lanes in a using bit 1 of the i64 lanes in v.

shuffle_av_i32_all_m256iavx2

Shuffle i32 lanes in a using i32 values in v.

shuffle_av_i32_all_m256avx2

Shuffle f32 lanes in a using i32 values in v.

shuffle_av_i8z_all_m128issse3

Shuffle i8 lanes in a using i8 values in v.

shuffle_av_i8z_half_m256iavx2

Shuffle i8 lanes in a using i8 values in v.

sign_apply_i16_m128issse3

Applies the sign of i16 values in b to the values in a.

sign_apply_i16_m256iavx2

Lanewise a * signum(b) with lanes as i16

sign_apply_i32_m128issse3

Applies the sign of i32 values in b to the values in a.

sign_apply_i32_m256iavx2

Lanewise a * signum(b) with lanes as i32

sign_apply_i8_m128issse3

Applies the sign of i8 values in b to the values in a.

sign_apply_i8_m256iavx2

Lanewise a * signum(b) with lanes as i8

splat_i16_m128i_s_m128iavx2

Splat the lowest 16-bit lane across the entire 128 bits.

splat_i32_m128i_s_m128iavx2

Splat the lowest 32-bit lane across the entire 128 bits.

splat_i64_m128i_s_m128iavx2

Splat the lowest 64-bit lane across the entire 128 bits.

splat_i8_m128i_s_m128iavx2

Splat the lowest 8-bit lane across the entire 128 bits.

splat_m128_s_m128avx2

Splat the lowest f32 across all four lanes.

splat_m128d_s_m128davx2

Splat the lower f64 across both lanes of m128d.

splat_m128i_m256iavx2

Splat the 128-bits across 256-bits.

sqrt_m128sse

Lanewise sqrt(a).

sqrt_m128_ssse

Low lane sqrt(a), other lanes unchanged.

sqrt_m128dsse2

Lanewise sqrt(a).

sqrt_m128d_ssse2

Low lane sqrt(b), upper lane is unchanged from a.

sqrt_m256davx

Lanewise sqrt on f64 lanes.

sqrt_m256avx

Lanewise sqrt on f64 lanes.

store_high_m128d_ssse2

Stores the high lane value to the reference given.

store_i64_m128i_ssse2

Stores the value to the reference given.

store_m128sse

Stores the value to the reference given.

store_m128_ssse

Stores the low lane value to the reference given.

store_m128dsse2

Stores the value to the reference given.

store_m128d_ssse2

Stores the low lane value to the reference given.

store_m128isse2

Stores the value to the reference given.

store_m256davx

Store data from a register into memory.

store_m256avx

Store data from a register into memory.

store_m256iavx

Store data from a register into memory.

store_masked_i32_m128iavx2

Stores the i32 masked lanes given to the reference.

store_masked_i32_m256iavx2

Stores the i32 masked lanes given to the reference.

store_masked_i64_m128iavx2

Stores the i32 masked lanes given to the reference.

store_masked_i64_m256iavx2

Stores the i32 masked lanes given to the reference.

store_masked_m128davx

Store data from a register into memory according to a mask.

store_masked_m128avx

Store data from a register into memory according to a mask.

store_masked_m256davx

Store data from a register into memory according to a mask.

store_masked_m256avx

Store data from a register into memory according to a mask.

store_reverse_m128sse

Stores the value to the reference given in reverse order.

store_reversed_m128dsse2

Stores the value to the reference given.

store_splat_m128sse

Stores the low lane value to all lanes of the reference given.

store_splat_m128dsse2

Stores the low lane value to all lanes of the reference given.

store_unaligned_hi_lo_m256davx

Store data from a register into memory.

store_unaligned_hi_lo_m256avx

Store data from a register into memory.

store_unaligned_hi_lo_m256iavx

Store data from a register into memory.

store_unaligned_m128sse

Stores the value to the reference given.

store_unaligned_m128dsse2

Stores the value to the reference given.

store_unaligned_m128isse2

Stores the value to the reference given.

store_unaligned_m256davx

Store data from a register into memory.

store_unaligned_m256avx

Store data from a register into memory.

store_unaligned_m256iavx

Store data from a register into memory.

sub_horizontal_i16_m128issse3

Subtract horizontal pairs of i16 values, pack the outputs as a then b.

sub_horizontal_i16_m256iavx2

Horizontal a - b with lanes as i16.

sub_horizontal_i32_m128issse3

Subtract horizontal pairs of i32 values, pack the outputs as a then b.

sub_horizontal_i32_m256iavx2

Horizontal a - b with lanes as i32.

sub_horizontal_m128dsse3

Subtract each lane horizontally, pack the outputs as a then b.

sub_horizontal_m128sse3

Subtract each lane horizontally, pack the outputs as a then b.

sub_horizontal_m256davx

Subtract adjacent f64 lanes.

sub_horizontal_m256avx

Subtract adjacent f32 lanes.

sub_horizontal_saturating_i16_m128issse3

Subtract horizontal pairs of i16 values, saturating, pack the outputs as a then b.

sub_horizontal_saturating_i16_m256iavx2

Horizontal saturating a - b with lanes as i16.

sub_i16_m128isse2

Lanewise a - b with lanes as i16.

sub_i16_m256iavx2

Lanewise a - b with lanes as i16.

sub_i32_m128isse2

Lanewise a - b with lanes as i32.

sub_i32_m256iavx2

Lanewise a - b with lanes as i32.

sub_i64_m128isse2

Lanewise a - b with lanes as i64.

sub_i64_m256iavx2

Lanewise a - b with lanes as i64.

sub_i8_m128isse2

Lanewise a - b with lanes as i8.

sub_i8_m256iavx2

Lanewise a - b with lanes as i8.

sub_m128sse

Lanewise a - b.

sub_m128_ssse

Low lane a - b, other lanes unchanged.

sub_m128dsse2

Lanewise a - b.

sub_m128d_ssse2

Lowest lane a - b, high lane unchanged.

sub_m256davx

Lanewise a - b with f64 lanes.

sub_m256avx

Lanewise a - b with f32 lanes.

sub_saturating_i16_m128isse2

Lanewise saturating a - b with lanes as i16.

sub_saturating_i16_m256iavx2

Lanewise saturating a - b with lanes as i16.

sub_saturating_i8_m128isse2

Lanewise saturating a - b with lanes as i8.

sub_saturating_i8_m256iavx2

Lanewise saturating a - b with lanes as i8.

sub_saturating_u16_m128isse2

Lanewise saturating a - b with lanes as u16.

sub_saturating_u16_m256iavx2

Lanewise saturating a - b with lanes as u16.

sub_saturating_u8_m128isse2

Lanewise saturating a - b with lanes as u8.

sub_saturating_u8_m256iavx2

Lanewise saturating a - b with lanes as u8.

sum_of_u8_abs_diff_m128isse2

Compute "sum of u8 absolute differences".

sum_of_u8_abs_diff_m256iavx2

Compute "sum of u8 absolute differences".

test_all_ones_m128isse4.1

Tests if all bits are 1.

test_all_zeroes_m128isse4.1

Returns if all masked bits are 0, (a & mask) as u128 == 0

test_mixed_ones_and_zeroes_m128isse4.1

Returns if, among the masked bits, there's both 0s and 1s

trailing_zero_count_u32bmi1

Counts the number of trailing zero bits in a u32.

trailing_zero_count_u64bmi1

Counts the number of trailing zero bits in a u64.

transpose_four_m128sse

Transpose four m128 as if they were a 4x4 matrix.

truncate_m128_to_m128isse2

Truncate the f32 lanes to i32 lanes.

truncate_m128d_to_m128isse2

Truncate the f64 lanes to the lower i32 lanes (upper i32 lanes 0).

truncate_to_i32_m128d_ssse2

Truncate the lower lane into an i32.

truncate_to_i64_m128d_ssse2

Truncate the lower lane into an i64.

unpack_hi_m256davx

Unpack and interleave the high lanes.

unpack_hi_m256avx

Unpack and interleave the high lanes.

unpack_high_i16_m128isse2

Unpack and interleave high i16 lanes of a and b.

unpack_high_i16_m256iavx2

Unpack and interleave high i16 lanes of a and b.

unpack_high_i32_m128isse2

Unpack and interleave high i32 lanes of a and b.

unpack_high_i32_m256iavx2

Unpack and interleave high i32 lanes of a and b.

unpack_high_i64_m128isse2

Unpack and interleave high i64 lanes of a and b.

unpack_high_i64_m256iavx2

Unpack and interleave high i64 lanes of a and b.

unpack_high_i8_m128isse2

Unpack and interleave high i8 lanes of a and b.

unpack_high_i8_m256iavx2

Unpack and interleave high i8 lanes of a and b.

unpack_high_m128sse

Unpack and interleave high lanes of a and b.

unpack_high_m128dsse2

Unpack and interleave high lanes of a and b.

unpack_lo_m256davx

Unpack and interleave the high lanes.

unpack_lo_m256avx

Unpack and interleave the high lanes.

unpack_low_i16_m128isse2

Unpack and interleave low i16 lanes of a and b.

unpack_low_i16_m256iavx2

Unpack and interleave low i16 lanes of a and b.

unpack_low_i32_m128isse2

Unpack and interleave low i32 lanes of a and b.

unpack_low_i32_m256iavx2

Unpack and interleave low i32 lanes of a and b.

unpack_low_i64_m128isse2

Unpack and interleave low i64 lanes of a and b.

unpack_low_i64_m256iavx2

Unpack and interleave low i64 lanes of a and b.

unpack_low_i8_m128isse2

Unpack and interleave low i8 lanes of a and b.

unpack_low_i8_m256iavx2

Unpack and interleave low i8 lanes of a and b.

unpack_low_m128sse

Unpack and interleave low lanes of a and b.

unpack_low_m128dsse2

Unpack and interleave low lanes of a and b.

zero_extend_m128davx

Zero extend an m128d to m256d

zero_extend_m128avx

Zero extend an m128 to m256

zero_extend_m128iavx

Zero extend an m128i to m256i

zeroed_m128sse

All lanes zero.

zeroed_m128isse2

All lanes zero.

zeroed_m128dsse2

Both lanes zero.

zeroed_m256davx

A zeroed m256d

zeroed_m256avx

A zeroed m256

zeroed_m256iavx

A zeroed m256i