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_m128i
  ?
• blend_i32_m128i
  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_m256i
  Blends the i16 lanes according to the immediate value.
• blend_imm_i32_m256i
  Blends the i32 lanes according to the immediate value.
• blend_imm_m128
  Blends the lanes according to the immediate mask.
• blend_imm_m128d
  Blends the lanes according to the immediate mask.
• blend_imm_m256
  Blends the f32 lanes according to the immediate mask.
• blend_imm_m256d
  Blends the f64 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_m256i
  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_m256i
  Shifts each u128 lane right by a number of bytes.
• cmp_op_mask_m128
  Compare f32 lanes according to the operation specified, mask output.
• cmp_op_mask_m128_s
  Compare f32 lanes according to the operation specified, mask output.
• cmp_op_mask_m128d
  Compare f64 lanes according to the operation specified, mask output.
• cmp_op_mask_m128d_s
  Compare f64 lanes according to the operation specified, mask output.
• cmp_op_mask_m256
  Compare f32 lanes according to the operation specified, mask output.
• cmp_op_mask_m256d
  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_translation
  Turns a comparison operator token to the correct constant value.
• dot_product_m128
  Performs a dot product of two m128 registers.
• dot_product_m128d
  Performs a dot product of two m128d registers.
• dot_product_m256
  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_i8_as_i32_imm_m128i
  Gets the i8 lane requested. Only the lowest 4 bits are considered.
• extract_i8_as_i32_m256i
  Gets an i8 value out of an m256i, returns as i32.
• extract_i16_as_i32_m128i
  Gets an i16 value out of an m128i, returns as i32.
• extract_i16_as_i32_m256i
  Gets an i16 value out of an m256i, returns as i32.
• extract_i32_from_m256i
  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_m256i
  Extracts an i64 lane from m256i
• extract_i64_imm_m128i
  Gets the i64 lane requested. Only the lowest bit is considered.
• extract_m128_from_m256
  Extracts an m128 from m256
• extract_m128d_from_m256d
  Extracts an m128d from m256d
• extract_m128i_from_m256i
  Extracts an m128i from m256i
• extract_m128i_m256i
  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_i8_imm_m128i
  Inserts a new value for the i64 lane specified.
• insert_i8_to_m256i
  Inserts an i8 to m256i
• insert_i16_from_i32_m128i
  Inserts the low 16 bits of an i32 value into an m128i.
• insert_i16_to_m256i
  Inserts an i16 to m256i
• insert_i32_imm_m128i
  Inserts a new value for the i32 lane specified.
• insert_i32_to_m256i
  Inserts an i32 to m256i
• insert_i64_imm_m128i
  Inserts a new value for the i64 lane specified.
• insert_i64_to_m256i
  Inserts an i64 to m256i
• insert_m128_to_m256
  Inserts an m128 to m256
• insert_m128d_to_m256d
  Inserts an m128d to m256d
• insert_m128i_to_m256i
  Inserts an m128i to an m256i at the high or low position.
• insert_m128i_to_m256i_slow_avx
  Slowly inserts an m128i to m256i.
• mul_i64_carryless_m128i
  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_m256i
  Computes eight u16 “sum of absolute difference” values according to the bytes selected.
• round_m128
  Rounds each lane in the style specified.
• round_m128_s
  Rounds $b low as specified, other lanes use $a.
• round_m128d
  Rounds each lane in the style specified.
• round_m128d_s
  Rounds $b low as specified, keeps $a high.
• round_m256
  Rounds each lane in the style specified.
• round_m256d
  Rounds each lane in the style specified.
• shl_imm_u16_m128i
  Shifts all u16 lanes left by an immediate.
• shl_imm_u16_m256i
  Shifts all u16 lanes left by an immediate.
• shl_imm_u32_m128i
  Shifts all u32 lanes left by an immediate.
• shl_imm_u32_m256i
  Shifts all u32 lanes left by an immediate.
• shl_imm_u64_m128i
  Shifts both u64 lanes left by an immediate.
• shl_imm_u64_m256i
  Shifts all u64 lanes left by an immediate.
• shr_imm_i16_m128i
  Shifts all i16 lanes right by an immediate.
• shr_imm_i16_m256i
  Shifts all i16 lanes left by an immediate.
• shr_imm_i32_m128i
  Shifts all i32 lanes right by an immediate.
• shr_imm_i32_m256i
  Shifts all i32 lanes left by an immediate.
• shr_imm_u16_m128i
  Shifts all u16 lanes right by an immediate.
• shr_imm_u16_m256i
  Shifts all u16 lanes right by an immediate.
• shr_imm_u32_m128i
  Shifts all u32 lanes right by an immediate.
• shr_imm_u32_m256i
  Shifts all u32 lanes right by an immediate.
• shr_imm_u64_m128i
  Shifts both u64 lanes right by an immediate.
• shr_imm_u64_m256i
  Shifts all u64 lanes right by an immediate.
• shuffle_abi_f32_all_m128
  Shuffle the f32 lanes from $a and $b together using an immediate control value.
• shuffle_abi_f32_half_m256
  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_m256d
  Shuffle the f64 lanes from $a and $b together using an immediate control value.
• shuffle_abi_f128z_all_m256
  Shuffle 128 bits of floating point data at a time from $a and $b using an immediate control value.
• shuffle_abi_f128z_all_m256d
  Shuffle 128 bits of floating point data at a time from $a and $b using an immediate control value.
• shuffle_abi_f128z_all_m256i
  Slowly swizzle 128 bits of integer data from $a and $b using an immediate control value.
• shuffle_abi_i128z_all_m256i
  Shuffle 128 bits of integer data from $a and $b using an immediate control value.
• shuffle_ai_f32_all_m128
  Shuffle the f32 lanes from $a using an immediate control value.
• shuffle_ai_f32_all_m128i
  Shuffle the i32 lanes in $a using an immediate control value.
• shuffle_ai_f32_half_m256
  Shuffle the f32 lanes in $a using an immediate control value.
• shuffle_ai_f64_all_m128d
  Shuffle the f64 lanes in $a using an immediate control value.
• shuffle_ai_f64_all_m256d
  Shuffle the f64 lanes from $a using an immediate control value.
• shuffle_ai_f64_half_m256d
  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_m256i
  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_m256i
  Shuffle the low i16 lanes in $a using an immediate control value.
• shuffle_ai_i32_half_m256i
  Shuffle the i32 lanes in $a using an immediate control value.
• shuffle_ai_i64_all_m256i
  Shuffle the f64 lanes in $a using an immediate control value.
• string_search_for_index
  Looks for $needle in $haystack and gives the index of the either the first or last match.
• string_search_for_mask
  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_i8_m128i
  Lanewise absolute value with lanes as i8.
• abs_i8_m256i
  Absolute value of i8 lanes.
• abs_i16_m128i
  Lanewise absolute value with lanes as i16.
• abs_i16_m256i
  Absolute value of i16 lanes.
• abs_i32_m128i
  Lanewise absolute value with lanes as i32.
• abs_i32_m256i
  Absolute value of i32 lanes.
• add_carry_u32
  Add two u32 with a carry value.
• add_carry_u64
  Add two u64 with a carry value.
• add_horizontal_i16_m128i
  Add horizontal pairs of i16 values, pack the outputs as a then b.
• add_horizontal_i16_m256i
  Horizontal a + b with lanes as i16.
• add_horizontal_i32_m128i
  Add horizontal pairs of i32 values, pack the outputs as a then b.
• add_horizontal_i32_m256i
  Horizontal a + b with lanes as i32.
• add_horizontal_m128
  Add each lane horizontally, pack the outputs as a then b.
• add_horizontal_m128d
  Add each lane horizontally, pack the outputs as a then b.
• add_horizontal_m256
  Add adjacent f32 lanes.
• add_horizontal_m256d
  Add adjacent f64 lanes.
• add_horizontal_saturating_i16_m128i
  Add horizontal pairs of i16 values, saturating, pack the outputs as a then b.
• add_horizontal_saturating_i16_m256i
  Horizontal saturating a + b with lanes as i16.
• add_i8_m128i
  Lanewise a + b with lanes as i8.
• add_i8_m256i
  Lanewise a + b with lanes as i8.
• add_i16_m128i
  Lanewise a + b with lanes as i16.
• add_i16_m256i
  Lanewise a + b with lanes as i16.
• add_i32_m128i
  Lanewise a + b with lanes as i32.
• add_i32_m256i
  Lanewise a + b with lanes as i32.
• add_i64_m128i
  Lanewise a + b with lanes as i64.
• add_i64_m256i
  Lanewise a + b with lanes as i64.
• add_m128
  Lanewise a + b.
• add_m128_s
  Low lane a + b, other lanes unchanged.
• add_m128d
  Lanewise a + b.
• add_m128d_s
  Lowest lane a + b, high lane unchanged.
• add_m256
  Lanewise a + b with f32 lanes.
• add_m256d
  Lanewise a + b with f64 lanes.
• add_saturating_i8_m128i
  Lanewise saturating a + b with lanes as i8.
• add_saturating_i8_m256i
  Lanewise saturating a + b with lanes as i8.
• add_saturating_i16_m128i
  Lanewise saturating a + b with lanes as i16.
• add_saturating_i16_m256i
  Lanewise saturating a + b with lanes as i16.
• add_saturating_u8_m128i
  Lanewise saturating a + b with lanes as u8.
• add_saturating_u8_m256i
  Lanewise saturating a + b with lanes as u8.
• add_saturating_u16_m128i
  Lanewise saturating a + b with lanes as u16.
• add_saturating_u16_m256i
  Lanewise saturating a + b with lanes as u16.
• addsub_m128
  Alternately, from the top, add a lane and then subtract a lane.
• addsub_m128d
  Add the high lane and subtract the low lane.
• addsub_m256
  Alternately, from the top, add f32 then sub f32.
• addsub_m256d
  Alternately, from the top, add f64 then sub f64.
• aes_decrypt_last_m128i
  “Perform the last round of AES decryption flow on a using the round_key.”
• aes_decrypt_m128i
  “Perform one round of AES decryption flow on a using the round_key.”
• aes_encrypt_last_m128i
  “Perform the last round of AES encryption flow on a using the round_key.”
• aes_encrypt_m128i
  “Perform one round of AES encryption flow on a using the round_key.”
• aes_inv_mix_columns_m128i
  “Perform the InvMixColumns transform on a.”
• average_u8_m128i
  Lanewise average of the u8 values.
• average_u8_m256i
  Average u8 lanes.
• average_u16_m128i
  Lanewise average of the u16 values.
• average_u16_m256i
  Average u16 lanes.
• bit_extract2_u32
  Extract a span of bits from the u32, control value style.
• bit_extract2_u64
  Extract a span of bits from the u64, control value style.
• bit_extract_u32
  Extract a span of bits from the u32, start and len style.
• bit_extract_u64
  Extract a span of bits from the u64, start and len style.
• bit_lowest_set_mask_u32
  Gets the mask of all bits up to and including the lowest set bit in a u32.
• bit_lowest_set_mask_u64
  Gets the mask of all bits up to and including the lowest set bit in a u64.
• bit_lowest_set_reset_u32
  Resets (clears) the lowest set bit.
• bit_lowest_set_reset_u64
  Resets (clears) the lowest set bit.
• bit_lowest_set_value_u32
  Gets the value of the lowest set bit in a u32.
• bit_lowest_set_value_u64
  Gets the value of the lowest set bit in a u64.
• bit_zero_high_index_u32
  Zero out all high bits in a u32 starting at the index given.
• bit_zero_high_index_u64
  Zero out all high bits in a u64 starting at the index given.
• bitand_m128
  Bitwise a & b.
• bitand_m128d
  Bitwise a & b.
• bitand_m128i
  Bitwise a & b.
• bitand_m256
  Bitwise a & b.
• bitand_m256d
  Bitwise a & b.
• bitand_m256i
  Bitwise a & b.
• bitandnot_m128
  Bitwise (!a) & b.
• bitandnot_m128d
  Bitwise (!a) & b.
• bitandnot_m128i
  Bitwise (!a) & b.
• bitandnot_m256
  Bitwise (!a) & b.
• bitandnot_m256d
  Bitwise (!a) & b.
• bitandnot_m256i
  Bitwise (!a) & b.
• bitandnot_u32
  Bitwise (!a) & b for u32
• bitandnot_u64
  Bitwise (!a) & b for u64
• bitor_m128
  Bitwise a | b.
• bitor_m128d
  Bitwise a | b.
• bitor_m128i
  Bitwise a | b.
• bitor_m256
  Bitwise a | b.
• bitor_m256d
  Bitwise a | b.
• bitor_m256i
  Bitwise a | b
• bitxor_m128
  Bitwise a ^ b.
• bitxor_m128d
  Bitwise a ^ b.
• bitxor_m128i
  Bitwise a ^ b.
• bitxor_m256
  Bitwise a ^ b.
• bitxor_m256d
  Bitwise a ^ b.
• bitxor_m256i
  Bitwise a ^ b.
• blend_varying_i8_m128i
  Blend the i8 lanes according to a runtime varying mask.
• blend_varying_i8_m256i
  Blend i8 lanes according to a runtime varying mask.
• blend_varying_m128
  Blend the lanes according to a runtime varying mask.
• blend_varying_m128d
  Blend the lanes according to a runtime varying mask.
• blend_varying_m256
  Blend the lanes according to a runtime varying mask.
• blend_varying_m256d
  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_m128d
  Bit-preserving cast to m128 from m128d
• cast_to_m128_from_m128i
  Bit-preserving cast to m128 from m128i
• cast_to_m128_from_m256
  Bit-preserving cast to m128 from m256.
• cast_to_m128d_from_m128
  Bit-preserving cast to m128d from m128
• cast_to_m128d_from_m128i
  Bit-preserving cast to m128d from m128i
• cast_to_m128d_from_m256d
  Bit-preserving cast to m128d from m256d.
• cast_to_m128i_from_m128
  Bit-preserving cast to m128i from m128
• cast_to_m128i_from_m128d
  Bit-preserving cast to m128i from m128d
• cast_to_m128i_from_m256i
  Bit-preserving cast to m128i from m256i.
• cast_to_m256_from_m256d
  Bit-preserving cast to m256 from m256d.
• cast_to_m256_from_m256i
  Bit-preserving cast to m256 from m256i.
• cast_to_m256d_from_m256
  Bit-preserving cast to m256i from m256.
• cast_to_m256d_from_m256i
  Bit-preserving cast to m256d from m256i.
• cast_to_m256i_from_m256
  Bit-preserving cast to m256i from m256.
• cast_to_m256i_from_m256d
  Bit-preserving cast to m256i from m256d.
• ceil_m128
  Round each lane to a whole number, towards positive infinity
• ceil_m128_s
  Round the low lane of b toward positive infinity, other lanes a.
• ceil_m128d
  Round each lane to a whole number, towards positive infinity
• ceil_m128d_s
  Round the low lane of b toward positive infinity, high lane is a.
• ceil_m256
  Round f32 lanes towards positive infinity.
• ceil_m256d
  Round f64 lanes towards positive infinity.
• cmp_eq_i32_m128_s
  Low lane equality.
• cmp_eq_i32_m128d_s
  Low lane f64 equal to.
• cmp_eq_mask_i8_m128i
  Lanewise a == b with lanes as i8.
• cmp_eq_mask_i8_m256i
  Compare i8 lanes for equality, mask output.
• cmp_eq_mask_i16_m128i
  Lanewise a == b with lanes as i16.
• cmp_eq_mask_i16_m256i
  Compare i16 lanes for equality, mask output.
• cmp_eq_mask_i32_m128i
  Lanewise a == b with lanes as i32.
• cmp_eq_mask_i32_m256i
  Compare i32 lanes for equality, mask output.
• cmp_eq_mask_i64_m128i
  Lanewise a == b with lanes as i64.
• cmp_eq_mask_i64_m256i
  Compare i64 lanes for equality, mask output.
• cmp_eq_mask_m128
  Lanewise a == b.
• cmp_eq_mask_m128_s
  Low lane a == b, other lanes unchanged.
• cmp_eq_mask_m128d
  Lanewise a == b, mask output.
• cmp_eq_mask_m128d_s
  Low lane a == b, other lanes unchanged.
• cmp_ge_i32_m128_s
  Low lane greater than or equal to.
• cmp_ge_i32_m128d_s
  Low lane f64 greater than or equal to.
• cmp_ge_mask_m128
  Lanewise a >= b.
• cmp_ge_mask_m128_s
  Low lane a >= b, other lanes unchanged.
• cmp_ge_mask_m128d
  Lanewise a >= b.
• cmp_ge_mask_m128d_s
  Low lane a >= b, other lanes unchanged.
• cmp_gt_i32_m128_s
  Low lane greater than.
• cmp_gt_i32_m128d_s
  Low lane f64 greater than.
• cmp_gt_mask_i8_m128i
  Lanewise a > b with lanes as i8.
• cmp_gt_mask_i8_m256i
  Compare i8 lanes for a > b, mask output.
• cmp_gt_mask_i16_m128i
  Lanewise a > b with lanes as i16.
• cmp_gt_mask_i16_m256i
  Compare i16 lanes for a > b, mask output.
• cmp_gt_mask_i32_m128i
  Lanewise a > b with lanes as i32.
• cmp_gt_mask_i32_m256i
  Compare i32 lanes for a > b, mask output.
• cmp_gt_mask_i64_m128i
  Lanewise a > b with lanes as i64.
• cmp_gt_mask_i64_m256i
  Compare i64 lanes for a > b, mask output.
• cmp_gt_mask_m128
  Lanewise a > b.
• cmp_gt_mask_m128_s
  Low lane a > b, other lanes unchanged.
• cmp_gt_mask_m128d
  Lanewise a > b.
• cmp_gt_mask_m128d_s
  Low lane a > b, other lanes unchanged.
• cmp_le_i32_m128_s
  Low lane less than or equal to.
• cmp_le_i32_m128d_s
  Low lane f64 less than or equal to.
• cmp_le_mask_m128
  Lanewise a <= b.
• cmp_le_mask_m128_s
  Low lane a <= b, other lanes unchanged.
• cmp_le_mask_m128d
  Lanewise a <= b.
• cmp_le_mask_m128d_s
  Low lane a <= b, other lanes unchanged.
• cmp_lt_i32_m128_s
  Low lane less than.
• cmp_lt_i32_m128d_s
  Low lane f64 less than.
• cmp_lt_mask_i8_m128i
  Lanewise a < b with lanes as i8.
• cmp_lt_mask_i16_m128i
  Lanewise a < b with lanes as i16.
• cmp_lt_mask_i32_m128i
  Lanewise a < b with lanes as i32.
• cmp_lt_mask_m128
  Lanewise a < b.
• cmp_lt_mask_m128_s
  Low lane a < b, other lanes unchanged.
• cmp_lt_mask_m128d
  Lanewise a < b.
• cmp_lt_mask_m128d_s
  Low lane a < b, other lane unchanged.
• cmp_neq_i32_m128_s
  Low lane not equal to.
• cmp_neq_i32_m128d_s
  Low lane f64 less than.
• cmp_neq_mask_m128
  Lanewise a != b.
• cmp_neq_mask_m128_s
  Low lane a != b, other lanes unchanged.
• cmp_neq_mask_m128d
  Lanewise a != b.
• cmp_neq_mask_m128d_s
  Low lane a != b, other lane unchanged.
• cmp_nge_mask_m128
  Lanewise !(a >= b).
• cmp_nge_mask_m128_s
  Low lane !(a >= b), other lanes unchanged.
• cmp_nge_mask_m128d
  Lanewise !(a >= b).
• cmp_nge_mask_m128d_s
  Low lane !(a >= b), other lane unchanged.
• cmp_ngt_mask_m128
  Lanewise !(a > b).
• cmp_ngt_mask_m128_s
  Low lane !(a > b), other lanes unchanged.
• cmp_ngt_mask_m128d
  Lanewise !(a > b).
• cmp_ngt_mask_m128d_s
  Low lane !(a > b), other lane unchanged.
• cmp_nle_mask_m128
  Lanewise !(a <= b).
• cmp_nle_mask_m128_s
  Low lane !(a <= b), other lanes unchanged.
• cmp_nle_mask_m128d
  Lanewise !(a <= b).
• cmp_nle_mask_m128d_s
  Low lane !(a <= b), other lane unchanged.
• cmp_nlt_mask_m128
  Lanewise !(a < b).
• cmp_nlt_mask_m128_s
  Low lane !(a < b), other lanes unchanged.
• cmp_nlt_mask_m128d
  Lanewise !(a < b).
• cmp_nlt_mask_m128d_s
  Low lane !(a < b), other lane unchanged.
• cmp_ordinary_mask_m128
  Lanewise (!a.is_nan()) & (!b.is_nan()).
• cmp_ordinary_mask_m128_s
  Low lane (!a.is_nan()) & (!b.is_nan()), other lanes unchanged.
• cmp_ordinary_mask_m128d
  Lanewise (!a.is_nan()) & (!b.is_nan()).
• cmp_ordinary_mask_m128d_s
  Low lane (!a.is_nan()) & (!b.is_nan()), other lane unchanged.
• cmp_unord_mask_m128
  Lanewise a.is_nan() | b.is_nan().
• cmp_unord_mask_m128_s
  Low lane a.is_nan() | b.is_nan(), other lanes unchanged.
• cmp_unord_mask_m128d
  Lanewise a.is_nan() | b.is_nan().
• cmp_unord_mask_m128d_s
  Low lane a.is_nan() | b.is_nan(), other lane unchanged.
• convert_i32_replace_m128_s
  Convert i32 to f32 and replace the low lane of the input.
• convert_i32_replace_m128d_s
  Convert i32 to f64 and replace the low lane of the input.
• convert_i64_replace_m128d_s
  Convert i64 to f64 and replace the low lane of the input.
• convert_m128_s_replace_m128d_s
  Converts the lower f32 to f64 and replace the low lane of the input
• convert_m128d_s_replace_m128_s
  Converts the low f64 to f32 and replaces the low lane of the input.
• convert_to_f32_from_m256_s
  Convert the lowest f32 lane to a single f32.
• convert_to_f64_from_m256d_s
  Convert the lowest f64 lane to a single f64.
• convert_to_i16_m128i_from_lower2_i16_m128i
  Convert the lower two i64 lanes to two i32 lanes.
• convert_to_i16_m128i_from_lower8_i8_m128i
  Convert the lower eight i8 lanes to eight i16 lanes.
• convert_to_i16_m256i_from_i8_m128i
  Convert i8 values to i16 values.
• convert_to_i16_m256i_from_lower4_u8_m128i
  Convert lower 4 u8 values to i16 values.
• convert_to_i16_m256i_from_lower8_u8_m128i
  Convert lower 8 u8 values to i16 values.
• convert_to_i16_m256i_from_u8_m128i
  Convert u8 values to i16 values.
• convert_to_i32_from_m256i_s
  Convert the lowest i32 lane to a single i32.
• convert_to_i32_m128i_from_lower4_i8_m128i
  Convert the lower four i8 lanes to four i32 lanes.
• convert_to_i32_m128i_from_lower4_i16_m128i
  Convert the lower four i16 lanes to four i32 lanes.
• convert_to_i32_m128i_from_m128
  Rounds the f32 lanes to i32 lanes.
• convert_to_i32_m128i_from_m128d
  Rounds the two f64 lanes to the low two i32 lanes.
• convert_to_i32_m128i_from_m256d
  Convert f64 lanes to be i32 lanes.
• convert_to_i32_m256i_from_i16_m128i
  Convert i16 values to i32 values.
• convert_to_i32_m256i_from_lower8_i8_m128i
  Convert the lower 8 i8 values to i32 values.
• convert_to_i32_m256i_from_m256
  Convert f32 lanes to be i32 lanes.
• convert_to_i32_m256i_from_u16_m128i
  Convert u16 values to i32 values.
• convert_to_i64_m128i_from_lower2_i8_m128i
  Convert the lower two i8 lanes to two i64 lanes.
• convert_to_i64_m128i_from_lower2_i32_m128i
  Convert the lower two i32 lanes to two i64 lanes.
• convert_to_i64_m256i_from_i32_m128i
  Convert i32 values to i64 values.
• convert_to_i64_m256i_from_lower4_i8_m128i
  Convert the lower 4 i8 values to i64 values.
• convert_to_i64_m256i_from_lower4_i16_m128i
  Convert i16 values to i64 values.
• convert_to_i64_m256i_from_lower4_u16_m128i
  Convert u16 values to i64 values.
• convert_to_i64_m256i_from_u32_m128i
  Convert u32 values to i64 values.
• convert_to_m128_from_i32_m128i
  Rounds the four i32 lanes to four f32 lanes.
• convert_to_m128_from_m128d
  Rounds the two f64 lanes to the low two f32 lanes.
• convert_to_m128_from_m256d
  Convert f64 lanes to be f32 lanes.
• convert_to_m128d_from_lower2_i32_m128i
  Rounds the lower two i32 lanes to two f64 lanes.
• convert_to_m128d_from_lower2_m128
  Rounds the two f64 lanes to the low two f32 lanes.
• convert_to_m256_from_i32_m256i
  Convert i32 lanes to be f32 lanes.
• convert_to_m256d_from_i32_m128i
  Convert i32 lanes to be f64 lanes.
• convert_to_m256d_from_m128
  Convert f32 lanes to be f64 lanes.
• convert_to_u16_m128i_from_lower8_u8_m128i
  Convert the lower eight u8 lanes to eight u16 lanes.
• convert_to_u32_m128i_from_lower4_u8_m128i
  Convert the lower four u8 lanes to four u32 lanes.
• convert_to_u32_m128i_from_lower4_u16_m128i
  Convert the lower four u16 lanes to four u32 lanes.
• convert_to_u64_m128i_from_lower2_u8_m128i
  Convert the lower two u8 lanes to two u64 lanes.
• convert_to_u64_m128i_from_lower2_u16_m128i
  Convert the lower two u16 lanes to two u64 lanes.
• convert_to_u64_m128i_from_lower2_u32_m128i
  Convert the lower two u32 lanes to two u64 lanes.
• convert_truncate_to_i32_m128i_from_m256d
  Convert f64 lanes to i32 lanes with truncation.
• convert_truncate_to_i32_m256i_from_m256
  Convert f32 lanes to i32 lanes with truncation.
• copy_i64_m128i_s
  Copy the low i64 lane to a new register, upper bits 0.
• copy_replace_low_f64_m128d
  Copies the a value and replaces the low lane with the low b value.
• crc32_u8
  Accumulates the u8 into a running CRC32 value.
• crc32_u16
  Accumulates the u16 into a running CRC32 value.
• crc32_u32
  Accumulates the u32 into a running CRC32 value.
• crc32_u64
  Accumulates the u64 into a running CRC32 value.
• div_m128
  Lanewise a / b.
• div_m128_s
  Low lane a / b, other lanes unchanged.
• div_m128d
  Lanewise a / b.
• div_m128d_s
  Lowest lane a / b, high lane unchanged.
• div_m256
  Lanewise a / b with f32.
• div_m256d
  Lanewise a / b with f64.
• duplicate_even_lanes_m128
  Duplicate the odd lanes to the even lanes.
• duplicate_even_lanes_m256
  Duplicate the even-indexed lanes to the odd lanes.
• duplicate_low_lane_m128d_s
  Copy the low lane of the input to both lanes of the output.
• duplicate_odd_lanes_m128
  Duplicate the odd lanes to the even lanes.
• duplicate_odd_lanes_m256
  Duplicate the odd-indexed lanes to the even lanes.
• duplicate_odd_lanes_m256d
  Duplicate the odd-indexed lanes to the even lanes.
• floor_m128
  Round each lane to a whole number, towards negative infinity
• floor_m128_s
  Round the low lane of b toward negative infinity, other lanes a.
• floor_m128d
  Round each lane to a whole number, towards negative infinity
• floor_m128d_s
  Round the low lane of b toward negative infinity, high lane is a.
• floor_m256
  Round f32 lanes towards negative infinity.
• floor_m256d
  Round f64 lanes towards negative infinity.
• fused_mul_add_m128
  Lanewise fused (a * b) + c
• fused_mul_add_m128_s
  Low lane fused (a * b) + c, other lanes unchanged
• fused_mul_add_m128d
  Lanewise fused (a * b) + c
• fused_mul_add_m128d_s
  Low lane fused (a * b) + c, other lanes unchanged
• fused_mul_add_m256
  Lanewise fused (a * b) + c
• fused_mul_add_m256d
  Lanewise fused (a * b) + c
• fused_mul_addsub_m128
  Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)
• fused_mul_addsub_m128d
  Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)
• fused_mul_addsub_m256
  Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)
• fused_mul_addsub_m256d
  Lanewise fused (a * b) addsub c (adds odd lanes and subtracts even lanes)
• fused_mul_neg_add_m128
  Lanewise fused -(a * b) + c
• fused_mul_neg_add_m128_s
  Low lane -(a * b) + c, other lanes unchanged.
• fused_mul_neg_add_m128d
  Lanewise fused -(a * b) + c
• fused_mul_neg_add_m128d_s
  Low lane -(a * b) + c, other lanes unchanged.
• fused_mul_neg_add_m256
  Lanewise fused -(a * b) + c
• fused_mul_neg_add_m256d
  Lanewise fused -(a * b) + c
• fused_mul_neg_sub_m128
  Lanewise fused -(a * b) - c
• fused_mul_neg_sub_m128_s
  Low lane fused -(a * b) - c, other lanes unchanged.
• fused_mul_neg_sub_m128d
  Lanewise fused -(a * b) - c
• fused_mul_neg_sub_m128d_s
  Low lane fused -(a * b) - c, other lanes unchanged.
• fused_mul_neg_sub_m256
  Lanewise fused -(a * b) - c
• fused_mul_neg_sub_m256d
  Lanewise fused -(a * b) - c
• fused_mul_sub_m128
  Lanewise fused (a * b) - c
• fused_mul_sub_m128_s
  Low lane fused (a * b) - c, other lanes unchanged.
• fused_mul_sub_m128d
  Lanewise fused (a * b) - c
• fused_mul_sub_m128d_s
  Low lane fused (a * b) - c, other lanes unchanged.
• fused_mul_sub_m256
  Lanewise fused (a * b) - c
• fused_mul_sub_m256d
  Lanewise fused (a * b) - c
• fused_mul_subadd_m128
  Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)
• fused_mul_subadd_m128d
  Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)
• fused_mul_subadd_m256
  Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)
• fused_mul_subadd_m256d
  Lanewise fused (a * b) subadd c (subtracts odd lanes and adds even lanes)
• get_f32_from_m128_s
  Gets the low lane as an individual f32 value.
• get_f64_from_m128d_s
  Gets the lower lane as an f64 value.
• get_i32_from_m128_s
  Converts the low lane to i32 and extracts as an individual value.
• get_i32_from_m128d_s
  Converts the lower lane to an i32 value.
• get_i32_from_m128i_s
  Converts the lower lane to an i32 value.
• get_i64_from_m128d_s
  Converts the lower lane to an i64 value.
• get_i64_from_m128i_s
  Converts the lower lane to an i64 value.
• leading_zero_count_u32
  Count the leading zeroes in a u32.
• leading_zero_count_u64
  Count the leading zeroes in a u64.
• load_f32_m128_s
  Loads the f32 reference into the low lane of the register.
• load_f32_splat_m128
  Loads the f32 reference into all lanes of a register.
• load_f32_splat_m256
  Load an f32 and splat it to all lanes of an m256d
• load_f64_m128d_s
  Loads the reference into the low lane of the register.
• load_f64_splat_m128d
  Loads the f64 reference into all lanes of a register.
• load_f64_splat_m256d
  Load an f64 and splat it to all lanes of an m256d
• load_i64_m128i_s
  Loads the low i64 into a register.
• load_m128
  Loads the reference into a register.
• load_m128_splat_m256
  Load an m128 and splat it to the lower and upper half of an m256
• load_m128d
  Loads the reference into a register.
• load_m128d_splat_m256d
  Load an m128d and splat it to the lower and upper half of an m256d
• load_m128i
  Loads the reference into a register.
• load_m256
  Load data from memory into a register.
• load_m256d
  Load data from memory into a register.
• load_m256i
  Load data from memory into a register.
• load_masked_i32_m128i
  Loads the reference given and zeroes any i32 lanes not in the mask.
• load_masked_i32_m256i
  Loads the reference given and zeroes any i32 lanes not in the mask.
• load_masked_i64_m128i
  Loads the reference given and zeroes any i64 lanes not in the mask.
• load_masked_i64_m256i
  Loads the reference given and zeroes any i64 lanes not in the mask.
• load_masked_m128
  Load data from memory into a register according to a mask.
• load_masked_m128d
  Load data from memory into a register according to a mask.
• load_masked_m256
  Load data from memory into a register according to a mask.
• load_masked_m256d
  Load data from memory into a register according to a mask.
• load_replace_high_m128d
  Loads the reference into a register, replacing the high lane.
• load_replace_low_m128d
  Loads the reference into a register, replacing the low lane.
• load_reverse_m128
  Loads the reference into a register with reversed order.
• load_reverse_m128d
  Loads the reference into a register with reversed order.
• load_unaligned_hi_lo_m256
  Load data from memory into a register.
• load_unaligned_hi_lo_m256d
  Load data from memory into a register.
• load_unaligned_hi_lo_m256i
  Load data from memory into a register.
• load_unaligned_m128
  Loads the reference into a register.
• load_unaligned_m128d
  Loads the reference into a register.
• load_unaligned_m128i
  Loads the reference into a register.
• load_unaligned_m256
  Load data from memory into a register.
• load_unaligned_m256d
  Load data from memory into a register.
• load_unaligned_m256i
  Load data from memory into a register.
• max_i8_m128i
  Lanewise max(a, b) with lanes as i8.
• max_i8_m256i
  Lanewise max(a, b) with lanes as i8.
• max_i16_m128i
  Lanewise max(a, b) with lanes as i16.
• max_i16_m256i
  Lanewise max(a, b) with lanes as i16.
• max_i32_m128i
  Lanewise max(a, b) with lanes as i32.
• max_i32_m256i
  Lanewise max(a, b) with lanes as i32.
• max_m128
  Lanewise max(a, b).
• max_m128_s
  Low lane max(a, b), other lanes unchanged.
• max_m128d
  Lanewise max(a, b).
• max_m128d_s
  Low lane max(a, b), other lanes unchanged.
• max_m256
  Lanewise max(a, b).
• max_m256d
  Lanewise max(a, b).
• max_u8_m128i
  Lanewise max(a, b) with lanes as u8.
• max_u8_m256i
  Lanewise max(a, b) with lanes as u8.
• max_u16_m128i
  Lanewise max(a, b) with lanes as u16.
• max_u16_m256i
  Lanewise max(a, b) with lanes as u16.
• max_u32_m128i
  Lanewise max(a, b) with lanes as u32.
• max_u32_m256i
  Lanewise max(a, b) with lanes as u32.
• min_i8_m128i
  Lanewise min(a, b) with lanes as i8.
• min_i8_m256i
  Lanewise min(a, b) with lanes as i8.
• min_i16_m128i
  Lanewise min(a, b) with lanes as i16.
• min_i16_m256i
  Lanewise min(a, b) with lanes as i16.
• min_i32_m128i
  Lanewise min(a, b) with lanes as i32.
• min_i32_m256i
  Lanewise min(a, b) with lanes as i32.
• min_m128
  Lanewise min(a, b).
• min_m128_s
  Low lane min(a, b), other lanes unchanged.
• min_m128d
  Lanewise min(a, b).
• min_m128d_s
  Low lane min(a, b), other lanes unchanged.
• min_m256
  Lanewise min(a, b).
• min_m256d
  Lanewise min(a, b).
• min_position_u16_m128i
  Min u16 value, position, and other lanes zeroed.
• min_u8_m128i
  Lanewise min(a, b) with lanes as u8.
• min_u8_m256i
  Lanewise min(a, b) with lanes as u8.
• min_u16_m128i
  Lanewise min(a, b) with lanes as u16.
• min_u16_m256i
  Lanewise min(a, b) with lanes as u16.
• min_u32_m128i
  Lanewise min(a, b) with lanes as u32.
• min_u32_m256i
  Lanewise min(a, b) with lanes as u32.
• move_high_low_m128
  Move the high lanes of b to the low lanes of a, other lanes unchanged.
• move_low_high_m128
  Move the low lanes of b to the high lanes of a, other lanes unchanged.
• move_m128_s
  Move the low lane of b to a, other lanes unchanged.
• move_mask_i8_m128i
  Gathers the i8 sign bit of each lane.
• move_mask_m128
  Gathers the sign bit of each lane.
• move_mask_m128d
  Gathers the sign bit of each lane.
• move_mask_m256
  Collects the sign bit of each lane into a 4-bit value.
• move_mask_m256d
  Collects the sign bit of each lane into a 4-bit value.
• move_mask_m256i
  Create an i32 mask of each sign bit in the i8 lanes.
• mul_extended_u32
  Multiply two u32, outputting the low bits and storing the high bits in the reference.
• mul_extended_u64
  Multiply two u64, outputting the low bits and storing the high bits in the reference.
• mul_i16_horizontal_add_m128i
  Multiply i16 lanes producing i32 values, horizontal add pairs of i32 values to produce the final output.
• mul_i16_horizontal_add_m256i
  Multiply i16 lanes producing i32 values, horizontal add pairs of i32 values to produce the final output.
• mul_i16_keep_high_m128i
  Lanewise a * b with lanes as i16, keep the high bits of the i32 intermediates.
• mul_i16_keep_high_m256i
  Multiply the i16 lanes and keep the high half of each 32-bit output.
• mul_i16_keep_low_m128i
  Lanewise a * b with lanes as i16, keep the low bits of the i32 intermediates.
• mul_i16_keep_low_m256i
  Multiply the i16 lanes and keep the low half of each 32-bit output.
• mul_i16_scale_round_m128i
  Multiply i16 lanes into i32 intermediates, keep the high 18 bits, round by adding 1, right shift by 1.
• mul_i16_scale_round_m256i
  Multiply i16 lanes into i32 intermediates, keep the high 18 bits, round by adding 1, right shift by 1.
• mul_i32_keep_low_m128i
  Lanewise a * b with lanes as i32, keep the low bits of the i64 intermediates.
• mul_i32_keep_low_m256i
  Multiply the i32 lanes and keep the low half of each 64-bit output.
• mul_i64_low_bits_m256i
  Multiply the lower i32 within each i64 lane, i64 output.
• mul_m128
  Lanewise a * b.
• mul_m128_s
  Low lane a * b, other lanes unchanged.
• mul_m128d
  Lanewise a * b.
• mul_m128d_s
  Lowest lane a * b, high lane unchanged.
• mul_m256
  Lanewise a * b with f32 lanes.
• mul_m256d
  Lanewise a * b with f64 lanes.
• mul_u8i8_add_horizontal_saturating_m128i
  This is dumb and weird.
• mul_u8i8_add_horizontal_saturating_m256i
  This is dumb and weird.
• mul_u16_keep_high_m128i
  Lanewise a * b with lanes as u16, keep the high bits of the u32 intermediates.
• mul_u16_keep_high_m256i
  Multiply the u16 lanes and keep the high half of each 32-bit output.
• mul_u64_low_bits_m256i
  Multiply the lower u32 within each u64 lane, u64 output.
• mul_widen_i32_odd_m128i
  Multiplies the odd i32 lanes and gives the widened (i64) results.
• mul_widen_u32_odd_m128i
  Multiplies the odd u32 lanes and gives the widened (u64) results.
• pack_i16_to_i8_m128i
  Saturating convert i16 to i8, and pack the values.
• pack_i16_to_i8_m256i
  Saturating convert i16 to i8, and pack the values.
• pack_i16_to_u8_m128i
  Saturating convert i16 to u8, and pack the values.
• pack_i16_to_u8_m256i
  Saturating convert i16 to u8, and pack the values.
• pack_i32_to_i16_m128i
  Saturating convert i32 to i16, and pack the values.
• pack_i32_to_i16_m256i
  Saturating convert i32 to i16, and pack the values.
• pack_i32_to_u16_m128i
  Saturating convert i32 to u16, and pack the values.
• pack_i32_to_u16_m256i
  Saturating convert i32 to u16, and pack the values.
• population_count_i32
  Count the number of bits set within an i32
• population_count_i64
  Count the number of bits set within an i64
• population_deposit_u32
  Deposit contiguous low bits from a u32 according to a mask.
• population_deposit_u64
  Deposit contiguous low bits from a u64 according to a mask.
• population_extract_u32
  Extract bits from a u32 according to a mask.
• population_extract_u64
  Extract bits from a u64 according to a mask.
• rdrand_u16
  Try to obtain a random u16 from the hardware RNG.
• rdrand_u32
  Try to obtain a random u32 from the hardware RNG.
• rdrand_u64
  Try to obtain a random u64 from the hardware RNG.
• rdseed_u16
  Try to obtain a random u16 from the hardware RNG.
• rdseed_u32
  Try to obtain a random u32 from the hardware RNG.
• rdseed_u64
  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_m128
  Lanewise 1.0 / a approximation.
• reciprocal_m128_s
  Low lane 1.0 / a approximation, other lanes unchanged.
• reciprocal_m256
  Reciprocal of f32 lanes.
• reciprocal_sqrt_m128
  Lanewise 1.0 / sqrt(a) approximation.
• reciprocal_sqrt_m128_s
  Low lane 1.0 / sqrt(a) approximation, other lanes unchanged.
• reciprocal_sqrt_m256
  Reciprocal of f32 lanes.
• set_i8_m128i
  Sets the args into an m128i, first arg is the high lane.
• set_i8_m256i
  Set i8 args into an m256i lane.
• set_i16_m128i
  Sets the args into an m128i, first arg is the high lane.
• set_i16_m256i
  Set i16 args into an m256i lane.
• set_i32_m128i
  Sets the args into an m128i, first arg is the high lane.
• set_i32_m128i_s
  Set an i32 as the low 32-bit lane of an m128i, other lanes blank.
• set_i32_m256i
  Set i32 args into an m256i lane.
• set_i64_m128i
  Sets the args into an m128i, first arg is the high lane.
• set_i64_m128i_s
  Set an i64 as the low 64-bit lane of an m128i, other lanes blank.
• set_m128
  Sets the args into an m128, first arg is the high lane.
• set_m128_s
  Sets the args into an m128, first arg is the high lane.
• set_m128d
  Sets the args into an m128d, first arg is the high lane.
• set_m128d_m256d
  Set m128d args into an m256d.
• set_m128d_s
  Sets the args into the low lane of a m128d.
• set_m128i_m256i
  Set m128i args into an m256i.
• set_m256
  Set f32 args into an m256 lane.
• set_m256d
  Set f64 args into an m256d lane.
• set_reversed_i8_m128i
  Sets the args into an m128i, first arg is the low lane.
• set_reversed_i8_m256i
  Set i8 args into an m256i lane.
• set_reversed_i16_m128i
  Sets the args into an m128i, first arg is the low lane.
• set_reversed_i16_m256i
  Set i16 args into an m256i lane.
• set_reversed_i32_m128i
  Sets the args into an m128i, first arg is the low lane.
• set_reversed_i32_m256i
  Set i32 args into an m256i lane.
• set_reversed_m128
  Sets the args into an m128, first arg is the low lane.
• set_reversed_m128d
  Sets the args into an m128d, first arg is the low lane.
• set_reversed_m128d_m256d
  Set m128d args into an m256d.
• set_reversed_m128i_m256i
  Set m128i args into an m256i.
• set_reversed_m256
  Set f32 args into an m256 lane.
• set_reversed_m256d
  Set f64 args into an m256d lane.
• set_splat_i8_m128i
  Splats the i8 to all lanes of the m128i.
• set_splat_i8_m128i_s_m256i
  Sets the lowest i8 lane of an m128i as all lanes of an m256i.
• set_splat_i8_m256i
  Splat an i8 arg into an m256i lane.
• set_splat_i16_m128i
  Splats the i16 to all lanes of the m128i.
• set_splat_i16_m128i_s_m256i
  Sets the lowest i16 lane of an m128i as all lanes of an m256i.
• set_splat_i16_m256i
  Splat an i16 arg into an m256i lane.
• set_splat_i32_m128i
  Splats the i32 to all lanes of the m128i.
• set_splat_i32_m128i_s_m256i
  Sets the lowest i32 lane of an m128i as all lanes of an m256i.
• set_splat_i32_m256i
  Splat an i32 arg into an m256i lane.
• set_splat_i64_m128i
  Splats the i64 to both lanes of the m128i.
• set_splat_i64_m128i_s_m256i
  Sets the lowest i64 lane of an m128i as all lanes of an m256i.
• set_splat_m128
  Splats the value to all lanes.
• set_splat_m128_s_m256
  Sets the lowest lane of an m128 as all lanes of an m256.
• set_splat_m128d
  Splats the args into both lanes of the m128d.
• set_splat_m128d_s_m256d
  Sets the lowest lane of an m128d as all lanes of an m256d.
• set_splat_m256
  Splat an f32 arg into an m256 lane.
• set_splat_m256d
  Splat an f64 arg into an m256d lane.
• shl_all_u16_m128i
  Shift all u16 lanes to the left by the count in the lower u64 lane.
• shl_all_u16_m256i
  Lanewise u16 shift left by the lower u64 lane of count.
• shl_all_u32_m128i
  Shift all u32 lanes to the left by the count in the lower u64 lane.
• shl_all_u32_m256i
  Shift all u32 lanes left by the lower u64 lane of count.
• shl_all_u64_m128i
  Shift all u64 lanes to the left by the count in the lower u64 lane.
• shl_all_u64_m256i
  Shift all u64 lanes left by the lower u64 lane of count.
• shl_each_u32_m128i
  Shift u32 values to the left by count bits.
• shl_each_u32_m256i
  Lanewise u32 shift left by the matching i32 lane in count.
• shl_each_u64_m128i
  Shift u64 values to the left by count bits.
• shl_each_u64_m256i
  Lanewise u64 shift left by the matching u64 lane in count.
• shr_all_i16_m128i
  Shift each i16 lane to the right by the count in the lower i64 lane.
• shr_all_i16_m256i
  Lanewise i16 shift right by the lower i64 lane of count.
• shr_all_i32_m128i
  Shift each i32 lane to the right by the count in the lower i64 lane.
• shr_all_i32_m256i
  Lanewise i32 shift right by the lower i64 lane of count.
• shr_all_u16_m128i
  Shift each u16 lane to the right by the count in the lower u64 lane.
• shr_all_u16_m256i
  Lanewise u16 shift right by the lower u64 lane of count.
• shr_all_u32_m128i
  Shift each u32 lane to the right by the count in the lower u64 lane.
• shr_all_u32_m256i
  Lanewise u32 shift right by the lower u64 lane of count.
• shr_all_u64_m128i
  Shift each u64 lane to the right by the count in the lower u64 lane.
• shr_all_u64_m256i
  Lanewise u64 shift right by the lower u64 lane of count.
• shr_each_i32_m128i
  Shift i32 values to the right by count bits.
• shr_each_i32_m256i
  Lanewise i32 shift right by the matching i32 lane in count.
• shr_each_u32_m128i
  Shift u32 values to the left by count bits.
• shr_each_u32_m256i
  Lanewise u32 shift right by the matching u32 lane in count.
• shr_each_u64_m128i
  Shift u64 values to the left by count bits.
• shr_each_u64_m256i
  Lanewise u64 shift right by the matching i64 lane in count.
• shuffle_av_f32_all_m128
  Shuffle f32 values in a using i32 values in v.
• shuffle_av_f32_half_m256
  Shuffle f32 values in a using i32 values in v.
• shuffle_av_f64_all_m128d
  Shuffle f64 lanes in a using bit 1 of the i64 lanes in v
• shuffle_av_f64_half_m256d
  Shuffle f64 lanes in a using bit 1 of the i64 lanes in v.
• shuffle_av_i8z_all_m128i
  Shuffle i8 lanes in a using i8 values in v.
• shuffle_av_i8z_half_m256i
  Shuffle i8 lanes in a using i8 values in v.
• shuffle_av_i32_all_m256
  Shuffle f32 lanes in a using i32 values in v.
• shuffle_av_i32_all_m256i
  Shuffle i32 lanes in a using i32 values in v.
• sign_apply_i8_m128i
  Applies the sign of i8 values in b to the values in a.
• sign_apply_i8_m256i
  Lanewise a * signum(b) with lanes as i8
• sign_apply_i16_m128i
  Applies the sign of i16 values in b to the values in a.
• sign_apply_i16_m256i
  Lanewise a * signum(b) with lanes as i16
• sign_apply_i32_m128i
  Applies the sign of i32 values in b to the values in a.
• sign_apply_i32_m256i
  Lanewise a * signum(b) with lanes as i32
• splat_i8_m128i_s_m128i
  Splat the lowest 8-bit lane across the entire 128 bits.
• splat_i16_m128i_s_m128i
  Splat the lowest 16-bit lane across the entire 128 bits.
• splat_i32_m128i_s_m128i
  Splat the lowest 32-bit lane across the entire 128 bits.
• splat_i64_m128i_s_m128i
  Splat the lowest 64-bit lane across the entire 128 bits.
• splat_m128_s_m128
  Splat the lowest f32 across all four lanes.
• splat_m128d_s_m128d
  Splat the lower f64 across both lanes of m128d.
• splat_m128i_m256i
  Splat the 128-bits across 256-bits.
• sqrt_m128
  Lanewise sqrt(a).
• sqrt_m128_s
  Low lane sqrt(a), other lanes unchanged.
• sqrt_m128d
  Lanewise sqrt(a).
• sqrt_m128d_s
  Low lane sqrt(b), upper lane is unchanged from a.
• sqrt_m256
  Lanewise sqrt on f64 lanes.
• sqrt_m256d
  Lanewise sqrt on f64 lanes.
• store_high_m128d_s
  Stores the high lane value to the reference given.
• store_i64_m128i_s
  Stores the value to the reference given.
• store_m128
  Stores the value to the reference given.
• store_m128_s
  Stores the low lane value to the reference given.
• store_m128d
  Stores the value to the reference given.
• store_m128d_s
  Stores the low lane value to the reference given.
• store_m128i
  Stores the value to the reference given.
• store_m256
  Store data from a register into memory.
• store_m256d
  Store data from a register into memory.
• store_m256i
  Store data from a register into memory.
• store_masked_i32_m128i
  Stores the i32 masked lanes given to the reference.
• store_masked_i32_m256i
  Stores the i32 masked lanes given to the reference.
• store_masked_i64_m128i
  Stores the i32 masked lanes given to the reference.
• store_masked_i64_m256i
  Stores the i32 masked lanes given to the reference.
• store_masked_m128
  Store data from a register into memory according to a mask.
• store_masked_m128d
  Store data from a register into memory according to a mask.
• store_masked_m256
  Store data from a register into memory according to a mask.
• store_masked_m256d
  Store data from a register into memory according to a mask.
• store_reverse_m128
  Stores the value to the reference given in reverse order.
• store_reversed_m128d
  Stores the value to the reference given.
• store_splat_m128
  Stores the low lane value to all lanes of the reference given.
• store_splat_m128d
  Stores the low lane value to all lanes of the reference given.
• store_unaligned_hi_lo_m256
  Store data from a register into memory.
• store_unaligned_hi_lo_m256d
  Store data from a register into memory.
• store_unaligned_hi_lo_m256i
  Store data from a register into memory.
• store_unaligned_m128
  Stores the value to the reference given.
• store_unaligned_m128d
  Stores the value to the reference given.
• store_unaligned_m128i
  Stores the value to the reference given.
• store_unaligned_m256
  Store data from a register into memory.
• store_unaligned_m256d
  Store data from a register into memory.
• store_unaligned_m256i
  Store data from a register into memory.
• sub_horizontal_i16_m128i
  Subtract horizontal pairs of i16 values, pack the outputs as a then b.
• sub_horizontal_i16_m256i
  Horizontal a - b with lanes as i16.
• sub_horizontal_i32_m128i
  Subtract horizontal pairs of i32 values, pack the outputs as a then b.
• sub_horizontal_i32_m256i
  Horizontal a - b with lanes as i32.
• sub_horizontal_m128
  Subtract each lane horizontally, pack the outputs as a then b.
• sub_horizontal_m128d
  Subtract each lane horizontally, pack the outputs as a then b.
• sub_horizontal_m256
  Subtract adjacent f32 lanes.
• sub_horizontal_m256d
  Subtract adjacent f64 lanes.
• sub_horizontal_saturating_i16_m128i
  Subtract horizontal pairs of i16 values, saturating, pack the outputs as a then b.
• sub_horizontal_saturating_i16_m256i
  Horizontal saturating a - b with lanes as i16.
• sub_i8_m128i
  Lanewise a - b with lanes as i8.
• sub_i8_m256i
  Lanewise a - b with lanes as i8.
• sub_i16_m128i
  Lanewise a - b with lanes as i16.
• sub_i16_m256i
  Lanewise a - b with lanes as i16.
• sub_i32_m128i
  Lanewise a - b with lanes as i32.
• sub_i32_m256i
  Lanewise a - b with lanes as i32.
• sub_i64_m128i
  Lanewise a - b with lanes as i64.
• sub_i64_m256i
  Lanewise a - b with lanes as i64.
• sub_m128
  Lanewise a - b.
• sub_m128_s
  Low lane a - b, other lanes unchanged.
• sub_m128d
  Lanewise a - b.
• sub_m128d_s
  Lowest lane a - b, high lane unchanged.
• sub_m256
  Lanewise a - b with f32 lanes.
• sub_m256d
  Lanewise a - b with f64 lanes.
• sub_saturating_i8_m128i
  Lanewise saturating a - b with lanes as i8.
• sub_saturating_i8_m256i
  Lanewise saturating a - b with lanes as i8.
• sub_saturating_i16_m128i
  Lanewise saturating a - b with lanes as i16.
• sub_saturating_i16_m256i
  Lanewise saturating a - b with lanes as i16.
• sub_saturating_u8_m128i
  Lanewise saturating a - b with lanes as u8.
• sub_saturating_u8_m256i
  Lanewise saturating a - b with lanes as u8.
• sub_saturating_u16_m128i
  Lanewise saturating a - b with lanes as u16.
• sub_saturating_u16_m256i
  Lanewise saturating a - b with lanes as u16.
• sum_of_u8_abs_diff_m128i
  Compute “sum of u8 absolute differences”.
• sum_of_u8_abs_diff_m256i
  Compute “sum of u8 absolute differences”.
• test_all_ones_m128i
  Tests if all bits are 1.
• test_all_zeroes_m128i
  Returns if all masked bits are 0, (a & mask) as u128 == 0
• test_mixed_ones_and_zeroes_m128i
  Returns if, among the masked bits, there’s both 0s and 1s
• trailing_zero_count_u32
  Counts the number of trailing zero bits in a u32.
• trailing_zero_count_u64
  Counts the number of trailing zero bits in a u64.
• transpose_four_m128
  Transpose four m128 as if they were a 4x4 matrix.
• truncate_m128_to_m128i
  Truncate the f32 lanes to i32 lanes.
• truncate_m128d_to_m128i
  Truncate the f64 lanes to the lower i32 lanes (upper i32 lanes 0).
• truncate_to_i32_m128d_s
  Truncate the lower lane into an i32.
• truncate_to_i64_m128d_s
  Truncate the lower lane into an i64.
• unpack_hi_m256
  Unpack and interleave the high lanes.
• unpack_hi_m256d
  Unpack and interleave the high lanes.
• unpack_high_i8_m128i
  Unpack and interleave high i8 lanes of a and b.
• unpack_high_i8_m256i
  Unpack and interleave high i8 lanes of a and b.
• unpack_high_i16_m128i
  Unpack and interleave high i16 lanes of a and b.
• unpack_high_i16_m256i
  Unpack and interleave high i16 lanes of a and b.
• unpack_high_i32_m128i
  Unpack and interleave high i32 lanes of a and b.
• unpack_high_i32_m256i
  Unpack and interleave high i32 lanes of a and b.
• unpack_high_i64_m128i
  Unpack and interleave high i64 lanes of a and b.
• unpack_high_i64_m256i
  Unpack and interleave high i64 lanes of a and b.
• unpack_high_m128
  Unpack and interleave high lanes of a and b.
• unpack_high_m128d
  Unpack and interleave high lanes of a and b.
• unpack_lo_m256
  Unpack and interleave the high lanes.
• unpack_lo_m256d
  Unpack and interleave the high lanes.
• unpack_low_i8_m128i
  Unpack and interleave low i8 lanes of a and b.
• unpack_low_i8_m256i
  Unpack and interleave low i8 lanes of a and b.
• unpack_low_i16_m128i
  Unpack and interleave low i16 lanes of a and b.
• unpack_low_i16_m256i
  Unpack and interleave low i16 lanes of a and b.
• unpack_low_i32_m128i
  Unpack and interleave low i32 lanes of a and b.
• unpack_low_i32_m256i
  Unpack and interleave low i32 lanes of a and b.
• unpack_low_i64_m128i
  Unpack and interleave low i64 lanes of a and b.
• unpack_low_i64_m256i
  Unpack and interleave low i64 lanes of a and b.
• unpack_low_m128
  Unpack and interleave low lanes of a and b.
• unpack_low_m128d
  Unpack and interleave low lanes of a and b.
• zero_extend_m128
  Zero extend an m128 to m256
• zero_extend_m128d
  Zero extend an m128d to m256d
• zero_extend_m128i
  Zero extend an m128i to m256i
• zeroed_m128
  All lanes zero.
• zeroed_m128d
  Both lanes zero.
• zeroed_m128i
  All lanes zero.
• zeroed_m256
  A zeroed m256
• zeroed_m256d
  A zeroed m256d
• zeroed_m256i
  A zeroed m256i