[turbofan] add some simplifications in the machine operator reducer

test/cctest/compiler/test-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 "test/cctest/cctest.h"
 
 #include "src/base/utils/random-number-generator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator-reducer.h"
@@ skipping 146 matching lines @@
     CHECK_EQ(op_expect->opcode(), r.replacement()->op()->opcode());
     CHECK_EQ(left_expect, r.replacement()->InputAt(0));
     CHECK_EQ(right_expect, ValueOf<T>(r.replacement()->InputAt(1)->op()));
   }
 
   // Check that if the given constant appears on the left, the reducer will
   // swap it to be on the right.
   template <typename T>
   void CheckPutConstantOnRight(volatile T constant) {
     // TODO(titzer): CHECK(binop->HasProperty(Operator::kCommutative));
+    Double tmp(static_cast<double>(constant));
+    if (tmp.IsSpecial() && !tmp.IsInfinite()) {

[titzer, 2014/09/25 09:08:41]

I would prefer to have this check in the callers.

[vincent.belliard, 2014/09/25 09:51:18]

Done.

+      // Don't check NaNs as they are reduced more.
+      return;
+    }
     Node* p = Parameter();
     Node* k = Constant<T>(constant);
     {
       Node* n = graph.NewNode(binop, k, p);
       MachineOperatorReducer reducer(&jsgraph);
       Reduction reduction = reducer.Reduce(n);
       CHECK(!reduction.Changed() || reduction.replacement() == n);
       CHECK_EQ(p, n->InputAt(0));
       CHECK_EQ(k, n->InputAt(1));
     }
@@ skipping 503 matching lines @@
 
 static void CheckNans(ReducerTester* R) {
   Node* x = R->Parameter();
   std::vector<double> nans = ValueHelper::nan_vector();
   for (std::vector<double>::const_iterator pl = nans.begin(); pl != nans.end();
        ++pl) {
     for (std::vector<double>::const_iterator pr = nans.begin();
          pr != nans.end(); ++pr) {
       Node* nan1 = R->Constant<double>(*pl);
       Node* nan2 = R->Constant<double>(*pr);
-      R->CheckBinop(nan1, x, nan1);     // x % NaN => NaN
-      R->CheckBinop(nan1, nan1, x);     // NaN % x => NaN
-      R->CheckBinop(nan1, nan2, nan1);  // NaN % NaN => NaN
+      R->CheckBinop(nan1, x, nan1);     // x op NaN => NaN
+      R->CheckBinop(nan1, nan1, x);     // NaN op x => NaN
+      R->CheckBinop(nan1, nan2, nan1);  // NaN op NaN => NaN
     }
   }
 }
 
 
 TEST(ReduceFloat64Add) {
   ReducerTester R;
   R.binop = R.machine.Float64Add();
 
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       double x = *pl, y = *pr;
       R.CheckFoldBinop<double>(x + y, x, y);
     }
   }
 
   FOR_FLOAT64_INPUTS(i) { R.CheckPutConstantOnRight(*i); }
-  // TODO(titzer): CheckNans(&R);
+
+  CheckNans(&R);
 }
 
 
 TEST(ReduceFloat64Sub) {
   ReducerTester R;
   R.binop = R.machine.Float64Sub();
 
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       double x = *pl, y = *pr;
       R.CheckFoldBinop<double>(x - y, x, y);
     }
   }
-  // TODO(titzer): CheckNans(&R);
+
+  Node* zero = R.Constant<double>(0.0);
+  Node* x = R.Parameter();
+
+  R.CheckBinop(x, x, zero);  // x - 0.0 => x
+
+  CheckNans(&R);
 }
 
 
 TEST(ReduceFloat64Mul) {
   ReducerTester R;
   R.binop = R.machine.Float64Mul();
 
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       double x = *pl, y = *pr;
@@ skipping 41 matching lines @@
   ReducerTester R;
   R.binop = R.machine.Float64Mod();
 
   FOR_FLOAT64_INPUTS(pl) {
     FOR_FLOAT64_INPUTS(pr) {
       double x = *pl, y = *pr;
       R.CheckFoldBinop<double>(modulo(x, y), x, y);
     }
   }
 
+  Node* x = R.Parameter();
+  Node* zero = R.Constant<double>(0.0);
+
+  R.CheckFoldBinop<double>(v8::base::OS::nan_value(), x, zero);
+
   CheckNans(&R);
 }
 
 
 // TODO(titzer): test MachineOperatorReducer for Word64And
 // TODO(titzer): test MachineOperatorReducer for Word64Or
 // TODO(titzer): test MachineOperatorReducer for Word64Xor
 // TODO(titzer): test MachineOperatorReducer for Word64Shl
 // TODO(titzer): test MachineOperatorReducer for Word64Shr
 // TODO(titzer): test MachineOperatorReducer for Word64Sar
 // TODO(titzer): test MachineOperatorReducer for Word64Equal
 // TODO(titzer): test MachineOperatorReducer for Word64Not
 // TODO(titzer): test MachineOperatorReducer for Int64Add
 // TODO(titzer): test MachineOperatorReducer for Int64Sub
 // TODO(titzer): test MachineOperatorReducer for Int64Mul
 // TODO(titzer): test MachineOperatorReducer for Int64UMul
 // TODO(titzer): test MachineOperatorReducer for Int64Div
 // TODO(titzer): test MachineOperatorReducer for Int64UDiv
 // TODO(titzer): test MachineOperatorReducer for Int64Mod
 // TODO(titzer): test MachineOperatorReducer for Int64UMod
 // TODO(titzer): test MachineOperatorReducer for Int64Neg
 // TODO(titzer): test MachineOperatorReducer for ChangeInt32ToFloat64
 // TODO(titzer): test MachineOperatorReducer for ChangeFloat64ToInt32
 // TODO(titzer): test MachineOperatorReducer for Float64Compare