user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace associated const hacks with inline consts

Browse source 
Fixes #1368
This commit is contained in:
Amanieu d'Antras 2023-03-05 15:41:21 +00:00
parent c7daba316e
commit 644e8f8900
41 changed files with 2095 additions and 2224 deletions
Download patch file Download diff file Expand all files Collapse all files

2
library/stdarch/crates/core_arch/src/aarch64/armclang.rs
View file

@ -18,6 +18,6 @@ use stdarch_test::assert_instr;
#[inline(always)]
#[rustc_legacy_const_generics(0)]
pub unsafe fn __breakpoint<const VAL: i32>() {
static_assert_imm16!(VAL);
static_assert_uimm_bits!(VAL, 16);
crate::arch::asm!("brk {}", const VAL);
}

872
library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
View file

File diff suppressed because it is too large Load diff

154
library/stdarch/crates/core_arch/src/aarch64/neon/mod.rs
View file

@ -373,8 +373,8 @@ pub unsafe fn vcopy_lane_s64<const N1: i32, const N2: i32>(
_a: int64x1_t,
b: int64x1_t,
) -> int64x1_t {
static_assert!(N1 : i32 where N1 == 0);
static_assert!(N2 : i32 where N2 == 0);
static_assert!(N1 == 0);
static_assert!(N2 == 0);
b
}
@ -388,8 +388,8 @@ pub unsafe fn vcopy_lane_u64<const N1: i32, const N2: i32>(
_a: uint64x1_t,
b: uint64x1_t,
) -> uint64x1_t {
static_assert!(N1 : i32 where N1 == 0);
static_assert!(N2 : i32 where N2 == 0);
static_assert!(N1 == 0);
static_assert!(N2 == 0);
b
}
@ -403,8 +403,8 @@ pub unsafe fn vcopy_lane_p64<const N1: i32, const N2: i32>(
_a: poly64x1_t,
b: poly64x1_t,
) -> poly64x1_t {
static_assert!(N1 : i32 where N1 == 0);
static_assert!(N2 : i32 where N2 == 0);
static_assert!(N1 == 0);
static_assert!(N2 == 0);
b
}
@ -418,8 +418,8 @@ pub unsafe fn vcopy_lane_f64<const N1: i32, const N2: i32>(
_a: float64x1_t,
b: float64x1_t,
) -> float64x1_t {
static_assert!(N1 : i32 where N1 == 0);
static_assert!(N2 : i32 where N2 == 0);
static_assert!(N1 == 0);
static_assert!(N2 == 0);
b
}
@ -433,8 +433,8 @@ pub unsafe fn vcopy_laneq_s64<const LANE1: i32, const LANE2: i32>(
_a: int64x1_t,
b: int64x2_t,
) -> int64x1_t {
static_assert!(LANE1 : i32 where LANE1 == 0);
static_assert_imm1!(LANE2);
static_assert!(LANE1 == 0);
static_assert_uimm_bits!(LANE2, 1);
transmute::<i64, _>(simd_extract(b, LANE2 as u32))
}
@ -448,8 +448,8 @@ pub unsafe fn vcopy_laneq_u64<const LANE1: i32, const LANE2: i32>(
_a: uint64x1_t,
b: uint64x2_t,
) -> uint64x1_t {
static_assert!(LANE1 : i32 where LANE1 == 0);
static_assert_imm1!(LANE2);
static_assert!(LANE1 == 0);
static_assert_uimm_bits!(LANE2, 1);
transmute::<u64, _>(simd_extract(b, LANE2 as u32))
}
@ -463,8 +463,8 @@ pub unsafe fn vcopy_laneq_p64<const LANE1: i32, const LANE2: i32>(
_a: poly64x1_t,
b: poly64x2_t,
) -> poly64x1_t {
static_assert!(LANE1 : i32 where LANE1 == 0);
static_assert_imm1!(LANE2);
static_assert!(LANE1 == 0);
static_assert_uimm_bits!(LANE2, 1);
transmute::<u64, _>(simd_extract(b, LANE2 as u32))
}
@ -478,8 +478,8 @@ pub unsafe fn vcopy_laneq_f64<const LANE1: i32, const LANE2: i32>(
_a: float64x1_t,
b: float64x2_t,
) -> float64x1_t {
static_assert!(LANE1 : i32 where LANE1 == 0);
static_assert_imm1!(LANE2);
static_assert!(LANE1 == 0);
static_assert_uimm_bits!(LANE2, 1);
transmute::<f64, _>(simd_extract(b, LANE2 as u32))
}
@ -747,7 +747,7 @@ pub unsafe fn vld1q_dup_f64(ptr: *const f64) -> float64x2_t {
#[cfg_attr(test, assert_instr(ldr, LANE = 0))]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vld1_lane_f64<const LANE: i32>(ptr: *const f64, src: float64x1_t) -> float64x1_t {
static_assert!(LANE : i32 where LANE == 0);
static_assert!(LANE == 0);
simd_insert(src, LANE as u32, *ptr)
}
@ -758,7 +758,7 @@ pub unsafe fn vld1_lane_f64<const LANE: i32>(ptr: *const f64, src: float64x1_t)
#[cfg_attr(test, assert_instr(ld1, LANE = 1))]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vld1q_lane_f64<const LANE: i32>(ptr: *const f64, src: float64x2_t) -> float64x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1950,7 +1950,7 @@ pub unsafe fn vpmaxq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vext_p64<const N: i32>(a: poly64x1_t, _b: poly64x1_t) -> poly64x1_t {
static_assert!(N : i32 where N == 0);
static_assert!(N == 0);
a
}
@ -1961,7 +1961,7 @@ pub unsafe fn vext_p64<const N: i32>(a: poly64x1_t, _b: poly64x1_t) -> poly64x1_
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vext_f64<const N: i32>(a: float64x1_t, _b: float64x1_t) -> float64x1_t {
static_assert!(N : i32 where N == 0);
static_assert!(N == 0);
a
}
@ -2080,7 +2080,7 @@ pub unsafe fn vget_low_p64(a: poly64x2_t) -> poly64x1_t {
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr(nop, IMM5 = 0))]
pub unsafe fn vget_lane_f64<const IMM5: i32>(v: float64x1_t) -> f64 {
static_assert!(IMM5 : i32 where IMM5 == 0);
static_assert!(IMM5 == 0);
simd_extract(v, IMM5 as u32)
}
@ -2091,7 +2091,7 @@ pub unsafe fn vget_lane_f64<const IMM5: i32>(v: float64x1_t) -> f64 {
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr(nop, IMM5 = 0))]
pub unsafe fn vgetq_lane_f64<const IMM5: i32>(v: float64x2_t) -> f64 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -3001,7 +3001,7 @@ pub unsafe fn vqtbx4q_p8(a: poly8x16_t, t: poly8x16x4_t, idx: uint8x16_t) -> pol
#[rustc_legacy_const_generics(1)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vshld_n_s64<const N: i32>(a: i64) -> i64 {
static_assert_imm6!(N);
static_assert_uimm_bits!(N, 6);
a << N
}
@ -3012,7 +3012,7 @@ pub unsafe fn vshld_n_s64<const N: i32>(a: i64) -> i64 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vshld_n_u64<const N: i32>(a: u64) -> u64 {
static_assert_imm6!(N);
static_assert_uimm_bits!(N, 6);
a << N
}
@ -3023,7 +3023,7 @@ pub unsafe fn vshld_n_u64<const N: i32>(a: u64) -> u64 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vshrd_n_s64<const N: i32>(a: i64) -> i64 {
static_assert!(N : i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
let n: i32 = if N == 64 { 63 } else { N };
a >> n
}
@ -3035,7 +3035,7 @@ pub unsafe fn vshrd_n_s64<const N: i32>(a: i64) -> i64 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vshrd_n_u64<const N: i32>(a: u64) -> u64 {
static_assert!(N : i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
let n: i32 = if N == 64 {
return 0;
} else {
@ -3051,7 +3051,7 @@ pub unsafe fn vshrd_n_u64<const N: i32>(a: u64) -> u64 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsrad_n_s64<const N: i32>(a: i64, b: i64) -> i64 {
static_assert!(N : i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
a.wrapping_add(vshrd_n_s64::<N>(b))
}
@ -3062,7 +3062,7 @@ pub unsafe fn vsrad_n_s64<const N: i32>(a: i64, b: i64) -> i64 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsrad_n_u64<const N: i32>(a: u64, b: u64) -> u64 {
static_assert!(N : i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
a.wrapping_add(vshrd_n_u64::<N>(b))
}
@ -3073,7 +3073,7 @@ pub unsafe fn vsrad_n_u64<const N: i32>(a: u64, b: u64) -> u64 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
vsli_n_s8_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3083,7 +3083,7 @@ pub unsafe fn vsli_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
vsliq_n_s8_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3093,7 +3093,7 @@ pub unsafe fn vsliq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
vsli_n_s16_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3103,7 +3103,7 @@ pub unsafe fn vsli_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
vsliq_n_s16_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3113,7 +3113,7 @@ pub unsafe fn vsliq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
vsli_n_s32_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3123,7 +3123,7 @@ pub unsafe fn vsli_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
vsliq_n_s32_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3133,7 +3133,7 @@ pub unsafe fn vsliq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t {
static_assert!(N: i32 where N >= 0 && N <= 63);
static_assert!(N >= 0 && N <= 63);
vsli_n_s64_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3143,7 +3143,7 @@ pub unsafe fn vsli_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t {
static_assert!(N: i32 where N >= 0 && N <= 63);
static_assert!(N >= 0 && N <= 63);
vsliq_n_s64_(a, b, N)
}
/// Shift Left and Insert (immediate)
@ -3153,7 +3153,7 @@ pub unsafe fn vsliq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
transmute(vsli_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3163,7 +3163,7 @@ pub unsafe fn vsli_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
transmute(vsliq_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3173,7 +3173,7 @@ pub unsafe fn vsliq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
transmute(vsli_n_s16_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3183,7 +3183,7 @@ pub unsafe fn vsli_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
transmute(vsliq_n_s16_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3193,7 +3193,7 @@ pub unsafe fn vsliq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
transmute(vsli_n_s32_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3203,7 +3203,7 @@ pub unsafe fn vsli_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
transmute(vsliq_n_s32_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3213,7 +3213,7 @@ pub unsafe fn vsliq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
static_assert!(N: i32 where N >= 0 && N <= 63);
static_assert!(N >= 0 && N <= 63);
transmute(vsli_n_s64_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3223,7 +3223,7 @@ pub unsafe fn vsli_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
static_assert!(N: i32 where N >= 0 && N <= 63);
static_assert!(N >= 0 && N <= 63);
transmute(vsliq_n_s64_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3233,7 +3233,7 @@ pub unsafe fn vsliq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
transmute(vsli_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3243,7 +3243,7 @@ pub unsafe fn vsli_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
transmute(vsliq_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3253,7 +3253,7 @@ pub unsafe fn vsliq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
transmute(vsli_n_s16_(transmute(a), transmute(b), N))
}
/// Shift Left and Insert (immediate)
@ -3263,7 +3263,7 @@ pub unsafe fn vsli_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
transmute(vsliq_n_s16_(transmute(a), transmute(b), N))
}
@ -3276,7 +3276,7 @@ pub unsafe fn vsliq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsli_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1_t {
static_assert!(N: i32 where N >= 0 && N <= 63);
static_assert!(N >= 0 && N <= 63);
transmute(vsli_n_s64_(transmute(a), transmute(b), N))
}
@ -3289,7 +3289,7 @@ pub unsafe fn vsli_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsliq_n_p64<const N: i32>(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
static_assert!(N: i32 where N >= 0 && N <= 63);
static_assert!(N >= 0 && N <= 63);
transmute(vsliq_n_s64_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3299,7 +3299,7 @@ pub unsafe fn vsliq_n_p64<const N: i32>(a: poly64x2_t, b: poly64x2_t) -> poly64x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
static_assert!(N: i32 where N >= 1 && N <= 8);
static_assert!(N >= 1 && N <= 8);
vsri_n_s8_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3309,7 +3309,7 @@ pub unsafe fn vsri_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t {
static_assert!(N: i32 where N >= 1 && N <= 8);
static_assert!(N >= 1 && N <= 8);
vsriq_n_s8_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3319,7 +3319,7 @@ pub unsafe fn vsriq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t {
static_assert!(N: i32 where N >= 1 && N <= 16);
static_assert!(N >= 1 && N <= 16);
vsri_n_s16_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3329,7 +3329,7 @@ pub unsafe fn vsri_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t {
static_assert!(N: i32 where N >= 1 && N <= 16);
static_assert!(N >= 1 && N <= 16);
vsriq_n_s16_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3339,7 +3339,7 @@ pub unsafe fn vsriq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t {
static_assert!(N: i32 where N >= 1 && N <= 32);
static_assert!(N >= 1 && N <= 32);
vsri_n_s32_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3349,7 +3349,7 @@ pub unsafe fn vsri_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t {
static_assert!(N: i32 where N >= 1 && N <= 32);
static_assert!(N >= 1 && N <= 32);
vsriq_n_s32_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3359,7 +3359,7 @@ pub unsafe fn vsriq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t {
static_assert!(N: i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
vsri_n_s64_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3369,7 +3369,7 @@ pub unsafe fn vsri_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t {
static_assert!(N: i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
vsriq_n_s64_(a, b, N)
}
/// Shift Right and Insert (immediate)
@ -3379,7 +3379,7 @@ pub unsafe fn vsriq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
static_assert!(N: i32 where N >= 1 && N <= 8);
static_assert!(N >= 1 && N <= 8);
transmute(vsri_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3389,7 +3389,7 @@ pub unsafe fn vsri_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
static_assert!(N: i32 where N >= 1 && N <= 8);
static_assert!(N >= 1 && N <= 8);
transmute(vsriq_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3399,7 +3399,7 @@ pub unsafe fn vsriq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
static_assert!(N: i32 where N >= 1 && N <= 16);
static_assert!(N >= 1 && N <= 16);
transmute(vsri_n_s16_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3409,7 +3409,7 @@ pub unsafe fn vsri_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
static_assert!(N: i32 where N >= 1 && N <= 16);
static_assert!(N >= 1 && N <= 16);
transmute(vsriq_n_s16_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3419,7 +3419,7 @@ pub unsafe fn vsriq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
static_assert!(N: i32 where N >= 1 && N <= 32);
static_assert!(N >= 1 && N <= 32);
transmute(vsri_n_s32_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3429,7 +3429,7 @@ pub unsafe fn vsri_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
static_assert!(N: i32 where N >= 1 && N <= 32);
static_assert!(N >= 1 && N <= 32);
transmute(vsriq_n_s32_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3439,7 +3439,7 @@ pub unsafe fn vsriq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
static_assert!(N: i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
transmute(vsri_n_s64_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3449,7 +3449,7 @@ pub unsafe fn vsri_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
static_assert!(N: i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
transmute(vsriq_n_s64_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3459,7 +3459,7 @@ pub unsafe fn vsriq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
static_assert!(N: i32 where N >= 1 && N <= 8);
static_assert!(N >= 1 && N <= 8);
transmute(vsri_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3469,7 +3469,7 @@ pub unsafe fn vsri_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16_t {
static_assert!(N: i32 where N >= 1 && N <= 8);
static_assert!(N >= 1 && N <= 8);
transmute(vsriq_n_s8_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3479,7 +3479,7 @@ pub unsafe fn vsriq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4_t {
static_assert!(N: i32 where N >= 1 && N <= 16);
static_assert!(N >= 1 && N <= 16);
transmute(vsri_n_s16_(transmute(a), transmute(b), N))
}
/// Shift Right and Insert (immediate)
@ -3489,7 +3489,7 @@ pub unsafe fn vsri_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
static_assert!(N: i32 where N >= 1 && N <= 16);
static_assert!(N >= 1 && N <= 16);
transmute(vsriq_n_s16_(transmute(a), transmute(b), N))
}
@ -3502,7 +3502,7 @@ pub unsafe fn vsriq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsri_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1_t {
static_assert!(N: i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
transmute(vsri_n_s64_(transmute(a), transmute(b), N))
}
@ -3515,7 +3515,7 @@ pub unsafe fn vsri_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1
#[rustc_legacy_const_generics(2)]
#[stable(feature = "neon_intrinsics", since = "1.59.0")]
pub unsafe fn vsriq_n_p64<const N: i32>(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
static_assert!(N: i32 where N >= 1 && N <= 64);
static_assert!(N >= 1 && N <= 64);
transmute(vsriq_n_s64_(transmute(a), transmute(b), N))
}
@ -3529,7 +3529,7 @@ pub unsafe fn vsm3tt1aq_u32<const IMM2: i32>(
b: uint32x4_t,
c: uint32x4_t,
) -> uint32x4_t {
static_assert_imm2!(IMM2);
static_assert_uimm_bits!(IMM2, 2);
#[allow(improper_ctypes)]
extern "unadjusted" {
#[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.crypto.sm3tt1a")]
@ -3548,7 +3548,7 @@ pub unsafe fn vsm3tt1bq_u32<const IMM2: i32>(
b: uint32x4_t,
c: uint32x4_t,
) -> uint32x4_t {
static_assert_imm2!(IMM2);
static_assert_uimm_bits!(IMM2, 2);
#[allow(improper_ctypes)]
extern "unadjusted" {
#[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.crypto.sm3tt1b")]
@ -3567,7 +3567,7 @@ pub unsafe fn vsm3tt2aq_u32<const IMM2: i32>(
b: uint32x4_t,
c: uint32x4_t,
) -> uint32x4_t {
static_assert_imm2!(IMM2);
static_assert_uimm_bits!(IMM2, 2);
#[allow(improper_ctypes)]
extern "unadjusted" {
#[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.crypto.sm3tt2a")]
@ -3586,7 +3586,7 @@ pub unsafe fn vsm3tt2bq_u32<const IMM2: i32>(
b: uint32x4_t,
c: uint32x4_t,
) -> uint32x4_t {
static_assert_imm2!(IMM2);
static_assert_uimm_bits!(IMM2, 2);
#[allow(improper_ctypes)]
extern "unadjusted" {
#[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.crypto.sm3tt2b")]
@ -3601,7 +3601,7 @@ pub unsafe fn vsm3tt2bq_u32<const IMM2: i32>(
#[cfg_attr(test, assert_instr(xar, IMM6 = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vxarq_u64<const IMM6: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
static_assert_imm6!(IMM6);
static_assert_uimm_bits!(IMM6, 6);
#[allow(improper_ctypes)]
extern "unadjusted" {
#[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.crypto.xar")]

4
library/stdarch/crates/core_arch/src/aarch64/prefetch.rs
View file

@ -67,7 +67,7 @@ pub const _PREFETCH_LOCALITY3: i32 = 3;
// FIXME: Replace this with the standard ACLE __pld/__pldx/__pli/__plix intrinsics
pub unsafe fn _prefetch<const RW: i32, const LOCALITY: i32>(p: *const i8) {
// We use the `llvm.prefetch` intrinsic with `cache type` = 1 (data cache).
static_assert_imm1!(RW);
static_assert_imm2!(LOCALITY);
static_assert_uimm_bits!(RW, 1);
static_assert_uimm_bits!(LOCALITY, 2);
prefetch(p, RW, LOCALITY, 1);
}

2
library/stdarch/crates/core_arch/src/aarch64/tme.rs
View file

@ -96,7 +96,7 @@ pub unsafe fn __tcommit() {
#[cfg_attr(test, assert_instr(tcancel, IMM16 = 0x0))]
#[rustc_legacy_const_generics(0)]
pub unsafe fn __tcancel<const IMM16: u64>() {
static_assert!(IMM16: u64 where IMM16 <= 65535);
static_assert!(IMM16 <= 65535);
aarch64_tcancel(IMM16);
}

2
library/stdarch/crates/core_arch/src/arm/armclang.rs
View file

@ -30,6 +30,6 @@ use stdarch_test::assert_instr;
#[inline(always)]
#[rustc_legacy_const_generics(0)]
pub unsafe fn __breakpoint<const VAL: i32>() {
static_assert_imm8!(VAL);
static_assert_uimm_bits!(VAL, 8);
crate::arch::asm!("bkpt #{}", const VAL);
}

2
library/stdarch/crates/core_arch/src/arm/mod.rs
View file

@ -103,7 +103,7 @@ pub unsafe fn udf() -> ! {
#[inline(always)]
#[rustc_legacy_const_generics(0)]
pub unsafe fn __dbg<const IMM4: i32>() {
static_assert_imm4!(IMM4);
static_assert_uimm_bits!(IMM4, 4);
dbg(IMM4);
}

88
library/stdarch/crates/core_arch/src/arm/neon.rs
View file

@ -821,7 +821,7 @@ pub unsafe fn vcvtq_u32_f32(a: float32x4_t) -> uint32x4_t {
#[cfg_attr(test, assert_instr("vsli.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
let n = N as i8;
vshiftins_v8i8(a, b, int8x8_t(n, n, n, n, n, n, n, n))
}
@ -831,7 +831,7 @@ pub unsafe fn vsli_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
#[cfg_attr(test, assert_instr("vsli.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
let n = N as i8;
vshiftins_v16i8(
a,
@ -845,7 +845,7 @@ pub unsafe fn vsliq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t
#[cfg_attr(test, assert_instr("vsli.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
let n = N as i16;
vshiftins_v4i16(a, b, int16x4_t(n, n, n, n))
}
@ -855,7 +855,7 @@ pub unsafe fn vsli_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t
#[cfg_attr(test, assert_instr("vsli.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
let n = N as i16;
vshiftins_v8i16(a, b, int16x8_t(n, n, n, n, n, n, n, n))
}
@ -865,7 +865,7 @@ pub unsafe fn vsliq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t
#[cfg_attr(test, assert_instr("vsli.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
vshiftins_v2i32(a, b, int32x2_t(N, N))
}
/// Shift Left and Insert (immediate)
@ -874,7 +874,7 @@ pub unsafe fn vsli_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t
#[cfg_attr(test, assert_instr("vsli.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
vshiftins_v4i32(a, b, int32x4_t(N, N, N, N))
}
/// Shift Left and Insert (immediate)
@ -883,7 +883,7 @@ pub unsafe fn vsliq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t
#[cfg_attr(test, assert_instr("vsli.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t {
static_assert!(N : i32 where 0 <= N && N <= 63);
static_assert!(0 <= N && N <= 63);
vshiftins_v1i64(a, b, int64x1_t(N as i64))
}
/// Shift Left and Insert (immediate)
@ -892,7 +892,7 @@ pub unsafe fn vsli_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t
#[cfg_attr(test, assert_instr("vsli.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t {
static_assert!(N : i32 where 0 <= N && N <= 63);
static_assert!(0 <= N && N <= 63);
vshiftins_v2i64(a, b, int64x2_t(N as i64, N as i64))
}
/// Shift Left and Insert (immediate)
@ -901,7 +901,7 @@ pub unsafe fn vsliq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t
#[cfg_attr(test, assert_instr("vsli.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
let n = N as i8;
transmute(vshiftins_v8i8(
transmute(a),
@ -915,7 +915,7 @@ pub unsafe fn vsli_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
#[cfg_attr(test, assert_instr("vsli.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
let n = N as i8;
transmute(vshiftins_v16i8(
transmute(a),
@ -929,7 +929,7 @@ pub unsafe fn vsliq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16
#[cfg_attr(test, assert_instr("vsli.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
let n = N as i16;
transmute(vshiftins_v4i16(
transmute(a),
@ -943,7 +943,7 @@ pub unsafe fn vsli_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4
#[cfg_attr(test, assert_instr("vsli.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
let n = N as i16;
transmute(vshiftins_v8i16(
transmute(a),
@ -957,7 +957,7 @@ pub unsafe fn vsliq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x
#[cfg_attr(test, assert_instr("vsli.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
transmute(vshiftins_v2i32(transmute(a), transmute(b), int32x2_t(N, N)))
}
/// Shift Left and Insert (immediate)
@ -966,7 +966,7 @@ pub unsafe fn vsli_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2
#[cfg_attr(test, assert_instr("vsli.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
static_assert!(N: i32 where N >= 0 && N <= 31);
static_assert!(N >= 0 && N <= 31);
transmute(vshiftins_v4i32(
transmute(a),
transmute(b),
@ -979,7 +979,7 @@ pub unsafe fn vsliq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x
#[cfg_attr(test, assert_instr("vsli.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
static_assert!(N : i32 where 0 <= N && N <= 63);
static_assert!(0 <= N && N <= 63);
transmute(vshiftins_v1i64(
transmute(a),
transmute(b),
@ -992,7 +992,7 @@ pub unsafe fn vsli_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1
#[cfg_attr(test, assert_instr("vsli.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
static_assert!(N : i32 where 0 <= N && N <= 63);
static_assert!(0 <= N && N <= 63);
transmute(vshiftins_v2i64(
transmute(a),
transmute(b),
@ -1005,7 +1005,7 @@ pub unsafe fn vsliq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x
#[cfg_attr(test, assert_instr("vsli.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
let n = N as i8;
transmute(vshiftins_v8i8(
transmute(a),
@ -1019,7 +1019,7 @@ pub unsafe fn vsli_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
#[cfg_attr(test, assert_instr("vsli.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16_t {
static_assert_imm3!(N);
static_assert_uimm_bits!(N, 3);
let n = N as i8;
transmute(vshiftins_v16i8(
transmute(a),
@ -1033,7 +1033,7 @@ pub unsafe fn vsliq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16
#[cfg_attr(test, assert_instr("vsli.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
let n = N as i16;
transmute(vshiftins_v4i16(
transmute(a),
@ -1048,7 +1048,7 @@ pub unsafe fn vsli_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4
#[cfg_attr(test, assert_instr("vsli.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
static_assert_imm4!(N);
static_assert_uimm_bits!(N, 4);
let n = N as i16;
transmute(vshiftins_v8i16(
transmute(a),
@ -1065,7 +1065,7 @@ pub unsafe fn vsliq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x
#[cfg_attr(test, assert_instr("vsli.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsli_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1_t {
static_assert!(N : i32 where 0 <= N && N <= 63);
static_assert!(0 <= N && N <= 63);
transmute(vshiftins_v1i64(
transmute(a),
transmute(b),
@ -1081,7 +1081,7 @@ pub unsafe fn vsli_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1
#[cfg_attr(test, assert_instr("vsli.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsliq_n_p64<const N: i32>(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
static_assert!(N : i32 where 0 <= N && N <= 63);
static_assert!(0 <= N && N <= 63);
transmute(vshiftins_v2i64(
transmute(a),
transmute(b),
@ -1094,7 +1094,7 @@ pub unsafe fn vsliq_n_p64<const N: i32>(a: poly64x2_t, b: poly64x2_t) -> poly64x
#[cfg_attr(test, assert_instr("vsri.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
static_assert!(N : i32 where 1 <= N && N <= 8);
static_assert!(1 <= N && N <= 8);
let n = -N as i8;
vshiftins_v8i8(a, b, int8x8_t(n, n, n, n, n, n, n, n))
}
@ -1104,7 +1104,7 @@ pub unsafe fn vsri_n_s8<const N: i32>(a: int8x8_t, b: int8x8_t) -> int8x8_t {
#[cfg_attr(test, assert_instr("vsri.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t {
static_assert!(N : i32 where 1 <= N && N <= 8);
static_assert!(1 <= N && N <= 8);
let n = -N as i8;
vshiftins_v16i8(
a,
@ -1118,7 +1118,7 @@ pub unsafe fn vsriq_n_s8<const N: i32>(a: int8x16_t, b: int8x16_t) -> int8x16_t
#[cfg_attr(test, assert_instr("vsri.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t {
static_assert!(N : i32 where 1 <= N && N <= 16);
static_assert!(1 <= N && N <= 16);
let n = -N as i16;
vshiftins_v4i16(a, b, int16x4_t(n, n, n, n))
}
@ -1128,7 +1128,7 @@ pub unsafe fn vsri_n_s16<const N: i32>(a: int16x4_t, b: int16x4_t) -> int16x4_t
#[cfg_attr(test, assert_instr("vsri.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t {
static_assert!(N : i32 where 1 <= N && N <= 16);
static_assert!(1 <= N && N <= 16);
let n = -N as i16;
vshiftins_v8i16(a, b, int16x8_t(n, n, n, n, n, n, n, n))
}
@ -1138,7 +1138,7 @@ pub unsafe fn vsriq_n_s16<const N: i32>(a: int16x8_t, b: int16x8_t) -> int16x8_t
#[cfg_attr(test, assert_instr("vsri.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t {
static_assert!(N : i32 where 1 <= N && N <= 32);
static_assert!(1 <= N && N <= 32);
vshiftins_v2i32(a, b, int32x2_t(-N, -N))
}
/// Shift Right and Insert (immediate)
@ -1147,7 +1147,7 @@ pub unsafe fn vsri_n_s32<const N: i32>(a: int32x2_t, b: int32x2_t) -> int32x2_t
#[cfg_attr(test, assert_instr("vsri.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t {
static_assert!(N : i32 where 1 <= N && N <= 32);
static_assert!(1 <= N && N <= 32);
vshiftins_v4i32(a, b, int32x4_t(-N, -N, -N, -N))
}
/// Shift Right and Insert (immediate)
@ -1156,7 +1156,7 @@ pub unsafe fn vsriq_n_s32<const N: i32>(a: int32x4_t, b: int32x4_t) -> int32x4_t
#[cfg_attr(test, assert_instr("vsri.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t {
static_assert!(N : i32 where 1 <= N && N <= 64);
static_assert!(1 <= N && N <= 64);
vshiftins_v1i64(a, b, int64x1_t(-N as i64))
}
/// Shift Right and Insert (immediate)
@ -1165,7 +1165,7 @@ pub unsafe fn vsri_n_s64<const N: i32>(a: int64x1_t, b: int64x1_t) -> int64x1_t
#[cfg_attr(test, assert_instr("vsri.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t {
static_assert!(N : i32 where 1 <= N && N <= 64);
static_assert!(1 <= N && N <= 64);
vshiftins_v2i64(a, b, int64x2_t(-N as i64, -N as i64))
}
/// Shift Right and Insert (immediate)
@ -1174,7 +1174,7 @@ pub unsafe fn vsriq_n_s64<const N: i32>(a: int64x2_t, b: int64x2_t) -> int64x2_t
#[cfg_attr(test, assert_instr("vsri.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
static_assert!(N : i32 where 1 <= N && N <= 8);
static_assert!(1 <= N && N <= 8);
let n = -N as i8;
transmute(vshiftins_v8i8(
transmute(a),
@ -1188,7 +1188,7 @@ pub unsafe fn vsri_n_u8<const N: i32>(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
#[cfg_attr(test, assert_instr("vsri.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
static_assert!(N : i32 where 1 <= N && N <= 8);
static_assert!(1 <= N && N <= 8);
let n = -N as i8;
transmute(vshiftins_v16i8(
transmute(a),
@ -1202,7 +1202,7 @@ pub unsafe fn vsriq_n_u8<const N: i32>(a: uint8x16_t, b: uint8x16_t) -> uint8x16
#[cfg_attr(test, assert_instr("vsri.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
static_assert!(N : i32 where 1 <= N && N <= 16);
static_assert!(1 <= N && N <= 16);
let n = -N as i16;
transmute(vshiftins_v4i16(
transmute(a),
@ -1216,7 +1216,7 @@ pub unsafe fn vsri_n_u16<const N: i32>(a: uint16x4_t, b: uint16x4_t) -> uint16x4
#[cfg_attr(test, assert_instr("vsri.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
static_assert!(N : i32 where 1 <= N && N <= 16);
static_assert!(1 <= N && N <= 16);
let n = -N as i16;
transmute(vshiftins_v8i16(
transmute(a),
@ -1230,7 +1230,7 @@ pub unsafe fn vsriq_n_u16<const N: i32>(a: uint16x8_t, b: uint16x8_t) -> uint16x
#[cfg_attr(test, assert_instr("vsri.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
static_assert!(N : i32 where 1 <= N && N <= 32);
static_assert!(1 <= N && N <= 32);
transmute(vshiftins_v2i32(
transmute(a),
transmute(b),
@ -1243,7 +1243,7 @@ pub unsafe fn vsri_n_u32<const N: i32>(a: uint32x2_t, b: uint32x2_t) -> uint32x2
#[cfg_attr(test, assert_instr("vsri.32", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
static_assert!(N : i32 where 1 <= N && N <= 32);
static_assert!(1 <= N && N <= 32);
transmute(vshiftins_v4i32(
transmute(a),
transmute(b),
@ -1256,7 +1256,7 @@ pub unsafe fn vsriq_n_u32<const N: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x
#[cfg_attr(test, assert_instr("vsri.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
static_assert!(N : i32 where 1 <= N && N <= 64);
static_assert!(1 <= N && N <= 64);
transmute(vshiftins_v1i64(
transmute(a),
transmute(b),
@ -1269,7 +1269,7 @@ pub unsafe fn vsri_n_u64<const N: i32>(a: uint64x1_t, b: uint64x1_t) -> uint64x1
#[cfg_attr(test, assert_instr("vsri.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
static_assert!(N : i32 where 1 <= N && N <= 64);
static_assert!(1 <= N && N <= 64);
transmute(vshiftins_v2i64(
transmute(a),
transmute(b),
@ -1282,7 +1282,7 @@ pub unsafe fn vsriq_n_u64<const N: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x
#[cfg_attr(test, assert_instr("vsri.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
static_assert!(N : i32 where 1 <= N && N <= 8);
static_assert!(1 <= N && N <= 8);
let n = -N as i8;
transmute(vshiftins_v8i8(
transmute(a),
@ -1296,7 +1296,7 @@ pub unsafe fn vsri_n_p8<const N: i32>(a: poly8x8_t, b: poly8x8_t) -> poly8x8_t {
#[cfg_attr(test, assert_instr("vsri.8", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16_t {
static_assert!(N : i32 where 1 <= N && N <= 8);
static_assert!(1 <= N && N <= 8);
let n = -N as i8;
transmute(vshiftins_v16i8(
transmute(a),
@ -1310,7 +1310,7 @@ pub unsafe fn vsriq_n_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16
#[cfg_attr(test, assert_instr("vsri.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4_t {
static_assert!(N : i32 where 1 <= N && N <= 16);
static_assert!(1 <= N && N <= 16);
let n = -N as i16;
transmute(vshiftins_v4i16(
transmute(a),
@ -1324,7 +1324,7 @@ pub unsafe fn vsri_n_p16<const N: i32>(a: poly16x4_t, b: poly16x4_t) -> poly16x4
#[cfg_attr(test, assert_instr("vsri.16", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
static_assert!(N : i32 where 1 <= N && N <= 16);
static_assert!(1 <= N && N <= 16);
let n = -N as i16;
transmute(vshiftins_v8i16(
transmute(a),
@ -1341,7 +1341,7 @@ pub unsafe fn vsriq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x
#[cfg_attr(test, assert_instr("vsri.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsri_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1_t {
static_assert!(N : i32 where 1 <= N && N <= 64);
static_assert!(1 <= N && N <= 64);
transmute(vshiftins_v1i64(
transmute(a),
transmute(b),
@ -1357,7 +1357,7 @@ pub unsafe fn vsri_n_p64<const N: i32>(a: poly64x1_t, b: poly64x1_t) -> poly64x1
#[cfg_attr(test, assert_instr("vsri.64", N = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn vsriq_n_p64<const N: i32>(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
static_assert!(N : i32 where 1 <= N && N <= 64);
static_assert!(1 <= N && N <= 64);
transmute(vshiftins_v2i64(
transmute(a),
transmute(b),

1062
library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
View file

File diff suppressed because it is too large Load diff

100
library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
View file

@ -975,7 +975,7 @@ extern "unadjusted" {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_s8<const LANE: i32>(ptr: *const i8, src: int8x8_t) -> int8x8_t {
static_assert_imm3!(LANE);
static_assert_uimm_bits!(LANE, 3);
simd_insert(src, LANE as u32, *ptr)
}
@ -991,7 +991,7 @@ pub unsafe fn vld1_lane_s8<const LANE: i32>(ptr: *const i8, src: int8x8_t) -> in
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_s8<const LANE: i32>(ptr: *const i8, src: int8x16_t) -> int8x16_t {
static_assert_imm4!(LANE);
static_assert_uimm_bits!(LANE, 4);
simd_insert(src, LANE as u32, *ptr)
}
@ -1007,7 +1007,7 @@ pub unsafe fn vld1q_lane_s8<const LANE: i32>(ptr: *const i8, src: int8x16_t) ->
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_s16<const LANE: i32>(ptr: *const i16, src: int16x4_t) -> int16x4_t {
static_assert_imm2!(LANE);
static_assert_uimm_bits!(LANE, 2);
simd_insert(src, LANE as u32, *ptr)
}
@ -1023,7 +1023,7 @@ pub unsafe fn vld1_lane_s16<const LANE: i32>(ptr: *const i16, src: int16x4_t) ->
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_s16<const LANE: i32>(ptr: *const i16, src: int16x8_t) -> int16x8_t {
static_assert_imm3!(LANE);
static_assert_uimm_bits!(LANE, 3);
simd_insert(src, LANE as u32, *ptr)
}
@ -1039,7 +1039,7 @@ pub unsafe fn vld1q_lane_s16<const LANE: i32>(ptr: *const i16, src: int16x8_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_s32<const LANE: i32>(ptr: *const i32, src: int32x2_t) -> int32x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1055,7 +1055,7 @@ pub unsafe fn vld1_lane_s32<const LANE: i32>(ptr: *const i32, src: int32x2_t) ->
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_s32<const LANE: i32>(ptr: *const i32, src: int32x4_t) -> int32x4_t {
static_assert_imm2!(LANE);
static_assert_uimm_bits!(LANE, 2);
simd_insert(src, LANE as u32, *ptr)
}
@ -1071,7 +1071,7 @@ pub unsafe fn vld1q_lane_s32<const LANE: i32>(ptr: *const i32, src: int32x4_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_s64<const LANE: i32>(ptr: *const i64, src: int64x1_t) -> int64x1_t {
static_assert!(LANE : i32 where LANE == 0);
static_assert!(LANE == 0);
simd_insert(src, LANE as u32, *ptr)
}
@ -1087,7 +1087,7 @@ pub unsafe fn vld1_lane_s64<const LANE: i32>(ptr: *const i64, src: int64x1_t) ->
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_s64<const LANE: i32>(ptr: *const i64, src: int64x2_t) -> int64x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1103,7 +1103,7 @@ pub unsafe fn vld1q_lane_s64<const LANE: i32>(ptr: *const i64, src: int64x2_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_u8<const LANE: i32>(ptr: *const u8, src: uint8x8_t) -> uint8x8_t {
static_assert_imm3!(LANE);
static_assert_uimm_bits!(LANE, 3);
simd_insert(src, LANE as u32, *ptr)
}
@ -1119,7 +1119,7 @@ pub unsafe fn vld1_lane_u8<const LANE: i32>(ptr: *const u8, src: uint8x8_t) -> u
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_u8<const LANE: i32>(ptr: *const u8, src: uint8x16_t) -> uint8x16_t {
static_assert_imm4!(LANE);
static_assert_uimm_bits!(LANE, 4);
simd_insert(src, LANE as u32, *ptr)
}
@ -1135,7 +1135,7 @@ pub unsafe fn vld1q_lane_u8<const LANE: i32>(ptr: *const u8, src: uint8x16_t) ->
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_u16<const LANE: i32>(ptr: *const u16, src: uint16x4_t) -> uint16x4_t {
static_assert_imm2!(LANE);
static_assert_uimm_bits!(LANE, 2);
simd_insert(src, LANE as u32, *ptr)
}
@ -1151,7 +1151,7 @@ pub unsafe fn vld1_lane_u16<const LANE: i32>(ptr: *const u16, src: uint16x4_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_u16<const LANE: i32>(ptr: *const u16, src: uint16x8_t) -> uint16x8_t {
static_assert_imm3!(LANE);
static_assert_uimm_bits!(LANE, 3);
simd_insert(src, LANE as u32, *ptr)
}
@ -1167,7 +1167,7 @@ pub unsafe fn vld1q_lane_u16<const LANE: i32>(ptr: *const u16, src: uint16x8_t)
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_u32<const LANE: i32>(ptr: *const u32, src: uint32x2_t) -> uint32x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1183,7 +1183,7 @@ pub unsafe fn vld1_lane_u32<const LANE: i32>(ptr: *const u32, src: uint32x2_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_u32<const LANE: i32>(ptr: *const u32, src: uint32x4_t) -> uint32x4_t {
static_assert_imm2!(LANE);
static_assert_uimm_bits!(LANE, 2);
simd_insert(src, LANE as u32, *ptr)
}
@ -1199,7 +1199,7 @@ pub unsafe fn vld1q_lane_u32<const LANE: i32>(ptr: *const u32, src: uint32x4_t)
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_u64<const LANE: i32>(ptr: *const u64, src: uint64x1_t) -> uint64x1_t {
static_assert!(LANE : i32 where LANE == 0);
static_assert!(LANE == 0);
simd_insert(src, LANE as u32, *ptr)
}
@ -1215,7 +1215,7 @@ pub unsafe fn vld1_lane_u64<const LANE: i32>(ptr: *const u64, src: uint64x1_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_u64<const LANE: i32>(ptr: *const u64, src: uint64x2_t) -> uint64x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1231,7 +1231,7 @@ pub unsafe fn vld1q_lane_u64<const LANE: i32>(ptr: *const u64, src: uint64x2_t)
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_p8<const LANE: i32>(ptr: *const p8, src: poly8x8_t) -> poly8x8_t {
static_assert_imm3!(LANE);
static_assert_uimm_bits!(LANE, 3);
simd_insert(src, LANE as u32, *ptr)
}
@ -1247,7 +1247,7 @@ pub unsafe fn vld1_lane_p8<const LANE: i32>(ptr: *const p8, src: poly8x8_t) -> p
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_p8<const LANE: i32>(ptr: *const p8, src: poly8x16_t) -> poly8x16_t {
static_assert_imm4!(LANE);
static_assert_uimm_bits!(LANE, 4);
simd_insert(src, LANE as u32, *ptr)
}
@ -1263,7 +1263,7 @@ pub unsafe fn vld1q_lane_p8<const LANE: i32>(ptr: *const p8, src: poly8x16_t) ->
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_p16<const LANE: i32>(ptr: *const p16, src: poly16x4_t) -> poly16x4_t {
static_assert_imm2!(LANE);
static_assert_uimm_bits!(LANE, 2);
simd_insert(src, LANE as u32, *ptr)
}
@ -1279,7 +1279,7 @@ pub unsafe fn vld1_lane_p16<const LANE: i32>(ptr: *const p16, src: poly16x4_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_p16<const LANE: i32>(ptr: *const p16, src: poly16x8_t) -> poly16x8_t {
static_assert_imm3!(LANE);
static_assert_uimm_bits!(LANE, 3);
simd_insert(src, LANE as u32, *ptr)
}
@ -1297,7 +1297,7 @@ pub unsafe fn vld1q_lane_p16<const LANE: i32>(ptr: *const p16, src: poly16x8_t)
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_p64<const LANE: i32>(ptr: *const p64, src: poly64x1_t) -> poly64x1_t {
static_assert!(LANE : i32 where LANE == 0);
static_assert!(LANE == 0);
simd_insert(src, LANE as u32, *ptr)
}
@ -1315,7 +1315,7 @@ pub unsafe fn vld1_lane_p64<const LANE: i32>(ptr: *const p64, src: poly64x1_t) -
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_p64<const LANE: i32>(ptr: *const p64, src: poly64x2_t) -> poly64x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1331,7 +1331,7 @@ pub unsafe fn vld1q_lane_p64<const LANE: i32>(ptr: *const p64, src: poly64x2_t)
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1_lane_f32<const LANE: i32>(ptr: *const f32, src: float32x2_t) -> float32x2_t {
static_assert_imm1!(LANE);
static_assert_uimm_bits!(LANE, 1);
simd_insert(src, LANE as u32, *ptr)
}
@ -1347,7 +1347,7 @@ pub unsafe fn vld1_lane_f32<const LANE: i32>(ptr: *const f32, src: float32x2_t)
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vld1q_lane_f32<const LANE: i32>(ptr: *const f32, src: float32x4_t) -> float32x4_t {
static_assert_imm2!(LANE);
static_assert_uimm_bits!(LANE, 2);
simd_insert(src, LANE as u32, *ptr)
}
@ -4655,7 +4655,7 @@ pub unsafe fn vpmax_f32(a: float32x2_t, b: float32x2_t) -> float32x2_t {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_u64<const IMM5: i32>(v: uint64x2_t) -> u64 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -4670,7 +4670,7 @@ pub unsafe fn vgetq_lane_u64<const IMM5: i32>(v: uint64x2_t) -> u64 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_u64<const IMM5: i32>(v: uint64x1_t) -> u64 {
static_assert!(IMM5 : i32 where IMM5 == 0);
static_assert!(IMM5 == 0);
simd_extract(v, 0)
}
@ -4685,7 +4685,7 @@ pub unsafe fn vget_lane_u64<const IMM5: i32>(v: uint64x1_t) -> u64 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_u16<const IMM5: i32>(v: uint16x4_t) -> u16 {
static_assert_imm2!(IMM5);
static_assert_uimm_bits!(IMM5, 2);
simd_extract(v, IMM5 as u32)
}
@ -4700,7 +4700,7 @@ pub unsafe fn vget_lane_u16<const IMM5: i32>(v: uint16x4_t) -> u16 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_s16<const IMM5: i32>(v: int16x4_t) -> i16 {
static_assert_imm2!(IMM5);
static_assert_uimm_bits!(IMM5, 2);
simd_extract(v, IMM5 as u32)
}
@ -4715,7 +4715,7 @@ pub unsafe fn vget_lane_s16<const IMM5: i32>(v: int16x4_t) -> i16 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_p16<const IMM5: i32>(v: poly16x4_t) -> p16 {
static_assert_imm2!(IMM5);
static_assert_uimm_bits!(IMM5, 2);
simd_extract(v, IMM5 as u32)
}
@ -4730,7 +4730,7 @@ pub unsafe fn vget_lane_p16<const IMM5: i32>(v: poly16x4_t) -> p16 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_u32<const IMM5: i32>(v: uint32x2_t) -> u32 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -4745,7 +4745,7 @@ pub unsafe fn vget_lane_u32<const IMM5: i32>(v: uint32x2_t) -> u32 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_s32<const IMM5: i32>(v: int32x2_t) -> i32 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -4760,7 +4760,7 @@ pub unsafe fn vget_lane_s32<const IMM5: i32>(v: int32x2_t) -> i32 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_f32<const IMM5: i32>(v: float32x2_t) -> f32 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -4775,7 +4775,7 @@ pub unsafe fn vget_lane_f32<const IMM5: i32>(v: float32x2_t) -> f32 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_f32<const IMM5: i32>(v: float32x4_t) -> f32 {
static_assert_imm2!(IMM5);
static_assert_uimm_bits!(IMM5, 2);
simd_extract(v, IMM5 as u32)
}
@ -4790,7 +4790,7 @@ pub unsafe fn vgetq_lane_f32<const IMM5: i32>(v: float32x4_t) -> f32 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_p64<const IMM5: i32>(v: poly64x1_t) -> p64 {
static_assert!(IMM5 : i32 where IMM5 == 0);
static_assert!(IMM5 == 0);
simd_extract(v, IMM5 as u32)
}
@ -4805,7 +4805,7 @@ pub unsafe fn vget_lane_p64<const IMM5: i32>(v: poly64x1_t) -> p64 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_p64<const IMM5: i32>(v: poly64x2_t) -> p64 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -4820,7 +4820,7 @@ pub unsafe fn vgetq_lane_p64<const IMM5: i32>(v: poly64x2_t) -> p64 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_s64<const IMM5: i32>(v: int64x1_t) -> i64 {
static_assert!(IMM5 : i32 where IMM5 == 0);
static_assert!(IMM5 == 0);
simd_extract(v, IMM5 as u32)
}
@ -4835,7 +4835,7 @@ pub unsafe fn vget_lane_s64<const IMM5: i32>(v: int64x1_t) -> i64 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_s64<const IMM5: i32>(v: int64x2_t) -> i64 {
static_assert_imm1!(IMM5);
static_assert_uimm_bits!(IMM5, 1);
simd_extract(v, IMM5 as u32)
}
@ -4850,7 +4850,7 @@ pub unsafe fn vgetq_lane_s64<const IMM5: i32>(v: int64x2_t) -> i64 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_u16<const IMM5: i32>(v: uint16x8_t) -> u16 {
static_assert_imm3!(IMM5);
static_assert_uimm_bits!(IMM5, 3);
simd_extract(v, IMM5 as u32)
}
@ -4865,7 +4865,7 @@ pub unsafe fn vgetq_lane_u16<const IMM5: i32>(v: uint16x8_t) -> u16 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_u32<const IMM5: i32>(v: uint32x4_t) -> u32 {
static_assert_imm2!(IMM5);
static_assert_uimm_bits!(IMM5, 2);
simd_extract(v, IMM5 as u32)
}
@ -4880,7 +4880,7 @@ pub unsafe fn vgetq_lane_u32<const IMM5: i32>(v: uint32x4_t) -> u32 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_s16<const IMM5: i32>(v: int16x8_t) -> i16 {
static_assert_imm3!(IMM5);
static_assert_uimm_bits!(IMM5, 3);
simd_extract(v, IMM5 as u32)
}
@ -4895,7 +4895,7 @@ pub unsafe fn vgetq_lane_s16<const IMM5: i32>(v: int16x8_t) -> i16 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_p16<const IMM5: i32>(v: poly16x8_t) -> p16 {
static_assert_imm3!(IMM5);
static_assert_uimm_bits!(IMM5, 3);
simd_extract(v, IMM5 as u32)
}
@ -4910,7 +4910,7 @@ pub unsafe fn vgetq_lane_p16<const IMM5: i32>(v: poly16x8_t) -> p16 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_s32<const IMM5: i32>(v: int32x4_t) -> i32 {
static_assert_imm2!(IMM5);
static_assert_uimm_bits!(IMM5, 2);
simd_extract(v, IMM5 as u32)
}
@ -4925,7 +4925,7 @@ pub unsafe fn vgetq_lane_s32<const IMM5: i32>(v: int32x4_t) -> i32 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_u8<const IMM5: i32>(v: uint8x8_t) -> u8 {
static_assert_imm3!(IMM5);
static_assert_uimm_bits!(IMM5, 3);
simd_extract(v, IMM5 as u32)
}
@ -4940,7 +4940,7 @@ pub unsafe fn vget_lane_u8<const IMM5: i32>(v: uint8x8_t) -> u8 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_s8<const IMM5: i32>(v: int8x8_t) -> i8 {
static_assert_imm3!(IMM5);
static_assert_uimm_bits!(IMM5, 3);
simd_extract(v, IMM5 as u32)
}
@ -4955,7 +4955,7 @@ pub unsafe fn vget_lane_s8<const IMM5: i32>(v: int8x8_t) -> i8 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vget_lane_p8<const IMM5: i32>(v: poly8x8_t) -> p8 {
static_assert_imm3!(IMM5);
static_assert_uimm_bits!(IMM5, 3);
simd_extract(v, IMM5 as u32)
}
@ -4970,7 +4970,7 @@ pub unsafe fn vget_lane_p8<const IMM5: i32>(v: poly8x8_t) -> p8 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_u8<const IMM5: i32>(v: uint8x16_t) -> u8 {
static_assert_imm4!(IMM5);
static_assert_uimm_bits!(IMM5, 4);
simd_extract(v, IMM5 as u32)
}
@ -4985,7 +4985,7 @@ pub unsafe fn vgetq_lane_u8<const IMM5: i32>(v: uint8x16_t) -> u8 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_s8<const IMM5: i32>(v: int8x16_t) -> i8 {
static_assert_imm4!(IMM5);
static_assert_uimm_bits!(IMM5, 4);
simd_extract(v, IMM5 as u32)
}
@ -5000,7 +5000,7 @@ pub unsafe fn vgetq_lane_s8<const IMM5: i32>(v: int8x16_t) -> i8 {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vgetq_lane_p8<const IMM5: i32>(v: poly8x16_t) -> p8 {
static_assert_imm4!(IMM5);
static_assert_uimm_bits!(IMM5, 4);
simd_extract(v, IMM5 as u32)
}
@ -6000,7 +6000,7 @@ pub unsafe fn vmovq_n_f32(value: f32) -> float32x4_t {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vext_s64<const N: i32>(a: int64x1_t, _b: int64x1_t) -> int64x1_t {
static_assert!(N : i32 where N == 0);
static_assert!(N == 0);
a
}
@ -6016,7 +6016,7 @@ pub unsafe fn vext_s64<const N: i32>(a: int64x1_t, _b: int64x1_t) -> int64x1_t {
stable(feature = "neon_intrinsics", since = "1.59.0")
)]
pub unsafe fn vext_u64<const N: i32>(a: uint64x1_t, _b: uint64x1_t) -> uint64x1_t {
static_assert!(N : i32 where N == 0);
static_assert!(N == 0);
a
}

116
library/stdarch/crates/core_arch/src/macros.rs
View file

@ -1,81 +1,51 @@
//! Utility macros.
// Helper struct used to trigger const eval errors when the const generic immediate value `IMM` is
// out of `[MIN-MAX]` range.
pub(crate) struct ValidateConstImm<const IMM: i32, const MIN: i32, const MAX: i32>;
impl<const IMM: i32, const MIN: i32, const MAX: i32> ValidateConstImm<IMM, MIN, MAX> {
pub(crate) const VALID: () = {
assert!(IMM >= MIN && IMM <= MAX, "IMM value not in expected range");
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm1 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 1) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm2 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 2) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm3 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 3) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm4 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 4) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm5 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 5) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm6 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 6) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm8 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 8) - 1 }>::VALID;
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm16 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, 0, { (1 << 16) - 1 }>::VALID;
};
}
#[allow(unused)]
macro_rules! static_assert {
($imm:ident : $ty:ty where $e:expr) => {{
struct Validate<const $imm: $ty>();
impl<const $imm: $ty> Validate<$imm> {
const VALID: () = {
assert!($e, concat!("Assertion failed: ", stringify!($e)));
};
($e:expr) => {
const {
assert!($e);
}
let _ = Validate::<$imm>::VALID;
}};
};
($e:expr, $msg:expr) => {
const {
assert!($e, $msg);
}
};
}
#[allow(unused_macros)]
macro_rules! static_assert_uimm_bits {
($imm:ident, $bits:expr) => {
// `0 <= $imm` produces a warning if the immediate has an unsigned type
#[allow(unused_comparisons)]
{
static_assert!(
0 <= $imm && $imm <= (1 << $bits) - 1,
concat!(
stringify!($imm),
" doesn't fit in ",
stringify!($bits),
" bits",
)
)
}
};
}
#[allow(unused_macros)]
macro_rules! static_assert_simm_bits {
($imm:ident, $bits:expr) => {
static_assert!(
(-1 << ($bits - 1)) - 1 <= $imm && $imm <= (1 << ($bits - 1)) - 1,
concat!(
stringify!($imm),
" doesn't fit in ",
stringify!($bits),
" bits",
)
)
};
}
#[allow(unused)]

295
library/stdarch/crates/core_arch/src/mips/msa.rs
View file

File diff suppressed because it is too large Load diff

31
library/stdarch/crates/core_arch/src/mips/msa/macros.rs
View file

@ -1,31 +0,0 @@
//! Utility macros.
macro_rules! static_assert_imm_s5 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, -16, 15>::VALID;
};
}
macro_rules! static_assert_imm_s10 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, -512, 511>::VALID;
};
}
macro_rules! static_assert_imm_s11 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, -1024, 1023>::VALID;
};
}
macro_rules! static_assert_imm_s12 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, -2048, 2047>::VALID;
};
}
macro_rules! static_assert_imm_s13 {
($imm:ident) => {
let _ = $crate::core_arch::macros::ValidateConstImm::<$imm, -4096, 4095>::VALID;
};
}

2
library/stdarch/crates/core_arch/src/powerpc/vsx.rs
View file

@ -80,7 +80,7 @@ pub unsafe fn vec_xxpermdi<T, const DM: i32>(a: T, b: T) -> T
where
T: sealed::VectorPermDI,
{
static_assert_imm2!(DM);
static_assert_uimm_bits!(DM, 2);
a.vec_xxpermdi(b, DM as u8)
}

4
library/stdarch/crates/core_arch/src/riscv_shared/mod.rs
View file

@ -691,7 +691,7 @@ pub fn sm3p1(x: u32) -> u32 {
#[inline]
#[target_feature(enable = "zksed")]
pub fn sm4ed<const BS: u8>(x: u32, a: u32) -> u32 {
static_assert!(BS: u8 where BS <= 3);
static_assert!(BS <= 3);
let ans: u32;
unsafe {
asm!("sm4ed {}, {}, {}, {}", lateout(reg) ans, in(reg) x, in(reg) a, const BS, options(pure, nomem, nostack))
@ -751,7 +751,7 @@ pub fn sm4ed<const BS: u8>(x: u32, a: u32) -> u32 {
#[inline]
#[target_feature(enable = "zksed")]
pub fn sm4ks<const BS: u8>(x: u32, k: u32) -> u32 {
static_assert!(BS: u8 where BS <= 3);
static_assert!(BS <= 3);
let ans: u32;
unsafe {
asm!("sm4ks {}, {}, {}, {}", lateout(reg) ans, in(reg) x, in(reg) k, const BS, options(pure, nomem, nostack))

4
library/stdarch/crates/core_arch/src/wasm32/memory.rs
View file

@ -26,7 +26,7 @@ extern "C" {
#[stable(feature = "simd_wasm32", since = "1.33.0")]
#[doc(alias("memory.size"))]
pub fn memory_size<const MEM: u32>() -> usize {
static_assert!(MEM: u32 where MEM == 0);
static_assert!(MEM == 0);
unsafe { llvm_memory_size(MEM) }
}
@ -52,7 +52,7 @@ pub fn memory_size<const MEM: u32>() -> usize {
#[doc(alias("memory.grow"))]
pub fn memory_grow<const MEM: u32>(delta: usize) -> usize {
unsafe {
static_assert!(MEM: u32 where MEM == 0);
static_assert!(MEM == 0);
llvm_memory_grow(MEM, delta)
}
}

92
library/stdarch/crates/core_arch/src/wasm32/simd128.rs
View file

@ -937,22 +937,22 @@ pub fn i8x16_shuffle<
a: v128,
b: v128,
) -> v128 {
static_assert!(I0: usize where I0 < 32);
static_assert!(I1: usize where I1 < 32);
static_assert!(I2: usize where I2 < 32);
static_assert!(I3: usize where I3 < 32);
static_assert!(I4: usize where I4 < 32);
static_assert!(I5: usize where I5 < 32);
static_assert!(I6: usize where I6 < 32);
static_assert!(I7: usize where I7 < 32);
static_assert!(I8: usize where I8 < 32);
static_assert!(I9: usize where I9 < 32);
static_assert!(I10: usize where I10 < 32);
static_assert!(I11: usize where I11 < 32);
static_assert!(I12: usize where I12 < 32);
static_assert!(I13: usize where I13 < 32);
static_assert!(I14: usize where I14 < 32);
static_assert!(I15: usize where I15 < 32);
static_assert!(I0 < 32);
static_assert!(I1 < 32);
static_assert!(I2 < 32);
static_assert!(I3 < 32);
static_assert!(I4 < 32);
static_assert!(I5 < 32);
static_assert!(I6 < 32);
static_assert!(I7 < 32);
static_assert!(I8 < 32);
static_assert!(I9 < 32);
static_assert!(I10 < 32);
static_assert!(I11 < 32);
static_assert!(I12 < 32);
static_assert!(I13 < 32);
static_assert!(I14 < 32);
static_assert!(I15 < 32);
let shuf: simd::u8x16 = unsafe {
simd_shuffle!(
a.as_u8x16(),
@ -1007,14 +1007,14 @@ pub fn i16x8_shuffle<
a: v128,
b: v128,
) -> v128 {
static_assert!(I0: usize where I0 < 16);
static_assert!(I1: usize where I1 < 16);
static_assert!(I2: usize where I2 < 16);
static_assert!(I3: usize where I3 < 16);
static_assert!(I4: usize where I4 < 16);
static_assert!(I5: usize where I5 < 16);
static_assert!(I6: usize where I6 < 16);
static_assert!(I7: usize where I7 < 16);
static_assert!(I0 < 16);
static_assert!(I1 < 16);
static_assert!(I2 < 16);
static_assert!(I3 < 16);
static_assert!(I4 < 16);
static_assert!(I5 < 16);
static_assert!(I6 < 16);
static_assert!(I7 < 16);
let shuf: simd::u16x8 = unsafe {
simd_shuffle!(
a.as_u16x8(),
@ -1047,10 +1047,10 @@ pub fn i32x4_shuffle<const I0: usize, const I1: usize, const I2: usize, const I3
a: v128,
b: v128,
) -> v128 {
static_assert!(I0: usize where I0 < 8);
static_assert!(I1: usize where I1 < 8);
static_assert!(I2: usize where I2 < 8);
static_assert!(I3: usize where I3 < 8);
static_assert!(I0 < 8);
static_assert!(I1 < 8);
static_assert!(I2 < 8);
static_assert!(I3 < 8);
let shuf: simd::u32x4 = unsafe {
simd_shuffle!(
a.as_u32x4(),
@ -1077,8 +1077,8 @@ pub use i32x4_shuffle as u32x4_shuffle;
#[doc(alias("i8x16.shuffle"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i64x2_shuffle<const I0: usize, const I1: usize>(a: v128, b: v128) -> v128 {
static_assert!(I0: usize where I0 < 4);
static_assert!(I1: usize where I1 < 4);
static_assert!(I0 < 4);
static_assert!(I1 < 4);
let shuf: simd::u64x2 =
unsafe { simd_shuffle!(a.as_u64x2(), b.as_u64x2(), [I0 as u32, I1 as u32]) };
shuf.v128()
@ -1097,7 +1097,7 @@ pub use i64x2_shuffle as u64x2_shuffle;
#[doc(alias("i8x16.extract_lane_s"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i8x16_extract_lane<const N: usize>(a: v128) -> i8 {
static_assert!(N: usize where N < 16);
static_assert!(N < 16);
unsafe { simd_extract(a.as_i8x16(), N as u32) }
}
@ -1111,7 +1111,7 @@ pub fn i8x16_extract_lane<const N: usize>(a: v128) -> i8 {
#[doc(alias("i8x16.extract_lane_u"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn u8x16_extract_lane<const N: usize>(a: v128) -> u8 {
static_assert!(N: usize where N < 16);
static_assert!(N < 16);
unsafe { simd_extract(a.as_u8x16(), N as u32) }
}
@ -1125,7 +1125,7 @@ pub fn u8x16_extract_lane<const N: usize>(a: v128) -> u8 {
#[doc(alias("i8x16.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i8x16_replace_lane<const N: usize>(a: v128, val: i8) -> v128 {
static_assert!(N: usize where N < 16);
static_assert!(N < 16);
unsafe { simd_insert(a.as_i8x16(), N as u32, val).v128() }
}
@ -1139,7 +1139,7 @@ pub fn i8x16_replace_lane<const N: usize>(a: v128, val: i8) -> v128 {
#[doc(alias("i8x16.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn u8x16_replace_lane<const N: usize>(a: v128, val: u8) -> v128 {
static_assert!(N: usize where N < 16);
static_assert!(N < 16);
unsafe { simd_insert(a.as_u8x16(), N as u32, val).v128() }
}
@ -1153,7 +1153,7 @@ pub fn u8x16_replace_lane<const N: usize>(a: v128, val: u8) -> v128 {
#[doc(alias("i16x8.extract_lane_s"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i16x8_extract_lane<const N: usize>(a: v128) -> i16 {
static_assert!(N: usize where N < 8);
static_assert!(N < 8);
unsafe { simd_extract(a.as_i16x8(), N as u32) }
}
@ -1167,7 +1167,7 @@ pub fn i16x8_extract_lane<const N: usize>(a: v128) -> i16 {
#[doc(alias("i16x8.extract_lane_u"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn u16x8_extract_lane<const N: usize>(a: v128) -> u16 {
static_assert!(N: usize where N < 8);
static_assert!(N < 8);
unsafe { simd_extract(a.as_u16x8(), N as u32) }
}
@ -1181,7 +1181,7 @@ pub fn u16x8_extract_lane<const N: usize>(a: v128) -> u16 {
#[doc(alias("i16x8.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i16x8_replace_lane<const N: usize>(a: v128, val: i16) -> v128 {
static_assert!(N: usize where N < 8);
static_assert!(N < 8);
unsafe { simd_insert(a.as_i16x8(), N as u32, val).v128() }
}
@ -1195,7 +1195,7 @@ pub fn i16x8_replace_lane<const N: usize>(a: v128, val: i16) -> v128 {
#[doc(alias("i16x8.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn u16x8_replace_lane<const N: usize>(a: v128, val: u16) -> v128 {
static_assert!(N: usize where N < 8);
static_assert!(N < 8);
unsafe { simd_insert(a.as_u16x8(), N as u32, val).v128() }
}
@ -1209,7 +1209,7 @@ pub fn u16x8_replace_lane<const N: usize>(a: v128, val: u16) -> v128 {
#[doc(alias("i32x4.extract_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i32x4_extract_lane<const N: usize>(a: v128) -> i32 {
static_assert!(N: usize where N < 4);
static_assert!(N < 4);
unsafe { simd_extract(a.as_i32x4(), N as u32) }
}
@ -1235,7 +1235,7 @@ pub fn u32x4_extract_lane<const N: usize>(a: v128) -> u32 {
#[doc(alias("i32x4.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i32x4_replace_lane<const N: usize>(a: v128, val: i32) -> v128 {
static_assert!(N: usize where N < 4);
static_assert!(N < 4);
unsafe { simd_insert(a.as_i32x4(), N as u32, val).v128() }
}
@ -1261,7 +1261,7 @@ pub fn u32x4_replace_lane<const N: usize>(a: v128, val: u32) -> v128 {
#[doc(alias("i64x2.extract_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i64x2_extract_lane<const N: usize>(a: v128) -> i64 {
static_assert!(N: usize where N < 2);
static_assert!(N < 2);
unsafe { simd_extract(a.as_i64x2(), N as u32) }
}
@ -1287,7 +1287,7 @@ pub fn u64x2_extract_lane<const N: usize>(a: v128) -> u64 {
#[doc(alias("i64x2.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn i64x2_replace_lane<const N: usize>(a: v128, val: i64) -> v128 {
static_assert!(N: usize where N < 2);
static_assert!(N < 2);
unsafe { simd_insert(a.as_i64x2(), N as u32, val).v128() }
}
@ -1313,7 +1313,7 @@ pub fn u64x2_replace_lane<const N: usize>(a: v128, val: u64) -> v128 {
#[doc(alias("f32x4.extract_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn f32x4_extract_lane<const N: usize>(a: v128) -> f32 {
static_assert!(N: usize where N < 4);
static_assert!(N < 4);
unsafe { simd_extract(a.as_f32x4(), N as u32) }
}
@ -1327,7 +1327,7 @@ pub fn f32x4_extract_lane<const N: usize>(a: v128) -> f32 {
#[doc(alias("f32x4.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn f32x4_replace_lane<const N: usize>(a: v128, val: f32) -> v128 {
static_assert!(N: usize where N < 4);
static_assert!(N < 4);
unsafe { simd_insert(a.as_f32x4(), N as u32, val).v128() }
}
@ -1341,7 +1341,7 @@ pub fn f32x4_replace_lane<const N: usize>(a: v128, val: f32) -> v128 {
#[doc(alias("f64x2.extract_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn f64x2_extract_lane<const N: usize>(a: v128) -> f64 {
static_assert!(N: usize where N < 2);
static_assert!(N < 2);
unsafe { simd_extract(a.as_f64x2(), N as u32) }
}
@ -1355,7 +1355,7 @@ pub fn f64x2_extract_lane<const N: usize>(a: v128) -> f64 {
#[doc(alias("f64x2.replace_lane"))]
#[stable(feature = "wasm_simd", since = "1.54.0")]
pub fn f64x2_replace_lane<const N: usize>(a: v128, val: f64) -> v128 {
static_assert!(N: usize where N < 2);
static_assert!(N < 2);
unsafe { simd_insert(a.as_f64x2(), N as u32, val).v128() }
}

2
library/stdarch/crates/core_arch/src/x86/aes.rs
View file

@ -96,7 +96,7 @@ pub unsafe fn _mm_aesimc_si128(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_aeskeygenassist_si128<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
aeskeygenassist(a, IMM8 as u8)
}

58
library/stdarch/crates/core_arch/src/x86/avx.rs
View file

@ -117,7 +117,7 @@ pub unsafe fn _mm256_or_ps(a: __m256, b: __m256) -> __m256 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_shuffle_pd<const MASK: i32>(a: __m256d, b: __m256d) -> __m256d {
static_assert_imm8!(MASK);
static_assert_uimm_bits!(MASK, 8);
simd_shuffle!(
a,
b,
@ -140,7 +140,7 @@ pub unsafe fn _mm256_shuffle_pd<const MASK: i32>(a: __m256d, b: __m256d) -> __m2
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_shuffle_ps<const MASK: i32>(a: __m256, b: __m256) -> __m256 {
static_assert_imm8!(MASK);
static_assert_uimm_bits!(MASK, 8);
simd_shuffle!(
a,
b,
@ -350,7 +350,7 @@ pub unsafe fn _mm256_div_pd(a: __m256d, b: __m256d) -> __m256d {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_round_pd<const ROUNDING: i32>(a: __m256d) -> __m256d {
static_assert_imm4!(ROUNDING);
static_assert_uimm_bits!(ROUNDING, 4);
roundpd256(a, ROUNDING)
}
@ -397,7 +397,7 @@ pub unsafe fn _mm256_floor_pd(a: __m256d) -> __m256d {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_round_ps<const ROUNDING: i32>(a: __m256) -> __m256 {
static_assert_imm4!(ROUNDING);
static_assert_uimm_bits!(ROUNDING, 4);
roundps256(a, ROUNDING)
}
@ -462,7 +462,7 @@ pub unsafe fn _mm256_sqrt_pd(a: __m256d) -> __m256d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_blend_pd<const IMM4: i32>(a: __m256d, b: __m256d) -> __m256d {
static_assert_imm4!(IMM4);
static_assert_uimm_bits!(IMM4, 4);
simd_shuffle!(
a,
b,
@ -485,7 +485,7 @@ pub unsafe fn _mm256_blend_pd<const IMM4: i32>(a: __m256d, b: __m256d) -> __m256
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_blend_ps<const IMM8: i32>(a: __m256, b: __m256) -> __m256 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
simd_shuffle!(
a,
b,
@ -538,7 +538,7 @@ pub unsafe fn _mm256_blendv_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_dp_ps<const IMM8: i32>(a: __m256, b: __m256) -> __m256 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
vdpps(a, b, IMM8)
}
@ -737,7 +737,7 @@ pub const _CMP_TRUE_US: i32 = 0x1f;
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmp_pd<const IMM5: i32>(a: __m128d, b: __m128d) -> __m128d {
static_assert_imm5!(IMM5);
static_assert_uimm_bits!(IMM5, 5);
vcmppd(a, b, IMM5 as i8)
}
@ -752,7 +752,7 @@ pub unsafe fn _mm_cmp_pd<const IMM5: i32>(a: __m128d, b: __m128d) -> __m128d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_cmp_pd<const IMM5: i32>(a: __m256d, b: __m256d) -> __m256d {
static_assert_imm5!(IMM5);
static_assert_uimm_bits!(IMM5, 5);
vcmppd256(a, b, IMM5 as u8)
}
@ -767,7 +767,7 @@ pub unsafe fn _mm256_cmp_pd<const IMM5: i32>(a: __m256d, b: __m256d) -> __m256d
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmp_ps<const IMM5: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm5!(IMM5);
static_assert_uimm_bits!(IMM5, 5);
vcmpps(a, b, IMM5 as i8)
}
@ -782,7 +782,7 @@ pub unsafe fn _mm_cmp_ps<const IMM5: i32>(a: __m128, b: __m128) -> __m128 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_cmp_ps<const IMM5: i32>(a: __m256, b: __m256) -> __m256 {
static_assert_imm5!(IMM5);
static_assert_uimm_bits!(IMM5, 5);
vcmpps256(a, b, IMM5 as u8)
}
@ -799,7 +799,7 @@ pub unsafe fn _mm256_cmp_ps<const IMM5: i32>(a: __m256, b: __m256) -> __m256 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmp_sd<const IMM5: i32>(a: __m128d, b: __m128d) -> __m128d {
static_assert_imm5!(IMM5);
static_assert_uimm_bits!(IMM5, 5);
vcmpsd(a, b, IMM5 as i8)
}
@ -816,7 +816,7 @@ pub unsafe fn _mm_cmp_sd<const IMM5: i32>(a: __m128d, b: __m128d) -> __m128d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmp_ss<const IMM5: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm5!(IMM5);
static_assert_uimm_bits!(IMM5, 5);
vcmpss(a, b, IMM5 as i8)
}
@ -929,7 +929,7 @@ pub unsafe fn _mm256_cvttps_epi32(a: __m256) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extractf128_ps<const IMM1: i32>(a: __m256) -> __m128 {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
simd_shuffle!(
a,
_mm256_undefined_ps(),
@ -950,7 +950,7 @@ pub unsafe fn _mm256_extractf128_ps<const IMM1: i32>(a: __m256) -> __m128 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extractf128_pd<const IMM1: i32>(a: __m256d) -> __m128d {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
simd_shuffle!(a, _mm256_undefined_pd(), [[0, 1], [2, 3]][IMM1 as usize])
}
@ -966,7 +966,7 @@ pub unsafe fn _mm256_extractf128_pd<const IMM1: i32>(a: __m256d) -> __m128d {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extractf128_si256<const IMM1: i32>(a: __m256i) -> __m128i {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
let dst: i64x2 = simd_shuffle!(
a.as_i64x4(),
_mm256_undefined_si256().as_i64x4(),
@ -1032,7 +1032,7 @@ pub unsafe fn _mm_permutevar_ps(a: __m128, b: __m128i) -> __m128 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute_ps<const IMM8: i32>(a: __m256) -> __m256 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
simd_shuffle!(
a,
_mm256_undefined_ps(),
@ -1059,7 +1059,7 @@ pub unsafe fn _mm256_permute_ps<const IMM8: i32>(a: __m256) -> __m256 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_permute_ps<const IMM8: i32>(a: __m128) -> __m128 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
simd_shuffle!(
a,
_mm_undefined_ps(),
@ -1106,7 +1106,7 @@ pub unsafe fn _mm_permutevar_pd(a: __m128d, b: __m128i) -> __m128d {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute_pd<const IMM4: i32>(a: __m256d) -> __m256d {
static_assert_imm4!(IMM4);
static_assert_uimm_bits!(IMM4, 4);
simd_shuffle!(
a,
_mm256_undefined_pd(),
@ -1129,7 +1129,7 @@ pub unsafe fn _mm256_permute_pd<const IMM4: i32>(a: __m256d) -> __m256d {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_permute_pd<const IMM2: i32>(a: __m128d) -> __m128d {
static_assert_imm2!(IMM2);
static_assert_uimm_bits!(IMM2, 2);
simd_shuffle!(
a,
_mm_undefined_pd(),
@ -1147,7 +1147,7 @@ pub unsafe fn _mm_permute_pd<const IMM2: i32>(a: __m128d) -> __m128d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute2f128_ps<const IMM8: i32>(a: __m256, b: __m256) -> __m256 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
vperm2f128ps256(a, b, IMM8 as i8)
}
@ -1161,7 +1161,7 @@ pub unsafe fn _mm256_permute2f128_ps<const IMM8: i32>(a: __m256, b: __m256) -> _
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute2f128_pd<const IMM8: i32>(a: __m256d, b: __m256d) -> __m256d {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
vperm2f128pd256(a, b, IMM8 as i8)
}
@ -1175,7 +1175,7 @@ pub unsafe fn _mm256_permute2f128_pd<const IMM8: i32>(a: __m256d, b: __m256d) ->
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute2f128_si256<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vperm2f128si256(a.as_i32x8(), b.as_i32x8(), IMM8 as i8))
}
@ -1256,7 +1256,7 @@ pub unsafe fn _mm256_broadcast_pd(a: &__m128d) -> __m256d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insertf128_ps<const IMM1: i32>(a: __m256, b: __m128) -> __m256 {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
simd_shuffle!(
a,
_mm256_castps128_ps256(b),
@ -1278,7 +1278,7 @@ pub unsafe fn _mm256_insertf128_ps<const IMM1: i32>(a: __m256, b: __m128) -> __m
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insertf128_pd<const IMM1: i32>(a: __m256d, b: __m128d) -> __m256d {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
simd_shuffle!(
a,
_mm256_castpd128_pd256(b),
@ -1299,7 +1299,7 @@ pub unsafe fn _mm256_insertf128_pd<const IMM1: i32>(a: __m256d, b: __m128d) -> _
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insertf128_si256<const IMM1: i32>(a: __m256i, b: __m128i) -> __m256i {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
let dst: i64x4 = simd_shuffle!(
a.as_i64x4(),
_mm256_castsi128_si256(b).as_i64x4(),
@ -1318,7 +1318,7 @@ pub unsafe fn _mm256_insertf128_si256<const IMM1: i32>(a: __m256i, b: __m128i) -
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insert_epi8<const INDEX: i32>(a: __m256i, i: i8) -> __m256i {
static_assert_imm5!(INDEX);
static_assert_uimm_bits!(INDEX, 5);
transmute(simd_insert(a.as_i8x32(), INDEX as u32, i))
}
@ -1332,7 +1332,7 @@ pub unsafe fn _mm256_insert_epi8<const INDEX: i32>(a: __m256i, i: i8) -> __m256i
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insert_epi16<const INDEX: i32>(a: __m256i, i: i16) -> __m256i {
static_assert_imm4!(INDEX);
static_assert_uimm_bits!(INDEX, 4);
transmute(simd_insert(a.as_i16x16(), INDEX as u32, i))
}
@ -1346,7 +1346,7 @@ pub unsafe fn _mm256_insert_epi16<const INDEX: i32>(a: __m256i, i: i16) -> __m25
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insert_epi32<const INDEX: i32>(a: __m256i, i: i32) -> __m256i {
static_assert_imm3!(INDEX);
static_assert_uimm_bits!(INDEX, 3);
transmute(simd_insert(a.as_i32x8(), INDEX as u32, i))
}

56
library/stdarch/crates/core_arch/src/x86/avx2.rs
View file

@ -157,7 +157,7 @@ pub unsafe fn _mm256_adds_epu16(a: __m256i, b: __m256i) -> __m256i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_alignr_epi8<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
// If palignr is shifting the pair of vectors more than the size of two
// lanes, emit zero.
if IMM8 > 32 {
@ -367,7 +367,7 @@ pub unsafe fn _mm256_avg_epu8(a: __m256i, b: __m256i) -> __m256i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_blend_epi32<const IMM4: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm4!(IMM4);
static_assert_uimm_bits!(IMM4, 4);
let a = a.as_i32x4();
let b = b.as_i32x4();
let r: i32x4 = simd_shuffle!(
@ -392,7 +392,7 @@ pub unsafe fn _mm_blend_epi32<const IMM4: i32>(a: __m128i, b: __m128i) -> __m128
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_blend_epi32<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i32x8();
let b = b.as_i32x8();
let r: i32x8 = simd_shuffle!(
@ -421,7 +421,7 @@ pub unsafe fn _mm256_blend_epi32<const IMM8: i32>(a: __m256i, b: __m256i) -> __m
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_blend_epi16<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x16();
let b = b.as_i16x16();
@ -888,7 +888,7 @@ pub unsafe fn _mm256_cvtepu8_epi64(a: __m128i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extracti128_si256<const IMM1: i32>(a: __m256i) -> __m128i {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
let a = a.as_i64x4();
let b = _mm256_undefined_si256().as_i64x4();
let dst: i64x2 = simd_shuffle!(a, b, [[0, 1], [2, 3]][IMM1 as usize]);
@ -1710,7 +1710,7 @@ pub unsafe fn _mm256_mask_i64gather_pd<const SCALE: i32>(
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_inserti128_si256<const IMM1: i32>(a: __m256i, b: __m128i) -> __m256i {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
let a = a.as_i64x4();
let b = _mm256_castsi128_si256(b).as_i64x4();
let dst: i64x4 = simd_shuffle!(a, b, [[4, 5, 2, 3], [0, 1, 4, 5]][IMM1 as usize]);
@ -2045,7 +2045,7 @@ pub unsafe fn _mm256_movemask_epi8(a: __m256i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_mpsadbw_epu8<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(mpsadbw(a.as_u8x32(), b.as_u8x32(), IMM8))
}
@ -2226,7 +2226,7 @@ pub unsafe fn _mm256_permutevar8x32_epi32(a: __m256i, b: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute4x64_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let zero = _mm256_setzero_si256().as_i64x4();
let r: i64x4 = simd_shuffle!(
a.as_i64x4(),
@ -2250,7 +2250,7 @@ pub unsafe fn _mm256_permute4x64_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute2x128_si256<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vperm2i128(a.as_i64x4(), b.as_i64x4(), IMM8 as i8))
}
@ -2264,7 +2264,7 @@ pub unsafe fn _mm256_permute2x128_si256<const IMM8: i32>(a: __m256i, b: __m256i)
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_permute4x64_pd<const IMM8: i32>(a: __m256d) -> __m256d {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
simd_shuffle!(
a,
_mm256_undefined_pd(),
@ -2377,7 +2377,7 @@ pub unsafe fn _mm256_shuffle_epi8(a: __m256i, b: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_shuffle_epi32<const MASK: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(MASK);
static_assert_uimm_bits!(MASK, 8);
let r: i32x8 = simd_shuffle!(
a.as_i32x8(),
a.as_i32x8(),
@ -2406,7 +2406,7 @@ pub unsafe fn _mm256_shuffle_epi32<const MASK: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_shufflehi_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x16();
let r: i16x16 = simd_shuffle!(
a,
@ -2444,7 +2444,7 @@ pub unsafe fn _mm256_shufflehi_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_shufflelo_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x16();
let r: i16x16 = simd_shuffle!(
a,
@ -2556,7 +2556,7 @@ pub unsafe fn _mm256_sll_epi64(a: __m256i, count: __m128i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_slli_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pslliw(a.as_i16x16(), IMM8))
}
@ -2570,7 +2570,7 @@ pub unsafe fn _mm256_slli_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_slli_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psllid(a.as_i32x8(), IMM8))
}
@ -2584,7 +2584,7 @@ pub unsafe fn _mm256_slli_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_slli_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pslliq(a.as_i64x4(), IMM8))
}
@ -2597,7 +2597,7 @@ pub unsafe fn _mm256_slli_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_slli_si256<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
_mm256_bslli_epi128::<IMM8>(a)
}
@ -2610,7 +2610,7 @@ pub unsafe fn _mm256_slli_si256<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_bslli_epi128<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
const fn mask(shift: i32, i: u32) -> u32 {
let shift = shift as u32 & 0xff;
if shift > 15 || i % 16 < shift {
@ -2748,7 +2748,7 @@ pub unsafe fn _mm256_sra_epi32(a: __m256i, count: __m128i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_srai_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psraiw(a.as_i16x16(), IMM8))
}
@ -2762,7 +2762,7 @@ pub unsafe fn _mm256_srai_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_srai_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psraid(a.as_i32x8(), IMM8))
}
@ -2799,7 +2799,7 @@ pub unsafe fn _mm256_srav_epi32(a: __m256i, count: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_srli_si256<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
_mm256_bsrli_epi128::<IMM8>(a)
}
@ -2812,7 +2812,7 @@ pub unsafe fn _mm256_srli_si256<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_bsrli_epi128<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i8x32();
let zero = _mm256_setzero_si256().as_i8x32();
let r: i8x32 = match IMM8 % 16 {
@ -2995,7 +2995,7 @@ pub unsafe fn _mm256_srl_epi64(a: __m256i, count: __m128i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_srli_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psrliw(a.as_i16x16(), IMM8))
}
@ -3009,7 +3009,7 @@ pub unsafe fn _mm256_srli_epi16<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_srli_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psrlid(a.as_i32x8(), IMM8))
}
@ -3023,7 +3023,7 @@ pub unsafe fn _mm256_srli_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_srli_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psrliq(a.as_i64x4(), IMM8))
}
@ -3543,7 +3543,7 @@ pub unsafe fn _mm256_xor_si256(a: __m256i, b: __m256i) -> __m256i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extract_epi8<const INDEX: i32>(a: __m256i) -> i32 {
static_assert_imm5!(INDEX);
static_assert_uimm_bits!(INDEX, 5);
simd_extract::<_, u8>(a.as_u8x32(), INDEX as u32) as i32
}
@ -3559,7 +3559,7 @@ pub unsafe fn _mm256_extract_epi8<const INDEX: i32>(a: __m256i) -> i32 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extract_epi16<const INDEX: i32>(a: __m256i) -> i32 {
static_assert_imm4!(INDEX);
static_assert_uimm_bits!(INDEX, 4);
simd_extract::<_, u16>(a.as_u16x16(), INDEX as u32) as i32
}
@ -3572,7 +3572,7 @@ pub unsafe fn _mm256_extract_epi16<const INDEX: i32>(a: __m256i) -> i32 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extract_epi32<const INDEX: i32>(a: __m256i) -> i32 {
static_assert_imm3!(INDEX);
static_assert_uimm_bits!(INDEX, 3);
simd_extract(a.as_i32x8(), INDEX as u32)
}

152
library/stdarch/crates/core_arch/src/x86/avx512bw.rs
View file

@ -3700,7 +3700,7 @@ pub unsafe fn _mm_mask_cmpneq_epi8_mask(k1: __mmask16, a: __m128i, b: __m128i) -
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm512_cmp_epu16_mask<const IMM8: i32>(a: __m512i, b: __m512i) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u16x32();
let b = b.as_u16x32();
let r = vpcmpuw(a, b, IMM8, 0b11111111_11111111_11111111_11111111);
@ -3719,7 +3719,7 @@ pub unsafe fn _mm512_mask_cmp_epu16_mask<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u16x32();
let b = b.as_u16x32();
let r = vpcmpuw(a, b, IMM8, k1);
@ -3734,7 +3734,7 @@ pub unsafe fn _mm512_mask_cmp_epu16_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm256_cmp_epu16_mask<const IMM8: i32>(a: __m256i, b: __m256i) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u16x16();
let b = b.as_u16x16();
let r = vpcmpuw256(a, b, IMM8, 0b11111111_11111111);
@ -3753,7 +3753,7 @@ pub unsafe fn _mm256_mask_cmp_epu16_mask<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u16x16();
let b = b.as_u16x16();
let r = vpcmpuw256(a, b, IMM8, k1);
@ -3768,7 +3768,7 @@ pub unsafe fn _mm256_mask_cmp_epu16_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm_cmp_epu16_mask<const IMM8: i32>(a: __m128i, b: __m128i) -> __mmask8 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u16x8();
let b = b.as_u16x8();
let r = vpcmpuw128(a, b, IMM8, 0b11111111);
@ -3787,7 +3787,7 @@ pub unsafe fn _mm_mask_cmp_epu16_mask<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __mmask8 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u16x8();
let b = b.as_u16x8();
let r = vpcmpuw128(a, b, IMM8, k1);
@ -3802,7 +3802,7 @@ pub unsafe fn _mm_mask_cmp_epu16_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm512_cmp_epu8_mask<const IMM8: i32>(a: __m512i, b: __m512i) -> __mmask64 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u8x64();
let b = b.as_u8x64();
let r = vpcmpub(
@ -3826,7 +3826,7 @@ pub unsafe fn _mm512_mask_cmp_epu8_mask<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __mmask64 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u8x64();
let b = b.as_u8x64();
let r = vpcmpub(a, b, IMM8, k1);
@ -3841,7 +3841,7 @@ pub unsafe fn _mm512_mask_cmp_epu8_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm256_cmp_epu8_mask<const IMM8: i32>(a: __m256i, b: __m256i) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u8x32();
let b = b.as_u8x32();
let r = vpcmpub256(a, b, IMM8, 0b11111111_11111111_11111111_11111111);
@ -3860,7 +3860,7 @@ pub unsafe fn _mm256_mask_cmp_epu8_mask<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u8x32();
let b = b.as_u8x32();
let r = vpcmpub256(a, b, IMM8, k1);
@ -3875,7 +3875,7 @@ pub unsafe fn _mm256_mask_cmp_epu8_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm_cmp_epu8_mask<const IMM8: i32>(a: __m128i, b: __m128i) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u8x16();
let b = b.as_u8x16();
let r = vpcmpub128(a, b, IMM8, 0b11111111_11111111);
@ -3894,7 +3894,7 @@ pub unsafe fn _mm_mask_cmp_epu8_mask<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_u8x16();
let b = b.as_u8x16();
let r = vpcmpub128(a, b, IMM8, k1);
@ -3909,7 +3909,7 @@ pub unsafe fn _mm_mask_cmp_epu8_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm512_cmp_epi16_mask<const IMM8: i32>(a: __m512i, b: __m512i) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i16x32();
let b = b.as_i16x32();
let r = vpcmpw(a, b, IMM8, 0b11111111_11111111_11111111_11111111);
@ -3928,7 +3928,7 @@ pub unsafe fn _mm512_mask_cmp_epi16_mask<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i16x32();
let b = b.as_i16x32();
let r = vpcmpw(a, b, IMM8, k1);
@ -3943,7 +3943,7 @@ pub unsafe fn _mm512_mask_cmp_epi16_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm256_cmp_epi16_mask<const IMM8: i32>(a: __m256i, b: __m256i) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i16x16();
let b = b.as_i16x16();
let r = vpcmpw256(a, b, IMM8, 0b11111111_11111111);
@ -3962,7 +3962,7 @@ pub unsafe fn _mm256_mask_cmp_epi16_mask<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i16x16();
let b = b.as_i16x16();
let r = vpcmpw256(a, b, IMM8, k1);
@ -3977,7 +3977,7 @@ pub unsafe fn _mm256_mask_cmp_epi16_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm_cmp_epi16_mask<const IMM8: i32>(a: __m128i, b: __m128i) -> __mmask8 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i16x8();
let b = b.as_i16x8();
let r = vpcmpw128(a, b, IMM8, 0b11111111);
@ -3996,7 +3996,7 @@ pub unsafe fn _mm_mask_cmp_epi16_mask<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __mmask8 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i16x8();
let b = b.as_i16x8();
let r = vpcmpw128(a, b, IMM8, k1);
@ -4011,7 +4011,7 @@ pub unsafe fn _mm_mask_cmp_epi16_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm512_cmp_epi8_mask<const IMM8: i32>(a: __m512i, b: __m512i) -> __mmask64 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i8x64();
let b = b.as_i8x64();
let r = vpcmpb(
@ -4035,7 +4035,7 @@ pub unsafe fn _mm512_mask_cmp_epi8_mask<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __mmask64 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i8x64();
let b = b.as_i8x64();
let r = vpcmpb(a, b, IMM8, k1);
@ -4050,7 +4050,7 @@ pub unsafe fn _mm512_mask_cmp_epi8_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm256_cmp_epi8_mask<const IMM8: i32>(a: __m256i, b: __m256i) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i8x32();
let b = b.as_i8x32();
let r = vpcmpb256(a, b, IMM8, 0b11111111_11111111_11111111_11111111);
@ -4069,7 +4069,7 @@ pub unsafe fn _mm256_mask_cmp_epi8_mask<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __mmask32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i8x32();
let b = b.as_i8x32();
let r = vpcmpb256(a, b, IMM8, k1);
@ -4084,7 +4084,7 @@ pub unsafe fn _mm256_mask_cmp_epi8_mask<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vpcmp, IMM8 = 0))]
pub unsafe fn _mm_cmp_epi8_mask<const IMM8: i32>(a: __m128i, b: __m128i) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i8x16();
let b = b.as_i8x16();
let r = vpcmpb128(a, b, IMM8, 0b11111111_11111111);
@ -4103,7 +4103,7 @@ pub unsafe fn _mm_mask_cmp_epi8_mask<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __mmask16 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
let a = a.as_i8x16();
let b = b.as_i8x16();
let r = vpcmpb128(a, b, IMM8, k1);
@ -5338,7 +5338,7 @@ pub unsafe fn _mm_maskz_sll_epi16(k: __mmask8, a: __m128i, count: __m128i) -> __
#[cfg_attr(test, assert_instr(vpsllw, IMM8 = 5))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_slli_epi16<const IMM8: u32>(a: __m512i) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let r = vpslliw(a, IMM8);
transmute(r)
@ -5356,7 +5356,7 @@ pub unsafe fn _mm512_mask_slli_epi16<const IMM8: u32>(
k: __mmask32,
a: __m512i,
) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let shf = vpslliw(a, IMM8);
transmute(simd_select_bitmask(k, shf, src.as_i16x32()))
@ -5370,7 +5370,7 @@ pub unsafe fn _mm512_mask_slli_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsllw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_maskz_slli_epi16<const IMM8: u32>(k: __mmask32, a: __m512i) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let shf = vpslliw(a, IMM8);
let zero = _mm512_setzero_si512().as_i16x32();
@ -5389,7 +5389,7 @@ pub unsafe fn _mm256_mask_slli_epi16<const IMM8: u32>(
k: __mmask16,
a: __m256i,
) -> __m256i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = pslliw256(a.as_i16x16(), imm8);
transmute(simd_select_bitmask(k, r, src.as_i16x16()))
@ -5403,7 +5403,7 @@ pub unsafe fn _mm256_mask_slli_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsllw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_maskz_slli_epi16<const IMM8: u32>(k: __mmask16, a: __m256i) -> __m256i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = pslliw256(a.as_i16x16(), imm8);
let zero = _mm256_setzero_si256().as_i16x16();
@ -5422,7 +5422,7 @@ pub unsafe fn _mm_mask_slli_epi16<const IMM8: u32>(
k: __mmask8,
a: __m128i,
) -> __m128i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = pslliw128(a.as_i16x8(), imm8);
transmute(simd_select_bitmask(k, r, src.as_i16x8()))
@ -5436,7 +5436,7 @@ pub unsafe fn _mm_mask_slli_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsllw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_maskz_slli_epi16<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = pslliw128(a.as_i16x8(), imm8);
let zero = _mm_setzero_si128().as_i16x8();
@ -5654,7 +5654,7 @@ pub unsafe fn _mm_maskz_srl_epi16(k: __mmask8, a: __m128i, count: __m128i) -> __
#[cfg_attr(test, assert_instr(vpsrlw, IMM8 = 5))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_srli_epi16<const IMM8: u32>(a: __m512i) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let r = vpsrliw(a, IMM8);
transmute(r)
@ -5672,7 +5672,7 @@ pub unsafe fn _mm512_mask_srli_epi16<const IMM8: u32>(
k: __mmask32,
a: __m512i,
) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let shf = vpsrliw(a, IMM8);
transmute(simd_select_bitmask(k, shf, src.as_i16x32()))
@ -5686,7 +5686,7 @@ pub unsafe fn _mm512_mask_srli_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsrlw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_maskz_srli_epi16<const IMM8: i32>(k: __mmask32, a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
//imm8 should be u32, it seems the document to verify is incorrect
let a = a.as_i16x32();
let shf = vpsrliw(a, IMM8 as u32);
@ -5706,7 +5706,7 @@ pub unsafe fn _mm256_mask_srli_epi16<const IMM8: i32>(
k: __mmask16,
a: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf = _mm256_srli_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, shf.as_i16x16(), src.as_i16x16()))
}
@ -5719,7 +5719,7 @@ pub unsafe fn _mm256_mask_srli_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpsrlw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_maskz_srli_epi16<const IMM8: i32>(k: __mmask16, a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf = _mm256_srli_epi16::<IMM8>(a);
let zero = _mm256_setzero_si256().as_i16x16();
transmute(simd_select_bitmask(k, shf.as_i16x16(), zero))
@ -5737,7 +5737,7 @@ pub unsafe fn _mm_mask_srli_epi16<const IMM8: i32>(
k: __mmask8,
a: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf = _mm_srli_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, shf.as_i16x8(), src.as_i16x8()))
}
@ -5750,7 +5750,7 @@ pub unsafe fn _mm_mask_srli_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpsrlw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_maskz_srli_epi16<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf = _mm_srli_epi16::<IMM8>(a);
let zero = _mm_setzero_si128().as_i16x8();
transmute(simd_select_bitmask(k, shf.as_i16x8(), zero))
@ -5967,7 +5967,7 @@ pub unsafe fn _mm_maskz_sra_epi16(k: __mmask8, a: __m128i, count: __m128i) -> __
#[cfg_attr(test, assert_instr(vpsraw, IMM8 = 1))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_srai_epi16<const IMM8: u32>(a: __m512i) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let r = vpsraiw(a, IMM8);
transmute(r)
@ -5985,7 +5985,7 @@ pub unsafe fn _mm512_mask_srai_epi16<const IMM8: u32>(
k: __mmask32,
a: __m512i,
) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let shf = vpsraiw(a, IMM8);
transmute(simd_select_bitmask(k, shf, src.as_i16x32()))
@ -5999,7 +5999,7 @@ pub unsafe fn _mm512_mask_srai_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsraw, IMM8 = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_maskz_srai_epi16<const IMM8: u32>(k: __mmask32, a: __m512i) -> __m512i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let shf = vpsraiw(a, IMM8);
let zero = _mm512_setzero_si512().as_i16x32();
@ -6018,7 +6018,7 @@ pub unsafe fn _mm256_mask_srai_epi16<const IMM8: u32>(
k: __mmask16,
a: __m256i,
) -> __m256i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = psraiw256(a.as_i16x16(), imm8);
transmute(simd_select_bitmask(k, r, src.as_i16x16()))
@ -6032,7 +6032,7 @@ pub unsafe fn _mm256_mask_srai_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsraw, IMM8 = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_maskz_srai_epi16<const IMM8: u32>(k: __mmask16, a: __m256i) -> __m256i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = psraiw256(a.as_i16x16(), imm8);
let zero = _mm256_setzero_si256().as_i16x16();
@ -6051,7 +6051,7 @@ pub unsafe fn _mm_mask_srai_epi16<const IMM8: u32>(
k: __mmask8,
a: __m128i,
) -> __m128i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = psraiw128(a.as_i16x8(), imm8);
transmute(simd_select_bitmask(k, r, src.as_i16x8()))
@ -6065,7 +6065,7 @@ pub unsafe fn _mm_mask_srai_epi16<const IMM8: u32>(
#[cfg_attr(test, assert_instr(vpsraw, IMM8 = 1))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_maskz_srai_epi16<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i32;
let r = psraiw128(a.as_i16x8(), imm8);
let zero = _mm_setzero_si128().as_i16x8();
@ -7458,7 +7458,7 @@ pub unsafe fn _mm_maskz_set1_epi8(k: __mmask16, a: i8) -> __m128i {
#[cfg_attr(test, assert_instr(vpshuflw, IMM8 = 0))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_shufflelo_epi16<const IMM8: i32>(a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let r: i16x32 = simd_shuffle!(
a,
@ -7513,7 +7513,7 @@ pub unsafe fn _mm512_mask_shufflelo_epi16<const IMM8: i32>(
k: __mmask32,
a: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm512_shufflelo_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, r.as_i16x32(), src.as_i16x32()))
}
@ -7526,7 +7526,7 @@ pub unsafe fn _mm512_mask_shufflelo_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshuflw, IMM8 = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_maskz_shufflelo_epi16<const IMM8: i32>(k: __mmask32, a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm512_shufflelo_epi16::<IMM8>(a);
let zero = _mm512_setzero_si512().as_i16x32();
transmute(simd_select_bitmask(k, r.as_i16x32(), zero))
@ -7544,7 +7544,7 @@ pub unsafe fn _mm256_mask_shufflelo_epi16<const IMM8: i32>(
k: __mmask16,
a: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm256_shufflelo_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, shuffle.as_i16x16(), src.as_i16x16()))
}
@ -7557,7 +7557,7 @@ pub unsafe fn _mm256_mask_shufflelo_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshuflw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_maskz_shufflelo_epi16<const IMM8: i32>(k: __mmask16, a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm256_shufflelo_epi16::<IMM8>(a);
let zero = _mm256_setzero_si256().as_i16x16();
transmute(simd_select_bitmask(k, shuffle.as_i16x16(), zero))
@ -7575,7 +7575,7 @@ pub unsafe fn _mm_mask_shufflelo_epi16<const IMM8: i32>(
k: __mmask8,
a: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm_shufflelo_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, shuffle.as_i16x8(), src.as_i16x8()))
}
@ -7588,7 +7588,7 @@ pub unsafe fn _mm_mask_shufflelo_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshuflw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_maskz_shufflelo_epi16<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm_shufflelo_epi16::<IMM8>(a);
let zero = _mm_setzero_si128().as_i16x8();
transmute(simd_select_bitmask(k, shuffle.as_i16x8(), zero))
@ -7602,7 +7602,7 @@ pub unsafe fn _mm_maskz_shufflelo_epi16<const IMM8: i32>(k: __mmask8, a: __m128i
#[cfg_attr(test, assert_instr(vpshufhw, IMM8 = 0))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_shufflehi_epi16<const IMM8: i32>(a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x32();
let r: i16x32 = simd_shuffle!(
a,
@ -7657,7 +7657,7 @@ pub unsafe fn _mm512_mask_shufflehi_epi16<const IMM8: i32>(
k: __mmask32,
a: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm512_shufflehi_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, r.as_i16x32(), src.as_i16x32()))
}
@ -7670,7 +7670,7 @@ pub unsafe fn _mm512_mask_shufflehi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshufhw, IMM8 = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_maskz_shufflehi_epi16<const IMM8: i32>(k: __mmask32, a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm512_shufflehi_epi16::<IMM8>(a);
let zero = _mm512_setzero_si512().as_i16x32();
transmute(simd_select_bitmask(k, r.as_i16x32(), zero))
@ -7688,7 +7688,7 @@ pub unsafe fn _mm256_mask_shufflehi_epi16<const IMM8: i32>(
k: __mmask16,
a: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm256_shufflehi_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, shuffle.as_i16x16(), src.as_i16x16()))
}
@ -7701,7 +7701,7 @@ pub unsafe fn _mm256_mask_shufflehi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshufhw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_maskz_shufflehi_epi16<const IMM8: i32>(k: __mmask16, a: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm256_shufflehi_epi16::<IMM8>(a);
let zero = _mm256_setzero_si256().as_i16x16();
transmute(simd_select_bitmask(k, shuffle.as_i16x16(), zero))
@ -7719,7 +7719,7 @@ pub unsafe fn _mm_mask_shufflehi_epi16<const IMM8: i32>(
k: __mmask8,
a: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm_shufflehi_epi16::<IMM8>(a);
transmute(simd_select_bitmask(k, shuffle.as_i16x8(), src.as_i16x8()))
}
@ -7732,7 +7732,7 @@ pub unsafe fn _mm_mask_shufflehi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshufhw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_maskz_shufflehi_epi16<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shuffle = _mm_shufflehi_epi16::<IMM8>(a);
let zero = _mm_setzero_si128().as_i16x8();
transmute(simd_select_bitmask(k, shuffle.as_i16x8(), zero))
@ -8173,7 +8173,7 @@ pub unsafe fn _mm512_sad_epu8(a: __m512i, b: __m512i) -> __m512i {
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vdbpsadbw, IMM8 = 0))]
pub unsafe fn _mm512_dbsad_epu8<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x64();
let b = b.as_u8x64();
let r = vdbpsadbw(a, b, IMM8);
@ -8193,7 +8193,7 @@ pub unsafe fn _mm512_mask_dbsad_epu8<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x64();
let b = b.as_u8x64();
let r = vdbpsadbw(a, b, IMM8);
@ -8212,7 +8212,7 @@ pub unsafe fn _mm512_maskz_dbsad_epu8<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x64();
let b = b.as_u8x64();
let r = vdbpsadbw(a, b, IMM8);
@ -8231,7 +8231,7 @@ pub unsafe fn _mm512_maskz_dbsad_epu8<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vdbpsadbw, IMM8 = 0))]
pub unsafe fn _mm256_dbsad_epu8<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x32();
let b = b.as_u8x32();
let r = vdbpsadbw256(a, b, IMM8);
@ -8251,7 +8251,7 @@ pub unsafe fn _mm256_mask_dbsad_epu8<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x32();
let b = b.as_u8x32();
let r = vdbpsadbw256(a, b, IMM8);
@ -8270,7 +8270,7 @@ pub unsafe fn _mm256_maskz_dbsad_epu8<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x32();
let b = b.as_u8x32();
let r = vdbpsadbw256(a, b, IMM8);
@ -8289,7 +8289,7 @@ pub unsafe fn _mm256_maskz_dbsad_epu8<const IMM8: i32>(
#[rustc_legacy_const_generics(2)]
#[cfg_attr(test, assert_instr(vdbpsadbw, IMM8 = 0))]
pub unsafe fn _mm_dbsad_epu8<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x16();
let b = b.as_u8x16();
let r = vdbpsadbw128(a, b, IMM8);
@ -8309,7 +8309,7 @@ pub unsafe fn _mm_mask_dbsad_epu8<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x16();
let b = b.as_u8x16();
let r = vdbpsadbw128(a, b, IMM8);
@ -8328,7 +8328,7 @@ pub unsafe fn _mm_maskz_dbsad_epu8<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_u8x16();
let b = b.as_u8x16();
let r = vdbpsadbw128(a, b, IMM8);
@ -9188,7 +9188,7 @@ pub unsafe fn _mm_maskz_cvtepu8_epi16(k: __mmask8, a: __m128i) -> __m128i {
#[cfg_attr(test, assert_instr(vpslldq, IMM8 = 3))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_bslli_epi128<const IMM8: i32>(a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
const fn mask(shift: i32, i: u32) -> u32 {
let shift = shift as u32 & 0xff;
if shift > 15 || i % 16 < shift {
@ -9280,7 +9280,7 @@ pub unsafe fn _mm512_bslli_epi128<const IMM8: i32>(a: __m512i) -> __m512i {
#[cfg_attr(test, assert_instr(vpsrldq, IMM8 = 3))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm512_bsrli_epi128<const IMM8: i32>(a: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i8x64();
let zero = _mm512_setzero_si512().as_i8x64();
let r: i8x64 = match IMM8 % 16 {
@ -9645,7 +9645,7 @@ pub unsafe fn _mm512_mask_alignr_epi8<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm512_alignr_epi8::<IMM8>(a, b);
transmute(simd_select_bitmask(k, r.as_i8x64(), src.as_i8x64()))
}
@ -9662,7 +9662,7 @@ pub unsafe fn _mm512_maskz_alignr_epi8<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm512_alignr_epi8::<IMM8>(a, b);
let zero = _mm512_setzero_si512().as_i8x64();
transmute(simd_select_bitmask(k, r.as_i8x64(), zero))
@ -9681,7 +9681,7 @@ pub unsafe fn _mm256_mask_alignr_epi8<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm256_alignr_epi8::<IMM8>(a, b);
transmute(simd_select_bitmask(k, r.as_i8x32(), src.as_i8x32()))
}
@ -9698,7 +9698,7 @@ pub unsafe fn _mm256_maskz_alignr_epi8<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm256_alignr_epi8::<IMM8>(a, b);
transmute(simd_select_bitmask(
k,
@ -9720,7 +9720,7 @@ pub unsafe fn _mm_mask_alignr_epi8<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm_alignr_epi8::<IMM8>(a, b);
transmute(simd_select_bitmask(k, r.as_i8x16(), src.as_i8x16()))
}
@ -9737,7 +9737,7 @@ pub unsafe fn _mm_maskz_alignr_epi8<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let r = _mm_alignr_epi8::<IMM8>(a, b);
let zero = _mm_setzero_si128().as_i8x16();
transmute(simd_select_bitmask(k, r.as_i8x16(), zero))

830
library/stdarch/crates/core_arch/src/x86/avx512f.rs
View file

File diff suppressed because it is too large Load diff

108
library/stdarch/crates/core_arch/src/x86/avx512vbmi2.rs
View file

@ -1214,7 +1214,7 @@ pub unsafe fn _mm_maskz_shrdv_epi16(k: __mmask8, a: __m128i, b: __m128i, c: __m1
#[cfg_attr(test, assert_instr(vpshldq, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_shldi_epi64<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
transmute(vpshldvq(
a.as_i64x8(),
@ -1236,7 +1236,7 @@ pub unsafe fn _mm512_mask_shldi_epi64<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x8 = vpshldvq(
a.as_i64x8(),
@ -1258,7 +1258,7 @@ pub unsafe fn _mm512_maskz_shldi_epi64<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x8 = vpshldvq(
a.as_i64x8(),
@ -1277,7 +1277,7 @@ pub unsafe fn _mm512_maskz_shldi_epi64<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldq, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_shldi_epi64<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
transmute(vpshldvq256(
a.as_i64x4(),
@ -1299,7 +1299,7 @@ pub unsafe fn _mm256_mask_shldi_epi64<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x4 = vpshldvq256(
a.as_i64x4(),
@ -1321,7 +1321,7 @@ pub unsafe fn _mm256_maskz_shldi_epi64<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x4 = vpshldvq256(
a.as_i64x4(),
@ -1340,7 +1340,7 @@ pub unsafe fn _mm256_maskz_shldi_epi64<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldq, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_shldi_epi64<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
transmute(vpshldvq128(
a.as_i64x2(),
@ -1362,7 +1362,7 @@ pub unsafe fn _mm_mask_shldi_epi64<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x2 = vpshldvq128(a.as_i64x2(), b.as_i64x2(), _mm_set1_epi64x(imm8).as_i64x2());
transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
@ -1380,7 +1380,7 @@ pub unsafe fn _mm_maskz_shldi_epi64<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x2 = vpshldvq128(a.as_i64x2(), b.as_i64x2(), _mm_set1_epi64x(imm8).as_i64x2());
let zero = _mm_setzero_si128().as_i64x2();
@ -1395,7 +1395,7 @@ pub unsafe fn _mm_maskz_shldi_epi64<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldd, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_shldi_epi32<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vpshldvd(
a.as_i32x16(),
b.as_i32x16(),
@ -1416,7 +1416,7 @@ pub unsafe fn _mm512_mask_shldi_epi32<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x16 = vpshldvd(
a.as_i32x16(),
b.as_i32x16(),
@ -1437,7 +1437,7 @@ pub unsafe fn _mm512_maskz_shldi_epi32<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x16 = vpshldvd(
a.as_i32x16(),
b.as_i32x16(),
@ -1455,7 +1455,7 @@ pub unsafe fn _mm512_maskz_shldi_epi32<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldd, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_shldi_epi32<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vpshldvd256(
a.as_i32x8(),
b.as_i32x8(),
@ -1476,7 +1476,7 @@ pub unsafe fn _mm256_mask_shldi_epi32<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x8 = vpshldvd256(
a.as_i32x8(),
b.as_i32x8(),
@ -1497,7 +1497,7 @@ pub unsafe fn _mm256_maskz_shldi_epi32<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x8 = vpshldvd256(
a.as_i32x8(),
b.as_i32x8(),
@ -1515,7 +1515,7 @@ pub unsafe fn _mm256_maskz_shldi_epi32<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldd, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_shldi_epi32<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vpshldvd128(
a.as_i32x4(),
b.as_i32x4(),
@ -1536,7 +1536,7 @@ pub unsafe fn _mm_mask_shldi_epi32<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x4 = vpshldvd128(a.as_i32x4(), b.as_i32x4(), _mm_set1_epi32(IMM8).as_i32x4());
transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
}
@ -1553,7 +1553,7 @@ pub unsafe fn _mm_maskz_shldi_epi32<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x4 = vpshldvd128(a.as_i32x4(), b.as_i32x4(), _mm_set1_epi32(IMM8).as_i32x4());
let zero = _mm_setzero_si128().as_i32x4();
transmute(simd_select_bitmask(k, shf, zero))
@ -1567,7 +1567,7 @@ pub unsafe fn _mm_maskz_shldi_epi32<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_shldi_epi16<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
transmute(vpshldvw(
a.as_i16x32(),
@ -1589,7 +1589,7 @@ pub unsafe fn _mm512_mask_shldi_epi16<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x32 = vpshldvw(
a.as_i16x32(),
@ -1611,7 +1611,7 @@ pub unsafe fn _mm512_maskz_shldi_epi16<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x32 = vpshldvw(
a.as_i16x32(),
@ -1630,7 +1630,7 @@ pub unsafe fn _mm512_maskz_shldi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_shldi_epi16<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
transmute(vpshldvw256(
a.as_i16x16(),
@ -1652,7 +1652,7 @@ pub unsafe fn _mm256_mask_shldi_epi16<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x16 = vpshldvw256(
a.as_i16x16(),
@ -1674,7 +1674,7 @@ pub unsafe fn _mm256_maskz_shldi_epi16<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x16 = vpshldvw256(
a.as_i16x16(),
@ -1693,7 +1693,7 @@ pub unsafe fn _mm256_maskz_shldi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldw, IMM8 = 5))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_shldi_epi16<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
transmute(vpshldvw128(
a.as_i16x8(),
@ -1715,7 +1715,7 @@ pub unsafe fn _mm_mask_shldi_epi16<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x8 = vpshldvw128(a.as_i16x8(), b.as_i16x8(), _mm_set1_epi16(imm8).as_i16x8());
transmute(simd_select_bitmask(k, shf, src.as_i16x8()))
@ -1733,7 +1733,7 @@ pub unsafe fn _mm_maskz_shldi_epi16<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x8 = vpshldvw128(a.as_i16x8(), b.as_i16x8(), _mm_set1_epi16(imm8).as_i16x8());
let zero = _mm_setzero_si128().as_i16x8();
@ -1748,7 +1748,7 @@ pub unsafe fn _mm_maskz_shldi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldq, IMM8 = 5))] //should be vpshrdq
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_shrdi_epi64<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
transmute(vpshrdvq(
a.as_i64x8(),
@ -1770,7 +1770,7 @@ pub unsafe fn _mm512_mask_shrdi_epi64<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x8 = vpshrdvq(
a.as_i64x8(),
@ -1792,7 +1792,7 @@ pub unsafe fn _mm512_maskz_shrdi_epi64<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x8 = vpshrdvq(
a.as_i64x8(),
@ -1811,7 +1811,7 @@ pub unsafe fn _mm512_maskz_shrdi_epi64<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldq, IMM8 = 5))] //should be vpshrdq
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_shrdi_epi64<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
transmute(vpshrdvq256(
a.as_i64x4(),
@ -1833,7 +1833,7 @@ pub unsafe fn _mm256_mask_shrdi_epi64<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x4 = vpshrdvq256(
a.as_i64x4(),
@ -1855,7 +1855,7 @@ pub unsafe fn _mm256_maskz_shrdi_epi64<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x4 = vpshrdvq256(
a.as_i64x4(),
@ -1874,7 +1874,7 @@ pub unsafe fn _mm256_maskz_shrdi_epi64<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldq, IMM8 = 5))] //should be vpshrdq
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_shrdi_epi64<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
transmute(vpshrdvq128(
a.as_i64x2(),
@ -1896,7 +1896,7 @@ pub unsafe fn _mm_mask_shrdi_epi64<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x2 = vpshrdvq128(a.as_i64x2(), b.as_i64x2(), _mm_set1_epi64x(imm8).as_i64x2());
transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
@ -1914,7 +1914,7 @@ pub unsafe fn _mm_maskz_shrdi_epi64<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i64;
let shf: i64x2 = vpshrdvq128(a.as_i64x2(), b.as_i64x2(), _mm_set1_epi64x(imm8).as_i64x2());
let zero = _mm_setzero_si128().as_i64x2();
@ -1929,7 +1929,7 @@ pub unsafe fn _mm_maskz_shrdi_epi64<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldd, IMM8 = 5))] //should be vpshldd
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_shrdi_epi32<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vpshrdvd(
a.as_i32x16(),
b.as_i32x16(),
@ -1950,7 +1950,7 @@ pub unsafe fn _mm512_mask_shrdi_epi32<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x16 = vpshrdvd(
a.as_i32x16(),
b.as_i32x16(),
@ -1971,7 +1971,7 @@ pub unsafe fn _mm512_maskz_shrdi_epi32<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x16 = vpshrdvd(
a.as_i32x16(),
b.as_i32x16(),
@ -1989,7 +1989,7 @@ pub unsafe fn _mm512_maskz_shrdi_epi32<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldd, IMM8 = 5))] //should be vpshldd
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_shrdi_epi32<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vpshrdvd256(
a.as_i32x8(),
b.as_i32x8(),
@ -2010,7 +2010,7 @@ pub unsafe fn _mm256_mask_shrdi_epi32<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x8 = vpshrdvd256(
a.as_i32x8(),
b.as_i32x8(),
@ -2031,7 +2031,7 @@ pub unsafe fn _mm256_maskz_shrdi_epi32<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x8 = vpshrdvd256(
a.as_i32x8(),
b.as_i32x8(),
@ -2049,7 +2049,7 @@ pub unsafe fn _mm256_maskz_shrdi_epi32<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldd, IMM8 = 5))] //should be vpshldd
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_shrdi_epi32<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(vpshrdvd128(
a.as_i32x4(),
b.as_i32x4(),
@ -2070,7 +2070,7 @@ pub unsafe fn _mm_mask_shrdi_epi32<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x4 = vpshrdvd128(a.as_i32x4(), b.as_i32x4(), _mm_set1_epi32(IMM8).as_i32x4());
transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
}
@ -2087,7 +2087,7 @@ pub unsafe fn _mm_maskz_shrdi_epi32<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let shf: i32x4 = vpshrdvd128(a.as_i32x4(), b.as_i32x4(), _mm_set1_epi32(IMM8).as_i32x4());
let zero = _mm_setzero_si128().as_i32x4();
transmute(simd_select_bitmask(k, shf, zero))
@ -2101,7 +2101,7 @@ pub unsafe fn _mm_maskz_shrdi_epi32<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldw, IMM8 = 5))] //should be vpshrdw
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_shrdi_epi16<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
assert!(imm8 >= 0 && imm8 <= 255);
transmute(vpshrdvw(
@ -2124,7 +2124,7 @@ pub unsafe fn _mm512_mask_shrdi_epi16<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
assert!(imm8 >= 0 && imm8 <= 255);
let shf: i16x32 = vpshrdvw(
@ -2147,7 +2147,7 @@ pub unsafe fn _mm512_maskz_shrdi_epi16<const IMM8: i32>(
a: __m512i,
b: __m512i,
) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
assert!(imm8 >= 0 && imm8 <= 255);
let shf: i16x32 = vpshrdvw(
@ -2167,7 +2167,7 @@ pub unsafe fn _mm512_maskz_shrdi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldw, IMM8 = 5))] //should be vpshrdw
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_shrdi_epi16<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
assert!(imm8 >= 0 && imm8 <= 255);
transmute(vpshrdvw256(
@ -2190,7 +2190,7 @@ pub unsafe fn _mm256_mask_shrdi_epi16<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
assert!(imm8 >= 0 && imm8 <= 255);
let shf: i16x16 = vpshrdvw256(
@ -2213,7 +2213,7 @@ pub unsafe fn _mm256_maskz_shrdi_epi16<const IMM8: i32>(
a: __m256i,
b: __m256i,
) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x16 = vpshrdvw256(
a.as_i16x16(),
@ -2232,7 +2232,7 @@ pub unsafe fn _mm256_maskz_shrdi_epi16<const IMM8: i32>(
#[cfg_attr(test, assert_instr(vpshldw, IMM8 = 5))] //should be vpshrdw
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_shrdi_epi16<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
transmute(vpshrdvw128(
a.as_i16x8(),
@ -2254,7 +2254,7 @@ pub unsafe fn _mm_mask_shrdi_epi16<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x8 = vpshrdvw128(a.as_i16x8(), b.as_i16x8(), _mm_set1_epi16(imm8).as_i16x8());
transmute(simd_select_bitmask(k, shf, src.as_i16x8()))
@ -2272,7 +2272,7 @@ pub unsafe fn _mm_maskz_shrdi_epi16<const IMM8: i32>(
a: __m128i,
b: __m128i,
) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let imm8 = IMM8 as i16;
let shf: i16x8 = vpshrdvw128(a.as_i16x8(), b.as_i16x8(), _mm_set1_epi16(imm8).as_i16x8());
let zero = _mm_setzero_si128().as_i16x8();

4
library/stdarch/crates/core_arch/src/x86/f16c.rs
View file

@ -58,7 +58,7 @@ pub unsafe fn _mm256_cvtph_ps(a: __m128i) -> __m256 {
#[cfg_attr(test, assert_instr("vcvtps2ph", IMM_ROUNDING = 0))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm_cvtps_ph<const IMM_ROUNDING: i32>(a: __m128) -> __m128i {
static_assert_imm3!(IMM_ROUNDING);
static_assert_uimm_bits!(IMM_ROUNDING, 3);
let a = a.as_f32x4();
let r = llvm_vcvtps2ph_128(a, IMM_ROUNDING);
transmute(r)
@ -79,7 +79,7 @@ pub unsafe fn _mm_cvtps_ph<const IMM_ROUNDING: i32>(a: __m128) -> __m128i {
#[cfg_attr(test, assert_instr("vcvtps2ph", IMM_ROUNDING = 0))]
#[rustc_legacy_const_generics(1)]
pub unsafe fn _mm256_cvtps_ph<const IMM_ROUNDING: i32>(a: __m256) -> __m128i {
static_assert_imm3!(IMM_ROUNDING);
static_assert_uimm_bits!(IMM_ROUNDING, 3);
let a = a.as_f32x8();
let r = llvm_vcvtps2ph_256(a, IMM_ROUNDING);
transmute(r)

36
library/stdarch/crates/core_arch/src/x86/gfni.rs
View file

@ -238,7 +238,7 @@ pub unsafe fn _mm_maskz_gf2p8mul_epi8(k: __mmask16, a: __m128i, b: __m128i) -> _
#[cfg_attr(test, assert_instr(vgf2p8affineqb, B = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_gf2p8affine_epi64_epi8<const B: i32>(x: __m512i, a: __m512i) -> __m512i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x64();
let a = a.as_i8x64();
@ -264,7 +264,7 @@ pub unsafe fn _mm512_maskz_gf2p8affine_epi64_epi8<const B: i32>(
x: __m512i,
a: __m512i,
) -> __m512i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let zero = _mm512_setzero_si512().as_i8x64();
let x = x.as_i8x64();
@ -292,7 +292,7 @@ pub unsafe fn _mm512_mask_gf2p8affine_epi64_epi8<const B: i32>(
x: __m512i,
a: __m512i,
) -> __m512i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x64();
let a = a.as_i8x64();
@ -311,7 +311,7 @@ pub unsafe fn _mm512_mask_gf2p8affine_epi64_epi8<const B: i32>(
#[cfg_attr(test, assert_instr(vgf2p8affineqb, B = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_gf2p8affine_epi64_epi8<const B: i32>(x: __m256i, a: __m256i) -> __m256i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x32();
let a = a.as_i8x32();
@ -337,7 +337,7 @@ pub unsafe fn _mm256_maskz_gf2p8affine_epi64_epi8<const B: i32>(
x: __m256i,
a: __m256i,
) -> __m256i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let zero = _mm256_setzero_si256().as_i8x32();
let x = x.as_i8x32();
@ -365,7 +365,7 @@ pub unsafe fn _mm256_mask_gf2p8affine_epi64_epi8<const B: i32>(
x: __m256i,
a: __m256i,
) -> __m256i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x32();
let a = a.as_i8x32();
@ -384,7 +384,7 @@ pub unsafe fn _mm256_mask_gf2p8affine_epi64_epi8<const B: i32>(
#[cfg_attr(test, assert_instr(gf2p8affineqb, B = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_gf2p8affine_epi64_epi8<const B: i32>(x: __m128i, a: __m128i) -> __m128i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x16();
let a = a.as_i8x16();
@ -410,7 +410,7 @@ pub unsafe fn _mm_maskz_gf2p8affine_epi64_epi8<const B: i32>(
x: __m128i,
a: __m128i,
) -> __m128i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let zero = _mm_setzero_si128().as_i8x16();
let x = x.as_i8x16();
@ -438,7 +438,7 @@ pub unsafe fn _mm_mask_gf2p8affine_epi64_epi8<const B: i32>(
x: __m128i,
a: __m128i,
) -> __m128i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x16();
let a = a.as_i8x16();
@ -459,7 +459,7 @@ pub unsafe fn _mm_mask_gf2p8affine_epi64_epi8<const B: i32>(
#[cfg_attr(test, assert_instr(vgf2p8affineinvqb, B = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_gf2p8affineinv_epi64_epi8<const B: i32>(x: __m512i, a: __m512i) -> __m512i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x64();
let a = a.as_i8x64();
@ -487,7 +487,7 @@ pub unsafe fn _mm512_maskz_gf2p8affineinv_epi64_epi8<const B: i32>(
x: __m512i,
a: __m512i,
) -> __m512i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let zero = _mm512_setzero_si512().as_i8x64();
let x = x.as_i8x64();
@ -517,7 +517,7 @@ pub unsafe fn _mm512_mask_gf2p8affineinv_epi64_epi8<const B: i32>(
x: __m512i,
a: __m512i,
) -> __m512i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x64();
let a = a.as_i8x64();
@ -538,7 +538,7 @@ pub unsafe fn _mm512_mask_gf2p8affineinv_epi64_epi8<const B: i32>(
#[cfg_attr(test, assert_instr(vgf2p8affineinvqb, B = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_gf2p8affineinv_epi64_epi8<const B: i32>(x: __m256i, a: __m256i) -> __m256i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x32();
let a = a.as_i8x32();
@ -566,7 +566,7 @@ pub unsafe fn _mm256_maskz_gf2p8affineinv_epi64_epi8<const B: i32>(
x: __m256i,
a: __m256i,
) -> __m256i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let zero = _mm256_setzero_si256().as_i8x32();
let x = x.as_i8x32();
@ -596,7 +596,7 @@ pub unsafe fn _mm256_mask_gf2p8affineinv_epi64_epi8<const B: i32>(
x: __m256i,
a: __m256i,
) -> __m256i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x32();
let a = a.as_i8x32();
@ -617,7 +617,7 @@ pub unsafe fn _mm256_mask_gf2p8affineinv_epi64_epi8<const B: i32>(
#[cfg_attr(test, assert_instr(gf2p8affineinvqb, B = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_gf2p8affineinv_epi64_epi8<const B: i32>(x: __m128i, a: __m128i) -> __m128i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x16();
let a = a.as_i8x16();
@ -645,7 +645,7 @@ pub unsafe fn _mm_maskz_gf2p8affineinv_epi64_epi8<const B: i32>(
x: __m128i,
a: __m128i,
) -> __m128i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let zero = _mm_setzero_si128().as_i8x16();
let x = x.as_i8x16();
@ -675,7 +675,7 @@ pub unsafe fn _mm_mask_gf2p8affineinv_epi64_epi8<const B: i32>(
x: __m128i,
a: __m128i,
) -> __m128i {
static_assert_imm8!(B);
static_assert_uimm_bits!(B, 8);
let b = B as u8;
let x = x.as_i8x16();
let a = a.as_i8x16();

75
library/stdarch/crates/core_arch/src/x86/macros.rs
View file

@ -1,89 +1,44 @@
//! Utility macros.
//!
// Helper struct used to trigger const eval errors when the const generic immediate value `imm` is
// not a round number.
pub(crate) struct ValidateConstRound<const IMM: i32>;
impl<const IMM: i32> ValidateConstRound<IMM> {
pub(crate) const VALID: () = {
assert!(
IMM == 4 || IMM == 8 || IMM == 9 || IMM == 10 || IMM == 11,
"Invalid IMM value"
);
};
}
// Helper macro used to trigger const eval errors when the const generic immediate value `imm` is
// not a round number.
#[allow(unused)]
macro_rules! static_assert_rounding {
($imm:ident) => {
let _ = $crate::core_arch::x86::macros::ValidateConstRound::<$imm>::VALID;
static_assert!(
$imm == 4 || $imm == 8 || $imm == 9 || $imm == 10 || $imm == 11,
"Invalid IMM value"
)
};
}
// Helper struct used to trigger const eval errors when the const generic immediate value `imm` is
// Helper macro used to trigger const eval errors when the const generic immediate value `imm` is
// not a sae number.
pub(crate) struct ValidateConstSae<const IMM: i32>;
impl<const IMM: i32> ValidateConstSae<IMM> {
pub(crate) const VALID: () = {
assert!(IMM == 4 || IMM == 8, "Invalid IMM value");
};
}
#[allow(unused)]
macro_rules! static_assert_sae {
($imm:ident) => {
let _ = $crate::core_arch::x86::macros::ValidateConstSae::<$imm>::VALID;
static_assert!($imm == 4 || $imm == 8, "Invalid IMM value")
};
}
// Helper struct used to trigger const eval errors when the const generic immediate value `imm` is
// Helper macro used to trigger const eval errors when the const generic immediate value `imm` is
// not a mantissas sae number.
pub(crate) struct ValidateConstMantissasSae<const IMM: i32>;
impl<const IMM: i32> ValidateConstMantissasSae<IMM> {
pub(crate) const VALID: () = {
assert!(IMM == 4 || IMM == 8 || IMM == 12, "Invalid IMM value");
};
}
#[allow(unused)]
macro_rules! static_assert_mantissas_sae {
($imm:ident) => {
let _ = $crate::core_arch::x86::macros::ValidateConstMantissasSae::<$imm>::VALID;
static_assert!($imm == 4 || $imm == 8 || $imm == 12, "Invalid IMM value")
};
}
// Helper struct used to trigger const eval errors when the unsigned const generic immediate value
// `IMM` is out of `[MIN-MAX]` range.
pub(crate) struct ValidateConstImmU32<const IMM: u32, const MIN: u32, const MAX: u32>;
impl<const IMM: u32, const MIN: u32, const MAX: u32> ValidateConstImmU32<IMM, MIN, MAX> {
pub(crate) const VALID: () = {
assert!(IMM >= MIN && IMM <= MAX, "IMM value not in expected range");
};
}
#[allow(unused_macros)]
macro_rules! static_assert_imm_u8 {
($imm:ident) => {
let _ =
$crate::core_arch::x86::macros::ValidateConstImmU32::<$imm, 0, { (1 << 8) - 1 }>::VALID;
};
}
// Helper struct used to trigger const eval errors when the const generic immediate value `SCALE` is
// Helper macro used to trigger const eval errors when the const generic immediate value `SCALE` is
// not valid for gather instructions: the only valid scale values are 1, 2, 4 and 8.
pub(crate) struct ValidateConstGatherScale<const SCALE: i32>;
impl<const SCALE: i32> ValidateConstGatherScale<SCALE> {
pub(crate) const VALID: () = {
assert!(
SCALE == 1 || SCALE == 2 || SCALE == 4 || SCALE == 8,
"Invalid SCALE value"
);
};
}
#[allow(unused)]
macro_rules! static_assert_imm8_scale {
($imm:ident) => {
let _ = $crate::core_arch::x86::macros::ValidateConstGatherScale::<$imm>::VALID;
static_assert!(
$imm == 1 || $imm == 2 || $imm == 4 || $imm == 8,
"Invalid SCALE value"
)
};
}

2
library/stdarch/crates/core_arch/src/x86/pclmulqdq.rs
View file

@ -33,7 +33,7 @@ extern "C" {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_clmulepi64_si128<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pclmulqdq(a, b, IMM8 as u8)
}

2
library/stdarch/crates/core_arch/src/x86/rtm.rs
View file

@ -79,7 +79,7 @@ pub unsafe fn _xend() {
#[cfg_attr(test, assert_instr(xabort, IMM8 = 0x0))]
#[rustc_legacy_const_generics(0)]
pub unsafe fn _xabort<const IMM8: u32>() {
static_assert_imm_u8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
x86_xabort(IMM8 as i8)
}

2
library/stdarch/crates/core_arch/src/x86/sha.rs
View file

@ -76,7 +76,7 @@ pub unsafe fn _mm_sha1nexte_epu32(a: __m128i, b: __m128i) -> __m128i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_sha1rnds4_epu32<const FUNC: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm2!(FUNC);
static_assert_uimm_bits!(FUNC, 2);
transmute(sha1rnds4(a.as_i32x4(), b.as_i32x4(), FUNC as i8))
}

2
library/stdarch/crates/core_arch/src/x86/sse.rs
View file

@ -1010,7 +1010,7 @@ pub const fn _MM_SHUFFLE(z: u32, y: u32, x: u32, w: u32) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_shuffle_ps<const MASK: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm8!(MASK);
static_assert_uimm_bits!(MASK, 8);
simd_shuffle!(
a,
b,

36
library/stdarch/crates/core_arch/src/x86/sse2.rs
View file

@ -423,7 +423,7 @@ pub unsafe fn _mm_subs_epu16(a: __m128i, b: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_slli_si128<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
_mm_slli_si128_impl::<IMM8>(a)
}
@ -474,7 +474,7 @@ unsafe fn _mm_slli_si128_impl<const IMM8: i32>(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_bslli_si128<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
_mm_slli_si128_impl::<IMM8>(a)
}
@ -487,7 +487,7 @@ pub unsafe fn _mm_bslli_si128<const IMM8: i32>(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_bsrli_si128<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
_mm_srli_si128_impl::<IMM8>(a)
}
@ -500,7 +500,7 @@ pub unsafe fn _mm_bsrli_si128<const IMM8: i32>(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_slli_epi16<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pslliw(a.as_i16x8(), IMM8))
}
@ -525,7 +525,7 @@ pub unsafe fn _mm_sll_epi16(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_slli_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psllid(a.as_i32x4(), IMM8))
}
@ -550,7 +550,7 @@ pub unsafe fn _mm_sll_epi32(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_slli_epi64<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pslliq(a.as_i64x2(), IMM8))
}
@ -576,7 +576,7 @@ pub unsafe fn _mm_sll_epi64(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_srai_epi16<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psraiw(a.as_i16x8(), IMM8))
}
@ -602,7 +602,7 @@ pub unsafe fn _mm_sra_epi16(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_srai_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psraid(a.as_i32x4(), IMM8))
}
@ -627,7 +627,7 @@ pub unsafe fn _mm_sra_epi32(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_srli_si128<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
_mm_srli_si128_impl::<IMM8>(a)
}
@ -679,7 +679,7 @@ unsafe fn _mm_srli_si128_impl<const IMM8: i32>(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_srli_epi16<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psrliw(a.as_i16x8(), IMM8))
}
@ -705,7 +705,7 @@ pub unsafe fn _mm_srl_epi16(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_srli_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psrlid(a.as_i32x4(), IMM8))
}
@ -731,7 +731,7 @@ pub unsafe fn _mm_srl_epi32(a: __m128i, count: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_srli_epi64<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(psrliq(a.as_i64x2(), IMM8))
}
@ -1361,7 +1361,7 @@ pub unsafe fn _mm_packus_epi16(a: __m128i, b: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_extract_epi16<const IMM8: i32>(a: __m128i) -> i32 {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
simd_extract::<_, u16>(a.as_u16x8(), IMM8 as u32) as i32
}
@ -1374,7 +1374,7 @@ pub unsafe fn _mm_extract_epi16<const IMM8: i32>(a: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_insert_epi16<const IMM8: i32>(a: __m128i, i: i32) -> __m128i {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
transmute(simd_insert(a.as_i16x8(), IMM8 as u32, i as i16))
}
@ -1400,7 +1400,7 @@ pub unsafe fn _mm_movemask_epi8(a: __m128i) -> i32 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_shuffle_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i32x4();
let x: i32x4 = simd_shuffle!(
a,
@ -1428,7 +1428,7 @@ pub unsafe fn _mm_shuffle_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_shufflehi_epi16<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x8();
let x: i16x8 = simd_shuffle!(
a,
@ -1460,7 +1460,7 @@ pub unsafe fn _mm_shufflehi_epi16<const IMM8: i32>(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_shufflelo_epi16<const IMM8: i32>(a: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
let a = a.as_i16x8();
let x: i16x8 = simd_shuffle!(
a,
@ -2656,7 +2656,7 @@ pub unsafe fn _mm_loadu_pd(mem_addr: *const f64) -> __m128d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_shuffle_pd<const MASK: i32>(a: __m128d, b: __m128d) -> __m128d {
static_assert_imm8!(MASK);
static_assert_uimm_bits!(MASK, 8);
simd_shuffle!(a, b, [MASK as u32 & 0b1, ((MASK as u32 >> 1) & 0b1) + 2])
}

32
library/stdarch/crates/core_arch/src/x86/sse41.rs
View file

@ -81,7 +81,7 @@ pub unsafe fn _mm_blendv_epi8(a: __m128i, b: __m128i, mask: __m128i) -> __m128i
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_blend_epi16<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pblendw(a.as_i16x8(), b.as_i16x8(), IMM8 as u8))
}
@ -122,7 +122,7 @@ pub unsafe fn _mm_blendv_ps(a: __m128, b: __m128, mask: __m128) -> __m128 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_blend_pd<const IMM2: i32>(a: __m128d, b: __m128d) -> __m128d {
static_assert_imm2!(IMM2);
static_assert_uimm_bits!(IMM2, 2);
blendpd(a, b, IMM2 as u8)
}
@ -136,7 +136,7 @@ pub unsafe fn _mm_blend_pd<const IMM2: i32>(a: __m128d, b: __m128d) -> __m128d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_blend_ps<const IMM4: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm4!(IMM4);
static_assert_uimm_bits!(IMM4, 4);
blendps(a, b, IMM4 as u8)
}
@ -174,7 +174,7 @@ pub unsafe fn _mm_blend_ps<const IMM4: i32>(a: __m128, b: __m128) -> __m128 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_extract_ps<const IMM8: i32>(a: __m128) -> i32 {
static_assert_imm2!(IMM8);
static_assert_uimm_bits!(IMM8, 2);
transmute(simd_extract::<_, f32>(a, IMM8 as u32))
}
@ -190,7 +190,7 @@ pub unsafe fn _mm_extract_ps<const IMM8: i32>(a: __m128) -> i32 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_extract_epi8<const IMM8: i32>(a: __m128i) -> i32 {
static_assert_imm4!(IMM8);
static_assert_uimm_bits!(IMM8, 4);
simd_extract::<_, u8>(a.as_u8x16(), IMM8 as u32) as i32
}
@ -206,7 +206,7 @@ pub unsafe fn _mm_extract_epi8<const IMM8: i32>(a: __m128i) -> i32 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_extract_epi32<const IMM8: i32>(a: __m128i) -> i32 {
static_assert_imm2!(IMM8);
static_assert_uimm_bits!(IMM8, 2);
simd_extract::<_, i32>(a.as_i32x4(), IMM8 as u32)
}
@ -240,7 +240,7 @@ pub unsafe fn _mm_extract_epi32<const IMM8: i32>(a: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_insert_ps<const IMM8: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
insertps(a, b, IMM8 as u8)
}
@ -254,7 +254,7 @@ pub unsafe fn _mm_insert_ps<const IMM8: i32>(a: __m128, b: __m128) -> __m128 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_insert_epi8<const IMM8: i32>(a: __m128i, i: i32) -> __m128i {
static_assert_imm4!(IMM8);
static_assert_uimm_bits!(IMM8, 4);
transmute(simd_insert(a.as_i8x16(), IMM8 as u32, i as i8))
}
@ -268,7 +268,7 @@ pub unsafe fn _mm_insert_epi8<const IMM8: i32>(a: __m128i, i: i32) -> __m128i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_insert_epi32<const IMM8: i32>(a: __m128i, i: i32) -> __m128i {
static_assert_imm2!(IMM8);
static_assert_uimm_bits!(IMM8, 2);
transmute(simd_insert(a.as_i32x4(), IMM8 as u32, i))
}
@ -582,7 +582,7 @@ pub unsafe fn _mm_cvtepu32_epi64(a: __m128i) -> __m128i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_dp_pd<const IMM8: i32>(a: __m128d, b: __m128d) -> __m128d {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
dppd(a, b, IMM8 as u8)
}
@ -601,7 +601,7 @@ pub unsafe fn _mm_dp_pd<const IMM8: i32>(a: __m128d, b: __m128d) -> __m128d {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_dp_ps<const IMM8: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
dpps(a, b, IMM8 as u8)
}
@ -754,7 +754,7 @@ pub unsafe fn _mm_ceil_ss(a: __m128, b: __m128) -> __m128 {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_round_pd<const ROUNDING: i32>(a: __m128d) -> __m128d {
static_assert_imm4!(ROUNDING);
static_assert_uimm_bits!(ROUNDING, 4);
roundpd(a, ROUNDING)
}
@ -795,7 +795,7 @@ pub unsafe fn _mm_round_pd<const ROUNDING: i32>(a: __m128d) -> __m128d {
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_round_ps<const ROUNDING: i32>(a: __m128) -> __m128 {
static_assert_imm4!(ROUNDING);
static_assert_uimm_bits!(ROUNDING, 4);
roundps(a, ROUNDING)
}
@ -838,7 +838,7 @@ pub unsafe fn _mm_round_ps<const ROUNDING: i32>(a: __m128) -> __m128 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_round_sd<const ROUNDING: i32>(a: __m128d, b: __m128d) -> __m128d {
static_assert_imm4!(ROUNDING);
static_assert_uimm_bits!(ROUNDING, 4);
roundsd(a, b, ROUNDING)
}
@ -881,7 +881,7 @@ pub unsafe fn _mm_round_sd<const ROUNDING: i32>(a: __m128d, b: __m128d) -> __m12
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_round_ss<const ROUNDING: i32>(a: __m128, b: __m128) -> __m128 {
static_assert_imm4!(ROUNDING);
static_assert_uimm_bits!(ROUNDING, 4);
roundss(a, b, ROUNDING)
}
@ -981,7 +981,7 @@ pub unsafe fn _mm_mullo_epi32(a: __m128i, b: __m128i) -> __m128i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_mpsadbw_epu8<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm3!(IMM8);
static_assert_uimm_bits!(IMM8, 3);
transmute(mpsadbw(a.as_u8x16(), b.as_u8x16(), IMM8 as u8))
}

28
library/stdarch/crates/core_arch/src/x86/sse42.rs
View file

@ -74,7 +74,7 @@ pub const _SIDD_UNIT_MASK: i32 = 0b0100_0000;
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistrm<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pcmpistrm128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8))
}
@ -262,7 +262,7 @@ pub unsafe fn _mm_cmpistrm<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistri<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpistri128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8)
}
@ -277,7 +277,7 @@ pub unsafe fn _mm_cmpistri<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistrz<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpistriz128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8)
}
@ -292,7 +292,7 @@ pub unsafe fn _mm_cmpistrz<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistrc<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpistric128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8)
}
@ -307,7 +307,7 @@ pub unsafe fn _mm_cmpistrc<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistrs<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpistris128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8)
}
@ -321,7 +321,7 @@ pub unsafe fn _mm_cmpistrs<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistro<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpistrio128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8)
}
@ -336,7 +336,7 @@ pub unsafe fn _mm_cmpistro<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpistra<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpistria128(a.as_i8x16(), b.as_i8x16(), IMM8 as i8)
}
@ -350,7 +350,7 @@ pub unsafe fn _mm_cmpistra<const IMM8: i32>(a: __m128i, b: __m128i) -> i32 {
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestrm<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
transmute(pcmpestrm128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8))
}
@ -439,7 +439,7 @@ pub unsafe fn _mm_cmpestrm<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb:
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestri<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpestri128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8)
}
@ -454,7 +454,7 @@ pub unsafe fn _mm_cmpestri<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb:
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestrz<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpestriz128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8)
}
@ -469,7 +469,7 @@ pub unsafe fn _mm_cmpestrz<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb:
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestrc<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpestric128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8)
}
@ -484,7 +484,7 @@ pub unsafe fn _mm_cmpestrc<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb:
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestrs<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpestris128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8)
}
@ -499,7 +499,7 @@ pub unsafe fn _mm_cmpestrs<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb:
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestro<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpestrio128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8)
}
@ -515,7 +515,7 @@ pub unsafe fn _mm_cmpestro<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb:
#[rustc_legacy_const_generics(4)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_cmpestra<const IMM8: i32>(a: __m128i, la: i32, b: __m128i, lb: i32) -> i32 {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pcmpestria128(a.as_i8x16(), la, b.as_i8x16(), lb, IMM8 as i8)
}

2
library/stdarch/crates/core_arch/src/x86/ssse3.rs
View file

@ -90,7 +90,7 @@ pub unsafe fn _mm_shuffle_epi8(a: __m128i, b: __m128i) -> __m128i {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_alignr_epi8<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
// If palignr is shifting the pair of vectors more than the size of two
// lanes, emit zero.
if IMM8 > 32 {

4
library/stdarch/crates/core_arch/src/x86/test.rs
View file

@ -94,7 +94,7 @@ mod x86_polyfill {
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm_insert_epi64<const INDEX: i32>(a: __m128i, val: i64) -> __m128i {
static_assert_imm1!(INDEX);
static_assert_uimm_bits!(INDEX, 1);
#[repr(C)]
union A {
a: __m128i,
@ -108,7 +108,7 @@ mod x86_polyfill {
#[target_feature(enable = "avx2")]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_insert_epi64<const INDEX: i32>(a: __m256i, val: i64) -> __m256i {
static_assert_imm2!(INDEX);
static_assert_uimm_bits!(INDEX, 2);
#[repr(C)]
union A {
a: __m256i,

4
library/stdarch/crates/core_arch/src/x86/vpclmulqdq.rs
View file

@ -37,7 +37,7 @@ extern "C" {
#[cfg_attr(test, assert_instr(vpclmul, IMM8 = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm512_clmulepi64_epi128<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pclmulqdq_512(a, b, IMM8 as u8)
}
@ -54,7 +54,7 @@ pub unsafe fn _mm512_clmulepi64_epi128<const IMM8: i32>(a: __m512i, b: __m512i)
#[cfg_attr(test, assert_instr(vpclmul, IMM8 = 0))]
#[rustc_legacy_const_generics(2)]
pub unsafe fn _mm256_clmulepi64_epi128<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
static_assert_imm8!(IMM8);
static_assert_uimm_bits!(IMM8, 8);
pclmulqdq_256(a, b, IMM8 as u8)
}

2
library/stdarch/crates/core_arch/src/x86_64/avx.rs
View file

@ -28,7 +28,7 @@ use crate::{
// This intrinsic has no corresponding instruction.
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_insert_epi64<const INDEX: i32>(a: __m256i, i: i64) -> __m256i {
static_assert_imm2!(INDEX);
static_assert_uimm_bits!(INDEX, 2);
transmute(simd_insert(a.as_i64x4(), INDEX as u32, i))
}

2
library/stdarch/crates/core_arch/src/x86_64/avx2.rs
View file

@ -29,7 +29,7 @@ use crate::core_arch::{simd_llvm::*, x86::*};
// This intrinsic has no corresponding instruction.
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm256_extract_epi64<const INDEX: i32>(a: __m256i) -> i64 {
static_assert_imm2!(INDEX);
static_assert_uimm_bits!(INDEX, 2);
simd_extract(a.as_i64x4(), INDEX as u32)
}

28
library/stdarch/crates/core_arch/src/x86_64/macros.rs
View file

@ -1,36 +1,22 @@
//! Utility macros.
// Helper struct used to trigger const eval errors when the const generic immediate value `imm` is
// Helper macro used to trigger const eval errors when the const generic immediate value `imm` is
// not a round number.
pub(crate) struct ValidateConstRound<const IMM: i32>;
impl<const IMM: i32> ValidateConstRound<IMM> {
pub(crate) const VALID: () = {
assert!(
IMM == 4 || IMM == 8 || IMM == 9 || IMM == 10 || IMM == 11,
"Invalid IMM value"
);
};
}
#[allow(unused)]
macro_rules! static_assert_rounding {
($imm:ident) => {
let _ = $crate::core_arch::x86_64::macros::ValidateConstRound::<$imm>::VALID;
static_assert!(
$imm == 4 || $imm == 8 || $imm == 9 || $imm == 10 || $imm == 11,
"Invalid IMM value"
)
};
}
// Helper struct used to trigger const eval errors when the const generic immediate value `imm` is
// Helper macro used to trigger const eval errors when the const generic immediate value `imm` is
// not a sae number.
pub(crate) struct ValidateConstSae<const IMM: i32>;
impl<const IMM: i32> ValidateConstSae<IMM> {
pub(crate) const VALID: () = {
assert!(IMM == 4 || IMM == 8, "Invalid IMM value");
};
}
#[allow(unused)]
macro_rules! static_assert_sae {
($imm:ident) => {
let _ = $crate::core_arch::x86_64::macros::ValidateConstSae::<$imm>::VALID;
static_assert!($imm == 4 || $imm == 8, "Invalid IMM value")
};
}

4
library/stdarch/crates/core_arch/src/x86_64/sse41.rs
View file

@ -17,7 +17,7 @@ use stdarch_test::assert_instr;
#[rustc_legacy_const_generics(1)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_extract_epi64<const IMM1: i32>(a: __m128i) -> i64 {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
simd_extract(a.as_i64x2(), IMM1 as u32)
}
@ -31,7 +31,7 @@ pub unsafe fn _mm_extract_epi64<const IMM1: i32>(a: __m128i) -> i64 {
#[rustc_legacy_const_generics(2)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_insert_epi64<const IMM1: i32>(a: __m128i, i: i64) -> __m128i {
static_assert_imm1!(IMM1);
static_assert_uimm_bits!(IMM1, 1);
transmute(simd_insert(a.as_i64x2(), IMM1 as u32, i))
}

16
library/stdarch/crates/stdarch-gen/src/main.rs
View file

@ -2844,12 +2844,9 @@ fn get_call(
_ => 0,
};
if len == 0 {
return format!(
r#"static_assert!({} : i32 where {} == 0);"#,
fn_format[2], fn_format[2]
);
return format!(r#"static_assert!({} == 0);"#, fn_format[2]);
} else {
return format!(r#"static_assert_imm{len}!({});"#, fn_format[2]);
return format!(r#"static_assert_uimm_bits!({}, {len});"#, fn_format[2]);
}
}
if fn_name.starts_with("static_assert") {
@ -2869,14 +2866,11 @@ fn get_call(
fn_format[3].clone()
};
if lim1 == lim2 {
return format!(
r#"static_assert!({} : i32 where {} == {lim1});"#,
fn_format[1], fn_format[1]
);
return format!(r#"static_assert!({} == {lim1});"#, fn_format[1]);
} else {
return format!(
r#"static_assert!({} : i32 where {} >= {lim1} && {} <= {lim2});"#,
fn_format[1], fn_format[1], fn_format[1]
r#"static_assert!({} >= {lim1} && {} <= {lim2});"#,
fn_format[1], fn_format[1]
);
}
}