[turbofan] Turn JSIntrinsicLowering into an AdvancedReducer.

src/compiler/js-intrinsic-lowering.cc

 // Copyright 2015 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/js-intrinsic-lowering.h"
 
 #include <stack>
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-JSIntrinsicLowering::JSIntrinsicLowering(JSGraph* jsgraph)
-    : jsgraph_(jsgraph), simplified_(jsgraph->zone()) {}
+JSIntrinsicLowering::JSIntrinsicLowering(Editor* editor, JSGraph* jsgraph)
+    : AdvancedReducer(editor),
+      jsgraph_(jsgraph),
+      simplified_(jsgraph->zone()) {}
 
 
 Reduction JSIntrinsicLowering::Reduce(Node* node) {
   if (node->opcode() != IrOpcode::kJSCallRuntime) return NoChange();
   const Runtime::Function* const f =
       Runtime::FunctionForId(CallRuntimeParametersOf(node->op()).id());
   if (f->intrinsic_type != Runtime::IntrinsicType::INLINE) return NoChange();
   switch (f->function_id) {
     case Runtime::kInlineConstructDouble:
       return ReduceConstructDouble(node);
@@ skipping 57 matching lines @@
 
 
 Reduction JSIntrinsicLowering::ReduceConstructDouble(Node* node) {
   Node* high = NodeProperties::GetValueInput(node, 0);
   Node* low = NodeProperties::GetValueInput(node, 1);
   Node* value =
       graph()->NewNode(machine()->Float64InsertHighWord32(),
                        graph()->NewNode(machine()->Float64InsertLowWord32(),
                                         jsgraph()->Constant(0), low),
                        high);
-  NodeProperties::ReplaceWithValue(node, value);
+  ReplaceWithValue(node, value);
   return Replace(value);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceDeoptimizeNow(Node* node) {
   // TODO(jarin): This should not depend on the global flag.
   if (!FLAG_turbo_deoptimization) return NoChange();
 
   Node* frame_state = NodeProperties::GetFrameStateInput(node, 0);
   DCHECK_EQ(frame_state->opcode(), IrOpcode::kFrameState);
 
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
 
   // We are making the continuation after the call dead. To
   // model this, we generate if (true) statement with deopt
   // in the true branch and continuation in the false branch.
   Node* branch =
       graph()->NewNode(common()->Branch(), jsgraph()->TrueConstant(), control);
 
   // False branch - the original continuation.
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
-  NodeProperties::ReplaceWithValue(node, jsgraph()->UndefinedConstant(), effect,
-                                   if_false);
+  ReplaceWithValue(node, jsgraph()->UndefinedConstant(), effect, if_false);
 
   // True branch: deopt.
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* deopt =
       graph()->NewNode(common()->Deoptimize(), frame_state, effect, if_true);
 
   // Connect the deopt to the merge exiting the graph.
   NodeProperties::MergeControlToEnd(graph(), common(), deopt);
 
   return Changed(deopt);
@@ skipping 69 matching lines @@
       graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()), value,
                        effect, if_false),
       effect, if_false);
   Node* vfalse = graph()->NewNode(machine()->Word32Equal(), efalse,
                                   jsgraph()->Int32Constant(instance_type));
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
 
   // Replace all effect uses of {node} with the {ephi}.
   Node* ephi = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, merge);
-  NodeProperties::ReplaceWithValue(node, node, ephi);
+  ReplaceWithValue(node, node, ephi);
 
   // Turn the {node} into a Phi.
   return Change(node, common()->Phi(type, 2), vtrue, vfalse, merge);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceIsNonNegativeSmi(Node* node) {
   return Change(node, simplified()->ObjectIsNonNegativeSmi());
 }
 
@@ skipping 40 matching lines @@
 
 Reduction JSIntrinsicLowering::ReduceSeqStringGetChar(
     Node* node, String::Encoding encoding) {
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
   node->set_op(
       simplified()->LoadElement(AccessBuilder::ForSeqStringChar(encoding)));
   node->ReplaceInput(2, effect);
   node->ReplaceInput(3, control);
   node->TrimInputCount(4);
-  NodeProperties::ReplaceWithValue(node, node, node);
+  RelaxControls(node);
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceSeqStringSetChar(
     Node* node, String::Encoding encoding) {
   // Note: The intrinsic has a strange argument order, so we need to reshuffle.
   Node* index = NodeProperties::GetValueInput(node, 0);
   Node* chr = NodeProperties::GetValueInput(node, 1);
   Node* string = NodeProperties::GetValueInput(node, 2);
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
   node->set_op(
       simplified()->StoreElement(AccessBuilder::ForSeqStringChar(encoding)));
   node->ReplaceInput(0, string);
   node->ReplaceInput(1, index);
   node->ReplaceInput(2, chr);
   node->ReplaceInput(3, effect);
   node->ReplaceInput(4, control);
   node->TrimInputCount(5);
   NodeProperties::RemoveBounds(node);
-  NodeProperties::ReplaceWithValue(node, string, node);
+  ReplaceWithValue(node, string, node);
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceStringGetLength(Node* node) {
   Node* value = NodeProperties::GetValueInput(node, 0);
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
   return Change(node, simplified()->LoadField(
                           AccessBuilder::ForStringLength(graph()->zone())),
@@ skipping 12 matching lines @@
         // We have to "look through" ToBoolean calls.
         nodes_to_visit.push(use);
       } else if (use->opcode() == IrOpcode::kBranch) {
         // Actually set the hint on any branch using the intrinsic node.
         use->set_op(common()->Branch(hint));
       }
     }
   }
   // Apart from adding hints to branchs nodes, this is the identity function.
   Node* value = NodeProperties::GetValueInput(node, 0);
-  NodeProperties::ReplaceWithValue(node, value);
+  ReplaceWithValue(node, value);
   return Changed(value);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceValueOf(Node* node) {
   // if (%_IsSmi(value)) {
   //   return value;
   // } else if (%_GetInstanceType(%_GetMap(value)) == JS_VALUE_TYPE) {
   //   return %_GetValue(value);
   // } else {
@@ skipping 40 matching lines @@
 
     Node* merge1 = graph()->NewNode(merge_op, if_true1, if_false1);
     efalse0 = graph()->NewNode(ephi_op, etrue1, efalse1, merge1);
     vfalse0 = graph()->NewNode(phi_op, vtrue1, vfalse1, merge1);
   }
 
   Node* merge0 = graph()->NewNode(merge_op, if_true0, if_false0);
 
   // Replace all effect uses of {node} with the {ephi0}.
   Node* ephi0 = graph()->NewNode(ephi_op, etrue0, efalse0, merge0);
-  NodeProperties::ReplaceWithValue(node, node, ephi0);
+  ReplaceWithValue(node, node, ephi0);
 
   // Turn the {node} into a Phi.
   return Change(node, phi_op, vtrue0, vfalse0, merge0);
 }
 
 
 Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op) {
   // Replace all effect uses of {node} with the effect dependency.
-  NodeProperties::ReplaceWithValue(node, node);
+  RelaxEffectsAndControls(node);
   // Remove the inputs corresponding to context, effect and control.
   NodeProperties::RemoveNonValueInputs(node);
   // Finally update the operator to the new one.
   node->set_op(op);
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceIsMinusZero(Node* node) {
   Node* value = NodeProperties::GetValueInput(node, 0);
   Node* effect = NodeProperties::GetEffectInput(node);
 
   Node* double_lo =
       graph()->NewNode(machine()->Float64ExtractLowWord32(), value);
   Node* check1 = graph()->NewNode(machine()->Word32Equal(), double_lo,
                                   jsgraph()->ZeroConstant());
 
   Node* double_hi =
       graph()->NewNode(machine()->Float64ExtractHighWord32(), value);
   Node* check2 = graph()->NewNode(
       machine()->Word32Equal(), double_hi,
       jsgraph()->Int32Constant(static_cast<int32_t>(0x80000000)));
 
-  NodeProperties::ReplaceWithValue(node, node, effect);
+  ReplaceWithValue(node, node, effect);
 
   Node* and_result = graph()->NewNode(machine()->Word32And(), check1, check2);
 
   return Change(node, machine()->Word32Equal(), and_result,
                 jsgraph()->Int32Constant(1));
 }
 
 
 Reduction JSIntrinsicLowering::ReduceFixedArraySet(Node* node) {
   Node* base = node->InputAt(0);
   Node* index = node->InputAt(1);
   Node* value = node->InputAt(2);
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
   Node* store = (graph()->NewNode(
       simplified()->StoreElement(AccessBuilder::ForFixedArrayElement()), base,
       index, value, effect, control));
-  NodeProperties::ReplaceWithValue(node, value, store);
+  ReplaceWithValue(node, value, store);
   return Changed(store);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceGetTypeFeedbackVector(Node* node) {
   Node* func = node->InputAt(0);
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
   FieldAccess access = AccessBuilder::ForJSFunctionSharedFunctionInfo();
   Node* load =
       graph()->NewNode(simplified()->LoadField(access), func, effect, control);
   access = AccessBuilder::ForSharedFunctionInfoTypeFeedbackVector();
   return Change(node, simplified()->LoadField(access), load, load, control);
 }
 
 
 Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
                                       Node* b) {
   node->set_op(op);
   node->ReplaceInput(0, a);
   node->ReplaceInput(1, b);
   node->TrimInputCount(2);
-  NodeProperties::ReplaceWithValue(node, node, node);
+  RelaxControls(node);
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
                                       Node* b, Node* c) {
   node->set_op(op);
   node->ReplaceInput(0, a);
   node->ReplaceInput(1, b);
   node->ReplaceInput(2, c);
   node->TrimInputCount(3);
-  NodeProperties::ReplaceWithValue(node, node, node);
+  RelaxControls(node);
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::ChangeToUndefined(Node* node, Node* effect) {
-  NodeProperties::ReplaceWithValue(node, jsgraph()->UndefinedConstant(),
-                                   effect);
+  ReplaceWithValue(node, jsgraph()->UndefinedConstant(), effect);
   return Changed(node);
 }
 
 
 Graph* JSIntrinsicLowering::graph() const { return jsgraph()->graph(); }
 
 
 CommonOperatorBuilder* JSIntrinsicLowering::common() const {
   return jsgraph()->common();
 }
 
 
 MachineOperatorBuilder* JSIntrinsicLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8