[interpreter] Deprecate notion of an unreachable environment.

src/compiler/bytecode-graph-builder.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/bytecode-graph-builder.h"
 
 #include "src/compiler/bytecode-branch-analysis.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/operator-properties.h"
 #include "src/interpreter/bytecodes.h"
@@ skipping 19 matching lines @@
   void ExchangeRegisters(interpreter::Register reg0,
                          interpreter::Register reg1);
 
   void BindAccumulator(Node* node, FrameStateBeforeAndAfter* states = nullptr);
   void BindRegister(interpreter::Register the_register, Node* node,
                     FrameStateBeforeAndAfter* states = nullptr);
   void BindRegistersToProjections(interpreter::Register first_reg, Node* node,
                                   FrameStateBeforeAndAfter* states = nullptr);
   void RecordAfterState(Node* node, FrameStateBeforeAndAfter* states);
 
-  bool IsMarkedAsUnreachable() const;
-  void MarkAsUnreachable();
-
   // Effect dependency tracked by this environment.
   Node* GetEffectDependency() { return effect_dependency_; }
   void UpdateEffectDependency(Node* dependency) {
     effect_dependency_ = dependency;
   }
 
   // Preserve a checkpoint of the environment for the IR graph. Any
   // further mutation of the environment will not affect checkpoints.
   Node* Checkpoint(BailoutId bytecode_offset, OutputFrameStateCombine combine);
 
@@ skipping 247 matching lines @@
   }
 }
 
 
 void BytecodeGraphBuilder::Environment::RecordAfterState(
     Node* node, FrameStateBeforeAndAfter* states) {
   states->AddToNode(node, OutputFrameStateCombine::Ignore());
 }
 
 
-bool BytecodeGraphBuilder::Environment::IsMarkedAsUnreachable() const {
-  return GetControlDependency()->opcode() == IrOpcode::kDead;
-}
-
-
-void BytecodeGraphBuilder::Environment::MarkAsUnreachable() {
-  UpdateControlDependency(builder()->jsgraph()->Dead());
-}
-
-
 BytecodeGraphBuilder::Environment*
 BytecodeGraphBuilder::Environment::CopyForLoop() {
   PrepareForLoop();
   return new (zone()) Environment(this);
 }
 
 
 BytecodeGraphBuilder::Environment*
 BytecodeGraphBuilder::Environment::CopyForConditional() const {
   return new (zone()) Environment(this);
 }
 
 
 void BytecodeGraphBuilder::Environment::Merge(
     BytecodeGraphBuilder::Environment* other) {
-  // Nothing to do if the other environment is dead.
-  if (other->IsMarkedAsUnreachable()) {
-    return;
-  }
-
   // Create a merge of the control dependencies of both environments and update
   // the current environment's control dependency accordingly.
   Node* control = builder()->MergeControl(GetControlDependency(),
                                           other->GetControlDependency());
   UpdateControlDependency(control);
 
   // Create a merge of the effect dependencies of both environments and update
   // the current environment's effect dependency accordingly.
   Node* effect = builder()->MergeEffect(GetEffectDependency(),
                                         other->GetEffectDependency(), control);
@@ skipping 899 matching lines @@
   const Operator* call = javascript()->CallConstruct(
       static_cast<int>(arg_count) + 2, VectorSlotPair());
   Node* value = ProcessCallNewArguments(call, callee, first_arg, arg_count + 2);
   environment()->BindAccumulator(value, &states);
 }
 
 void BytecodeGraphBuilder::VisitNew() { BuildCallConstruct(); }
 
 void BytecodeGraphBuilder::VisitNewWide() { BuildCallConstruct(); }
 
-void BytecodeGraphBuilder::VisitThrow() {
+void BytecodeGraphBuilder::BuildThrowOp(const Operator* call_op) {
   FrameStateBeforeAndAfter states(this);
   Node* value = environment()->LookupAccumulator();
-  Node* call = NewNode(javascript()->CallRuntime(Runtime::kThrow), value);
+  Node* call = NewNode(call_op, value);
   environment()->RecordAfterState(call, &states);
-  Node* control = NewNode(common()->Throw(), value);
-  UpdateControlDependencyToLeaveFunction(control);
+}
+
+void BytecodeGraphBuilder::VisitThrow() {
+  BuildThrowOp(javascript()->CallRuntime(Runtime::kThrow));
+  Node* control =
+      NewNode(common()->Throw(), environment()->LookupAccumulator());
+  MergeControlToLeaveFunction(control);
 }
 
 void BytecodeGraphBuilder::VisitReThrow() {
-  FrameStateBeforeAndAfter states(this);
-  Node* value = environment()->LookupAccumulator();
-  Node* call = NewNode(javascript()->CallRuntime(Runtime::kReThrow), value);
-  environment()->RecordAfterState(call, &states);
-  Node* control = NewNode(common()->Throw(), value);
-  UpdateControlDependencyToLeaveFunction(control);
+  BuildThrowOp(javascript()->CallRuntime(Runtime::kReThrow));
+  Node* control =
+      NewNode(common()->Throw(), environment()->LookupAccumulator());
+  MergeControlToLeaveFunction(control);
 }
 
 void BytecodeGraphBuilder::BuildBinaryOp(const Operator* js_op) {
   FrameStateBeforeAndAfter states(this);
   Node* left =
       environment()->LookupRegister(bytecode_iterator().GetRegisterOperand(0));
   Node* right = environment()->LookupAccumulator();
   Node* node = NewNode(js_op, left, right);
   environment()->BindAccumulator(node, &states);
 }
@@ skipping 254 matching lines @@
   BuildJumpIfEqual(jsgraph()->UndefinedConstant());
 }
 
 void BytecodeGraphBuilder::VisitJumpIfUndefinedConstantWide() {
   BuildJumpIfEqual(jsgraph()->UndefinedConstant());
 }
 
 void BytecodeGraphBuilder::VisitReturn() {
   Node* control =
       NewNode(common()->Return(), environment()->LookupAccumulator());
-  UpdateControlDependencyToLeaveFunction(control);
-  set_environment(nullptr);
+  MergeControlToLeaveFunction(control);
 }
 
 void BytecodeGraphBuilder::BuildForInPrepare() {
   FrameStateBeforeAndAfter states(this);
   Node* receiver = environment()->LookupAccumulator();
   Node* prepare = NewNode(javascript()->ForInPrepare(), receiver);
   environment()->BindRegistersToProjections(
       bytecode_iterator().GetRegisterOperand(0), prepare, &states);
 }
 
@@ skipping 64 matching lines @@
     // but will be eliminated in a later pass.
     // TODO(mstarzinger): Be smarter about this!
     NewMerge();
     merge_environments_[target_offset] = environment();
   } else {
     merge_environments_[target_offset]->Merge(environment());
   }
   set_environment(nullptr);
 }
 
+void BytecodeGraphBuilder::MergeControlToLeaveFunction(Node* exit) {
+  exit_controls_.push_back(exit);
+  set_environment(nullptr);
+}
 
 void BytecodeGraphBuilder::BuildJump() {
   MergeIntoSuccessorEnvironment(bytecode_iterator().GetJumpTargetOffset());
 }
 
 
 void BytecodeGraphBuilder::BuildConditionalJump(Node* condition) {
   NewBranch(condition);
   Environment* if_false_environment = environment()->CopyForConditional();
   NewIfTrue();
@@ skipping 95 matching lines @@
       // with the real frame state.
       *current_input++ = jsgraph()->Dead();
     }
     if (has_effect) {
       *current_input++ = environment()->GetEffectDependency();
     }
     if (has_control) {
       *current_input++ = environment()->GetControlDependency();
     }
     result = graph()->NewNode(op, input_count_with_deps, buffer, incomplete);
-    if (!environment()->IsMarkedAsUnreachable()) {
-      // Update the current control dependency for control-producing nodes.
-      if (NodeProperties::IsControl(result)) {
-        environment()->UpdateControlDependency(result);
-      }
-      // Update the current effect dependency for effect-producing nodes.
-      if (result->op()->EffectOutputCount() > 0) {
-        environment()->UpdateEffectDependency(result);
-      }
-      // Add implicit exception continuation for throwing nodes.
-      if (!result->op()->HasProperty(Operator::kNoThrow) && inside_handler) {
-        int handler_offset = exception_handlers_.top().handler_offset_;
-        // TODO(mstarzinger): Thread through correct prediction!
-        IfExceptionHint hint = IfExceptionHint::kLocallyCaught;
-        Environment* success_env = environment()->CopyForConditional();
-        const Operator* op = common()->IfException(hint);
-        Node* effect = environment()->GetEffectDependency();
-        Node* on_exception = graph()->NewNode(op, effect, result);
-        environment()->UpdateControlDependency(on_exception);
-        environment()->UpdateEffectDependency(on_exception);
-        environment()->BindAccumulator(on_exception);
-        MergeIntoSuccessorEnvironment(handler_offset);
-        set_environment(success_env);
-      }
-      // Add implicit success continuation for throwing nodes.
-      if (!result->op()->HasProperty(Operator::kNoThrow)) {
-        const Operator* if_success = common()->IfSuccess();
-        Node* on_success = graph()->NewNode(if_success, result);
-        environment()->UpdateControlDependency(on_success);
-      }
+    // Update the current control dependency for control-producing nodes.
+    if (NodeProperties::IsControl(result)) {
+      environment()->UpdateControlDependency(result);
+    }
+    // Update the current effect dependency for effect-producing nodes.
+    if (result->op()->EffectOutputCount() > 0) {
+      environment()->UpdateEffectDependency(result);
+    }
+    // Add implicit exception continuation for throwing nodes.
+    if (!result->op()->HasProperty(Operator::kNoThrow) && inside_handler) {
+      int handler_offset = exception_handlers_.top().handler_offset_;
+      // TODO(mstarzinger): Thread through correct prediction!
+      IfExceptionHint hint = IfExceptionHint::kLocallyCaught;
+      Environment* success_env = environment()->CopyForConditional();
+      const Operator* op = common()->IfException(hint);
+      Node* effect = environment()->GetEffectDependency();
+      Node* on_exception = graph()->NewNode(op, effect, result);
+      environment()->UpdateControlDependency(on_exception);
+      environment()->UpdateEffectDependency(on_exception);
+      environment()->BindAccumulator(on_exception);
+      MergeIntoSuccessorEnvironment(handler_offset);
+      set_environment(success_env);
+    }
+    // Add implicit success continuation for throwing nodes.
+    if (!result->op()->HasProperty(Operator::kNoThrow)) {
+      const Operator* if_success = common()->IfSuccess();
+      Node* on_success = graph()->NewNode(if_success, result);
+      environment()->UpdateControlDependency(on_success);
     }
   }
 
   return result;
 }
 
 
 Node* BytecodeGraphBuilder::NewPhi(int count, Node* input, Node* control) {
   const Operator* phi_op = common()->Phi(MachineRepresentation::kTagged, count);
   Node** buffer = EnsureInputBufferSize(count + 1);
@@ skipping 62 matching lines @@
     NodeProperties::ChangeOp(
         value, common()->Phi(MachineRepresentation::kTagged, inputs));
   } else if (value != other) {
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
-
-void BytecodeGraphBuilder::UpdateControlDependencyToLeaveFunction(Node* exit) {
-  if (environment()->IsMarkedAsUnreachable()) return;
-  environment()->MarkAsUnreachable();
-  exit_controls_.push_back(exit);
-}
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8