[turbofan] Add frame state propagation to linearizer.

src/compiler/effect-control-linearizer.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/effect-control-linearizer.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
@@ skipping 19 matching lines @@
 }
 MachineOperatorBuilder* EffectControlLinearizer::machine() const {
   return js_graph_->machine();
 }
 
 namespace {
 
 struct BlockEffectControlData {
   Node* current_effect = nullptr;  // New effect.
   Node* current_control = nullptr;  // New control.
+  Node* current_frame_state = nullptr;  // New frame state.
 };
 
 // Effect phis that need to be updated after the first pass.
 struct PendingEffectPhi {
   Node* effect_phi;
   BasicBlock* block;
 
   PendingEffectPhi(Node* effect_phi, BasicBlock* block)
       : effect_phi(effect_phi), block(block) {}
 };
@@ skipping 165 matching lines @@
           effect = control;
         }
       }
     }
 
     // Fixup the Terminate node.
     if (terminate != nullptr) {
       NodeProperties::ReplaceEffectInput(terminate, effect);
     }
 
+    // The frame state at block entry is determined by the frame states leaving
+    // all predecessors. In case there is no frame state dominating this block,
+    // we can rely on a checkpoint being present before the next deoptimization.
+    // TODO(mstarzinger): Eventually we will need to go hunt for a frame state
+    // once deoptimizing nodes roam freely through the schedule.
+    Node* frame_state = nullptr;
+    if (block != schedule()->start()) {
+      // If all the predecessors have the same effect, we can use it
+      // as our current effect.
+      int rpo_number = block->PredecessorAt(0)->rpo_number();
+      frame_state = block_effects[rpo_number].current_frame_state;
+      for (size_t i = 1; i < block->PredecessorCount(); i++) {
+        int rpo_number = block->PredecessorAt(i)->rpo_number();
+        if (block_effects[rpo_number].current_frame_state != frame_state) {
+          frame_state = nullptr;
+          break;
+        }
+      }
+    }
+
     // Process the ordinary instructions.
     for (; instr < block->NodeCount(); instr++) {
       Node* node = block->NodeAt(instr);
-      ProcessNode(node, &effect, &control);
+      ProcessNode(node, &frame_state, &effect, &control);
     }
 
     switch (block->control()) {
       case BasicBlock::kGoto:
       case BasicBlock::kNone:
         break;
 
       case BasicBlock::kCall:
       case BasicBlock::kTailCall:
       case BasicBlock::kBranch:
       case BasicBlock::kSwitch:
       case BasicBlock::kReturn:
       case BasicBlock::kDeoptimize:
       case BasicBlock::kThrow:
-        ProcessNode(block->control_input(), &effect, &control);
+        ProcessNode(block->control_input(), &frame_state, &effect, &control);
         break;
     }
 
     // Store the effect for later use.
     block_effects[block->rpo_number()].current_effect = effect;
     block_effects[block->rpo_number()].current_control = control;
+    block_effects[block->rpo_number()].current_frame_state = frame_state;
   }
 
   // Update the incoming edges of the effect phis that could not be processed
   // during the first pass (because they could have incoming back edges).
   for (const PendingEffectPhi& pending_effect_phi : pending_effect_phis) {
     UpdateEffectPhi(pending_effect_phi.effect_phi, pending_effect_phi.block,
                     &block_effects);
   }
   for (BasicBlock* pending_block_control : pending_block_controls) {
     UpdateBlockControl(pending_block_control, &block_effects);
   }
 }
 
 namespace {
 
 void TryScheduleCallIfSuccess(Node* node, Node** control) {
   // Schedule the call's IfSuccess node if there is no exception use.
   if (!NodeProperties::IsExceptionalCall(node)) {
     for (Edge edge : node->use_edges()) {
       if (NodeProperties::IsControlEdge(edge) &&
           edge.from()->opcode() == IrOpcode::kIfSuccess) {
         *control = edge.from();
       }
     }
   }
 }
 
 }  // namespace
 
-void EffectControlLinearizer::ProcessNode(Node* node, Node** effect,
-                                          Node** control) {
+void EffectControlLinearizer::ProcessNode(Node* node, Node** frame_state,
+                                          Node** effect, Node** control) {
   // If the node needs to be wired into the effect/control chain, do this
-  // here.
-  if (TryWireInStateEffect(node, effect, control)) {
+  // here. Pass current frame state for lowering to eager deoptimization.
+  if (TryWireInStateEffect(node, *frame_state, effect, control)) {
     return;
   }
 
+#ifdef DEBUG

[Benedikt Meurer, 2016/06/03 10:53:10]

Nit: Please no DEBUG.

[Michael Starzinger, 2016/06/03 10:59:08]

Done.

+  // If the node has a visible effect, then there must be a checkpoint in the
+  // effect chain before we are allowed to place another eager deoptimization
+  // point. We zap the frame state to ensure this invariant is maintained.
+  if (!node->op()->HasProperty(Operator::kNoWrite)) *frame_state = nullptr;
+#endif
+
   // Remove the end markers of 'atomic' allocation region because the
   // region should be wired-in now.
   if (node->opcode() == IrOpcode::kFinishRegion ||
       node->opcode() == IrOpcode::kBeginRegion) {
     // Update the value uses to the value input of the finish node and
     // the effect uses to the effect input.
     return RemoveRegionNode(node);
   }
 
   // Special treatment for checkpoint nodes.
-  // TODO(epertoso): Pickup the current frame state.
   if (node->opcode() == IrOpcode::kCheckpoint) {
     // Unlink the check point; effect uses will be updated to the incoming
-    // effect that is passed.
+    // effect that is passed. The frame state is preserved for lowering.
+    *frame_state = NodeProperties::GetFrameStateInput(node, 0);
     node->TrimInputCount(0);
     return;
   }
 
   if (node->opcode() == IrOpcode::kIfSuccess) {
     // We always schedule IfSuccess with its call, so skip it here.
     DCHECK_EQ(IrOpcode::kCall, node->InputAt(0)->opcode());
     // The IfSuccess node should not belong to an exceptional call node
     // because such IfSuccess nodes should only start a basic block (and
     // basic block start nodes are not handled in the ProcessNode method).
@@ skipping 29 matching lines @@
   // Update the current control and wire IfSuccess right after calls.
   if (node->op()->ControlOutputCount() > 0) {
     *control = node;
     if (node->opcode() == IrOpcode::kCall) {
       // Schedule the call's IfSuccess node (if there is no exception use).
       TryScheduleCallIfSuccess(node, control);
     }
   }
 }
 
-bool EffectControlLinearizer::TryWireInStateEffect(Node* node, Node** effect,
+bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
+                                                   Node* frame_state,
+                                                   Node** effect,
                                                    Node** control) {
   ValueEffectControl state(nullptr, nullptr, nullptr);
   switch (node->opcode()) {
     case IrOpcode::kTypeGuard:
       state = LowerTypeGuard(node, *effect, *control);
       break;
     case IrOpcode::kChangeBitToTagged:
       state = LowerChangeBitToTagged(node, *effect, *control);
       break;
     case IrOpcode::kChangeInt31ToTaggedSigned:
@@ skipping 20 matching lines @@
     case IrOpcode::kChangeTaggedToUint32:
       state = LowerChangeTaggedToUint32(node, *effect, *control);
       break;
     case IrOpcode::kChangeTaggedToFloat64:
       state = LowerChangeTaggedToFloat64(node, *effect, *control);
       break;
     case IrOpcode::kTruncateTaggedToFloat64:
       state = LowerTruncateTaggedToFloat64(node, *effect, *control);
       break;
     case IrOpcode::kCheckedUint32ToInt32:
-      state = LowerCheckedUint32ToInt32(node, *effect, *control);
+      state = LowerCheckedUint32ToInt32(node, frame_state, *effect, *control);
       break;
     case IrOpcode::kCheckedFloat64ToInt32:
-      state = LowerCheckedFloat64ToInt32(node, *effect, *control);
+      state = LowerCheckedFloat64ToInt32(node, frame_state, *effect, *control);
       break;
     case IrOpcode::kCheckedTaggedToInt32:
-      state = LowerCheckedTaggedToInt32(node, *effect, *control);
+      state = LowerCheckedTaggedToInt32(node, frame_state, *effect, *control);
       break;
     case IrOpcode::kCheckedTaggedToFloat64:
-      state = LowerCheckedTaggedToFloat64(node, *effect, *control);
+      state = LowerCheckedTaggedToFloat64(node, frame_state, *effect, *control);
       break;
     case IrOpcode::kTruncateTaggedToWord32:
       state = LowerTruncateTaggedToWord32(node, *effect, *control);
       break;
     case IrOpcode::kObjectIsCallable:
       state = LowerObjectIsCallable(node, *effect, *control);
       break;
     case IrOpcode::kObjectIsNumber:
       state = LowerObjectIsNumber(node, *effect, *control);
       break;
@@ skipping 300 matching lines @@
 
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
   value = graph()->NewNode(common()->Phi(MachineRepresentation::kFloat64, 2),
                            vtrue, vfalse, control);
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerCheckedUint32ToInt32(Node* node, Node* effect,
+EffectControlLinearizer::LowerCheckedUint32ToInt32(Node* node,
+                                                   Node* frame_state,
+                                                   Node* effect,
                                                    Node* control) {
   Node* value = node->InputAt(0);
-  Node* frame_state = NodeProperties::GetFrameStateInput(node, 0);
   Node* max_int = jsgraph()->Int32Constant(std::numeric_limits<int32_t>::max());
   Node* is_safe =
       graph()->NewNode(machine()->Uint32LessThanOrEqual(), value, max_int);
   control = effect = graph()->NewNode(common()->DeoptimizeUnless(), is_safe,
                                       frame_state, effect, control);
 
   // Make sure the lowered node does not appear in any use lists.
   node->TrimInputCount(0);
 
   return ValueEffectControl(value, effect, control);
@@ skipping 32 matching lines @@
   Node* merge =
       graph()->NewNode(common()->Merge(2), deopt_minus_zero, if_notzero);
 
   effect =
       graph()->NewNode(common()->EffectPhi(2), deopt_minus_zero, effect, merge);
 
   return ValueEffectControl(value32, effect, merge);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerCheckedFloat64ToInt32(Node* node, Node* effect,
+EffectControlLinearizer::LowerCheckedFloat64ToInt32(Node* node,
+                                                    Node* frame_state,
+                                                    Node* effect,
                                                     Node* control) {
   Node* value = node->InputAt(0);
-  Node* frame_state = NodeProperties::GetFrameStateInput(node, 0);
 
   // Make sure the lowered node does not appear in any use lists.
   node->TrimInputCount(0);
 
   return BuildCheckedFloat64ToInt32(value, frame_state, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerCheckedTaggedToInt32(Node* node, Node* effect,
+EffectControlLinearizer::LowerCheckedTaggedToInt32(Node* node,
+                                                   Node* frame_state,
+                                                   Node* effect,
                                                    Node* control) {
   Node* value = node->InputAt(0);
-  Node* frame_state = NodeProperties::GetFrameStateInput(node, 0);
 
   Node* check = ObjectIsSmi(value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   // In the Smi case, just convert to int32.
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = ChangeSmiToInt32(value);
 
@@ skipping 53 matching lines @@
   control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, control);
 
   Node* result = effect = graph()->NewNode(
       simplified()->LoadField(AccessBuilder::ForHeapNumberValue()), value,
       effect, control);
   return ValueEffectControl(result, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
-EffectControlLinearizer::LowerCheckedTaggedToFloat64(Node* node, Node* effect,
+EffectControlLinearizer::LowerCheckedTaggedToFloat64(Node* node,
+                                                     Node* frame_state,
+                                                     Node* effect,
                                                      Node* control) {
   Node* value = node->InputAt(0);
-  Node* frame_state = NodeProperties::GetFrameStateInput(node, 0);
 
   Node* check = ObjectIsSmi(value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   // In the Smi case, just convert to int32 and then float64.
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* etrue = effect;
   Node* vtrue = ChangeSmiToInt32(value);
   vtrue = graph()->NewNode(machine()->ChangeInt32ToFloat64(), vtrue);
@@ skipping 425 matching lines @@
   return isolate()->factory();
 }
 
 Isolate* EffectControlLinearizer::isolate() const {
   return jsgraph()->isolate();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8