[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 669 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);
+  FOR_FLOAT64_INPUTS(i) {
+    Double tmp(*i);
+    if (!tmp.IsSpecial() || tmp.IsInfinite()) {
+      // Don't check NaNs as they are reduced more.
+      R.CheckPutConstantOnRight(*i);
+    }
+  }
+
+  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