1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
//@ run-pass
#![feature(repr_simd, core_intrinsics, macro_metavar_expr_concat)]
#![allow(non_camel_case_types)]
#[path = "../../../auxiliary/minisimd.rs"]
mod minisimd;
use minisimd::*;
use std::intrinsics::simd::{simd_eq, simd_ge, simd_gt, simd_le, simd_lt, simd_ne};
macro_rules! cmp {
($method: ident($lhs: expr, $rhs: expr)) => {{
let lhs = $lhs;
let rhs = $rhs;
let e: u32x4 = ${concat(simd_, $method)}($lhs, $rhs);
// assume the scalar version is correct/the behaviour we want.
let (lhs, rhs, e) = (lhs.as_array(), rhs.as_array(), e.as_array());
assert!((e[0] != 0) == lhs[0].$method(&rhs[0]));
assert!((e[1] != 0) == lhs[1].$method(&rhs[1]));
assert!((e[2] != 0) == lhs[2].$method(&rhs[2]));
assert!((e[3] != 0) == lhs[3].$method(&rhs[3]));
}};
}
macro_rules! tests {
($($lhs: ident, $rhs: ident;)*) => {{
$(
(|| {
cmp!(eq($lhs, $rhs));
cmp!(ne($lhs, $rhs));
// test both directions
cmp!(lt($lhs, $rhs));
cmp!(lt($rhs, $lhs));
cmp!(le($lhs, $rhs));
cmp!(le($rhs, $lhs));
cmp!(gt($lhs, $rhs));
cmp!(gt($rhs, $lhs));
cmp!(ge($lhs, $rhs));
cmp!(ge($rhs, $lhs));
})();
)*
}}
}
fn main() {
// 13 vs. -100 tests that we get signed vs. unsigned comparisons
// correct (i32: 13 > -100, u32: 13 < -100). let i1 = i32x4(10, -11, 12, 13);
let i1 = i32x4::from_array([10, -11, 12, 13]);
let i2 = i32x4::from_array([5, -5, 20, -100]);
let i3 = i32x4::from_array([10, -11, 20, -100]);
let u1 = u32x4::from_array([10, !11 + 1, 12, 13]);
let u2 = u32x4::from_array([5, !5 + 1, 20, !100 + 1]);
let u3 = u32x4::from_array([10, !11 + 1, 20, !100 + 1]);
let f1 = f32x4::from_array([10.0, -11.0, 12.0, 13.0]);
let f2 = f32x4::from_array([5.0, -5.0, 20.0, -100.0]);
let f3 = f32x4::from_array([10.0, -11.0, 20.0, -100.0]);
unsafe {
tests! {
i1, i1;
u1, u1;
f1, f1;
i1, i2;
u1, u2;
f1, f2;
i1, i3;
u1, u3;
f1, f3;
}
}
// NAN comparisons are special:
// -11 (*) 13
// -5 -100 (*)
let f4 = f32x4::from_array([f32::NAN, f1[1], f32::NAN, f2[3]]);
unsafe {
tests! {
f1, f4;
f2, f4;
f4, f4;
}
}
}
|
