[turbofan] Add Float32(Max|Min) machine operators.

test/cctest/wasm/test-run-wasm.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/platform/elapsed-timer.h"
-
+#include "src/utils.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/test-signatures.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
@@ skipping 2518 matching lines @@
 
   FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(F32Min) {
   WasmRunner<float> r(execution_mode, MachineType::Float32(),
                       MachineType::Float32());
   BUILD(r, WASM_F32_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT32_INPUTS(i) {
-    FOR_FLOAT32_INPUTS(j) {
-      float expected;
-      if (*i < *j) {
-        expected = *i;
-      } else if (*j < *i) {
-        expected = *j;
-      } else if (*i != *i) {
-        // If *i or *j is NaN, then the result is NaN.
-        expected = *i;
-      } else {
-        expected = *j;
-      }
-
-      CHECK_FLOAT_EQ(expected, r.Call(*i, *j));
-    }
+    FOR_FLOAT32_INPUTS(j) { CHECK_DOUBLE_EQ(JSMin(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(F64Min) {
   WasmRunner<double> r(execution_mode, MachineType::Float64(),
                        MachineType::Float64());
   BUILD(r, WASM_F64_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT64_INPUTS(i) {
-    FOR_FLOAT64_INPUTS(j) {
-      double result = r.Call(*i, *j);
-      if (std::isnan(*i) || std::isnan(*j)) {
-        // If one of the inputs is nan, the result should be nan.
-        CHECK(std::isnan(result));
-      } else if ((*i == 0.0) && (*j == 0.0) &&
-                 (copysign(1.0, *i) != copysign(1.0, *j))) {
-        // If one input is +0.0 and the other input is -0.0, the result should
-        // be -0.0.
-        CHECK_EQ(bit_cast<uint64_t>(-0.0), bit_cast<uint64_t>(result));
-      } else {
-        double expected = *i < *j ? *i : *j;
-        CHECK_DOUBLE_EQ(expected, result);
-      }
-    }
+    FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(JSMin(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(F32Max) {
   WasmRunner<float> r(execution_mode, MachineType::Float32(),
                       MachineType::Float32());
   BUILD(r, WASM_F32_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT32_INPUTS(i) {
-    FOR_FLOAT32_INPUTS(j) {
-      float expected;
-      if (*i > *j) {
-        expected = *i;
-      } else if (*j > *i) {
-        expected = *j;
-      } else if (*i != *i) {
-        // If *i or *j is NaN, then the result is NaN.
-        expected = *i;
-      } else {
-        expected = *j;
-      }
-
-      CHECK_FLOAT_EQ(expected, r.Call(*i, *j));
-    }
+    FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(JSMax(*i, *j), r.Call(*i, *j)); }
   }
 }
 
 WASM_EXEC_TEST(F64Max) {
   WasmRunner<double> r(execution_mode, MachineType::Float64(),
                        MachineType::Float64());
   BUILD(r, WASM_F64_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_FLOAT64_INPUTS(i) {
     FOR_FLOAT64_INPUTS(j) {
       double result = r.Call(*i, *j);
-      if (std::isnan(*i) || std::isnan(*j)) {
-        // If one of the inputs is nan, the result should be nan.
-        CHECK(std::isnan(result));
-      } else if ((*i == 0.0) && (*j == 0.0) &&
-                 (copysign(1.0, *i) != copysign(1.0, *j))) {
-        // If one input is +0.0 and the other input is -0.0, the result should
-        // be -0.0.
-        CHECK_EQ(bit_cast<uint64_t>(0.0), bit_cast<uint64_t>(result));
-      } else {
-        double expected = *i > *j ? *i : *j;
-        CHECK_DOUBLE_EQ(expected, result);
-      }
+      CHECK_DOUBLE_EQ(JSMax(*i, *j), result);
     }
   }
 }
 
 WASM_EXEC_TEST(I32SConvertF32) {
   WasmRunner<int32_t> r(execution_mode, MachineType::Float32());
   BUILD(r, WASM_I32_SCONVERT_F32(WASM_GET_LOCAL(0)));
 
   // The upper bound is (INT32_MAX + 1), which is the lowest float-representable
   // number above INT32_MAX which cannot be represented as int32.
@@ skipping 124 matching lines @@
                         MachineType::Int32());
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_ZERO);
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_EQ(0, r.Call(133, 100));
   CHECK_EQ(0, r.Call(kMin, -1));
   CHECK_EQ(0, r.Call(0, 1));
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
 }