Rollup merge of #154043 - RalfJung:simd-min-max, r=Amanieu,calebzulawski,antoyo

simd_fmin/fmax: make semantics and name consistent with scalar intrinsics

This is the SIMD version of rust-lang/rust#153343: change the documented semantics of the SIMD float min/max intrinsics to that of the scalar intrinsics, and also make the name consistent. The overall semantic change this amounts to is that we restrict the non-determinism: the old semantics effectively mean "when one input is an SNaN, the result non-deterministically is a NaN or the other input"; the new semantics say that in this case the other input must be returned. For all other cases, old and new semantics are equivalent. This means all users of these intrinsics that were correct with the old semantics are still correct: the overall set of possible behaviors has become smaller, no new possible behaviors are being added.

In terms of providers of this API:
- Miri, GCC, and cranelift already implement the new semantics, so no changes are needed.
- LLVM is adjusted to use `minimumnum nsz` instead of `minnum`, thus giving us the new semantics.

In terms of consumers of this API:
- Portable SIMD almost certainly wants to match the scalar behavior, so this is strictly a bugfix here.
- Stdarch mostly stopped using the intrinsic, except on nvptx, where arguably the new semantics are closer to what we actually want than the old semantics (rust-lang/stdarch#2056).

Q: Should there be an `f` in the intrinsic name to indicate that it is for floats? E.g., `simd_fminimum_number_nsz`?

Also see rust-lang/rust#153395.

Author: GuillaumeGomez

example/float-minmax-pass.rs

@@ -33,24 +33,24 @@ fn main() {
     let n = f32x4([nan, nan, nan, nan]);
 
     unsafe {
-        let min0 = simd_fmin(x, y);
-        let min1 = simd_fmin(y, x);
+        let min0 = simd_minimum_number_nsz(x, y);
+        let min1 = simd_minimum_number_nsz(y, x);
         assert_eq!(min0.into_array(), min1.into_array());
         let e = f32x4([1.0, 1.0, 3.0, 3.0]);
         assert_eq!(min0.into_array(), e.into_array());
-        let minn = simd_fmin(x, n);
+        let minn = simd_minimum_number_nsz(x, n);
         assert_eq!(minn.into_array(), x.into_array());
-        let minn = simd_fmin(y, n);
+        let minn = simd_minimum_number_nsz(y, n);
         assert_eq!(minn.into_array(), y.into_array());
 
-        let max0 = simd_fmax(x, y);
-        let max1 = simd_fmax(y, x);
+        let max0 = simd_maximum_number_nsz(x, y);
+        let max1 = simd_maximum_number_nsz(y, x);
         assert_eq!(max0.into_array(), max1.into_array());
         let e = f32x4([2.0, 2.0, 4.0, 4.0]);
         assert_eq!(max0.into_array(), e.into_array());
-        let maxn = simd_fmax(x, n);
+        let maxn = simd_maximum_number_nsz(x, n);
         assert_eq!(maxn.into_array(), x.into_array());
-        let maxn = simd_fmax(y, n);
+        let maxn = simd_maximum_number_nsz(y, n);
         assert_eq!(maxn.into_array(), y.into_array());
     }
 }

src/intrinsics/simd.rs

@@ -493,7 +493,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             }
         }
 
-        sym::simd_fmin | sym::simd_fmax => {
+        sym::simd_minimum_number_nsz | sym::simd_maximum_number_nsz => {
             intrinsic_args!(fx, args => (x, y); intrinsic);
 
             if !x.layout().ty.is_simd() {
@@ -508,8 +508,12 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                     _ => unreachable!("{:?}", lane_ty),
                 }
                 match intrinsic {
-                    sym::simd_fmin => crate::num::codegen_float_min(fx, x_lane, y_lane),
-                    sym::simd_fmax => crate::num::codegen_float_max(fx, x_lane, y_lane),
+                    sym::simd_minimum_number_nsz => {
+                        crate::num::codegen_float_min(fx, x_lane, y_lane)
+                    }
+                    sym::simd_maximum_number_nsz => {
+                        crate::num::codegen_float_max(fx, x_lane, y_lane)
+                    }
                     _ => unreachable!(),
                 }
             });

src/num.rs

@@ -500,8 +500,8 @@ fn codegen_ptr_binop<'tcx>(
 
 // In Rust floating point min and max don't propagate NaN (not even SNaN). In Cranelift they do
 // however. For this reason it is necessary to use `a.is_nan() ? b : (a >= b ? b : a)` for
-// `minnumf*` and `a.is_nan() ? b : (a <= b ? b : a)` for `maxnumf*`. NaN checks are done by
-// comparing a float against itself. Only in case of NaN is it not equal to itself.
+// `minimum_number_nsz` and `a.is_nan() ? b : (a <= b ? b : a)` for `maximum_number_nsz`. NaN checks
+// are done by comparing a float against itself. Only in case of NaN is it not equal to itself.
 pub(crate) fn codegen_float_min(fx: &mut FunctionCx<'_, '_, '_>, a: Value, b: Value) -> Value {
     // FIXME(bytecodealliance/wasmtime#8312): Replace with Cranelift `fcmp` once
     // `f16`/`f128` backend lowerings have been added to Cranelift.