Add tests for various intrinsic behaviours.

Author: huonw

src/test/compile-fail/simd-intrinsic-declaration-type.rs

@@ -0,0 +1,57 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(repr_simd, platform_intrinsics)]
+
+#[repr(simd)]
+struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
+#[repr(simd)]
+struct u16x8(u16, u16, u16, u16, u16, u16, u16, u16);
+
+#[repr(simd)]
+struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
+             i8, i8, i8, i8, i8, i8, i8, i8);
+#[repr(simd)]
+struct i32x4(i32, i32, i32, i32);
+#[repr(simd)]
+struct f32x4(f32, f32, f32, f32);
+#[repr(simd)]
+struct i64x2(i64, i64);
+
+// signed vs. unsigned doesn't matter
+mod i {
+    use i16x8;
+    extern "platform-intrinsic" {
+        fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8;
+    }
+}
+mod u {
+    use u16x8;
+    extern "platform-intrinsic" {
+        fn x86_mm_adds_epi16(x: u16x8, y: u16x8) -> u16x8;
+    }
+}
+// but lengths do
+extern "platform-intrinsic" {
+    fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
+    //~^ ERROR intrinsic argument 1 has wrong type
+    //~^^ ERROR intrinsic argument 2 has wrong type
+    //~^^^ ERROR intrinsic return value has wrong type
+}
+// and so does int vs. float
+extern "platform-intrinsic" {
+    fn x86_mm_max_ps(x: i32x4, y: i32x4) -> i32x4;
+    //~^ ERROR intrinsic argument 1 has wrong type
+    //~^^ ERROR intrinsic argument 2 has wrong type
+    //~^^^ ERROR intrinsic return value has wrong type
+}
+
+
+fn main() {}

src/test/compile-fail/simd-intrinsic-generic-arithmetic.rs

@@ -0,0 +1,102 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(repr_simd, platform_intrinsics)]
+#![allow(non_camel_case_types)]
+#[repr(simd)]
+#[derive(Copy, Clone)]
+pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
+
+extern "platform-intrinsic" {
+    fn simd_add<T>(x: T, y: T) -> T;
+    fn simd_sub<T>(x: T, y: T) -> T;
+    fn simd_mul<T>(x: T, y: T) -> T;
+    fn simd_div<T>(x: T, y: T) -> T;
+    fn simd_shl<T>(x: T, y: T) -> T;
+    fn simd_shr<T>(x: T, y: T) -> T;
+    fn simd_and<T>(x: T, y: T) -> T;
+    fn simd_or<T>(x: T, y: T) -> T;
+    fn simd_xor<T>(x: T, y: T) -> T;
+}
+
+fn main() {
+    let x = i32x4(0, 0, 0, 0);
+    let y = u32x4(0, 0, 0, 0);
+    let z = f32x4(0.0, 0.0, 0.0, 0.0);
+
+    unsafe {
+        simd_add(x, x);
+        simd_add(y, y);
+        simd_add(z, z);
+        simd_sub(x, x);
+        simd_sub(y, y);
+        simd_sub(z, z);
+        simd_mul(x, x);
+        simd_mul(y, y);
+        simd_mul(z, z);
+
+        simd_div(z, z);
+
+        simd_shl(x, x);
+        simd_shl(y, y);
+        simd_shr(x, x);
+        simd_shr(y, y);
+        simd_and(x, x);
+        simd_and(y, y);
+        simd_or(x, x);
+        simd_or(y, y);
+        simd_xor(x, x);
+        simd_xor(y, y);
+
+
+        simd_add(0, 0);
+        //~^ ERROR `simd_add` intrinsic monomorphized with non-SIMD type
+        simd_sub(0, 0);
+        //~^ ERROR `simd_sub` intrinsic monomorphized with non-SIMD type
+        simd_mul(0, 0);
+        //~^ ERROR `simd_mul` intrinsic monomorphized with non-SIMD type
+        simd_div(0, 0);
+        //~^ ERROR `simd_div` intrinsic monomorphized with non-SIMD type
+        simd_shl(0, 0);
+        //~^ ERROR `simd_shl` intrinsic monomorphized with non-SIMD type
+        simd_shr(0, 0);
+        //~^ ERROR `simd_shr` intrinsic monomorphized with non-SIMD type
+        simd_and(0, 0);
+        //~^ ERROR `simd_and` intrinsic monomorphized with non-SIMD type
+        simd_or(0, 0);
+        //~^ ERROR `simd_or` intrinsic monomorphized with non-SIMD type
+        simd_xor(0, 0);
+        //~^ ERROR `simd_xor` intrinsic monomorphized with non-SIMD type
+
+
+        simd_div(x, x);
+//~^ ERROR `simd_div` intrinsic monomorphized with SIMD vector `i32x4` with unsupported element type
+        simd_div(y, y);
+//~^ ERROR `simd_div` intrinsic monomorphized with SIMD vector `u32x4` with unsupported element type
+        simd_shl(z, z);
+//~^ ERROR `simd_shl` intrinsic monomorphized with SIMD vector `f32x4` with unsupported element type
+        simd_shr(z, z);
+//~^ ERROR `simd_shr` intrinsic monomorphized with SIMD vector `f32x4` with unsupported element type
+        simd_and(z, z);
+//~^ ERROR `simd_and` intrinsic monomorphized with SIMD vector `f32x4` with unsupported element type
+        simd_or(z, z);
+//~^ ERROR `simd_or` intrinsic monomorphized with SIMD vector `f32x4` with unsupported element type
+        simd_xor(z, z);
+//~^ ERROR `simd_xor` intrinsic monomorphized with SIMD vector `f32x4` with unsupported element type
+    }
+}

src/test/compile-fail/simd-intrinsic-generic-cast.rs

@@ -0,0 +1,51 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(repr_simd, platform_intrinsics)]
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x4(i32, i32, i32, i32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x8(i32, i32, i32, i32,
+             i32, i32, i32, i32);
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct f32x4(f32, f32, f32, f32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct f32x8(f32, f32, f32, f32,
+             f32, f32, f32, f32);
+
+
+extern "platform-intrinsic" {
+    fn simd_cast<T, U>(x: T) -> U;
+}
+
+fn main() {
+    let x = i32x4(0, 0, 0, 0);
+
+    unsafe {
+        simd_cast::<i32, i32>(0);
+        //~^ ERROR SIMD cast intrinsic monomorphized with non-SIMD input type `i32`
+        simd_cast::<i32, i32x4>(0);
+        //~^ ERROR SIMD cast intrinsic monomorphized with non-SIMD input type `i32`
+        simd_cast::<i32x4, i32>(x);
+        //~^ ERROR SIMD cast intrinsic monomorphized with non-SIMD return type `i32`
+        simd_cast::<_, i32x8>(x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i32x8` with different lengths
+    }
+}

src/test/compile-fail/simd-intrinsic-generic-comparison.rs

@@ -0,0 +1,75 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(repr_simd, platform_intrinsics)]
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x4(i32, i32, i32, i32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i16x8(i16, i16, i16, i16,
+             i16, i16, i16, i16);
+
+extern "platform-intrinsic" {
+    fn simd_eq<T, U>(x: T, y: T) -> U;
+    fn simd_ne<T, U>(x: T, y: T) -> U;
+    fn simd_lt<T, U>(x: T, y: T) -> U;
+    fn simd_le<T, U>(x: T, y: T) -> U;
+    fn simd_gt<T, U>(x: T, y: T) -> U;
+    fn simd_ge<T, U>(x: T, y: T) -> U;
+}
+
+fn main() {
+    let x = i32x4(0, 0, 0, 0);
+
+    unsafe {
+        simd_eq::<i32, i32>(0, 0);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD argument type
+        simd_ne::<i32, i32>(0, 0);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD argument type
+        simd_lt::<i32, i32>(0, 0);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD argument type
+        simd_le::<i32, i32>(0, 0);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD argument type
+        simd_gt::<i32, i32>(0, 0);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD argument type
+        simd_ge::<i32, i32>(0, 0);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD argument type
+
+        simd_eq::<_, i32>(x, x);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD return type
+        simd_ne::<_, i32>(x, x);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD return type
+        simd_lt::<_, i32>(x, x);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD return type
+        simd_le::<_, i32>(x, x);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD return type
+        simd_gt::<_, i32>(x, x);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD return type
+        simd_ge::<_, i32>(x, x);
+        //~^ ERROR SIMD comparison intrinsic monomorphized for non-SIMD return type
+
+        simd_eq::<_, i16x8>(x, x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i16x8` with different lengths
+        simd_ne::<_, i16x8>(x, x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i16x8` with different lengths
+        simd_lt::<_, i16x8>(x, x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i16x8` with different lengths
+        simd_le::<_, i16x8>(x, x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i16x8` with different lengths
+        simd_gt::<_, i16x8>(x, x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i16x8` with different lengths
+        simd_ge::<_, i16x8>(x, x);
+//~^ ERROR monomorphized with input type `i32x4` and return type `i16x8` with different lengths
+    }
+}

src/test/compile-fail/simd-intrinsic-generic-elements.rs

@@ -0,0 +1,88 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(repr_simd, platform_intrinsics)]
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x2(i32, i32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x3(i32, i32, i32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x4(i32, i32, i32, i32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct i32x8(i32, i32, i32, i32,
+             i32, i32, i32, i32);
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct f32x2(f32, f32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct f32x3(f32, f32, f32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct f32x4(f32, f32, f32, f32);
+#[repr(simd)]
+#[derive(Copy, Clone)]
+#[allow(non_camel_case_types)]
+struct f32x8(f32, f32, f32, f32,
+             f32, f32, f32, f32);
+
+extern "platform-intrinsic" {
+    fn simd_insert<T, E>(x: T, idx: u32, y: E) -> T;
+    fn simd_extract<T, E>(x: T, idx: u32) -> E;
+
+    fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U;
+    fn simd_shuffle3<T, U>(x: T, y: T, idx: [u32; 3]) -> U;
+    fn simd_shuffle4<T, U>(x: T, y: T, idx: [u32; 4]) -> U;
+    fn simd_shuffle8<T, U>(x: T, y: T, idx: [u32; 8]) -> U;
+}
+
+fn main() {
+    let x = i32x4(0, 0, 0, 0);
+
+    unsafe {
+        simd_insert(0, 0, 0);
+        //~^ ERROR SIMD insert intrinsic monomorphized for non-SIMD input type
+        simd_insert(x, 0, 1.0);
+        //~^ ERROR SIMD insert intrinsic monomorphized with inserted type not SIMD element type
+        simd_extract::<_, f32>(x, 0);
+        //~^ ERROR SIMD insert intrinsic monomorphized with returned type not SIMD element type
+
+        simd_shuffle2::<i32, i32>(0, 0, [0; 2]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with non-SIMD input type
+        simd_shuffle3::<i32, i32>(0, 0, [0; 3]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with non-SIMD input type
+        simd_shuffle4::<i32, i32>(0, 0, [0; 4]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with non-SIMD input type
+        simd_shuffle8::<i32, i32>(0, 0, [0; 8]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with non-SIMD input type
+
+        simd_shuffle2::<_, f32x2>(x, x, [0; 2]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with different input and return element
+        simd_shuffle3::<_, f32x3>(x, x, [0; 3]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with different input and return element
+        simd_shuffle4::<_, f32x4>(x, x, [0; 4]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with different input and return element
+        simd_shuffle8::<_, f32x8>(x, x, [0; 8]);
+        //~^ ERROR SIMD shuffle intrinsic monomorphized with different input and return element
+    }
+}