Add _mm_cmpunord_ss

Author: nominolo

src/x86/sse.rs

@@ -329,6 +329,17 @@ pub unsafe fn _mm_cmpord_ss(a: f32x4, b: f32x4) -> f32x4 {
     cmpss(a, b, 7)
 }
 
+/// Check if the lowest `f32` of both inputs are unordered. The lowest 32 bits
+/// of the result will be `0xffffffff` if any of `a.extract(0)` or
+/// `b.extract(0)` is a NaN, or `0` otherwise. The upper 96 bits of the result
+/// are the upper 96 bits of `a`.
+#[inline(always)]
+#[target_feature = "+sse"]
+#[cfg_attr(test, assert_instr(cmpunordss))]
+pub unsafe fn _mm_cmpunord_ss(a: f32x4, b: f32x4) -> f32x4 {
+    cmpss(a, b, 3)
+}
+
 /// Construct a `f32x4` with the lowest element set to `a` and the rest set to
 /// zero.
 #[inline(always)]
@@ -1338,9 +1349,6 @@ mod tests {
 
     #[simd_test = "sse"]
     unsafe fn _mm_cmpord_ss() {
-        // TODO: This test is exactly the same as for _mm_cmplt_ss, but there
-        // must be a difference. It may have to do with behavior in the presence
-        // of NaNs (signaling or quiet). If so, we should add tests for those.
         use std::mem::transmute;
         use std::f32::NAN;
 
@@ -1366,6 +1374,33 @@ mod tests {
         assert_eq!(rd, ed);
     }
 
+    #[simd_test = "sse"]
+    unsafe fn _mm_cmpunord_ss() {
+        use std::mem::transmute;
+        use std::f32::NAN;
+
+        let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
+        let b = f32x4::new(0.0, 5.0, 6.0, 7.0);
+        let c = f32x4::new(NAN, 5.0, 6.0, 7.0);
+        let d = f32x4::new(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = 0u32;  // a.extract(0) unord b.extract(0)
+        let c1 = !0u32;  // a.extract(0) unord c.extract(0)
+        let d1 = 0u32;  // a.extract(0) unord d.extract(0)
+
+        let rb: u32x4 = transmute(sse::_mm_cmpunord_ss(a, b));
+        let eb: u32x4 = transmute(f32x4::new(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: u32x4 = transmute(sse::_mm_cmpunord_ss(a, c));
+        let ec: u32x4 = transmute(f32x4::new(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: u32x4 = transmute(sse::_mm_cmpunord_ss(a, d));
+        let ed: u32x4 = transmute(f32x4::new(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+
     #[simd_test = "sse"]
     unsafe fn _mm_set_ss() {
         let r = sse::_mm_set_ss(black_box(4.25));