[turbofan] Allow ReplaceWithValue to kill control.

This allows any AdvancedReducer to remove exception projections from
graphs. This is the common case when JS-operators are being replaced
with pure values. The old NodeProperties::ReplaceWithValue is being
deprecated in favor of AdvancedReducer::ReplaceWithValue.

R=titzer@chromium.org
TEST=unittests/AdvancedReducerTest

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

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

src/compiler/control-reducer.cc

@@ -425,7 +425,7 @@ class ControlReducerImpl final : public AdvancedReducer {
 
 void ControlReducer::ReduceGraph(Zone* zone, JSGraph* jsgraph,
                                  int max_phis_for_select) {
-  GraphReducer graph_reducer(jsgraph->graph(), zone);
+  GraphReducer graph_reducer(zone, jsgraph->graph());
   ControlReducerImpl impl(&graph_reducer, zone, jsgraph);
   impl.max_phis_for_select_ = max_phis_for_select;
   graph_reducer.AddReducer(&impl);

src/compiler/graph-reducer.cc

@@ -25,8 +25,11 @@ enum class GraphReducer::State : uint8_t {
 };
 
 
-GraphReducer::GraphReducer(Graph* graph, Zone* zone)
+GraphReducer::GraphReducer(Zone* zone, Graph* graph, Node* dead_value,
+                           Node* dead_control)
     : graph_(graph),
+      dead_value_(dead_value),
+      dead_control_(dead_control),
       state_(graph, 4),
       reducers_(zone),
       revisit_(zone),
@@ -212,7 +215,7 @@ void GraphReducer::Replace(Node* node, Node* replacement, NodeId max_id) {
 
 void GraphReducer::ReplaceWithValue(Node* node, Node* value, Node* effect,
                                     Node* control) {
-  if (!effect && node->op()->EffectInputCount() > 0) {
+  if (effect == nullptr && node->op()->EffectInputCount() > 0) {
     effect = NodeProperties::GetEffectInput(node);
   }
   if (control == nullptr && node->op()->ControlInputCount() > 0) {
@@ -226,9 +229,11 @@ void GraphReducer::ReplaceWithValue(Node* node, Node* value, Node* effect,
       if (user->opcode() == IrOpcode::kIfSuccess) {
         Replace(user, control);
       } else if (user->opcode() == IrOpcode::kIfException) {
-        // TODO(titzer): replace with dead control from JSGraph, and
-        // require the control reducer to propagate it.
-        UNREACHABLE();
+        for (Edge e : user->use_edges()) {
+          if (NodeProperties::IsValueEdge(e)) e.UpdateTo(dead_value_);
+          if (NodeProperties::IsControlEdge(e)) e.UpdateTo(dead_control_);
+        }
+        user->Kill();
       } else {
         UNREACHABLE();
       }

src/compiler/graph-reducer.h

@@ -77,9 +77,8 @@ class AdvancedReducer : public Reducer {
     // Replace value uses of {node} with {value} and effect uses of {node} with
     // {effect}. If {effect == NULL}, then use the effect input to {node}. All
     // control uses will be relaxed assuming {node} cannot throw.
-    virtual void ReplaceWithValue(Node* node, Node* value,
-                                  Node* effect = nullptr,
-                                  Node* control = nullptr) = 0;
+    virtual void ReplaceWithValue(Node* node, Node* value, Node* effect,
+                                  Node* control) = 0;
   };
 
   explicit AdvancedReducer(Editor* editor) : editor_(editor) {}
@@ -107,15 +106,13 @@ class AdvancedReducer : public Reducer {
   // uses of {node} with the effect and control input to {node}.
   // TODO(turbofan): replace the effect input to {node} with {graph->start()}.
   void RelaxEffectsAndControls(Node* node) {
-    DCHECK_NOT_NULL(editor_);
-    editor_->ReplaceWithValue(node, node, nullptr, nullptr);
+    ReplaceWithValue(node, node, nullptr, nullptr);
   }
 
   // Relax the control uses of {node} by immediately replacing them with the
   // control input to {node}.
   void RelaxControls(Node* node) {
-    DCHECK_NOT_NULL(editor_);
-    editor_->ReplaceWithValue(node, node, node, nullptr);
+    ReplaceWithValue(node, node, node, nullptr);
   }
 
  private:
@@ -124,10 +121,11 @@ class AdvancedReducer : public Reducer {
 
 
 // Performs an iterative reduction of a node graph.
-class GraphReducer final : public AdvancedReducer::Editor {
+class GraphReducer : public AdvancedReducer::Editor {
  public:
-  GraphReducer(Graph* graph, Zone* zone);
-  ~GraphReducer() final;
+  GraphReducer(Zone* zone, Graph* graph, Node* dead_value = nullptr,
+               Node* dead_control = nullptr);
+  ~GraphReducer();
 
   Graph* graph() const { return graph_; }
 
@@ -156,8 +154,8 @@ class GraphReducer final : public AdvancedReducer::Editor {
   // Replace value uses of {node} with {value} and effect uses of {node} with
   // {effect}. If {effect == NULL}, then use the effect input to {node}. All
   // control uses will be relaxed assuming {node} cannot throw.
-  void ReplaceWithValue(Node* node, Node* value, Node* effect = nullptr,
-                        Node* control = nullptr) final;
+  void ReplaceWithValue(Node* node, Node* value, Node* effect,
+                        Node* control) final;
 
   // Replace all uses of {node} with {replacement} if the id of {replacement} is
   // less than or equal to {max_id}. Otherwise, replace all uses of {node} whose
@@ -173,6 +171,8 @@ class GraphReducer final : public AdvancedReducer::Editor {
   void Revisit(Node* node) final;
 
   Graph* const graph_;
+  Node* dead_value_;
+  Node* dead_control_;
   NodeMarker<State> state_;
   ZoneVector<Reducer*> reducers_;
   ZoneStack<Node*> revisit_;

src/compiler/js-inlining.cc

@@ -277,7 +277,7 @@ Reduction JSInliner::Reduce(Node* node) {
   AstGraphBuilder graph_builder(local_zone_, &info, &jsgraph);
   graph_builder.CreateGraph(true, false);
   JSContextSpecializer context_specializer(&jsgraph);
-  GraphReducer graph_reducer(&graph, local_zone_);
+  GraphReducer graph_reducer(local_zone_, &graph);
   graph_reducer.AddReducer(&context_specializer);
   graph_reducer.ReduceGraph();
 

src/compiler/pipeline.cc

@@ -410,6 +410,15 @@ class SourcePositionWrapper final : public Reducer {
 };
 
 
+class JSGraphReducer final : public GraphReducer {
+ public:
+  JSGraphReducer(JSGraph* jsgraph, Zone* zone)
+      : GraphReducer(zone, jsgraph->graph(), jsgraph->TheHoleConstant(),
+                     jsgraph->DeadControl()) {}
+  ~JSGraphReducer() final {}
+};
+
+
 void AddReducer(PipelineData* data, GraphReducer* graph_reducer,
                 Reducer* reducer) {
   if (data->info()->is_source_positions_enabled()) {
@@ -488,7 +497,7 @@ struct ContextSpecializerPhase {
 
   void Run(PipelineData* data, Zone* temp_zone) {
     JSContextSpecializer spec(data->jsgraph());
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     AddReducer(data, &graph_reducer, &spec);
     graph_reducer.ReduceGraph();
   }
@@ -499,7 +508,7 @@ struct InliningPhase {
   static const char* phase_name() { return "inlining"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     JSInliner inliner(&graph_reducer, data->info()->is_inlining_enabled()
                                           ? JSInliner::kGeneralInlining
                                           : JSInliner::kRestrictedInlining,
@@ -535,7 +544,7 @@ struct JSTypeFeedbackPhase {
     TypeFeedbackOracle oracle(data->isolate(), temp_zone,
                               data->info()->unoptimized_code(),
                               data->info()->feedback_vector(), native_context);
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     Handle<GlobalObject> global_object = Handle<GlobalObject>::null();
     if (data->info()->has_global_object()) {
       global_object =
@@ -559,7 +568,7 @@ struct TypedLoweringPhase {
   static const char* phase_name() { return "typed lowering"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     LoadElimination load_elimination;
     JSBuiltinReducer builtin_reducer(data->jsgraph());
     JSTypedLowering typed_lowering(&graph_reducer, data->jsgraph(), temp_zone);
@@ -589,7 +598,7 @@ struct SimplifiedLoweringPhase {
     ValueNumberingReducer vn_reducer(temp_zone);
     MachineOperatorReducer machine_reducer(data->jsgraph());
     CommonOperatorReducer common_reducer(data->jsgraph());
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     AddReducer(data, &graph_reducer, &vn_reducer);
     AddReducer(data, &graph_reducer, &machine_reducer);
     AddReducer(data, &graph_reducer, &common_reducer);
@@ -617,7 +626,7 @@ struct ChangeLoweringPhase {
     ChangeLowering lowering(data->jsgraph());
     MachineOperatorReducer machine_reducer(data->jsgraph());
     CommonOperatorReducer common_reducer(data->jsgraph());
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     AddReducer(data, &graph_reducer, &vn_reducer);
     AddReducer(data, &graph_reducer, &lowering);
     AddReducer(data, &graph_reducer, &machine_reducer);
@@ -666,7 +675,7 @@ struct GenericLoweringPhase {
                               data->jsgraph());
     SelectLowering select(data->jsgraph()->graph(), data->jsgraph()->common());
     TailCallOptimization tco(data->common(), data->graph());
-    GraphReducer graph_reducer(data->graph(), temp_zone);
+    JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
     AddReducer(data, &graph_reducer, &generic);
     AddReducer(data, &graph_reducer, &select);
     // TODO(turbofan): TCO is currently limited to stubs.

src/compiler/typer.cc

@@ -439,7 +439,7 @@ void Typer::Run() {
   }
 
   Visitor visitor(this);
-  GraphReducer graph_reducer(graph(), zone());
+  GraphReducer graph_reducer(zone(), graph());
   graph_reducer.AddReducer(&visitor);
   graph_reducer.ReduceGraph();
 }

src/compiler/verifier.cc

@@ -194,7 +194,11 @@ void Verifier::Visitor::Check(Node* node) {
       break;
     case IrOpcode::kDead:
       // Dead is never connected to the graph.
-      UNREACHABLE();
+      // TODO(mstarzinger): Make the GraphReducer immediately perform control
+      // reduction in case control is killed. This will prevent {Dead} from
+      // being reachable after a phase finished. Then re-enable below assert.
+      // UNREACHABLE();
+      break;
     case IrOpcode::kBranch: {
       // Branch uses are IfTrue and IfFalse.
       int count_true = 0, count_false = 0;

test/cctest/cctest.status

@@ -97,9 +97,6 @@
   ##############################################################################
   # TurboFan compiler failures.
 
-  # TODO(mstarzinger): control edges are messed up in exception tests.
-  'test-run-jsexceptions/*': [PASS, NO_VARIANTS],
-
   # Some tests are just too slow to run for now.
   'test-api/Threading*': [PASS, NO_VARIANTS],
   'test-heap/IncrementalMarkingStepMakesBigProgressWithLargeObjects': [PASS, NO_VARIANTS],

test/cctest/compiler/test-changes-lowering.cc

@@ -130,7 +130,7 @@ class ChangesLoweringTester : public GraphBuilderTester<ReturnType> {
     typer.Run();
     ChangeLowering change_lowering(&jsgraph);
     SelectLowering select_lowering(this->graph(), this->common());
-    GraphReducer reducer(this->graph(), this->zone());
+    GraphReducer reducer(this->zone(), this->graph());
     reducer.AddReducer(&change_lowering);
     reducer.AddReducer(&select_lowering);
     reducer.ReduceNode(change);

test/cctest/compiler/test-js-context-specialization.cc

@@ -231,7 +231,7 @@ TEST(SpecializeToContext) {
     CheckEffectInput(load, effect_use);
 
     // Perform the reduction on the entire graph.
-    GraphReducer graph_reducer(t.graph(), t.main_zone());
+    GraphReducer graph_reducer(t.main_zone(), t.graph());
     graph_reducer.AddReducer(&spec);
     graph_reducer.ReduceGraph();
 

test/cctest/compiler/test-js-typed-lowering.cc

@@ -90,7 +90,7 @@ class JSTypedLoweringTester : public HandleAndZoneScope {
   Node* reduce(Node* node) {
     JSGraph jsgraph(main_isolate(), &graph, &common, &javascript, &machine);
     // TODO(titzer): mock the GraphReducer here for better unit testing.
-    GraphReducer graph_reducer(&graph, main_zone());
+    GraphReducer graph_reducer(main_zone(), &graph);
     JSTypedLowering reducer(&graph_reducer, &jsgraph, main_zone());
     Reduction reduction = reducer.Reduce(node);
     if (reduction.Changed()) return reduction.replacement();

test/cctest/compiler/test-run-jsexceptions.cc

@@ -13,10 +13,7 @@ TEST(Throw) {
   i::FLAG_turbo_exceptions = true;
   FunctionTester T("(function(a,b) { if (a) { throw b; } else { return b; }})");
 
-// TODO(mstarzinger)
-#if 0
   T.CheckThrows(T.true_value(), T.NewObject("new Error"));
-#endif
   T.CheckCall(T.Val(23), T.false_value(), T.Val(23));
 }
 
@@ -56,14 +53,11 @@ TEST(ThrowMessageDirectly) {
   FunctionTester T(src);
   v8::Handle<v8::Message> message;
 
-// TODO(mstarzinger)
-#if 0
   message = T.CheckThrowsReturnMessage(T.false_value(), T.Val("Wat?"));
   CHECK(message->Get()->Equals(v8_str("Uncaught Error: Wat?")));
 
   message = T.CheckThrowsReturnMessage(T.true_value(), T.Val("Kaboom!"));
   CHECK(message->Get()->Equals(v8_str("Uncaught Kaboom!")));
-#endif
 }
 
 
@@ -80,14 +74,11 @@ TEST(ThrowMessageIndirectly) {
   FunctionTester T(src);
   v8::Handle<v8::Message> message;
 
-// TODO(mstarzinger)
-#if 0
   message = T.CheckThrowsReturnMessage(T.false_value(), T.Val("Wat?"));
   CHECK(message->Get()->Equals(v8_str("Uncaught Error: Wat?")));
 
   message = T.CheckThrowsReturnMessage(T.true_value(), T.Val("Kaboom!"));
   CHECK(message->Get()->Equals(v8_str("Uncaught Kaboom!")));
-#endif
 }
 
 

test/cctest/compiler/test-simplified-lowering.cc

@@ -60,7 +60,7 @@ class SimplifiedLoweringTester : public GraphBuilderTester<ReturnType> {
     lowering.LowerAllNodes();
 
     ChangeLowering lowering(&jsgraph);
-    GraphReducer reducer(this->graph(), this->zone());
+    GraphReducer reducer(this->zone(), this->graph());
     reducer.AddReducer(&lowering);
     reducer.ReduceGraph();
     Verifier::Run(this->graph());

test/unittests/compiler/graph-reducer-unittest.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
@@ -10,9 +11,11 @@
 
 using testing::_;
 using testing::DefaultValue;
+using testing::ElementsAre;
 using testing::Return;
 using testing::Sequence;
 using testing::StrictMock;
+using testing::UnorderedElementsAre;
 
 namespace v8 {
 namespace internal {
@@ -264,6 +267,124 @@ TEST_F(AdvancedReducerTest, Revisit) {
 }
 
 
+namespace {
+
+struct ReplaceWithValueReducer final : public AdvancedReducer {
+  explicit ReplaceWithValueReducer(Editor* editor) : AdvancedReducer(editor) {}
+  Reduction Reduce(Node* node) final { return NoChange(); }
+  using AdvancedReducer::ReplaceWithValue;
+};
+
+const Operator kMockOperator(IrOpcode::kDead, Operator::kNoProperties,
+                             "MockOperator", 0, 0, 0, 1, 0, 0);
+const Operator kMockOpEffect(IrOpcode::kDead, Operator::kNoProperties,
+                             "MockOpEffect", 0, 1, 0, 1, 1, 0);
+const Operator kMockOpControl(IrOpcode::kDead, Operator::kNoProperties,
+                              "MockOpControl", 0, 0, 1, 1, 0, 1);
+
+const IfExceptionHint kNoHint = IfExceptionHint::kLocallyCaught;
+
+}  // namespace
+
+
+TEST_F(AdvancedReducerTest, ReplaceWithValue_ValueUse) {
+  CommonOperatorBuilder common(zone());
+  Node* node = graph()->NewNode(&kMockOperator);
+  Node* use_value = graph()->NewNode(common.Return(), node);
+  Node* replacement = graph()->NewNode(&kMockOperator);
+  GraphReducer graph_reducer(zone(), graph(), nullptr, nullptr);
+  ReplaceWithValueReducer r(&graph_reducer);
+  r.ReplaceWithValue(node, replacement);
+  EXPECT_EQ(replacement, use_value->InputAt(0));
+  EXPECT_EQ(0, node->UseCount());
+  EXPECT_EQ(1, replacement->UseCount());
+  EXPECT_THAT(replacement->uses(), ElementsAre(use_value));
+}
+
+
+TEST_F(AdvancedReducerTest, ReplaceWithValue_EffectUse) {
+  CommonOperatorBuilder common(zone());
+  Node* start = graph()->NewNode(common.Start(1));
+  Node* node = graph()->NewNode(&kMockOpEffect, start);
+  Node* use_effect = graph()->NewNode(common.EffectPhi(1), node);
+  Node* replacement = graph()->NewNode(&kMockOperator);
+  GraphReducer graph_reducer(zone(), graph(), nullptr, nullptr);
+  ReplaceWithValueReducer r(&graph_reducer);
+  r.ReplaceWithValue(node, replacement);
+  EXPECT_EQ(start, use_effect->InputAt(0));
+  EXPECT_EQ(0, node->UseCount());
+  EXPECT_EQ(2, start->UseCount());
+  EXPECT_EQ(0, replacement->UseCount());
+  EXPECT_THAT(start->uses(), UnorderedElementsAre(use_effect, node));
+}
+
+
+TEST_F(AdvancedReducerTest, ReplaceWithValue_ControlUse1) {
+  CommonOperatorBuilder common(zone());
+  Node* start = graph()->NewNode(common.Start(1));
+  Node* node = graph()->NewNode(&kMockOpControl, start);
+  Node* success = graph()->NewNode(common.IfSuccess(), node);
+  Node* use_control = graph()->NewNode(common.Merge(1), success);
+  Node* replacement = graph()->NewNode(&kMockOperator);
+  GraphReducer graph_reducer(zone(), graph(), nullptr, nullptr);
+  ReplaceWithValueReducer r(&graph_reducer);
+  r.ReplaceWithValue(node, replacement);
+  EXPECT_EQ(start, use_control->InputAt(0));
+  EXPECT_EQ(0, node->UseCount());
+  EXPECT_EQ(2, start->UseCount());
+  EXPECT_EQ(0, replacement->UseCount());
+  EXPECT_THAT(start->uses(), UnorderedElementsAre(use_control, node));
+}
+
+
+TEST_F(AdvancedReducerTest, ReplaceWithValue_ControlUse2) {
+  CommonOperatorBuilder common(zone());
+  Node* start = graph()->NewNode(common.Start(1));
+  Node* dead = graph()->NewNode(&kMockOperator);
+  Node* node = graph()->NewNode(&kMockOpControl, start);
+  Node* success = graph()->NewNode(common.IfSuccess(), node);
+  Node* exception = graph()->NewNode(common.IfException(kNoHint), node);
+  Node* use_control = graph()->NewNode(common.Merge(1), success);
+  Node* use_exception_control = graph()->NewNode(common.Merge(1), exception);
+  Node* replacement = graph()->NewNode(&kMockOperator);
+  GraphReducer graph_reducer(zone(), graph(), nullptr, dead);
+  ReplaceWithValueReducer r(&graph_reducer);
+  r.ReplaceWithValue(node, replacement);
+  EXPECT_EQ(start, use_control->InputAt(0));
+  EXPECT_EQ(dead, use_exception_control->InputAt(0));
+  EXPECT_EQ(0, node->UseCount());
+  EXPECT_EQ(2, start->UseCount());
+  EXPECT_EQ(1, dead->UseCount());
+  EXPECT_EQ(0, replacement->UseCount());
+  EXPECT_THAT(start->uses(), UnorderedElementsAre(use_control, node));
+  EXPECT_THAT(dead->uses(), ElementsAre(use_exception_control));
+}
+
+
+TEST_F(AdvancedReducerTest, ReplaceWithValue_ControlUse3) {
+  CommonOperatorBuilder common(zone());
+  Node* start = graph()->NewNode(common.Start(1));
+  Node* dead = graph()->NewNode(&kMockOperator);
+  Node* node = graph()->NewNode(&kMockOpControl, start);
+  Node* success = graph()->NewNode(common.IfSuccess(), node);
+  Node* exception = graph()->NewNode(common.IfException(kNoHint), node);
+  Node* use_control = graph()->NewNode(common.Merge(1), success);
+  Node* use_exception_value = graph()->NewNode(common.Return(), exception);
+  Node* replacement = graph()->NewNode(&kMockOperator);
+  GraphReducer graph_reducer(zone(), graph(), dead, nullptr);
+  ReplaceWithValueReducer r(&graph_reducer);
+  r.ReplaceWithValue(node, replacement);
+  EXPECT_EQ(start, use_control->InputAt(0));
+  EXPECT_EQ(dead, use_exception_value->InputAt(0));
+  EXPECT_EQ(0, node->UseCount());
+  EXPECT_EQ(2, start->UseCount());
+  EXPECT_EQ(1, dead->UseCount());
+  EXPECT_EQ(0, replacement->UseCount());
+  EXPECT_THAT(start->uses(), UnorderedElementsAre(use_control, node));
+  EXPECT_THAT(dead->uses(), ElementsAre(use_exception_value));
+}
+
+
 class GraphReducerTest : public TestWithZone {
  public:
   GraphReducerTest() : graph_(zone()) {}
@@ -280,20 +401,20 @@ class GraphReducerTest : public TestWithZone {
 
  protected:
   void ReduceNode(Node* node, Reducer* r) {
-    GraphReducer reducer(graph(), zone());
+    GraphReducer reducer(zone(), graph());
     reducer.AddReducer(r);
     reducer.ReduceNode(node);
   }
 
   void ReduceNode(Node* node, Reducer* r1, Reducer* r2) {
-    GraphReducer reducer(graph(), zone());
+    GraphReducer reducer(zone(), graph());
     reducer.AddReducer(r1);
     reducer.AddReducer(r2);
     reducer.ReduceNode(node);
   }
 
   void ReduceNode(Node* node, Reducer* r1, Reducer* r2, Reducer* r3) {
-    GraphReducer reducer(graph(), zone());
+    GraphReducer reducer(zone(), graph());
     reducer.AddReducer(r1);
     reducer.AddReducer(r2);
     reducer.AddReducer(r3);
@@ -301,20 +422,20 @@ class GraphReducerTest : public TestWithZone {
   }
 
   void ReduceGraph(Reducer* r1) {
-    GraphReducer reducer(graph(), zone());
+    GraphReducer reducer(zone(), graph());
     reducer.AddReducer(r1);
     reducer.ReduceGraph();
   }
 
   void ReduceGraph(Reducer* r1, Reducer* r2) {
-    GraphReducer reducer(graph(), zone());
+    GraphReducer reducer(zone(), graph());
     reducer.AddReducer(r1);
     reducer.AddReducer(r2);
     reducer.ReduceGraph();
   }
 
   void ReduceGraph(Reducer* r1, Reducer* r2, Reducer* r3) {
-    GraphReducer reducer(graph(), zone());
+    GraphReducer reducer(zone(), graph());
     reducer.AddReducer(r1);
     reducer.AddReducer(r2);
     reducer.AddReducer(r3);

test/unittests/compiler/js-intrinsic-lowering-unittest.cc

@@ -34,7 +34,7 @@ class JSIntrinsicLoweringTest : public GraphTest {
     MachineOperatorBuilder machine(zone(), kMachPtr, flags);
     JSGraph jsgraph(isolate(), graph(), common(), javascript(), &machine);
     // TODO(titzer): mock the GraphReducer here for better unit testing.
-    GraphReducer graph_reducer(graph(), zone());
+    GraphReducer graph_reducer(zone(), graph());
     JSIntrinsicLowering reducer(&graph_reducer, &jsgraph,
                                 JSIntrinsicLowering::kDeoptimizationEnabled);
     return reducer.Reduce(node);

test/unittests/compiler/js-type-feedback-unittest.cc

@@ -43,7 +43,7 @@ class JSTypeFeedbackTest : public TypedGraphTest {
     JSGraph jsgraph(isolate(), graph(), common(), javascript(), &machine);
     JSTypeFeedbackTable table(zone());
     // TODO(titzer): mock the GraphReducer here for better unit testing.
-    GraphReducer graph_reducer(graph(), zone());
+    GraphReducer graph_reducer(zone(), graph());
     JSTypeFeedbackSpecializer reducer(&graph_reducer, &jsgraph, &table, nullptr,
                                       global_object, mode, &dependencies_);
     return reducer.Reduce(node);

test/unittests/compiler/js-typed-lowering-unittest.cc

@@ -81,7 +81,7 @@ class JSTypedLoweringTest : public TypedGraphTest {
     MachineOperatorBuilder machine(zone());
     JSGraph jsgraph(isolate(), graph(), common(), javascript(), &machine);
     // TODO(titzer): mock the GraphReducer here for better unit testing.
-    GraphReducer graph_reducer(graph(), zone());
+    GraphReducer graph_reducer(zone(), graph());
     JSTypedLowering reducer(&graph_reducer, &jsgraph, zone());
     return reducer.Reduce(node);
   }