[turbofan] Deprecate NodeProperties::ReplaceWithValue.

src/compiler/js-generic-lowering.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/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 177 matching lines @@
     case Token::GTE:  // a >= 0 becomes !(a < 0)
       op = machine()->IntLessThan();
       std::swap(true_value, false_value);
       break;
     default:
       UNREACHABLE();
   }
   Node* booleanize = graph()->NewNode(op, compare, jsgraph()->ZeroConstant());
 
   // Finally patch the original node to select a boolean.
-  NodeProperties::ReplaceWithValue(node, node, compare);
+  NodeProperties::ReplaceUses(node, node, compare, compare, compare);
   // TODO(mstarzinger): Just a work-around because SelectLowering might
   // otherwise introduce a Phi without any uses, making Scheduler unhappy.
   if (node->UseCount() == 0) return;
   node->TrimInputCount(3);
   node->ReplaceInput(0, booleanize);
   node->ReplaceInput(1, true_value);
   node->ReplaceInput(2, false_value);
   node->set_op(common()->Select(kMachAnyTagged));
 }
 
@@ skipping 233 matching lines @@
       machine()->Store(StoreRepresentation(kMachAnyTagged, kFullWriteBarrier)));
 }
 
 
 void JSGenericLowering::LowerJSLoadDynamicGlobal(Node* node) {
   const DynamicGlobalAccess& access = DynamicGlobalAccessOf(node->op());
   Runtime::FunctionId function_id =
       (access.mode() == CONTEXTUAL) ? Runtime::kLoadLookupSlot
                                     : Runtime::kLoadLookupSlotNoReferenceError;
   Node* projection = graph()->NewNode(common()->Projection(0), node);
-  NodeProperties::ReplaceWithValue(node, projection, node, node);
+  NodeProperties::ReplaceUses(node, projection, node, node, node);
   node->RemoveInput(NodeProperties::FirstFrameStateIndex(node) + 1);
   node->RemoveInput(NodeProperties::FirstValueIndex(node));
   node->InsertInput(zone(), 1, jsgraph()->Constant(access.name()));
   ReplaceWithRuntimeCall(node, function_id);
   projection->ReplaceInput(0, node);
 }
 
 
 void JSGenericLowering::LowerJSLoadDynamicContext(Node* node) {
   const DynamicContextAccess& access = DynamicContextAccessOf(node->op());
   Node* projection = graph()->NewNode(common()->Projection(0), node);
-  NodeProperties::ReplaceWithValue(node, projection, node, node);
+  NodeProperties::ReplaceUses(node, projection, node, node, node);
   node->InsertInput(zone(), 1, jsgraph()->Constant(access.name()));
   ReplaceWithRuntimeCall(node, Runtime::kLoadLookupSlot);
   projection->ReplaceInput(0, node);
 }
 
 
 void JSGenericLowering::LowerJSCreateClosure(Node* node) {
   CreateClosureParameters p = CreateClosureParametersOf(node->op());
   node->InsertInput(zone(), 1, jsgraph()->HeapConstant(p.shared_info()));
   node->InsertInput(zone(), 2, jsgraph()->BooleanConstant(p.pretenure()));
@@ skipping 266 matching lines @@
       graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_length_true0,
                        cache_length_false0, control);
   cache_type = graph()->NewNode(common()->Phi(kMachAnyTagged, 2),
                                 cache_type_true0, cache_type_false0, control);
 
   for (auto edge : node->use_edges()) {
     if (NodeProperties::IsEffectEdge(edge)) {
       edge.UpdateTo(effect);
     } else if (NodeProperties::IsControlEdge(edge)) {
       Node* const use = edge.from();
-      DCHECK_EQ(IrOpcode::kIfSuccess, use->opcode());
-      use->ReplaceUses(control);
-      use->Kill();
+      if (use->opcode() == IrOpcode::kIfSuccess) {
+        use->ReplaceUses(control);
+        use->Kill();
+      } else if (use->opcode() == IrOpcode::kIfException) {
+        edge.UpdateTo(cache_type_true0);
+      } else {
+        UNREACHABLE();
+      }
     } else {
       Node* const use = edge.from();
       DCHECK(NodeProperties::IsValueEdge(edge));
       DCHECK_EQ(IrOpcode::kProjection, use->opcode());
       switch (ProjectionIndexOf(use->op())) {
         case 0:
           use->ReplaceUses(cache_type);
           break;
         case 1:
           use->ReplaceUses(cache_array);
@@ skipping 34 matching lines @@
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   NodeProperties::ReplaceControlInput(node, if_false);
   Node* efalse = node;
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
   Node* ephi = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, merge);
 
-  // Relax controls of {node}, i.e. make it free floating.
-  NodeProperties::ReplaceWithValue(node, node, ephi, merge);
+  // Wire the new diamond into the graph, {node} can still throw.
+  NodeProperties::ReplaceUses(node, node, ephi, node, node);
   NodeProperties::ReplaceEffectInput(ephi, efalse, 1);
 
+  // TODO(mstarzinger): This iteration cuts out the IfSuccess projection from
+  // the node and places it inside the diamond. Come up with a helper method!
+  for (Node* use : node->uses()) {
+    if (use->opcode() == IrOpcode::kIfSuccess) {
+      use->ReplaceUses(merge);
+      merge->ReplaceInput(1, use);
+    }
+  }
+
   // Turn the stack check into a runtime call.
   ReplaceWithRuntimeCall(node, Runtime::kStackGuard);
 }
 
 
 Zone* JSGenericLowering::zone() const { return graph()->zone(); }
 
 
 Isolate* JSGenericLowering::isolate() const { return jsgraph()->isolate(); }
 
 
 Graph* JSGenericLowering::graph() const { return jsgraph()->graph(); }
 
 
 CommonOperatorBuilder* JSGenericLowering::common() const {
   return jsgraph()->common();
 }
 
 
 MachineOperatorBuilder* JSGenericLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8