src/test/ui/simd/generics.rs

   1 // run-pass
   2 #![allow(non_camel_case_types)]
   3 #![feature(repr_simd, platform_intrinsics)]
   4
   5 use std::ops;
   6
   7 #[repr(simd)]
   8 #[derive(Copy, Clone)]
   9 struct f32x4(f32, f32, f32, f32);
  10
  11 #[repr(simd)]
  12 #[derive(Copy, Clone)]
  13 struct A<const N: usize>([f32; N]);
  14
  15 #[repr(simd)]
  16 #[derive(Copy, Clone)]
  17 struct B<T>([T; 4]);
  18
  19 #[repr(simd)]
  20 #[derive(Copy, Clone)]
  21 struct C<T, const N: usize>([T; N]);
  22
  23
  24 extern "platform-intrinsic" {
  25     fn simd_add<T>(x: T, y: T) -> T;
  26 }
  27
  28 fn add<T: ops::Add<Output=T>>(lhs: T, rhs: T) -> T {
  29     lhs + rhs
  30 }
  31
  32 impl ops::Add for f32x4 {
  33     type Output = f32x4;
  34
  35     fn add(self, rhs: f32x4) -> f32x4 {
  36         unsafe { simd_add(self, rhs) }
  37     }
  38 }
  39
  40 impl ops::Add for A<4> {
  41     type Output = Self;
  42
  43     fn add(self, rhs: Self) -> Self {
  44         unsafe { simd_add(self, rhs) }
  45     }
  46 }
  47
  48 impl ops::Add for B<f32> {
  49     type Output = Self;
  50
  51     fn add(self, rhs: Self) -> Self {
  52         unsafe { simd_add(self, rhs) }
  53     }
  54 }
  55
  56 impl ops::Add for C<f32, 4> {
  57     type Output = Self;
  58
  59     fn add(self, rhs: Self) -> Self {
  60         unsafe { simd_add(self, rhs) }
  61     }
  62 }
  63
  64
  65 pub fn main() {
  66     let x = [1.0f32, 2.0f32, 3.0f32, 4.0f32];
  67     let y = [2.0f32, 4.0f32, 6.0f32, 8.0f32];
  68
  69     // lame-o
  70     let a = f32x4(1.0f32, 2.0f32, 3.0f32, 4.0f32);
  71     let f32x4(a0, a1, a2, a3) = add(a, a);
  72     assert_eq!(a0, 2.0f32);
  73     assert_eq!(a1, 4.0f32);
  74     assert_eq!(a2, 6.0f32);
  75     assert_eq!(a3, 8.0f32);
  76
  77     let a = A(x);
  78     assert_eq!(add(a, a).0, y);
  79
  80     let b = B(x);
  81     assert_eq!(add(b, b).0, y);
  82
  83     let c = C(x);
  84     assert_eq!(add(c, c).0, y);
  85 }