[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, allowing pushing and
+// popping of the current {context_register} during visitation.
+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);
 
-  // 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 244 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 43 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