src/test/ui/simd/simd-intrinsic-generic-reduction.rs

   1 // run-pass
   2 #![allow(non_camel_case_types)]
   3
   4 // ignore-emscripten
   5
   6 // Test that the simd_reduce_{op} intrinsics produce the correct results.
   7
   8 #![feature(repr_simd, platform_intrinsics)]
   9 #[allow(non_camel_case_types)]
  10
  11 #[repr(simd)]
  12 #[derive(Copy, Clone)]
  13 struct i32x4(pub i32, pub i32, pub i32, pub i32);
  14
  15 #[repr(simd)]
  16 #[derive(Copy, Clone)]
  17 struct u32x4(pub u32, pub u32, pub u32, pub u32);
  18
  19 #[repr(simd)]
  20 #[derive(Copy, Clone)]
  21 struct f32x4(pub f32, pub f32, pub f32, pub f32);
  22
  23 #[repr(simd)]
  24 #[derive(Copy, Clone)]
  25 struct b8x4(pub i8, pub i8, pub i8, pub i8);
  26
  27 #[repr(simd)]
  28 #[derive(Copy, Clone)]
  29 struct b8x16(
  30     pub i8, pub i8, pub i8, pub i8,
  31     pub i8, pub i8, pub i8, pub i8,
  32     pub i8, pub i8, pub i8, pub i8,
  33     pub i8, pub i8, pub i8, pub i8
  34 );
  35
  36 extern "platform-intrinsic" {
  37     fn simd_reduce_add_unordered<T, U>(x: T) -> U;
  38     fn simd_reduce_mul_unordered<T, U>(x: T) -> U;
  39     fn simd_reduce_add_ordered<T, U>(x: T, acc: U) -> U;
  40     fn simd_reduce_mul_ordered<T, U>(x: T, acc: U) -> U;
  41     fn simd_reduce_min<T, U>(x: T) -> U;
  42     fn simd_reduce_max<T, U>(x: T) -> U;
  43     fn simd_reduce_min_nanless<T, U>(x: T) -> U;
  44     fn simd_reduce_max_nanless<T, U>(x: T) -> U;
  45     fn simd_reduce_and<T, U>(x: T) -> U;
  46     fn simd_reduce_or<T, U>(x: T) -> U;
  47     fn simd_reduce_xor<T, U>(x: T) -> U;
  48     fn simd_reduce_all<T>(x: T) -> bool;
  49     fn simd_reduce_any<T>(x: T) -> bool;
  50 }
  51
  52 fn main() {
  53     unsafe {
  54         let x = i32x4(1, -2, 3, 4);
  55         let r: i32 = simd_reduce_add_unordered(x);
  56         assert_eq!(r, 6_i32);
  57         let r: i32 = simd_reduce_mul_unordered(x);
  58         assert_eq!(r, -24_i32);
  59         let r: i32 = simd_reduce_add_ordered(x, -1);
  60         assert_eq!(r, 5_i32);
  61         let r: i32 = simd_reduce_mul_ordered(x, -1);
  62         assert_eq!(r, 24_i32);
  63
  64         let r: i32 = simd_reduce_min(x);
  65         assert_eq!(r, -2_i32);
  66         let r: i32 = simd_reduce_max(x);
  67         assert_eq!(r, 4_i32);
  68
  69         let x = i32x4(-1, -1, -1, -1);
  70         let r: i32 = simd_reduce_and(x);
  71         assert_eq!(r, -1_i32);
  72         let r: i32 = simd_reduce_or(x);
  73         assert_eq!(r, -1_i32);
  74         let r: i32 = simd_reduce_xor(x);
  75         assert_eq!(r, 0_i32);
  76
  77         let x = i32x4(-1, -1, 0, -1);
  78         let r: i32 = simd_reduce_and(x);
  79         assert_eq!(r, 0_i32);
  80         let r: i32 = simd_reduce_or(x);
  81         assert_eq!(r, -1_i32);
  82         let r: i32 = simd_reduce_xor(x);
  83         assert_eq!(r, -1_i32);
  84     }
  85
  86     unsafe {
  87         let x = u32x4(1, 2, 3, 4);
  88         let r: u32 = simd_reduce_add_unordered(x);
  89         assert_eq!(r, 10_u32);
  90         let r: u32 = simd_reduce_mul_unordered(x);
  91         assert_eq!(r, 24_u32);
  92         let r: u32 = simd_reduce_add_ordered(x, 1);
  93         assert_eq!(r, 11_u32);
  94         let r: u32 = simd_reduce_mul_ordered(x, 2);
  95         assert_eq!(r, 48_u32);
  96
  97         let r: u32 = simd_reduce_min(x);
  98         assert_eq!(r, 1_u32);
  99         let r: u32 = simd_reduce_max(x);
 100         assert_eq!(r, 4_u32);
 101
 102         let t = u32::MAX;
 103         let x = u32x4(t, t, t, t);
 104         let r: u32 = simd_reduce_and(x);
 105         assert_eq!(r, t);
 106         let r: u32 = simd_reduce_or(x);
 107         assert_eq!(r, t);
 108         let r: u32 = simd_reduce_xor(x);
 109         assert_eq!(r, 0_u32);
 110
 111         let x = u32x4(t, t, 0, t);
 112         let r: u32 = simd_reduce_and(x);
 113         assert_eq!(r, 0_u32);
 114         let r: u32 = simd_reduce_or(x);
 115         assert_eq!(r, t);
 116         let r: u32 = simd_reduce_xor(x);
 117         assert_eq!(r, t);
 118     }
 119
 120     unsafe {
 121         let x = f32x4(1., -2., 3., 4.);
 122         let r: f32 = simd_reduce_add_unordered(x);
 123         assert_eq!(r, 6_f32);
 124         let r: f32 = simd_reduce_mul_unordered(x);
 125         assert_eq!(r, -24_f32);
 126         let r: f32 = simd_reduce_add_ordered(x, 0.);
 127         assert_eq!(r, 6_f32);
 128         let r: f32 = simd_reduce_mul_ordered(x, 1.);
 129         assert_eq!(r, -24_f32);
 130         let r: f32 = simd_reduce_add_ordered(x, 1.);
 131         assert_eq!(r, 7_f32);
 132         let r: f32 = simd_reduce_mul_ordered(x, 2.);
 133         assert_eq!(r, -48_f32);
 134
 135         let r: f32 = simd_reduce_min(x);
 136         assert_eq!(r, -2_f32);
 137         let r: f32 = simd_reduce_max(x);
 138         assert_eq!(r, 4_f32);
 139         let r: f32 = simd_reduce_min_nanless(x);
 140         assert_eq!(r, -2_f32);
 141         let r: f32 = simd_reduce_max_nanless(x);
 142         assert_eq!(r, 4_f32);
 143     }
 144
 145     unsafe {
 146         let x = b8x4(!0, !0, !0, !0);
 147         let r: bool = simd_reduce_all(x);
 148         assert_eq!(r, true);
 149         let r: bool = simd_reduce_any(x);
 150         assert_eq!(r, true);
 151
 152         let x = b8x4(!0, !0, 0, !0);
 153         let r: bool = simd_reduce_all(x);
 154         assert_eq!(r, false);
 155         let r: bool = simd_reduce_any(x);
 156         assert_eq!(r, true);
 157
 158         let x = b8x4(0, 0, 0, 0);
 159         let r: bool = simd_reduce_all(x);
 160         assert_eq!(r, false);
 161         let r: bool = simd_reduce_any(x);
 162         assert_eq!(r, false);
 163     }
 164 }