[turbofan] Introduce explicit loop exits markers.

src/compiler/ast-graph-builder.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/compiler/ast-graph-builder.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
@@ skipping 160 matching lines @@
   enum Command { CMD_BREAK, CMD_CONTINUE, CMD_RETURN, CMD_THROW };
 
   // Performs one of the above commands on this stack of control scopes. This
   // walks through the stack giving each scope a chance to execute or defer the
   // given command by overriding the {Execute} method appropriately. Note that
   // this also drops extra operands from the environment for each skipped scope.
   void PerformCommand(Command cmd, Statement* target, Node* value);
 
   // Interface to execute a given command in this scope. Returning {true} here
   // indicates successful execution whereas {false} requests to skip scope.
-  virtual bool Execute(Command cmd, Statement* target, Node* value) {
+  virtual bool Execute(Command cmd, Statement* target, Node** value) {
     // For function-level control.
     switch (cmd) {
       case CMD_THROW:
-        builder()->BuildThrow(value);
+        builder()->BuildThrow(*value);
         return true;
       case CMD_RETURN:
-        builder()->BuildReturn(value);
+        builder()->BuildReturn(*value);
         return true;
       case CMD_BREAK:
       case CMD_CONTINUE:
         break;
     }
     return false;
   }
 
   Environment* environment() { return builder_->environment(); }
   AstGraphBuilder* builder() const { return builder_; }
@@ skipping 97 matching lines @@
 
 
 // Control scope implementation for a BreakableStatement.
 class AstGraphBuilder::ControlScopeForBreakable : public ControlScope {
  public:
   ControlScopeForBreakable(AstGraphBuilder* owner, BreakableStatement* target,
                            ControlBuilder* control)
       : ControlScope(owner), target_(target), control_(control) {}
 
  protected:
-  bool Execute(Command cmd, Statement* target, Node* value) override {
+  bool Execute(Command cmd, Statement* target, Node** value) override {
     if (target != target_) return false;  // We are not the command target.
     switch (cmd) {
       case CMD_BREAK:
         control_->Break();
         return true;
       case CMD_CONTINUE:
       case CMD_THROW:
       case CMD_RETURN:
         break;
     }
     return false;
   }
 
  private:
   BreakableStatement* target_;
   ControlBuilder* control_;
 };
 
 
 // Control scope implementation for an IterationStatement.
 class AstGraphBuilder::ControlScopeForIteration : public ControlScope {
  public:
   ControlScopeForIteration(AstGraphBuilder* owner, IterationStatement* target,
                            LoopBuilder* control)
       : ControlScope(owner), target_(target), control_(control) {}
 
  protected:
-  bool Execute(Command cmd, Statement* target, Node* value) override {
-    if (target != target_) return false;  // We are not the command target.
+  bool Execute(Command cmd, Statement* target, Node** value) override {
+    if (target != target_) {
+      control_->ExitLoop(value);
+      return false;
+    }
     switch (cmd) {
       case CMD_BREAK:
         control_->Break();
         return true;
       case CMD_CONTINUE:
         control_->Continue();
         return true;
       case CMD_THROW:
       case CMD_RETURN:
         break;
@@ skipping 17 matching lines @@
         outer_prediction_(owner->try_catch_prediction_) {
     builder()->try_nesting_level_++;  // Increment nesting.
     builder()->try_catch_prediction_ = stmt->catch_predicted();
   }
   ~ControlScopeForCatch() {
     builder()->try_nesting_level_--;  // Decrement nesting.
     builder()->try_catch_prediction_ = outer_prediction_;
   }
 
  protected:
-  bool Execute(Command cmd, Statement* target, Node* value) override {
+  bool Execute(Command cmd, Statement* target, Node** value) override {
     switch (cmd) {
       case CMD_THROW:
-        control_->Throw(value);
+        control_->Throw(*value);
         return true;
       case CMD_BREAK:
       case CMD_CONTINUE:
       case CMD_RETURN:
         break;
     }
     return false;
   }
 
  private:
@@ skipping 13 matching lines @@
         outer_prediction_(owner->try_catch_prediction_) {
     builder()->try_nesting_level_++;  // Increment nesting.
     builder()->try_catch_prediction_ = stmt->catch_predicted();
   }
   ~ControlScopeForFinally() {
     builder()->try_nesting_level_--;  // Decrement nesting.
     builder()->try_catch_prediction_ = outer_prediction_;
   }
 
  protected:
-  bool Execute(Command cmd, Statement* target, Node* value) override {
-    Node* token = commands_->RecordCommand(cmd, target, value);
-    control_->LeaveTry(token, value);
+  bool Execute(Command cmd, Statement* target, Node** value) override {
+    Node* token = commands_->RecordCommand(cmd, target, *value);
+    control_->LeaveTry(token, *value);
     return true;
   }
 
  private:
   DeferredCommands* commands_;
   TryFinallyBuilder* control_;
   bool outer_prediction_;
 };
 
 
@@ skipping 505 matching lines @@
     // to use an explicit frame state for the exceptional path.
     if (owner_has_exception) {
       liveness_block()->GetPredecessor()->Checkpoint(result);
     } else {
       liveness_block()->Checkpoint(result);
     }
   }
   return result;
 }
 
+void AstGraphBuilder::Environment::PrepareForLoopExit(
+    Node* loop, BitVector* assigned_variables) {
+  if (IsMarkedAsUnreachable()) return;
+
+  DCHECK_EQ(loop->opcode(), IrOpcode::kLoop);
+
+  Node* control = GetControlDependency();
+
+  // Create the loop exit node.
+  Node* loop_exit = graph()->NewNode(common()->LoopExit(), control, loop);
+  UpdateControlDependency(loop_exit);
+
+  // Rename the environmnent values.
+  for (size_t i = 0; i < values()->size(); i++) {
+    if (assigned_variables == nullptr ||
+        static_cast<int>(i) >= assigned_variables->length() ||
+        assigned_variables->Contains(static_cast<int>(i))) {
+      Node* rename = graph()->NewNode(common()->LoopExitValue(), (*values())[i],
+                                      loop_exit);
+      (*values())[i] = rename;

[Michael Starzinger, 2016/07/14 13:09:40]

nit: Why not just "values_[i] = rename"?

+    }
+  }
+
+  // Rename the effect.
+  Node* effect_rename = graph()->NewNode(common()->LoopExitEffect(),
+                                         GetEffectDependency(), loop_exit);
+  UpdateEffectDependency(effect_rename);
+}
 
 bool AstGraphBuilder::Environment::IsLivenessAnalysisEnabled() {
   return FLAG_analyze_environment_liveness &&
          builder()->info()->is_deoptimization_enabled();
 }
 
 
 bool AstGraphBuilder::Environment::IsLivenessBlockConsistent() {
   return (!IsLivenessAnalysisEnabled() || IsMarkedAsUnreachable()) ==
          (liveness_block() == nullptr);
@@ skipping 72 matching lines @@
 
 
 void AstGraphBuilder::ControlScope::PerformCommand(Command command,
                                                    Statement* target,
                                                    Node* value) {
   Environment* env = environment()->CopyAsUnreachable();
   ControlScope* current = this;
   while (current != nullptr) {
     environment()->TrimStack(current->stack_height());
     environment()->TrimContextChain(current->context_length());
-    if (current->Execute(command, target, value)) break;
+    if (current->Execute(command, target, &value)) break;
     current = current->outer_;
   }
   builder()->set_environment(env);
   DCHECK_NOT_NULL(current);  // Always handled (unless stack is malformed).
 }
 
 
 void AstGraphBuilder::ControlScope::BreakTo(BreakableStatement* stmt) {
   PerformCommand(CMD_BREAK, stmt, builder()->jsgraph()->TheHoleConstant());
 }
@@ skipping 3345 matching lines @@
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8