[turbofan] Keep AstGraphBuilder context chain length in sync.

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/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/js-type-feedback.h"
@@ skipping 94 matching lines @@
 
 // Scoped class tracking context objects created by the visitor. Represents
 // mutations of the context chain within the function body and allows to
 // change the current {scope} and {context} during visitation.
 class AstGraphBuilder::ContextScope BASE_EMBEDDED {
  public:
   ContextScope(AstGraphBuilder* builder, Scope* scope, Node* context)
       : builder_(builder),
         outer_(builder->execution_context()),
         scope_(scope),
-        depth_(builder_->environment()->ContextStackDepth()) {
+        depth_(builder_->environment()->context_chain_length()) {
     builder_->environment()->PushContext(context);  // Push.
     builder_->set_execution_context(this);
   }
 
   ~ContextScope() {
     builder_->set_execution_context(outer_);  // Pop.
     builder_->environment()->PopContext();
-    CHECK_EQ(depth_, builder_->environment()->ContextStackDepth());
+    CHECK_EQ(depth_, builder_->environment()->context_chain_length());
   }
 
   // Current scope during visitation.
   Scope* scope() const { return scope_; }
 
  private:
   AstGraphBuilder* builder_;
   ContextScope* outer_;
   Scope* scope_;
   int depth_;
 };
 
 
 // Scoped class tracking control statements entered by the visitor. There are
 // different types of statements participating in this stack to properly track
 // local as well as non-local control flow:
 //  - IterationStatement : Allows proper 'break' and 'continue' behavior.
 //  - BreakableStatement : Allows 'break' from block and switch statements.
 //  - TryCatchStatement  : Intercepts 'throw' and implicit exceptional edges.
 //  - TryFinallyStatement: Intercepts 'break', 'continue', 'throw' and 'return'.
 class AstGraphBuilder::ControlScope BASE_EMBEDDED {
  public:
   explicit ControlScope(AstGraphBuilder* builder)
       : builder_(builder),
         outer_(builder->execution_control()),
+        context_length_(builder->environment()->context_chain_length()),
         stack_height_(builder->environment()->stack_height()) {
     builder_->set_execution_control(this);  // Push.
   }
 
   virtual ~ControlScope() {
     builder_->set_execution_control(outer_);  // Pop.
   }
 
   // Either 'break' or 'continue' to the target statement.
   void BreakTo(BreakableStatement* target);
@@ skipping 27 matching lines @@
         return true;
       case CMD_BREAK:
       case CMD_CONTINUE:
         break;
     }
     return false;
   }
 
   Environment* environment() { return builder_->environment(); }
   AstGraphBuilder* builder() const { return builder_; }
+  int context_length() const { return context_length_; }
   int stack_height() const { return stack_height_; }
 
  private:
   AstGraphBuilder* builder_;
   ControlScope* outer_;
+  int context_length_;
   int stack_height_;
 };
 
 
 // Helper class for a try-finally control scope. It can record intercepted
 // control-flow commands that cause entry into a finally-block, and re-apply
 // them after again leaving that block. Special tokens are used to identify
 // paths going through the finally-block to dispatch after leaving the block.
 class AstGraphBuilder::ControlScope::DeferredCommands : public ZoneObject {
  public:
@@ skipping 232 matching lines @@
   DCHECK(graph() != NULL);
 
   // Set up the basic structure of the graph.
   int parameter_count = info()->num_parameters();
   graph()->SetStart(graph()->NewNode(common()->Start(parameter_count)));
 
   // Initialize the top-level environment.
   Environment env(this, scope, graph()->start());
   set_environment(&env);
 
-  // Initialize control scope.
-  ControlScope control(this);
-
   if (info()->is_osr()) {
     // Use OSR normal entry as the start of the top-level environment.
     // It will be replaced with {Dead} after typing and optimizations.
     NewNode(common()->OsrNormalEntry());
   }
 
   // Initialize the incoming context.
   CreateFunctionContext(constant_context);
   ContextScope incoming(this, scope, function_context_.get());
 
+  // Initialize control scope.
+  ControlScope control(this);
+
   // Build receiver check for sloppy mode if necessary.
   // TODO(mstarzinger/verwaest): Should this be moved back into the CallIC?
   Node* original_receiver = env.Lookup(scope->receiver());
   Node* patched_receiver = BuildPatchReceiverToGlobalProxy(original_receiver);
   env.Bind(scope->receiver(), patched_receiver);
 
   // Build function context only if there are context allocated variables.
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots > 0) {
     // Push a new inner context scope for the function.
@@ skipping 330 matching lines @@
   return environment()->Context();
 }
 
 
 void AstGraphBuilder::ControlScope::PerformCommand(Command command,
                                                    Statement* target,
                                                    Node* value) {
   Environment* env = environment()->CopyAsUnreachable();
   ControlScope* current = this;
   while (current != NULL) {
-    environment()->Trim(current->stack_height());
+    environment()->TrimStack(current->stack_height());
+    environment()->TrimContextChain(current->context_length());
     if (current->Execute(command, target, value)) break;
     current = current->outer_;
   }
   builder()->set_environment(env);
   DCHECK(current != NULL);  // Always handled (unless stack is malformed).
 }
 
 
 void AstGraphBuilder::ControlScope::BreakTo(BreakableStatement* stmt) {
   PerformCommand(CMD_BREAK, stmt, builder()->jsgraph()->TheHoleConstant());
@@ skipping 2500 matching lines @@
   if (exit_control() != NULL) {
     exit = MergeControl(exit_control(), exit);
   }
   environment()->MarkAsUnreachable();
   set_exit_control(exit);
 }
 
 
 void AstGraphBuilder::Environment::Merge(Environment* other) {
   DCHECK(values_.size() == other->values_.size());
-  // TODO(titzer): make context stack heights match.
-  DCHECK(contexts_.size() <= other->contexts_.size());
+  DCHECK(contexts_.size() == other->contexts_.size());
 
   // Nothing to do if the other environment is dead.
   if (other->IsMarkedAsUnreachable()) return;
 
   // Resurrect a dead environment by copying the contents of the other one and
   // placing a singleton merge as the new control dependency.
   if (this->IsMarkedAsUnreachable()) {
     Node* other_control = other->control_dependency_;
     Node* inputs[] = {other_control};
     liveness_block_ = other->liveness_block_;
     control_dependency_ =
         graph()->NewNode(common()->Merge(1), arraysize(inputs), inputs, true);
     effect_dependency_ = other->effect_dependency_;
     values_ = other->values_;
-    // TODO(titzer): make context stack heights match.
-    size_t min = std::min(contexts_.size(), other->contexts_.size());
     contexts_ = other->contexts_;
-    contexts_.resize(min, nullptr);
     return;
   }
 
   // Record the merge for the local variable liveness calculation.
   // Unfortunately, we have to mirror the logic in the MergeControl method:
   // connect before merge or loop, or create a new merge otherwise.
   if (FLAG_analyze_environment_liveness) {
     if (GetControlDependency()->opcode() != IrOpcode::kLoop &&
         GetControlDependency()->opcode() != IrOpcode::kMerge) {
       liveness_block_ =
@@ skipping 165 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