[turbofan] Revive the useful parts of the SimplifiedOperatorReducer.

This partially reverts https://codereview.chromium.org/1162563002
because we might actually be able to optimize certain combinations
now due to dead code elimination.

R=titzer@chromium.org

Review URL: https://codereview.chromium.org/1202263006

Cr-Commit-Position: refs/heads/master@{#29277}

BUILD.gn

@@ -732,6 +732,8 @@ source_set("v8_base") {
     "src/compiler/select-lowering.h",
     "src/compiler/simplified-lowering.cc",
     "src/compiler/simplified-lowering.h",
+    "src/compiler/simplified-operator-reducer.cc",
+    "src/compiler/simplified-operator-reducer.h",
     "src/compiler/simplified-operator.cc",
     "src/compiler/simplified-operator.h",
     "src/compiler/source-position.cc",

src/compiler/pipeline.cc

@@ -45,6 +45,7 @@
 #include "src/compiler/scheduler.h"
 #include "src/compiler/select-lowering.h"
 #include "src/compiler/simplified-lowering.h"
+#include "src/compiler/simplified-operator-reducer.h"
 #include "src/compiler/tail-call-optimization.h"
 #include "src/compiler/typer.h"
 #include "src/compiler/value-numbering-reducer.h"
@@ -597,12 +598,14 @@ struct SimplifiedLoweringPhase {
     JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     DeadCodeElimination dead_code_elimination(&graph_reducer, data->graph(),
                                               data->common());
-    ValueNumberingReducer vn_reducer(temp_zone);
+    SimplifiedOperatorReducer simple_reducer(data->jsgraph());
+    ValueNumberingReducer value_numbering(temp_zone);
     MachineOperatorReducer machine_reducer(data->jsgraph());
     CommonOperatorReducer common_reducer(&graph_reducer, data->graph(),
                                          data->common(), data->machine());
     AddReducer(data, &graph_reducer, &dead_code_elimination);
-    AddReducer(data, &graph_reducer, &vn_reducer);
+    AddReducer(data, &graph_reducer, &simple_reducer);
+    AddReducer(data, &graph_reducer, &value_numbering);
     AddReducer(data, &graph_reducer, &machine_reducer);
     AddReducer(data, &graph_reducer, &common_reducer);
     graph_reducer.ReduceGraph();
@@ -628,13 +631,15 @@ struct ChangeLoweringPhase {
     JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     DeadCodeElimination dead_code_elimination(&graph_reducer, data->graph(),
                                               data->common());
-    ValueNumberingReducer vn_reducer(temp_zone);
+    SimplifiedOperatorReducer simple_reducer(data->jsgraph());
+    ValueNumberingReducer value_numbering(temp_zone);
     ChangeLowering lowering(data->jsgraph());
     MachineOperatorReducer machine_reducer(data->jsgraph());
     CommonOperatorReducer common_reducer(&graph_reducer, data->graph(),
                                          data->common(), data->machine());
     AddReducer(data, &graph_reducer, &dead_code_elimination);
-    AddReducer(data, &graph_reducer, &vn_reducer);
+    AddReducer(data, &graph_reducer, &simple_reducer);
+    AddReducer(data, &graph_reducer, &value_numbering);
     AddReducer(data, &graph_reducer, &lowering);
     AddReducer(data, &graph_reducer, &machine_reducer);
     AddReducer(data, &graph_reducer, &common_reducer);

src/compiler/simplified-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/simplified-operator-reducer.h"
+
+#include "src/compiler/js-graph.h"
+#include "src/compiler/machine-operator.h"
+#include "src/compiler/node-matchers.h"
+#include "src/compiler/operator-properties.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+SimplifiedOperatorReducer::SimplifiedOperatorReducer(JSGraph* jsgraph)
+    : jsgraph_(jsgraph), simplified_(jsgraph->zone()) {}
+
+
+SimplifiedOperatorReducer::~SimplifiedOperatorReducer() {}
+
+
+Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
+  switch (node->opcode()) {
+    case IrOpcode::kBooleanNot: {
+      HeapObjectMatcher m(node->InputAt(0));
+      if (m.HasValue()) {
+        return Replace(
+            jsgraph()->BooleanConstant(!m.Value().handle()->BooleanValue()));
+      }
+      if (m.IsBooleanNot()) return Replace(m.InputAt(0));
+      break;
+    }
+    case IrOpcode::kChangeBitToBool: {
+      Int32Matcher m(node->InputAt(0));
+      if (m.Is(0)) return Replace(jsgraph()->FalseConstant());
+      if (m.Is(1)) return Replace(jsgraph()->TrueConstant());
+      if (m.IsChangeBoolToBit()) return Replace(m.InputAt(0));
+      break;
+    }
+    case IrOpcode::kChangeBoolToBit: {
+      HeapObjectMatcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceInt32(m.Value().handle()->BooleanValue());
+      if (m.IsChangeBitToBool()) return Replace(m.InputAt(0));
+      break;
+    }
+    case IrOpcode::kChangeFloat64ToTagged: {
+      Float64Matcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceNumber(m.Value());
+      break;
+    }
+    case IrOpcode::kChangeInt32ToTagged: {
+      Int32Matcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceNumber(m.Value());
+      break;
+    }
+    case IrOpcode::kChangeTaggedToFloat64: {
+      NumberMatcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceFloat64(m.Value());
+      if (m.IsChangeFloat64ToTagged()) return Replace(m.node()->InputAt(0));
+      if (m.IsChangeInt32ToTagged()) {
+        return Change(node, machine()->ChangeInt32ToFloat64(), m.InputAt(0));
+      }
+      if (m.IsChangeUint32ToTagged()) {
+        return Change(node, machine()->ChangeUint32ToFloat64(), m.InputAt(0));
+      }
+      break;
+    }
+    case IrOpcode::kChangeTaggedToInt32: {
+      NumberMatcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceInt32(DoubleToInt32(m.Value()));
+      if (m.IsChangeFloat64ToTagged()) {
+        return Change(node, machine()->ChangeFloat64ToInt32(), m.InputAt(0));
+      }
+      if (m.IsChangeInt32ToTagged()) return Replace(m.InputAt(0));
+      break;
+    }
+    case IrOpcode::kChangeTaggedToUint32: {
+      NumberMatcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceUint32(DoubleToUint32(m.Value()));
+      if (m.IsChangeFloat64ToTagged()) {
+        return Change(node, machine()->ChangeFloat64ToUint32(), m.InputAt(0));
+      }
+      if (m.IsChangeUint32ToTagged()) return Replace(m.InputAt(0));
+      break;
+    }
+    case IrOpcode::kChangeUint32ToTagged: {
+      Uint32Matcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceNumber(FastUI2D(m.Value()));
+      break;
+    }
+    default:
+      break;
+  }
+  return NoChange();
+}
+
+
+Reduction SimplifiedOperatorReducer::Change(Node* node, const Operator* op,
+                                            Node* a) {
+  DCHECK_EQ(node->InputCount(), OperatorProperties::GetTotalInputCount(op));
+  DCHECK_LE(1, node->InputCount());
+  node->set_op(op);
+  node->ReplaceInput(0, a);
+  return Changed(node);
+}
+
+
+Reduction SimplifiedOperatorReducer::ReplaceFloat64(double value) {
+  return Replace(jsgraph()->Float64Constant(value));
+}
+
+
+Reduction SimplifiedOperatorReducer::ReplaceInt32(int32_t value) {
+  return Replace(jsgraph()->Int32Constant(value));
+}
+
+
+Reduction SimplifiedOperatorReducer::ReplaceNumber(double value) {
+  return Replace(jsgraph()->Constant(value));
+}
+
+
+Reduction SimplifiedOperatorReducer::ReplaceNumber(int32_t value) {
+  return Replace(jsgraph()->Constant(value));
+}
+
+
+Graph* SimplifiedOperatorReducer::graph() const { return jsgraph()->graph(); }
+
+
+MachineOperatorBuilder* SimplifiedOperatorReducer::machine() const {
+  return jsgraph()->machine();
+}
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

src/compiler/simplified-operator-reducer.h

+// 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.
+
+#ifndef V8_COMPILER_SIMPLIFIED_OPERATOR_REDUCER_H_
+#define V8_COMPILER_SIMPLIFIED_OPERATOR_REDUCER_H_
+
+#include "src/compiler/graph-reducer.h"
+#include "src/compiler/simplified-operator.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// Forward declarations.
+class JSGraph;
+class MachineOperatorBuilder;
+
+
+class SimplifiedOperatorReducer final : public Reducer {
+ public:
+  explicit SimplifiedOperatorReducer(JSGraph* jsgraph);
+  ~SimplifiedOperatorReducer() final;
+
+  Reduction Reduce(Node* node) final;
+
+ private:
+  Reduction Change(Node* node, const Operator* op, Node* a);
+  Reduction ReplaceFloat64(double value);
+  Reduction ReplaceInt32(int32_t value);
+  Reduction ReplaceUint32(uint32_t value) {
+    return ReplaceInt32(bit_cast<int32_t>(value));
+  }
+  Reduction ReplaceNumber(double value);
+  Reduction ReplaceNumber(int32_t value);
+
+  Graph* graph() const;
+  JSGraph* jsgraph() const { return jsgraph_; }
+  MachineOperatorBuilder* machine() const;
+  SimplifiedOperatorBuilder* simplified() { return &simplified_; }
+
+  JSGraph* const jsgraph_;
+  SimplifiedOperatorBuilder simplified_;
+
+  DISALLOW_COPY_AND_ASSIGN(SimplifiedOperatorReducer);
+};
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_COMPILER_SIMPLIFIED_OPERATOR_REDUCER_H_

test/unittests/unittests.gyp

@@ -79,6 +79,7 @@
         'compiler/schedule-unittest.cc',
         'compiler/select-lowering-unittest.cc',
         'compiler/scheduler-unittest.cc',
+        'compiler/simplified-operator-reducer-unittest.cc',
         'compiler/simplified-operator-unittest.cc',
         'compiler/state-values-utils-unittest.cc',
         'compiler/tail-call-optimization-unittest.cc',

tools/gyp/v8.gyp

@@ -566,6 +566,8 @@
         '../../src/compiler/select-lowering.h',
         '../../src/compiler/simplified-lowering.cc',
         '../../src/compiler/simplified-lowering.h',
+        '../../src/compiler/simplified-operator-reducer.cc',
+        '../../src/compiler/simplified-operator-reducer.h',
         '../../src/compiler/simplified-operator.cc',
         '../../src/compiler/simplified-operator.h',
         '../../src/compiler/source-position.cc',