[WebAssembly] Revert result operand ordering for pmin/pmax

[samparker]

Summary

In D143581 I made a few changes around pmin and pmax, including reversing the operand ordering. Is this what's causing the issue with NaN propagation @tlively ?

[tlively]

Yes, pmin is rhs < lhs ? rhs : lhs and pmax is lhs < rhs ? rhs : lhs, so if either input is NaN, the result for either operation should be lhs. IIUC, before this patch NaN inputs would result in rhs instead.

llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td

 // NaN-propagating minimum: min
 defm MIN : SIMDBinaryFP<fminimum, "min", 232>;
 
 // NaN-propagating maximum: max
 defm MAX : SIMDBinaryFP<fmaximum, "max", 233>;
 
 // Pseudo-minimum: pmin
 def pmin : PatFrags<(ops node:$lhs, node:$rhs), [
-                    (vselect (setolt $lhs, $rhs), $lhs, $rhs),
-                    (vselect (setole $lhs, $rhs), $lhs, $rhs),
-                    (vselect (setogt $rhs, $lhs), $lhs, $rhs),
-                    (vselect (setoge $rhs, $lhs), $lhs, $rhs)
+                    (vselect (setolt $rhs, $lhs), $rhs, $lhs),
+                    (vselect (setole $rhs, $lhs), $rhs, $lhs),
+                    (vselect (setogt $lhs, $rhs), $rhs, $lhs),
+                    (vselect (setoge $lhs, $rhs), $rhs, $lhs)
 ]>;
 defm PMIN : SIMDBinaryFP<pmin, "pmin", 234>;
 
 // Pseudo-maximum: pmax
 def pmax : PatFrags<(ops node:$lhs, node:$rhs), [
-                    (vselect (setogt $lhs, $rhs), $lhs, $rhs),
-                    (vselect (setoge $lhs, $rhs), $lhs, $rhs),
-                    (vselect (setolt $rhs, $lhs), $lhs, $rhs),
-                    (vselect (setole $rhs, $lhs), $lhs, $rhs)
+                    (vselect (setogt $rhs, $lhs), $rhs, $lhs),
+                    (vselect (setoge $rhs, $lhs), $rhs, $lhs),
+                    (vselect (setolt $lhs, $rhs), $rhs, $lhs),
+                    (vselect (setole $lhs, $rhs), $rhs, $lhs)
 ]>;
 defm PMAX : SIMDBinaryFP<pmax, "pmax", 235>;
 
 // Also match the pmin/pmax cases where the operands are int vectors (but the
 // comparison is still a floating point comparison). This can happen when using
 // the wasm_simd128.h intrinsics because v128_t is an integer vector.
 foreach vec = [F32x4, F64x2] in {
 defvar pmin = !cast<NI>("PMIN_"#vec);

llvm/test/CodeGen/WebAssembly/simd-arith.ll

; NO-SIMD128-FAST-NEXT:    return
   ret <4 x float> %a
 }
 
 define <4 x float> @min_unordered_v4f32(<4 x float> %x) {
 ; SIMD128-LABEL: min_unordered_v4f32:
 ; SIMD128:         .functype min_unordered_v4f32 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f32x4.pmin $push1=, $pop0, $0
+; SIMD128-NEXT:    f32x4.pmin $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: min_unordered_v4f32:
 ; SIMD128-FAST:         .functype min_unordered_v4f32 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f32x4.pmin $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f32x4.pmin $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: min_unordered_v4f32:
 ; NO-SIMD128:         .functype min_unordered_v4f32 (i32, f32, f32, f32, f32) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f32.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.const $push17=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.gt $push1=, $3, $pop17
; NO-SIMD128-FAST-NEXT:    return
   ret <4 x float> %a
 }
 
 define <4 x float> @max_unordered_v4f32(<4 x float> %x) {
 ; SIMD128-LABEL: max_unordered_v4f32:
 ; SIMD128:         .functype max_unordered_v4f32 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f32x4.pmax $push1=, $pop0, $0
+; SIMD128-NEXT:    f32x4.pmax $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: max_unordered_v4f32:
 ; SIMD128-FAST:         .functype max_unordered_v4f32 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f32x4.pmax $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f32x4.pmax $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: max_unordered_v4f32:
 ; NO-SIMD128:         .functype max_unordered_v4f32 (i32, f32, f32, f32, f32) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f32.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.const $push17=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.lt $push1=, $3, $pop17
; NO-SIMD128-FAST-NEXT:    return
   ret <4 x float> %a
 }
 
 define <4 x float> @min_ordered_v4f32(<4 x float> %x) {
 ; SIMD128-LABEL: min_ordered_v4f32:
 ; SIMD128:         .functype min_ordered_v4f32 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f32x4.pmin $push1=, $pop0, $0
+; SIMD128-NEXT:    f32x4.pmin $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: min_ordered_v4f32:
 ; SIMD128-FAST:         .functype min_ordered_v4f32 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f32x4.pmin $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f32x4.pmin $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: min_ordered_v4f32:
 ; NO-SIMD128:         .functype min_ordered_v4f32 (i32, f32, f32, f32, f32) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f32.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.const $push17=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.ge $push1=, $3, $pop17
; NO-SIMD128-FAST-NEXT:    return
   ret <4 x float> %a
 }
 
 define <4 x float> @max_ordered_v4f32(<4 x float> %x) {
 ; SIMD128-LABEL: max_ordered_v4f32:
 ; SIMD128:         .functype max_ordered_v4f32 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f32x4.pmax $push1=, $pop0, $0
+; SIMD128-NEXT:    f32x4.pmax $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: max_ordered_v4f32:
 ; SIMD128-FAST:         .functype max_ordered_v4f32 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f32x4.pmax $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f32x4.pmax $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: max_ordered_v4f32:
 ; NO-SIMD128:         .functype max_ordered_v4f32 (i32, f32, f32, f32, f32) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f32.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.const $push17=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f32.le $push1=, $3, $pop17
; NO-SIMD128-FAST-NEXT:    return
   )
   ret <4 x float> %a
 }
 
 define <4 x float> @pmin_v4f32(<4 x float> %x, <4 x float> %y) {
 ; SIMD128-LABEL: pmin_v4f32:
 ; SIMD128:         .functype pmin_v4f32 (v128, v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
-; SIMD128-NEXT:    f32x4.pmin $push0=, $1, $0
+; SIMD128-NEXT:    f32x4.pmin $push0=, $0, $1
 ; SIMD128-NEXT:    return $pop0
 ;
 ; SIMD128-FAST-LABEL: pmin_v4f32:
 ; SIMD128-FAST:         .functype pmin_v4f32 (v128, v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
-; SIMD128-FAST-NEXT:    f32x4.pmin $push0=, $1, $0
+; SIMD128-FAST-NEXT:    f32x4.pmin $push0=, $0, $1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: pmin_v4f32:
 ; NO-SIMD128:         .functype pmin_v4f32 (i32, f32, f32, f32, f32, f32, f32, f32, f32) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f32.lt $push0=, $7, $3
 ; NO-SIMD128-NEXT:    f32.select $push1=, $7, $3, $pop0
 ; NO-SIMD128-NEXT:    f32.store 8($0), $pop1
; NO-SIMD128-FAST-NEXT:    return
   %a = select <4 x i1> %c, <4 x i32> %y, <4 x i32> %x
   ret <4 x i32> %a
 }
 
 define <4 x float> @pmax_v4f32(<4 x float> %x, <4 x float> %y) {
 ; SIMD128-LABEL: pmax_v4f32:
 ; SIMD128:         .functype pmax_v4f32 (v128, v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
-; SIMD128-NEXT:    f32x4.pmax $push0=, $1, $0
+; SIMD128-NEXT:    f32x4.pmax $push0=, $0, $1
 ; SIMD128-NEXT:    return $pop0
 ;
 ; SIMD128-FAST-LABEL: pmax_v4f32:
 ; SIMD128-FAST:         .functype pmax_v4f32 (v128, v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
-; SIMD128-FAST-NEXT:    f32x4.pmax $push0=, $1, $0
+; SIMD128-FAST-NEXT:    f32x4.pmax $push0=, $0, $1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: pmax_v4f32:
 ; NO-SIMD128:         .functype pmax_v4f32 (i32, f32, f32, f32, f32, f32, f32, f32, f32) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f32.lt $push0=, $3, $7
 ; NO-SIMD128-NEXT:    f32.select $push1=, $7, $3, $pop0
 ; NO-SIMD128-NEXT:    f32.store 8($0), $pop1
; NO-SIMD128-FAST-NEXT:    return
   ret <2 x double> %a
 }
 
 define <2 x double> @min_unordered_v2f64(<2 x double> %x) {
 ; SIMD128-LABEL: min_unordered_v2f64:
 ; SIMD128:         .functype min_unordered_v2f64 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f64x2.pmin $push1=, $pop0, $0
+; SIMD128-NEXT:    f64x2.pmin $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: min_unordered_v2f64:
 ; SIMD128-FAST:         .functype min_unordered_v2f64 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f64x2.pmin $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f64x2.pmin $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: min_unordered_v2f64:
 ; NO-SIMD128:         .functype min_unordered_v2f64 (i32, f64, f64) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f64.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.const $push7=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.gt $push1=, $2, $pop7
; NO-SIMD128-FAST-NEXT:    return
   ret <2 x double> %a
 }
 
 define <2 x double> @max_unordered_v2f64(<2 x double> %x) {
 ; SIMD128-LABEL: max_unordered_v2f64:
 ; SIMD128:         .functype max_unordered_v2f64 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f64x2.pmax $push1=, $pop0, $0
+; SIMD128-NEXT:    f64x2.pmax $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: max_unordered_v2f64:
 ; SIMD128-FAST:         .functype max_unordered_v2f64 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f64x2.pmax $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f64x2.pmax $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: max_unordered_v2f64:
 ; NO-SIMD128:         .functype max_unordered_v2f64 (i32, f64, f64) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f64.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.const $push7=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.lt $push1=, $2, $pop7
; NO-SIMD128-FAST-NEXT:    return
   ret <2 x double> %a
 }
 
 define <2 x double> @min_ordered_v2f64(<2 x double> %x) {
 ; SIMD128-LABEL: min_ordered_v2f64:
 ; SIMD128:         .functype min_ordered_v2f64 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f64x2.pmin $push1=, $pop0, $0
+; SIMD128-NEXT:    f64x2.pmin $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: min_ordered_v2f64:
 ; SIMD128-FAST:         .functype min_ordered_v2f64 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f64x2.pmin $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f64x2.pmin $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: min_ordered_v2f64:
 ; NO-SIMD128:         .functype min_ordered_v2f64 (i32, f64, f64) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f64.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.const $push7=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.ge $push1=, $2, $pop7
; NO-SIMD128-FAST-NEXT:    return
   ret <2 x double> %a
 }
 
 define <2 x double> @max_ordered_v2f64(<2 x double> %x) {
 ; SIMD128-LABEL: max_ordered_v2f64:
 ; SIMD128:         .functype max_ordered_v2f64 (v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
 ; SIMD128-NEXT:    v128.const $push0=, 0x1.4p2, 0x1.4p2
-; SIMD128-NEXT:    f64x2.pmax $push1=, $pop0, $0
+; SIMD128-NEXT:    f64x2.pmax $push1=, $0, $pop0
 ; SIMD128-NEXT:    return $pop1
 ;
 ; SIMD128-FAST-LABEL: max_ordered_v2f64:
 ; SIMD128-FAST:         .functype max_ordered_v2f64 (v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
 ; SIMD128-FAST-NEXT:    v128.const $push1=, 0x1.4p2, 0x1.4p2
-; SIMD128-FAST-NEXT:    f64x2.pmax $push0=, $pop1, $0
+; SIMD128-FAST-NEXT:    f64x2.pmax $push0=, $0, $pop1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: max_ordered_v2f64:
 ; NO-SIMD128:         .functype max_ordered_v2f64 (i32, f64, f64) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f64.const $push0=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.const $push7=, 0x1.4p2
 ; NO-SIMD128-NEXT:    f64.le $push1=, $2, $pop7
; NO-SIMD128-FAST-NEXT:    return
   )
   ret <2 x double> %a
 }
 
 define <2 x double> @pmin_v2f64(<2 x double> %x, <2 x double> %y) {
 ; SIMD128-LABEL: pmin_v2f64:
 ; SIMD128:         .functype pmin_v2f64 (v128, v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
-; SIMD128-NEXT:    f64x2.pmin $push0=, $1, $0
+; SIMD128-NEXT:    f64x2.pmin $push0=, $0, $1
 ; SIMD128-NEXT:    return $pop0
 ;
 ; SIMD128-FAST-LABEL: pmin_v2f64:
 ; SIMD128-FAST:         .functype pmin_v2f64 (v128, v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
-; SIMD128-FAST-NEXT:    f64x2.pmin $push0=, $1, $0
+; SIMD128-FAST-NEXT:    f64x2.pmin $push0=, $0, $1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: pmin_v2f64:
 ; NO-SIMD128:         .functype pmin_v2f64 (i32, f64, f64, f64, f64) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f64.lt $push0=, $4, $2
 ; NO-SIMD128-NEXT:    f64.select $push1=, $4, $2, $pop0
 ; NO-SIMD128-NEXT:    f64.store 8($0), $pop1
; NO-SIMD128-FAST-NEXT:    return
   %a = select <2 x i1> %c, <2 x i64> %y, <2 x i64> %x
   ret <2 x i64> %a
 }
 
 define <2 x double> @pmax_v2f64(<2 x double> %x, <2 x double> %y) {
 ; SIMD128-LABEL: pmax_v2f64:
 ; SIMD128:         .functype pmax_v2f64 (v128, v128) -> (v128)
 ; SIMD128-NEXT:  # %bb.0:
-; SIMD128-NEXT:    f64x2.pmax $push0=, $1, $0
+; SIMD128-NEXT:    f64x2.pmax $push0=, $0, $1
 ; SIMD128-NEXT:    return $pop0
 ;
 ; SIMD128-FAST-LABEL: pmax_v2f64:
 ; SIMD128-FAST:         .functype pmax_v2f64 (v128, v128) -> (v128)
 ; SIMD128-FAST-NEXT:  # %bb.0:
-; SIMD128-FAST-NEXT:    f64x2.pmax $push0=, $1, $0
+; SIMD128-FAST-NEXT:    f64x2.pmax $push0=, $0, $1
 ; SIMD128-FAST-NEXT:    return $pop0
 ;
 ; NO-SIMD128-LABEL: pmax_v2f64:
 ; NO-SIMD128:         .functype pmax_v2f64 (i32, f64, f64, f64, f64) -> ()
 ; NO-SIMD128-NEXT:  # %bb.0:
 ; NO-SIMD128-NEXT:    f64.lt $push0=, $2, $4
 ; NO-SIMD128-NEXT:    f64.select $push1=, $4, $2, $pop0
 ; NO-SIMD128-NEXT:    f64.store 8($0), $pop1