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

Modify stdarch-gen to generate instructions with a single parameter and add vceqz instructions

Browse source
This commit is contained in:
SparrowLii 2021-03-04 21:21:46 +08:00 • committed by Amanieu d'Antras
parent df368a531f
commit 5c8f08afc4
5 changed files with 472 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -73,6 +73,150 @@ pub unsafe fn vceqq_f64(a: float64x2_t, b: float64x2_t) -> uint64x2_t {
simd_eq(a, b)
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_s8(a: int8x8_t) -> uint8x8_t {
simd_eq(a, int8x8_t(0, 0, 0, 0, 0, 0, 0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_s8(a: int8x16_t) -> uint8x16_t {
simd_eq(a, int8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_s16(a: int16x4_t) -> uint16x4_t {
simd_eq(a, int16x4_t(0, 0, 0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_s16(a: int16x8_t) -> uint16x8_t {
simd_eq(a, int16x8_t(0, 0, 0, 0, 0, 0, 0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_s32(a: int32x2_t) -> uint32x2_t {
simd_eq(a, int32x2_t(0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_s32(a: int32x4_t) -> uint32x4_t {
simd_eq(a, int32x4_t(0, 0, 0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_s64(a: int64x1_t) -> uint64x1_t {
simd_eq(a, int64x1_t(0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_s64(a: int64x2_t) -> uint64x2_t {
simd_eq(a, int64x2_t(0, 0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_p64(a: poly64x1_t) -> uint64x1_t {
simd_eq(a, poly64x1_t(0))
}
/// Signed Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_p64(a: poly64x2_t) -> uint64x2_t {
simd_eq(a, poly64x2_t(0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_u8(a: uint8x8_t) -> uint8x8_t {
simd_eq(a, uint8x8_t(0, 0, 0, 0, 0, 0, 0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_u8(a: uint8x16_t) -> uint8x16_t {
simd_eq(a, uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_u16(a: uint16x4_t) -> uint16x4_t {
simd_eq(a, uint16x4_t(0, 0, 0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_u16(a: uint16x8_t) -> uint16x8_t {
simd_eq(a, uint16x8_t(0, 0, 0, 0, 0, 0, 0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_u32(a: uint32x2_t) -> uint32x2_t {
simd_eq(a, uint32x2_t(0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_u32(a: uint32x4_t) -> uint32x4_t {
simd_eq(a, uint32x4_t(0, 0, 0, 0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqz_u64(a: uint64x1_t) -> uint64x1_t {
simd_eq(a, uint64x1_t(0))
}
/// Unsigned Compare bitwise equal to zero
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr(vceqz))]
pub unsafe fn vceqzq_u64(a: uint64x2_t) -> uint64x2_t {
simd_eq(a, uint64x2_t(0, 0))
}
/// Compare signed greater than
#[inline]
#[target_feature(enable = "neon")]
@ -358,14 +502,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_u64() {
let a: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let b: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let a: u64x1 = u64x1::new(0);
let b: u64x1 = u64x1::new(0);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceq_u64(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let b: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let a: u64x1 = u64x1::new(0);
let b: u64x1 = u64x1::new(0);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceq_u64(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -373,14 +517,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_u64() {
let a: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0x01);
let b: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0x01);
let a: u64x2 = u64x2::new(0, 0x01);
let b: u64x2 = u64x2::new(0, 0x01);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x2 = transmute(vceqq_u64(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let b: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0);
let a: u64x2 = u64x2::new(0, 0);
let b: u64x2 = u64x2::new(0, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0);
let r: u64x2 = transmute(vceqq_u64(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -388,14 +532,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_s64() {
let a: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let b: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let a: i64x1 = i64x1::new(-9223372036854775808);
let b: i64x1 = i64x1::new(-9223372036854775808);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceq_s64(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let b: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let a: i64x1 = i64x1::new(-9223372036854775808);
let b: i64x1 = i64x1::new(-9223372036854775808);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceq_s64(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -403,14 +547,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_s64() {
let a: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, 0x01);
let b: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, 0x01);
let a: i64x2 = i64x2::new(-9223372036854775808, 0x01);
let b: i64x2 = i64x2::new(-9223372036854775808, 0x01);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x2 = transmute(vceqq_s64(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, 0x7F_FF_FF_FF_FF_FF_FF_FF);
let b: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, -9223372036854775808);
let a: i64x2 = i64x2::new(-9223372036854775808, -9223372036854775808);
let b: i64x2 = i64x2::new(-9223372036854775808, 0x7F_FF_FF_FF_FF_FF_FF_FF);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0);
let r: u64x2 = transmute(vceqq_s64(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -418,14 +562,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_p64() {
let a: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let b: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let a: i64x1 = i64x1::new(-9223372036854775808);
let b: i64x1 = i64x1::new(-9223372036854775808);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceq_p64(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let b: i64x1 = i64x1::new(0x7F_FF_FF_FF_FF_FF_FF_FF);
let a: i64x1 = i64x1::new(-9223372036854775808);
let b: i64x1 = i64x1::new(-9223372036854775808);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceq_p64(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -433,14 +577,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_p64() {
let a: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, 0x01);
let b: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, 0x01);
let a: i64x2 = i64x2::new(-9223372036854775808, 0x01);
let b: i64x2 = i64x2::new(-9223372036854775808, 0x01);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x2 = transmute(vceqq_p64(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, 0x7F_FF_FF_FF_FF_FF_FF_FF);
let b: i64x2 = i64x2::new(0x7F_FF_FF_FF_FF_FF_FF_FF, -9223372036854775808);
let a: i64x2 = i64x2::new(-9223372036854775808, -9223372036854775808);
let b: i64x2 = i64x2::new(-9223372036854775808, 0x7F_FF_FF_FF_FF_FF_FF_FF);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0);
let r: u64x2 = transmute(vceqq_p64(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -464,6 +608,150 @@ mod test {
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_s8() {
let a: i8x8 = i8x8::new(-128, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06);
let e: u8x8 = u8x8::new(0, 0xFF, 0, 0, 0, 0, 0, 0);
let r: u8x8 = transmute(vceqz_s8(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_s8() {
let a: i8x16 = i8x16::new(-128, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x7F);
let e: u8x16 = u8x16::new(0, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
let r: u8x16 = transmute(vceqzq_s8(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_s16() {
let a: i16x4 = i16x4::new(-32768, 0x00, 0x01, 0x02);
let e: u16x4 = u16x4::new(0, 0xFF_FF, 0, 0);
let r: u16x4 = transmute(vceqz_s16(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_s16() {
let a: i16x8 = i16x8::new(-32768, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06);
let e: u16x8 = u16x8::new(0, 0xFF_FF, 0, 0, 0, 0, 0, 0);
let r: u16x8 = transmute(vceqzq_s16(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_s32() {
let a: i32x2 = i32x2::new(-2147483648, 0x00);
let e: u32x2 = u32x2::new(0, 0xFF_FF_FF_FF);
let r: u32x2 = transmute(vceqz_s32(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_s32() {
let a: i32x4 = i32x4::new(-2147483648, 0x00, 0x01, 0x02);
let e: u32x4 = u32x4::new(0, 0xFF_FF_FF_FF, 0, 0);
let r: u32x4 = transmute(vceqzq_s32(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_s64() {
let a: i64x1 = i64x1::new(-9223372036854775808);
let e: u64x1 = u64x1::new(0);
let r: u64x1 = transmute(vceqz_s64(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_s64() {
let a: i64x2 = i64x2::new(-9223372036854775808, 0x00);
let e: u64x2 = u64x2::new(0, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x2 = transmute(vceqzq_s64(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_p64() {
let a: i64x1 = i64x1::new(-9223372036854775808);
let e: u64x1 = u64x1::new(0);
let r: u64x1 = transmute(vceqz_p64(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_p64() {
let a: i64x2 = i64x2::new(-9223372036854775808, 0x00);
let e: u64x2 = u64x2::new(0, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x2 = transmute(vceqzq_p64(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_u8() {
let a: u8x8 = u8x8::new(0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06);
let e: u8x8 = u8x8::new(0xFF, 0xFF, 0, 0, 0, 0, 0, 0);
let r: u8x8 = transmute(vceqz_u8(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_u8() {
let a: u8x16 = u8x16::new(0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0xFF);
let e: u8x16 = u8x16::new(0xFF, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
let r: u8x16 = transmute(vceqzq_u8(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_u16() {
let a: u16x4 = u16x4::new(0, 0x00, 0x01, 0x02);
let e: u16x4 = u16x4::new(0xFF_FF, 0xFF_FF, 0, 0);
let r: u16x4 = transmute(vceqz_u16(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_u16() {
let a: u16x8 = u16x8::new(0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06);
let e: u16x8 = u16x8::new(0xFF_FF, 0xFF_FF, 0, 0, 0, 0, 0, 0);
let r: u16x8 = transmute(vceqzq_u16(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_u32() {
let a: u32x2 = u32x2::new(0, 0x00);
let e: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF);
let r: u32x2 = transmute(vceqz_u32(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_u32() {
let a: u32x4 = u32x4::new(0, 0x00, 0x01, 0x02);
let e: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF, 0, 0);
let r: u32x4 = transmute(vceqzq_u32(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqz_u64() {
let a: u64x1 = u64x1::new(0);
let e: u64x1 = u64x1::new(0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x1 = transmute(vceqz_u64(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vceqzq_u64() {
let a: u64x2 = u64x2::new(0, 0x00);
let e: u64x2 = u64x2::new(0xFF_FF_FF_FF_FF_FF_FF_FF, 0xFF_FF_FF_FF_FF_FF_FF_FF);
let r: u64x2 = transmute(vceqzq_u64(transmute(a)));
assert_eq!(r, e);
}
#[simd_test(enable = "neon")]
unsafe fn test_vcgt_s64() {
let a: i64x1 = i64x1::new(1);

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

@ -3455,14 +3455,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_u8() {
let a: u8x8 = u8x8::new(0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u8x8 = u8x8::new(0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let a: u8x8 = u8x8::new(0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u8x8 = u8x8::new(0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let e: u8x8 = u8x8::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
let r: u8x8 = transmute(vceq_u8(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u8x8 = u8x8::new(0xFF, 0xFF, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u8x8 = u8x8::new(0xFF, 0, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let a: u8x8 = u8x8::new(0, 0, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u8x8 = u8x8::new(0, 0xFF, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let e: u8x8 = u8x8::new(0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0);
let r: u8x8 = transmute(vceq_u8(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3470,14 +3470,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_u8() {
let a: u8x16 = u8x16::new(0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0);
let b: u8x16 = u8x16::new(0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0);
let a: u8x16 = u8x16::new(0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0xFF);
let b: u8x16 = u8x16::new(0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0xFF);
let e: u8x16 = u8x16::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
let r: u8x16 = transmute(vceqq_u8(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u8x16 = u8x16::new(0xFF, 0xFF, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xCC, 0x0D, 0xEE, 0);
let b: u8x16 = u8x16::new(0xFF, 0, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08, 0x08, 0x00, 0x0A, 0x0A, 0xCC, 0xD0, 0xEE, 0xFF);
let a: u8x16 = u8x16::new(0, 0, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xCC, 0x0D, 0xEE, 0xFF);
let b: u8x16 = u8x16::new(0, 0xFF, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08, 0x08, 0x00, 0x0A, 0x0A, 0xCC, 0xD0, 0xEE, 0);
let e: u8x16 = u8x16::new(0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0);
let r: u8x16 = transmute(vceqq_u8(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3485,14 +3485,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_u16() {
let a: u16x4 = u16x4::new(0xFF_FF, 0x01, 0x02, 0x03);
let b: u16x4 = u16x4::new(0xFF_FF, 0x01, 0x02, 0x03);
let a: u16x4 = u16x4::new(0, 0x01, 0x02, 0x03);
let b: u16x4 = u16x4::new(0, 0x01, 0x02, 0x03);
let e: u16x4 = u16x4::new(0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF);
let r: u16x4 = transmute(vceq_u16(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u16x4 = u16x4::new(0xFF_FF, 0xFF_FF, 0x02, 0x03);
let b: u16x4 = u16x4::new(0xFF_FF, 0, 0x02, 0x04);
let a: u16x4 = u16x4::new(0, 0, 0x02, 0x03);
let b: u16x4 = u16x4::new(0, 0xFF_FF, 0x02, 0x04);
let e: u16x4 = u16x4::new(0xFF_FF, 0, 0xFF_FF, 0);
let r: u16x4 = transmute(vceq_u16(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3500,14 +3500,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_u16() {
let a: u16x8 = u16x8::new(0xFF_FF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u16x8 = u16x8::new(0xFF_FF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let a: u16x8 = u16x8::new(0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u16x8 = u16x8::new(0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let e: u16x8 = u16x8::new(0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF);
let r: u16x8 = transmute(vceqq_u16(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u16x8 = u16x8::new(0xFF_FF, 0xFF_FF, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u16x8 = u16x8::new(0xFF_FF, 0, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let a: u16x8 = u16x8::new(0, 0, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: u16x8 = u16x8::new(0, 0xFF_FF, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let e: u16x8 = u16x8::new(0xFF_FF, 0, 0xFF_FF, 0, 0xFF_FF, 0, 0xFF_FF, 0);
let r: u16x8 = transmute(vceqq_u16(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3515,14 +3515,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_u32() {
let a: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0x01);
let b: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0x01);
let a: u32x2 = u32x2::new(0, 0x01);
let b: u32x2 = u32x2::new(0, 0x01);
let e: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF);
let r: u32x2 = transmute(vceq_u32(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF);
let b: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0);
let a: u32x2 = u32x2::new(0, 0);
let b: u32x2 = u32x2::new(0, 0xFF_FF_FF_FF);
let e: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0);
let r: u32x2 = transmute(vceq_u32(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3530,14 +3530,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_u32() {
let a: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0x01, 0x02, 0x03);
let b: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0x01, 0x02, 0x03);
let a: u32x4 = u32x4::new(0, 0x01, 0x02, 0x03);
let b: u32x4 = u32x4::new(0, 0x01, 0x02, 0x03);
let e: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF, 0xFF_FF_FF_FF, 0xFF_FF_FF_FF);
let r: u32x4 = transmute(vceqq_u32(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF, 0x02, 0x03);
let b: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0, 0x02, 0x04);
let a: u32x4 = u32x4::new(0, 0, 0x02, 0x03);
let b: u32x4 = u32x4::new(0, 0xFF_FF_FF_FF, 0x02, 0x04);
let e: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0, 0xFF_FF_FF_FF, 0);
let r: u32x4 = transmute(vceqq_u32(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3545,14 +3545,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_s8() {
let a: i8x8 = i8x8::new(0x7F, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i8x8 = i8x8::new(0x7F, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let a: i8x8 = i8x8::new(-128, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i8x8 = i8x8::new(-128, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let e: u8x8 = u8x8::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
let r: u8x8 = transmute(vceq_s8(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i8x8 = i8x8::new(0x7F, 0x7F, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i8x8 = i8x8::new(0x7F, -128, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let a: i8x8 = i8x8::new(-128, -128, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i8x8 = i8x8::new(-128, 0x7F, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let e: u8x8 = u8x8::new(0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0);
let r: u8x8 = transmute(vceq_s8(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3560,14 +3560,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_s8() {
let a: i8x16 = i8x16::new(0x7F, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, -128);
let b: i8x16 = i8x16::new(0x7F, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, -128);
let a: i8x16 = i8x16::new(-128, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x7F);
let b: i8x16 = i8x16::new(-128, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x7F);
let e: u8x16 = u8x16::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
let r: u8x16 = transmute(vceqq_s8(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i8x16 = i8x16::new(0x7F, 0x7F, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xCC, 0x0D, 0xEE, -128);
let b: i8x16 = i8x16::new(0x7F, -128, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08, 0x08, 0x00, 0x0A, 0x0A, 0xCC, 0xD0, 0xEE, 0x7F);
let a: i8x16 = i8x16::new(-128, -128, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xCC, 0x0D, 0xEE, 0x7F);
let b: i8x16 = i8x16::new(-128, 0x7F, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08, 0x08, 0x00, 0x0A, 0x0A, 0xCC, 0xD0, 0xEE, -128);
let e: u8x16 = u8x16::new(0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF, 0);
let r: u8x16 = transmute(vceqq_s8(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3575,14 +3575,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_s16() {
let a: i16x4 = i16x4::new(0x7F_FF, 0x01, 0x02, 0x03);
let b: i16x4 = i16x4::new(0x7F_FF, 0x01, 0x02, 0x03);
let a: i16x4 = i16x4::new(-32768, 0x01, 0x02, 0x03);
let b: i16x4 = i16x4::new(-32768, 0x01, 0x02, 0x03);
let e: u16x4 = u16x4::new(0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF);
let r: u16x4 = transmute(vceq_s16(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i16x4 = i16x4::new(0x7F_FF, 0x7F_FF, 0x02, 0x03);
let b: i16x4 = i16x4::new(0x7F_FF, -32768, 0x02, 0x04);
let a: i16x4 = i16x4::new(-32768, -32768, 0x02, 0x03);
let b: i16x4 = i16x4::new(-32768, 0x7F_FF, 0x02, 0x04);
let e: u16x4 = u16x4::new(0xFF_FF, 0, 0xFF_FF, 0);
let r: u16x4 = transmute(vceq_s16(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3590,14 +3590,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_s16() {
let a: i16x8 = i16x8::new(0x7F_FF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i16x8 = i16x8::new(0x7F_FF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let a: i16x8 = i16x8::new(-32768, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i16x8 = i16x8::new(-32768, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let e: u16x8 = u16x8::new(0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF, 0xFF_FF);
let r: u16x8 = transmute(vceqq_s16(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i16x8 = i16x8::new(0x7F_FF, 0x7F_FF, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i16x8 = i16x8::new(0x7F_FF, -32768, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let a: i16x8 = i16x8::new(-32768, -32768, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
let b: i16x8 = i16x8::new(-32768, 0x7F_FF, 0x02, 0x04, 0x04, 0x00, 0x06, 0x08);
let e: u16x8 = u16x8::new(0xFF_FF, 0, 0xFF_FF, 0, 0xFF_FF, 0, 0xFF_FF, 0);
let r: u16x8 = transmute(vceqq_s16(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3605,14 +3605,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceq_s32() {
let a: i32x2 = i32x2::new(0x7F_FF_FF_FF, 0x01);
let b: i32x2 = i32x2::new(0x7F_FF_FF_FF, 0x01);
let a: i32x2 = i32x2::new(-2147483648, 0x01);
let b: i32x2 = i32x2::new(-2147483648, 0x01);
let e: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF);
let r: u32x2 = transmute(vceq_s32(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i32x2 = i32x2::new(0x7F_FF_FF_FF, 0x7F_FF_FF_FF);
let b: i32x2 = i32x2::new(0x7F_FF_FF_FF, -2147483648);
let a: i32x2 = i32x2::new(-2147483648, -2147483648);
let b: i32x2 = i32x2::new(-2147483648, 0x7F_FF_FF_FF);
let e: u32x2 = u32x2::new(0xFF_FF_FF_FF, 0);
let r: u32x2 = transmute(vceq_s32(transmute(a), transmute(b)));
assert_eq!(r, e);
@ -3620,14 +3620,14 @@ mod test {
#[simd_test(enable = "neon")]
unsafe fn test_vceqq_s32() {
let a: i32x4 = i32x4::new(0x7F_FF_FF_FF, 0x01, 0x02, 0x03);
let b: i32x4 = i32x4::new(0x7F_FF_FF_FF, 0x01, 0x02, 0x03);
let a: i32x4 = i32x4::new(-2147483648, 0x01, 0x02, 0x03);
let b: i32x4 = i32x4::new(-2147483648, 0x01, 0x02, 0x03);
let e: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0xFF_FF_FF_FF, 0xFF_FF_FF_FF, 0xFF_FF_FF_FF);
let r: u32x4 = transmute(vceqq_s32(transmute(a), transmute(b)));
assert_eq!(r, e);
let a: i32x4 = i32x4::new(0x7F_FF_FF_FF, 0x7F_FF_FF_FF, 0x02, 0x03);
let b: i32x4 = i32x4::new(0x7F_FF_FF_FF, -2147483648, 0x02, 0x04);
let a: i32x4 = i32x4::new(-2147483648, -2147483648, 0x02, 0x03);
let b: i32x4 = i32x4::new(-2147483648, 0x7F_FF_FF_FF, 0x02, 0x04);
let e: u32x4 = u32x4::new(0xFF_FF_FF_FF, 0, 0xFF_FF_FF_FF, 0);
let r: u32x4 = transmute(vceqq_s32(transmute(a), transmute(b)));
assert_eq!(r, e);

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

@ -426,13 +426,13 @@ macro_rules! constify_imm3 {
macro_rules! types {
($(
$(#[$doc:meta])*
pub struct $name:ident($($fields:tt)*);
pub struct $name:ident($field:ty$(, $fields:ty)*$(,)?);
)*) => ($(
$(#[$doc])*
#[derive(Copy, Clone, Debug)]
#[allow(non_camel_case_types)]
#[repr(simd)]
#[allow(clippy::missing_inline_in_public_items)]
pub struct $name($($fields)*);
pub struct $name(pub $field$(, pub $fields)*);
)*)
}

20
library/stdarch/crates/stdarch-gen/neon.spec
View file

@ -136,6 +136,26 @@ arm = vceq.
// we are missing float16x4_t:uint16x4_t, float16x8_t:uint16x8_t
generate float32x2_t:uint32x2_t, float32x4_t:uint32x4_t
/// Signed Compare bitwise equal to zero
name = vceqz
fn = simd_eq
a = MIN, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, MAX
fixed = 0
validate FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
aarch64 = vceqz
generate int8x8_t:uint8x8_t, int8x16_t:uint8x16_t, int16x4_t:uint16x4_t, int16x8_t:uint16x8_t, int32x2_t:uint32x2_t, int32x4_t:uint32x4_t, int64x1_t:uint64x1_t, int64x2_t:uint64x2_t, poly64x1_t:uint64x1_t, poly64x2_t:uint64x2_t
/// Unsigned Compare bitwise equal to zero
name = vceqz
fn = simd_eq
a = MIN, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, MAX
fixed = 0
validate TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
aarch64 = vceqz
generate uint*_t, uint64x*_t
////////////////////
// greater then
////////////////////

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

@ -282,8 +282,8 @@ fn map_val<'v>(t: &str, v: &'v str) -> &'v str {
match v {
"FALSE" => false_val(t),
"TRUE" => true_val(t),
"MAX" => min_val(t),
"MIN" => max_val(t),
"MAX" => max_val(t),
"MIN" => min_val(t),
"FF" => ff_val(t),
o => o,
}
@ -299,6 +299,8 @@ fn gen_aarch64(
in_t: &str,
out_t: &str,
current_tests: &[(Vec<String>, Vec<String>, Vec<String>)],
has_b: bool,
fixed: &Option<String>,
) -> (String, String) {
let _global_t = type_to_global_type(in_t);
let _global_ret_t = type_to_global_type(out_t);
@ -333,20 +335,40 @@ fn gen_aarch64(
} else {
String::new()
};
let call = if has_b {
format!(
r#"pub unsafe fn {}(a: {}, b: {}) -> {} {{
{}{}(a, b)
}}"#,
name, in_t, in_t, out_t, ext_c, current_fn,
)
} else if let Some(fixed_val) = fixed {
let mut fixed_vals = fixed_val.clone();
for _i in 1..type_len(in_t) {
fixed_vals.push_str(", ");
fixed_vals.push_str(fixed_val);
}
format!(
r#"pub unsafe fn {}(a: {}) -> {} {{
{}{}(a, {}({}))
}}"#,
name, in_t, out_t, ext_c, current_fn, in_t, fixed_vals,
)
} else {
String::new()
};
let function = format!(
r#"
{}
#[inline]
#[target_feature(enable = "neon")]
#[cfg_attr(test, assert_instr({}))]
pub unsafe fn {}(a: {}, b: {}) -> {} {{
{}{}(a, b)
}}
{}
"#,
current_comment, current_aarch64, name, in_t, in_t, out_t, ext_c, current_fn,
current_comment, current_aarch64, call
);
let test = gen_test(name, &in_t, &out_t, current_tests, type_len(in_t));
let test = gen_test(name, &in_t, &out_t, current_tests, type_len(in_t), has_b);
(function, test)
}
@ -356,6 +378,7 @@ fn gen_test(
out_t: &str,
current_tests: &[(Vec<String>, Vec<String>, Vec<String>)],
len: usize,
has_b: bool,
) -> String {
let mut test = format!(
r#"
@ -367,20 +390,35 @@ fn gen_test(
let a: Vec<String> = a.iter().take(len).cloned().collect();
let b: Vec<String> = b.iter().take(len).cloned().collect();
let e: Vec<String> = e.iter().take(len).cloned().collect();
let t = format!(
r#"
let t = if has_b {
format!(
r#"
let a{};
let b{};
let e{};
let r: {} = transmute({}(transmute(a), transmute(b)));
assert_eq!(r, e);
"#,
values(in_t, &a),
values(in_t, &b),
values(out_t, &e),
type_to_global_type(out_t),
name
);
values(in_t, &a),
values(in_t, &b),
values(out_t, &e),
type_to_global_type(out_t),
name
)
} else {
format!(
r#"
let a{};
let e{};
let r: {} = transmute({}(transmute(a)));
assert_eq!(r, e);
"#,
values(in_t, &a),
values(out_t, &e),
type_to_global_type(out_t),
name
)
};
test.push_str(&t);
}
test.push_str(" }\n");
@ -399,6 +437,8 @@ fn gen_arm(
in_t: &str,
out_t: &str,
current_tests: &[(Vec<String>, Vec<String>, Vec<String>)],
has_b: bool,
fixed: &Option<String>,
) -> (String, String) {
let _global_t = type_to_global_type(in_t);
let _global_ret_t = type_to_global_type(out_t);
@ -446,7 +486,28 @@ fn gen_arm(
} else {
String::new()
};
let call = if has_b {
format!(
r#"pub unsafe fn {}(a: {}, b: {}) -> {} {{
{}{}(a, b)
}}"#,
name, in_t, in_t, out_t, ext_c, current_fn,
)
} else if let Some(fixed_val) = fixed {
let mut fixed_vals = fixed_val.clone();
for _i in 1..type_len(in_t) {
fixed_vals.push_str(", ");
fixed_vals.push_str(fixed_val);
}
format!(
r#"pub unsafe fn {}(a: {}) -> {} {{
{}{}(a, {}({}))
}}"#,
name, in_t, out_t, ext_c, current_fn, in_t, fixed_vals,
)
} else {
String::new()
};
let function = format!(
r#"
{}
@ -455,21 +516,14 @@ fn gen_arm(
#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
#[cfg_attr(all(test, target_arch = "arm"), assert_instr({}))]
#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr({}))]
pub unsafe fn {}(a: {}, b: {}) -> {} {{
{}{}(a, b)
}}
{}
"#,
current_comment,
expand_intrinsic(&current_arm, in_t),
expand_intrinsic(&current_aarch64, in_t),
name,
in_t,
in_t,
out_t,
ext_c,
current_fn,
call,
);
let test = gen_test(name, &in_t, &out_t, current_tests, type_len(in_t));
let test = gen_test(name, &in_t, &out_t, current_tests, type_len(in_t), has_b);
(function, test)
}
@ -558,6 +612,7 @@ fn main() -> io::Result<()> {
let mut link_aarch64: Option<String> = None;
let mut a: Vec<String> = Vec::new();
let mut b: Vec<String> = Vec::new();
let mut fixed: Option<String> = None;
let mut current_tests: Vec<(Vec<String>, Vec<String>, Vec<String>)> = Vec::new();
//
@ -628,6 +683,9 @@ mod test {
link_aarch64 = None;
link_arm = None;
current_tests = Vec::new();
a = Vec::new();
b = Vec::new();
fixed = None;
} else if line.starts_with("//") {
} else if line.starts_with("name = ") {
current_name = Some(String::from(&line[7..]));
@ -641,6 +699,8 @@ mod test {
a = line[4..].split(',').map(|v| v.trim().to_string()).collect();
} else if line.starts_with("b = ") {
b = line[4..].split(',').map(|v| v.trim().to_string()).collect();
} else if line.starts_with("fixed = ") {
fixed = Some(String::from(&line[8..]));
} else if line.starts_with("validate ") {
let e = line[9..].split(',').map(|v| v.trim().to_string()).collect();
current_tests.push((a.clone(), b.clone(), e));
@ -692,6 +752,8 @@ mod test {
&in_t,
&out_t,
&current_tests,
b.len() > 0,
&fixed,
);
out_arm.push_str(&function);
tests_arm.push_str(&test);
@ -705,6 +767,8 @@ mod test {
&in_t,
&out_t,
&current_tests,
b.len() > 0,
&fixed,
);
out_aarch64.push_str(&function);
tests_aarch64.push_str(&test);