[wasm] Fixed FxxMin and FxxMax for cases where one operand is NaN.

src/compiler/wasm-compiler.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 "src/compiler/access-builder.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/graph.h"
@@ skipping 597 matching lines @@
       op = m->Float64LessThanOrEqual();
       break;
     case wasm::kExprF64Gt:
       op = m->Float64LessThan();
       std::swap(left, right);
       break;
     case wasm::kExprF64Ge:
       op = m->Float64LessThanOrEqual();
       std::swap(left, right);
       break;
-    case wasm::kExprF32Min: {
-      if (m->Float32Min().IsSupported()) {
-        op = m->Float32Min().op();
-        break;
-      } else {
-        op = UnsupportedOpcode(opcode);
-        break;
-      }
-    }
-    case wasm::kExprF64Min: {
-      if (m->Float64Min().IsSupported()) {
-        op = m->Float64Min().op();
-        break;
-      } else {
-        op = UnsupportedOpcode(opcode);
-        break;
-      }
-    }
-    case wasm::kExprF32Max: {
-      if (m->Float32Max().IsSupported()) {
-        op = m->Float32Max().op();
-        break;
-      } else {
-        op = UnsupportedOpcode(opcode);
-        break;
-      }
-    }
-    case wasm::kExprF64Max: {
-      if (m->Float64Max().IsSupported()) {
-        op = m->Float64Max().op();
-        break;
-      } else {
-        op = UnsupportedOpcode(opcode);
-        break;
-      }
-    }
+    case wasm::kExprF32Min:
+      return BuildF32Min(left, right);
+    case wasm::kExprF64Min:
+      return BuildF64Min(left, right);
+    case wasm::kExprF32Max:
+      return BuildF32Max(left, right);
+    case wasm::kExprF64Max:
+      return BuildF64Max(left, right);
     default:
       op = UnsupportedOpcode(opcode);
   }
   return graph()->NewNode(op, left, right);
 }
 
 
 Node* WasmGraphBuilder::Unop(wasm::WasmOpcode opcode, Node* input) {
   const Operator* op;
   MachineOperatorBuilder* m = jsgraph()->machine();
@@ skipping 320 matching lines @@
       Binop(wasm::kExprI32Ior, Binop(wasm::kExprI32And, high_word_left,
                                      jsgraph()->Int32Constant(0x7fffffff)),
             Binop(wasm::kExprI32And, high_word_right,
                   jsgraph()->Int32Constant(0x80000000)));
 
   return graph()->NewNode(m->Float64InsertHighWord32(), left, new_high_word);
 #endif
 }
 
 
+Node* WasmGraphBuilder::BuildF32Min(Node* left, Node* right) {
+  Diamond left_le_right(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF32Le, left, right));
+
+  Diamond right_lt_left(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF32Lt, right, left));
+
+  Diamond left_is_not_nan(graph(), jsgraph()->common(),
+                          Binop(wasm::kExprF32Eq, left, left));
+
+  return left_le_right.Phi(
+      wasm::kAstF32, left,
+      right_lt_left.Phi(wasm::kAstF32, right,
+                        left_is_not_nan.Phi(wasm::kAstF32, right, left)));
+}
+
+
+Node* WasmGraphBuilder::BuildF32Max(Node* left, Node* right) {
+  Diamond left_ge_right(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF32Ge, left, right));
+
+  Diamond right_gt_left(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF32Gt, right, left));
+
+  Diamond left_is_not_nan(graph(), jsgraph()->common(),
+                          Binop(wasm::kExprF32Eq, left, left));
+
+  return left_ge_right.Phi(
+      wasm::kAstF32, left,
+      right_gt_left.Phi(wasm::kAstF32, right,
+                        left_is_not_nan.Phi(wasm::kAstF32, right, left)));
+}
+
+
+Node* WasmGraphBuilder::BuildF64Min(Node* left, Node* right) {
+  Diamond left_le_right(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF64Le, left, right));
+
+  Diamond right_lt_left(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF64Lt, right, left));
+
+  Diamond left_is_not_nan(graph(), jsgraph()->common(),
+                          Binop(wasm::kExprF64Eq, left, left));
+
+  return left_le_right.Phi(
+      wasm::kAstF64, left,
+      right_lt_left.Phi(wasm::kAstF64, right,
+                        left_is_not_nan.Phi(wasm::kAstF64, right, left)));
+}
+
+
+Node* WasmGraphBuilder::BuildF64Max(Node* left, Node* right) {
+  Diamond left_ge_right(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF64Ge, left, right));
+
+  Diamond right_gt_left(graph(), jsgraph()->common(),
+                        Binop(wasm::kExprF64Lt, right, left));
+
+  Diamond left_is_not_nan(graph(), jsgraph()->common(),
+                          Binop(wasm::kExprF64Eq, left, left));
+
+  return left_ge_right.Phi(
+      wasm::kAstF64, left,
+      right_gt_left.Phi(wasm::kAstF64, right,
+                        left_is_not_nan.Phi(wasm::kAstF64, right, left)));
+}
+
+
 Node* WasmGraphBuilder::BuildI32Ctz(Node* input) {
   //// Implement the following code as TF graph.
   // value = value | (value << 1);
   // value = value | (value << 2);
   // value = value | (value << 4);
   // value = value | (value << 8);
   // value = value | (value << 16);
   // return CountPopulation32(0xffffffff XOR value);
 
   Node* result =
@@ skipping 826 matching lines @@
     code->Disassemble(buffer, os);
   }
 #endif
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8