[turbofan] Make ContextScope a proper encapsulation of the current context.

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/linkage.h"
@@ skipping 87 matching lines @@
   void ProduceValue(Node* value) FINAL;
   Node* ConsumeValue() FINAL;
 };
 
 
 // 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* owner, Scope* scope, Node* context)
-      : owner_(owner),
-        next_(owner->execution_context()),
-        outer_(owner->current_context()),
-        scope_(scope) {
-    owner_->set_execution_context(this);  // Push.
-    owner_->set_current_context(context);
+  ContextScope(AstGraphBuilder* builder, Scope* scope, Node* context)
+      : builder_(builder),
+        outer_(builder->execution_context()),
+        scope_(scope),
+        context_(context) {
+    builder_->set_execution_context(this);  // Push.
   }
 
   ~ContextScope() {
-    owner_->set_execution_context(next_);  // Pop.
-    owner_->set_current_context(outer_);
+    builder_->set_execution_context(outer_);  // Pop.
   }
 
   // Current scope during visitation.
   Scope* scope() const { return scope_; }
+  // Current context node during visitation.
+  Node* context() const { return context_; }
 
  private:
-  AstGraphBuilder* owner_;
-  ContextScope* next_;
-  Node* outer_;
+  AstGraphBuilder* builder_;
+  ContextScope* outer_;
   Scope* scope_;
+  Node* context_;
 };
 
 
 // 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:
   ControlScope(AstGraphBuilder* builder, int stack_delta)
       : builder_(builder),
-        next_(builder->execution_control()),
+        outer_(builder->execution_control()),
         stack_delta_(stack_delta) {
     builder_->set_execution_control(this);  // Push.
   }
 
   virtual ~ControlScope() {
-    builder_->set_execution_control(next_);  // Pop.
+    builder_->set_execution_control(outer_);  // Pop.
   }
 
   // Either 'break' or 'continue' to the target statement.
   void BreakTo(BreakableStatement* target);
   void ContinueTo(BreakableStatement* target);
 
   // Either 'return' or 'throw' the given value.
   void ReturnValue(Node* return_value);
   void ThrowValue(Node* exception_value);
 
@@ skipping 25 matching lines @@
     }
     return false;
   }
 
   Environment* environment() { return builder_->environment(); }
   AstGraphBuilder* builder() const { return builder_; }
   int stack_delta() const { return stack_delta_; }
 
  private:
   AstGraphBuilder* builder_;
-  ControlScope* next_;
+  ControlScope* outer_;
   int stack_delta_;
 };
 
 
 // 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 166 matching lines @@
     : local_zone_(local_zone),
       info_(info),
       jsgraph_(jsgraph),
       environment_(nullptr),
       ast_context_(nullptr),
       globals_(0, local_zone),
       execution_control_(nullptr),
       execution_context_(nullptr),
       input_buffer_size_(0),
       input_buffer_(nullptr),
-      current_context_(nullptr),
       exit_control_(nullptr),
       loop_assignment_analysis_(loop) {
   InitializeAstVisitor(info->isolate(), local_zone);
 }
 
 
 Node* AstGraphBuilder::GetFunctionClosure() {
   if (!function_closure_.is_set()) {
     const Operator* op =
         common()->Parameter(Linkage::kJSFunctionCallClosureParamIndex);
@@ skipping 30 matching lines @@
   Environment env(this, scope, graph()->start());
   set_environment(&env);
 
   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.
-  Node* outer_context = GetFunctionContext();
-  set_current_context(outer_context);
+  Node* incoming_context = GetFunctionContext();
+  ContextScope incoming(this, scope, incoming_context);
 
   // 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 node to initialize local function context.
   Node* closure = GetFunctionClosure();
-  Node* inner_context = BuildLocalFunctionContext(outer_context, closure);
+  Node* inner_context = BuildLocalFunctionContext(incoming_context, closure);
 
-  // Push top-level function scope for the function body.
+  // Push top-level function context for the function body.
   ContextScope top_context(this, scope, inner_context);
 
   // Build the arguments object if it is used.
   BuildArgumentsObject(scope->arguments());
 
   // Emit tracing call if requested to do so.
   if (FLAG_trace) {
     NewNode(javascript()->CallRuntime(Runtime::kTraceEnter, 0));
   }
 
@@ skipping 190 matching lines @@
 Node* AstGraphBuilder::AstTestContext::ConsumeValue() {
   return environment()->Pop();
 }
 
 
 Scope* AstGraphBuilder::current_scope() const {
   return execution_context_->scope();
 }
 
 
+Node* AstGraphBuilder::current_context() const {
+  return execution_context_->context();
+}
+
+
 void AstGraphBuilder::ControlScope::PerformCommand(Command command,
                                                    Statement* target,
                                                    Node* value) {
   Environment* env = environment()->CopyAsUnreachable();
   ControlScope* current = this;
   while (current != NULL) {
     if (current->Execute(command, target, value)) break;
     environment()->Drop(current->stack_delta());
-    current = current->next_;
+    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, nullptr);
 }
 
@@ skipping 1724 matching lines @@
 }
 
 
 Node* AstGraphBuilder::BuildLocalFunctionContext(Node* context, Node* closure) {
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots <= 0) return context;
 
   // Allocate a new local context.
   const Operator* op = javascript()->CreateFunctionContext();
   Node* local_context = NewNode(op, closure);
-  set_current_context(local_context);
 
   // Copy parameters into context if necessary.
   int num_parameters = info()->scope()->num_parameters();
   for (int i = 0; i < num_parameters; i++) {
     Variable* variable = info()->scope()->parameter(i);
     if (!variable->IsContextSlot()) continue;
     // Temporary parameter node. The parameter indices are shifted by 1
     // (receiver is parameter index -1 but environment index 0).
     Node* parameter = NewNode(common()->Parameter(i + 1), graph()->start());
     // Context variable (at bottom of the context chain).
@@ skipping 698 matching lines @@
     Node* dead_node = graph()->NewNode(common()->Dead());
     dead_control_.set(dead_node);
     return dead_node;
   }
   return dead_control_.get();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8