src/test/ui/simd/simd-intrinsic-generic-arithmetic-saturating.rs

   1 // run-pass
   2 // ignore-emscripten
   3
   4 #![allow(non_camel_case_types)]
   5 #![feature(repr_simd, platform_intrinsics)]
   6
   7 #[repr(simd)]
   8 #[derive(Copy, Clone, PartialEq, Debug)]
   9 struct u32x4(pub u32, pub u32, pub u32, pub u32);
  10
  11 #[repr(simd)]
  12 #[derive(Copy, Clone)]
  13 struct I32<const N: usize>([i32; N]);
  14
  15 extern "platform-intrinsic" {
  16     fn simd_saturating_add<T>(x: T, y: T) -> T;
  17     fn simd_saturating_sub<T>(x: T, y: T) -> T;
  18 }
  19
  20 fn main() {
  21     // unsigned
  22     {
  23         const M: u32 = u32::MAX;
  24
  25         let a = u32x4(1, 2, 3, 4);
  26         let b = u32x4(2, 4, 6, 8);
  27         let m = u32x4(M, M, M, M);
  28         let m1 = u32x4(M - 1, M - 1, M - 1, M - 1);
  29         let z = u32x4(0, 0, 0, 0);
  30
  31         unsafe {
  32             assert_eq!(simd_saturating_add(z, z), z);
  33             assert_eq!(simd_saturating_add(z, a), a);
  34             assert_eq!(simd_saturating_add(b, z), b);
  35             assert_eq!(simd_saturating_add(a, a), b);
  36             assert_eq!(simd_saturating_add(a, m), m);
  37             assert_eq!(simd_saturating_add(m, b), m);
  38             assert_eq!(simd_saturating_add(m1, a), m);
  39
  40             assert_eq!(simd_saturating_sub(b, z), b);
  41             assert_eq!(simd_saturating_sub(b, a), a);
  42             assert_eq!(simd_saturating_sub(a, a), z);
  43             assert_eq!(simd_saturating_sub(a, b), z);
  44             assert_eq!(simd_saturating_sub(a, m1), z);
  45             assert_eq!(simd_saturating_sub(b, m1), z);
  46         }
  47     }
  48
  49     // signed
  50     {
  51         const MIN: i32 = i32::MIN;
  52         const MAX: i32 = i32::MAX;
  53
  54         let a = I32::<4>([1, 2, 3, 4]);
  55         let b = I32::<4>([2, 4, 6, 8]);
  56         let c = I32::<4>([-1, -2, -3, -4]);
  57         let d = I32::<4>([-2, -4, -6, -8]);
  58
  59         let max = I32::<4>([MAX, MAX, MAX, MAX]);
  60         let max1 = I32::<4>([MAX - 1, MAX - 1, MAX - 1, MAX - 1]);
  61         let min = I32::<4>([MIN, MIN, MIN, MIN]);
  62         let min1 = I32::<4>([MIN + 1, MIN + 1, MIN + 1, MIN + 1]);
  63
  64         let z = I32::<4>([0, 0, 0, 0]);
  65
  66         unsafe {
  67             assert_eq!(simd_saturating_add(z, z).0, z.0);
  68             assert_eq!(simd_saturating_add(z, a).0, a.0);
  69             assert_eq!(simd_saturating_add(b, z).0, b.0);
  70             assert_eq!(simd_saturating_add(a, a).0, b.0);
  71             assert_eq!(simd_saturating_add(a, max).0, max.0);
  72             assert_eq!(simd_saturating_add(max, b).0, max.0);
  73             assert_eq!(simd_saturating_add(max1, a).0, max.0);
  74             assert_eq!(simd_saturating_add(min1, z).0, min1.0);
  75             assert_eq!(simd_saturating_add(min, z).0, min.0);
  76             assert_eq!(simd_saturating_add(min1, c).0, min.0);
  77             assert_eq!(simd_saturating_add(min, c).0, min.0);
  78             assert_eq!(simd_saturating_add(min1, d).0, min.0);
  79             assert_eq!(simd_saturating_add(min, d).0, min.0);
  80
  81             assert_eq!(simd_saturating_sub(b, z).0, b.0);
  82             assert_eq!(simd_saturating_sub(b, a).0, a.0);
  83             assert_eq!(simd_saturating_sub(a, a).0, z.0);
  84             assert_eq!(simd_saturating_sub(a, b).0, c.0);
  85             assert_eq!(simd_saturating_sub(z, max).0, min1.0);
  86             assert_eq!(simd_saturating_sub(min1, z).0, min1.0);
  87             assert_eq!(simd_saturating_sub(min1, a).0, min.0);
  88             assert_eq!(simd_saturating_sub(min1, b).0, min.0);
  89         }
  90     }
  91 }