[Interpreter] Add support for new local function context creation.

src/interpreter/bytecode-generator.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/interpreter/bytecode-generator.h"
 
 #include <stack>
 
 #include "src/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
 #include "src/objects.h"
 #include "src/scopes.h"
 #include "src/token.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 
+// 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.

[Michael Starzinger, 2015/10/13 09:38:43]

nit: Comment looks outdated. Doesn't really track {scope} and also tracks
{context_register} instead of {context} IIUC.

[rmcilroy, 2015/10/13 10:35:22]

Done.

+class BytecodeGenerator::ContextScope BASE_EMBEDDED {
+ public:
+  explicit ContextScope(BytecodeGenerator* generator,
+                        bool is_function_context = false)
+      : generator_(generator),
+        outer_(generator_->current_context()),
+        is_function_context_(is_function_context) {
+    DCHECK(!is_function_context ||
+           outer_.index() == Register::function_context().index());
+    Register new_context_reg = NewContextRegister();
+    generator_->builder()->PushContext(new_context_reg);
+    generator_->set_current_context(new_context_reg);
+  }
+
+  ~ContextScope() {
+    if (!is_function_context_) {
+      generator_->builder()->PopContext(outer_);
+    }
+    generator_->set_current_context(outer_);
+  }
+
+ private:
+  Register NewContextRegister() const {
+    if (outer_.index() == Register::function_context().index()) {
+      return generator_->builder()->first_context_register();
+    } else {
+      DCHECK_LT(outer_.index(),
+                generator_->builder()->last_context_register().index());
+      return Register(outer_.index() + 1);
+    }
+  }
+
+  BytecodeGenerator* generator_;
+  Register outer_;
+  bool is_function_context_;
+};
+
+
 // Scoped class for tracking control statements entered by the
 // visitor. The pattern derives AstGraphBuilder::ControlScope.
 class BytecodeGenerator::ControlScope BASE_EMBEDDED {
  public:
   explicit ControlScope(BytecodeGenerator* generator)
       : generator_(generator), outer_(generator->control_scope()) {
     generator_->set_control_scope(this);
   }
   virtual ~ControlScope() { generator_->set_control_scope(outer()); }
 
@@ skipping 72 matching lines @@
 
 BytecodeGenerator::~BytecodeGenerator() {}
 
 
 Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
   set_info(info);
   set_scope(info->scope());
 
   builder()->set_parameter_count(info->num_parameters_including_this());
   builder()->set_locals_count(scope()->num_stack_slots());
+  // TODO(rmcilroy): Set correct context count.
+  builder()->set_context_count(info->num_heap_slots() > 0 ? 1 : 0);

[Michael Starzinger, 2015/10/13 09:38:43]

How hard will it be to determine in advance how deep the longest context chain
is? AFAICT we don't have that information, or do we?

[rmcilroy, 2015/10/13 10:35:22]

Yeah, we don't have that information yet. I'll need to add this support to the
parser before we can do anything with nested context chains. I'm hoping it
shouldn't be to tricky though since the parser knows when it needs to push and
pop contexts.

[Michael Starzinger, 2015/10/13 11:12:13]

Acknowledged. Not sure how hard/easy this will be, more thinking/discussion
required. But let's defer that to another CL to unblock this one.

 
-  // Visit implicit declaration of the function name.
-  if (scope()->is_function_scope() && scope()->function() != NULL) {
-    VisitVariableDeclaration(scope()->function());
+  // Build function context only if there are context allocated variables.
+  if (info->num_heap_slots() > 0) {
+    // Push a new inner context scope for the function.
+    VisitNewLocalFunctionContext();
+    ContextScope top_context(this, true);
+    MakeBytecodeBody();
+  } else {
+    MakeBytecodeBody();
   }
 
-  // Visit declarations within the function scope.
-  VisitDeclarations(scope()->declarations());
-
-  // Visit statements in the function body.
-  VisitStatements(info->literal()->body());
-
   set_scope(nullptr);
   set_info(nullptr);
   return builder_.ToBytecodeArray();
 }
 
 
+void BytecodeGenerator::MakeBytecodeBody() {
+  // Visit declarations within the function scope.
+  VisitDeclarations(scope()->declarations());
+
+  // Visit statements in the function body.
+  VisitStatements(info()->literal()->body());
+}
+
+
 void BytecodeGenerator::VisitBlock(Block* node) {
   builder()->EnterBlock();
   if (node->scope() == NULL) {
     // Visit statements in the same scope, no declarations.
     VisitStatements(node->statements());
   } else {
     // Visit declarations and statements in a block scope.
     if (node->scope()->ContextLocalCount() > 0) {
       UNIMPLEMENTED();
     } else {
@@ skipping 72 matching lines @@
   AstVisitor::VisitDeclarations(declarations);
   if (globals()->empty()) return;
   int array_index = 0;
   Handle<FixedArray> data = isolate()->factory()->NewFixedArray(
       static_cast<int>(globals()->size()), TENURED);
   for (Handle<Object> obj : *globals()) data->set(array_index++, *obj);
   int encoded_flags = DeclareGlobalsEvalFlag::encode(info()->is_eval()) |
                       DeclareGlobalsNativeFlag::encode(info()->is_native()) |
                       DeclareGlobalsLanguageMode::encode(language_mode());
 
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   Register pairs = temporary_register_scope.NewRegister();
   builder()->LoadLiteral(data);
   builder()->StoreAccumulatorInRegister(pairs);
 
   Register flags = temporary_register_scope.NewRegister();
   builder()->LoadLiteral(Smi::FromInt(encoded_flags));
   builder()->StoreAccumulatorInRegister(flags);
   DCHECK(flags.index() == pairs.index() + 1);
 
   builder()->CallRuntime(Runtime::kDeclareGlobals, pairs, 2);
@@ skipping 237 matching lines @@
     case VariableLocation::GLOBAL: {
       // Global var, const, or let variable.
       // TODO(rmcilroy): If context chain depth is short enough, do this using
       // a generic version of LoadGlobalViaContextStub rather than calling the
       // runtime.
       DCHECK(variable->IsStaticGlobalObjectProperty());
       builder()->LoadGlobal(variable->index());
       break;
     }
     case VariableLocation::UNALLOCATED: {
-      TemporaryRegisterScope temporary_register_scope(&builder_);
+      TemporaryRegisterScope temporary_register_scope(builder());
       Register obj = temporary_register_scope.NewRegister();
       builder()->LoadContextSlot(current_context(),
                                  Context::GLOBAL_OBJECT_INDEX);
       builder()->StoreAccumulatorInRegister(obj);
       builder()->LoadLiteral(variable->name());
       builder()->LoadNamedProperty(obj, feedback_index(slot), language_mode());
       break;
     }
     case VariableLocation::CONTEXT:
     case VariableLocation::LOOKUP:
@@ skipping 21 matching lines @@
     case VariableLocation::GLOBAL: {
       // Global var, const, or let variable.
       // TODO(rmcilroy): If context chain depth is short enough, do this using
       // a generic version of LoadGlobalViaContextStub rather than calling the
       // runtime.
       DCHECK(variable->IsStaticGlobalObjectProperty());
       builder()->StoreGlobal(variable->index(), language_mode());
       break;
     }
     case VariableLocation::UNALLOCATED: {
-      TemporaryRegisterScope temporary_register_scope(&builder_);
+      TemporaryRegisterScope temporary_register_scope(builder());
       Register value = temporary_register_scope.NewRegister();
       Register obj = temporary_register_scope.NewRegister();
       Register name = temporary_register_scope.NewRegister();
       // TODO(rmcilroy): Investigate whether we can avoid having to stash the
       // value in a register.
       builder()->StoreAccumulatorInRegister(value);
       builder()->LoadContextSlot(current_context(),
                                  Context::GLOBAL_OBJECT_INDEX);
       builder()->StoreAccumulatorInRegister(obj);
       builder()->LoadLiteral(variable->name());
       builder()->StoreAccumulatorInRegister(name);
       builder()->LoadAccumulatorWithRegister(value);
       builder()->StoreNamedProperty(obj, name, feedback_index(slot),
                                     language_mode());
       break;
     }
     case VariableLocation::CONTEXT:
     case VariableLocation::LOOKUP:
       UNIMPLEMENTED();
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
   DCHECK(expr->target()->IsValidReferenceExpression());
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   Register object, key;
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->target()->AsProperty();
   LhsKind assign_type = Property::GetAssignType(property);
 
   // Evaluate LHS expression.
   switch (assign_type) {
     case VARIABLE:
       // Nothing to do to evaluate variable assignment LHS.
@@ skipping 73 matching lines @@
       break;
     }
     case NAMED_SUPER_PROPERTY:
     case KEYED_SUPER_PROPERTY:
       UNIMPLEMENTED();
   }
 }
 
 
 void BytecodeGenerator::VisitProperty(Property* expr) {
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   Register obj = temporary_register_scope.NewRegister();
   Visit(expr->obj());
   builder()->StoreAccumulatorInRegister(obj);
   VisitPropertyLoad(obj, expr);
 }
 
 
 void BytecodeGenerator::VisitCall(Call* expr) {
   Expression* callee_expr = expr->expression();
   Call::CallType call_type = expr->GetCallType(isolate());
 
   // Prepare the callee and the receiver to the function call. This depends on
   // the semantics of the underlying call type.
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   Register callee = temporary_register_scope.NewRegister();
   Register receiver = temporary_register_scope.NewRegister();
 
   switch (call_type) {
     case Call::PROPERTY_CALL: {
       Property* property = callee_expr->AsProperty();
       if (property->IsSuperAccess()) {
         UNIMPLEMENTED();
       }
       Visit(property->obj());
@@ skipping 38 matching lines @@
 void BytecodeGenerator::VisitCallNew(CallNew* expr) { UNIMPLEMENTED(); }
 
 
 void BytecodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   if (expr->is_jsruntime()) {
     UNIMPLEMENTED();
   }
 
   // Evaluate all arguments to the runtime call.
   ZoneList<Expression*>* args = expr->arguments();
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   // Ensure we always have a valid first_arg register even if there are no
   // arguments to pass.
   Register first_arg = temporary_register_scope.NewRegister();
   for (int i = 0; i < args->length(); ++i) {
     Register arg =
         (i == 0) ? first_arg : temporary_register_scope.NewRegister();
     Visit(args->at(i));
     DCHECK_EQ(arg.index() - i, first_arg.index());
     builder()->StoreAccumulatorInRegister(arg);
   }
@@ skipping 60 matching lines @@
       break;
   }
 }
 
 
 void BytecodeGenerator::VisitCompareOperation(CompareOperation* expr) {
   Token::Value op = expr->op();
   Expression* left = expr->left();
   Expression* right = expr->right();
 
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   Register temporary = temporary_register_scope.NewRegister();
 
   Visit(left);
   builder()->StoreAccumulatorInRegister(temporary);
   Visit(right);
   builder()->CompareOperation(op, temporary, language_mode_strength());
 }
 
 
 void BytecodeGenerator::VisitSpread(Spread* expr) { UNREACHABLE(); }
@@ skipping 13 matching lines @@
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitSuperPropertyReference(
     SuperPropertyReference* expr) {
   UNIMPLEMENTED();
 }
 
 
+void BytecodeGenerator::VisitNewLocalFunctionContext() {
+  Scope* scope = this->scope();
+
+  // Allocate a new local context.
+  if (scope->is_script_scope()) {
+    TemporaryRegisterScope temporary_register_scope(builder());
+    Register closure = temporary_register_scope.NewRegister();
+    Register scope_info = temporary_register_scope.NewRegister();
+    DCHECK_EQ(closure.index() + 1, scope_info.index());
+    builder()
+        ->LoadAccumulatorWithRegister(Register::function_closure())
+        .StoreAccumulatorInRegister(closure)
+        .LoadLiteral(scope->GetScopeInfo(isolate()))
+        .StoreAccumulatorInRegister(scope_info)
+        .CallRuntime(Runtime::kNewScriptContext, closure, 2);
+  } else {
+    builder()->CallRuntime(Runtime::kNewFunctionContext,
+                           Register::function_closure(), 1);
+  }
+
+  if (scope->has_this_declaration() && scope->receiver()->IsContextSlot()) {
+    UNIMPLEMENTED();
+  }
+
+  // Copy parameters into context if necessary.
+  int num_parameters = scope->num_parameters();
+  for (int i = 0; i < num_parameters; i++) {
+    Variable* variable = scope->parameter(i);
+    if (variable->IsContextSlot()) {
+      UNIMPLEMENTED();
+    }
+  }
+}
+
+
 void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* binop) {
   Token::Value op = binop->op();
   Expression* left = binop->left();
   Expression* right = binop->right();
 
-  TemporaryRegisterScope temporary_register_scope(&builder_);
+  TemporaryRegisterScope temporary_register_scope(builder());
   Register temporary = temporary_register_scope.NewRegister();
 
   Visit(left);
   builder()->StoreAccumulatorInRegister(temporary);
   Visit(right);
   builder()->BinaryOperation(op, temporary, language_mode_strength());
 }
 
 
 LanguageMode BytecodeGenerator::language_mode() const {
   return info()->language_mode();
 }
 
 
 Strength BytecodeGenerator::language_mode_strength() const {
   return strength(language_mode());
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
-
-Register BytecodeGenerator::current_context() const { return current_context_; }
-
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8