[wasm] Fix constant folding with signalling NaN.

src/compiler/machine-operator-reducer.cc

 // Copyright 2014 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/machine-operator-reducer.h"
 
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/base/ieee754.h"
 #include "src/codegen.h"
@@ skipping 298 matching lines @@
       if (m.left().Is(0)) return ReplaceBool(true);            // 0 <= x => true
       if (m.right().Is(kMaxUInt32)) return ReplaceBool(true);  // x <= M => true
       if (m.IsFoldable()) {                                    // K <= K => K
         return ReplaceBool(m.left().Value() <= m.right().Value());
       }
       if (m.LeftEqualsRight()) return ReplaceBool(true);  // x <= x => true
       break;
     }
     case IrOpcode::kFloat32Sub: {
       Float32BinopMatcher m(node);
-      if (m.right().Is(0) && (copysign(1.0, m.right().Value()) > 0)) {
-        return Replace(m.left().node());  // x - 0 => x
-      }
       if (m.right().IsNaN()) {  // x - NaN => NaN
-        return Replace(m.right().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat32(m.right().Value() - 0.0);
       }
       if (m.left().IsNaN()) {  // NaN - x => NaN
-        return Replace(m.left().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat32(m.left().Value() - 0.0);
       }
       if (m.IsFoldable()) {  // L - R => (L - R)
         return ReplaceFloat32(m.left().Value() - m.right().Value());
       }
       if (m.left().IsMinusZero()) {
         // -0.0 - round_down(-0.0 - R) => round_up(R)
         if (machine()->Float32RoundUp().IsSupported() &&
             m.right().IsFloat32RoundDown()) {
           if (m.right().InputAt(0)->opcode() == IrOpcode::kFloat32Sub) {
             Float32BinopMatcher mright0(m.right().InputAt(0));
             if (mright0.left().IsMinusZero()) {
               return Replace(graph()->NewNode(machine()->Float32RoundUp().op(),
                                               mright0.right().node()));
             }
           }
         }
         // -0.0 - R => -R
         node->RemoveInput(0);
         NodeProperties::ChangeOp(node, machine()->Float32Neg());
         return Changed(node);
       }
       break;
     }
     case IrOpcode::kFloat64Add: {
       Float64BinopMatcher m(node);
       if (m.right().IsNaN()) {  // x + NaN => NaN
-        return Replace(m.right().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat64(m.right().Value() - 0.0);
       }
       if (m.IsFoldable()) {  // K + K => K
         return ReplaceFloat64(m.left().Value() + m.right().Value());
       }
       break;
     }
     case IrOpcode::kFloat64Sub: {
       Float64BinopMatcher m(node);
-      if (m.right().Is(0) && (Double(m.right().Value()).Sign() > 0)) {
-        return Replace(m.left().node());  // x - 0 => x
-      }
       if (m.right().IsNaN()) {  // x - NaN => NaN

[titzer, 2017/01/25 13:28:57]

Can you leave a TODO here that we could still do the original strength reduction
if we know the non-zero input was not a signaling NaN (which is AFAICT the case
for normal JS code?)

-        return Replace(m.right().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat64(m.right().Value() - 0.0);
       }
       if (m.left().IsNaN()) {  // NaN - x => NaN
-        return Replace(m.left().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat64(m.left().Value() - 0.0);
       }
       if (m.IsFoldable()) {  // L - R => (L - R)
         return ReplaceFloat64(m.left().Value() - m.right().Value());
       }
       if (m.left().IsMinusZero()) {
         // -0.0 - round_down(-0.0 - R) => round_up(R)
         if (machine()->Float64RoundUp().IsSupported() &&
             m.right().IsFloat64RoundDown()) {
           if (m.right().InputAt(0)->opcode() == IrOpcode::kFloat64Sub) {
             Float64BinopMatcher mright0(m.right().InputAt(0));
@@ skipping 11 matching lines @@
       break;
     }
     case IrOpcode::kFloat64Mul: {
       Float64BinopMatcher m(node);
       if (m.right().Is(-1)) {  // x * -1.0 => -0.0 - x
         node->ReplaceInput(0, Float64Constant(-0.0));
         node->ReplaceInput(1, m.left().node());
         NodeProperties::ChangeOp(node, machine()->Float64Sub());
         return Changed(node);
       }
-      if (m.right().Is(1)) return Replace(m.left().node());  // x * 1.0 => x
       if (m.right().IsNaN()) {                               // x * NaN => NaN
-        return Replace(m.right().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat64(m.right().Value() - 0.0);
       }
       if (m.IsFoldable()) {  // K * K => K
         return ReplaceFloat64(m.left().Value() * m.right().Value());
       }
       if (m.right().Is(2)) {  // x * 2.0 => x + x
         node->ReplaceInput(1, m.left().node());
         NodeProperties::ChangeOp(node, machine()->Float64Add());
         return Changed(node);
       }
       break;
     }
     case IrOpcode::kFloat64Div: {
       Float64BinopMatcher m(node);
-      if (m.right().Is(1)) return Replace(m.left().node());  // x / 1.0 => x
       if (m.right().IsNaN()) {                               // x / NaN => NaN
-        return Replace(m.right().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat64(m.right().Value() - 0.0);
       }
       if (m.left().IsNaN()) {  // NaN / x => NaN
-        return Replace(m.left().node());
+        // - 0.0 to make a signalling NaN quiet.
+        return ReplaceFloat64(m.left().Value() - 0.0);
       }
       if (m.IsFoldable()) {  // K / K => K
         return ReplaceFloat64(m.left().Value() / m.right().Value());
       }
       if (m.right().Is(-1)) {  // x / -1.0 => -x
         node->RemoveInput(1);
         NodeProperties::ChangeOp(node, machine()->Float64Neg());
         return Changed(node);
       }
       if (m.right().IsNormal() && m.right().IsPositiveOrNegativePowerOf2()) {
@@ skipping 977 matching lines @@
 MachineOperatorBuilder* MachineOperatorReducer::machine() const {
   return jsgraph()->machine();
 }
 
 
 Graph* MachineOperatorReducer::graph() const { return jsgraph()->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8