[Interpreter] Add support for local context loads and stores.

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/parser.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)
+  ContextScope(BytecodeGenerator* generator, Scope* scope,
+               bool should_pop_context = true)
       : 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);
+        scope_(scope),
+        outer_(generator_->execution_context()),
+        register_(generator_->NextContextRegister()),
+        depth_(0),
+        should_pop_context_(should_pop_context) {
+    if (outer_) {
+      depth_ = outer_->depth_ + 1;
+      generator_->builder()->PushContext(register_);
+    }
+    generator_->set_execution_context(this);
   }
 
   ~ContextScope() {
-    if (!is_function_context_) {
-      generator_->builder()->PopContext(outer_);
+    if (should_pop_context_) {

[Michael Starzinger, 2015/10/16 13:29:06]

nit: Let's be defensive and keep checking "outer_ && should_pop_context_" here.

[rmcilroy, 2015/10/16 14:11:35]

Ok, done.

+      generator_->builder()->PopContext(outer_->reg());
     }
-    generator_->set_current_context(outer_);
+    generator_->set_execution_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);
+  // Returns the execution context for the given |scope| if it is a function
+  // local execution context, otherwise returns nullptr.
+  ContextScope* Previous(Scope* scope) {
+    int depth = scope_->ContextChainLength(scope);
+    if (depth > depth_) {
+      return nullptr;
     }
+
+    ContextScope* previous = this;
+    for (int i = depth; i > 0; --i) {
+      previous = previous->outer_;
+    }
+    DCHECK_EQ(previous->scope_, scope);
+    return previous;
   }
 
+  Scope* scope() const { return scope_; }
+  Register reg() const { return register_; }
+
+ private:
   BytecodeGenerator* generator_;
-  Register outer_;
-  bool is_function_context_;
+  Scope* scope_;
+  ContextScope* outer_;
+  Register register_;
+  int depth_;
+  bool should_pop_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);
+      : generator_(generator), outer_(generator->execution_control()) {
+    generator_->set_execution_control(this);
   }
-  virtual ~ControlScope() { generator_->set_control_scope(outer()); }
+  virtual ~ControlScope() { generator_->set_execution_control(outer()); }
 
   void Break(Statement* stmt) { PerformCommand(CMD_BREAK, stmt); }
   void Continue(Statement* stmt) { PerformCommand(CMD_CONTINUE, stmt); }
 
  protected:
   enum Command { CMD_BREAK, CMD_CONTINUE };
   void PerformCommand(Command command, Statement* statement);
   virtual bool Execute(Command command, Statement* statement) = 0;
 
   BytecodeGenerator* generator() const { return generator_; }
@@ skipping 50 matching lines @@
 }
 
 
 BytecodeGenerator::BytecodeGenerator(Isolate* isolate, Zone* zone)
     : isolate_(isolate),
       zone_(zone),
       builder_(isolate, zone),
       info_(nullptr),
       scope_(nullptr),
       globals_(0, zone),
-      control_scope_(nullptr),
-      current_context_(Register::function_context()) {
+      execution_control_(nullptr),
+      execution_context_(nullptr) {
   InitializeAstVisitor(isolate);
 }
 
 
 BytecodeGenerator::~BytecodeGenerator() {}
 
 
 Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
   set_info(info);
   set_scope(info->scope());
 
+  // Initialize the incoming context.
+  ContextScope incoming_context(this, scope(), false);
+
   builder()->set_parameter_count(info->num_parameters_including_this());
   builder()->set_locals_count(scope()->num_stack_slots());
   builder()->set_context_count(scope()->MaxNestedContextChainLength());
 
   // Build function context only if there are context allocated variables.
   if (scope()->NeedsContext()) {
     // Push a new inner context scope for the function.
     VisitNewLocalFunctionContext();
-    ContextScope top_context(this, true);
+    ContextScope local_function_context(this, scope(), false);
+    VisitBuildLocalActivationContext();
     MakeBytecodeBody();
   } else {
     MakeBytecodeBody();
   }
 
   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) {
+void BytecodeGenerator::VisitBlock(Block* stmt) {
   builder()->EnterBlock();
-  if (node->scope() == NULL) {
+  if (stmt->scope() == NULL) {
     // Visit statements in the same scope, no declarations.
-    VisitStatements(node->statements());
+    VisitStatements(stmt->statements());
   } else {
     // Visit declarations and statements in a block scope.
-    if (node->scope()->ContextLocalCount() > 0) {
-      UNIMPLEMENTED();
+    if (stmt->scope()->NeedsContext()) {
+      VisitNewLocalBlockContext(stmt->scope());
+      ContextScope scope(this, stmt->scope());
+      VisitDeclarations(stmt->scope()->declarations());
+      VisitStatements(stmt->statements());
     } else {
-      VisitDeclarations(node->scope()->declarations());
-      VisitStatements(node->statements());
+      VisitDeclarations(stmt->scope()->declarations());
+      VisitStatements(stmt->statements());
     }
   }
   builder()->LeaveBlock();
 }
 
 
 void BytecodeGenerator::VisitVariableDeclaration(VariableDeclaration* decl) {
   Variable* variable = decl->proxy()->var();
   VariableMode mode = decl->mode();
+  // Const and let variables are initialized with the hole so that we can
+  // check that they are only assigned once.
   bool hole_init = mode == CONST || mode == CONST_LEGACY || mode == LET;
-  if (hole_init) {
-    UNIMPLEMENTED();
-  }
   switch (variable->location()) {
     case VariableLocation::GLOBAL:
     case VariableLocation::UNALLOCATED: {
       Handle<Oddball> value = variable->binding_needs_init()
                                   ? isolate()->factory()->the_hole_value()
                                   : isolate()->factory()->undefined_value();
       globals()->push_back(variable->name());
       globals()->push_back(value);
       break;
     }
+    case VariableLocation::LOCAL:
+      if (hole_init) {
+        Register destination(variable->index());
+        builder()->LoadTheHole().StoreAccumulatorInRegister(destination);
+      }
+      break;
     case VariableLocation::PARAMETER:
-    case VariableLocation::LOCAL:
-      // Details stored in scope, i.e. variable index.
+      if (hole_init) {
+        // The parameter indices are shifted by 1 (receiver is variable
+        // index -1 but is parameter index 0 in BytecodeArrayBuilder).
+        Register destination(builder()->Parameter(variable->index() + 1));
+        builder()->LoadTheHole().StoreAccumulatorInRegister(destination);
+      }
       break;
     case VariableLocation::CONTEXT:
+      if (hole_init) {
+        builder()->LoadTheHole().StoreContextSlot(execution_context()->reg(),
+                                                  variable->index());
+      }
+      break;
     case VariableLocation::LOOKUP:
       UNIMPLEMENTED();
       break;
   }
 }
 
 
 void BytecodeGenerator::VisitFunctionDeclaration(FunctionDeclaration* decl) {
   Variable* variable = decl->proxy()->var();
   switch (variable->location()) {
@@ skipping 86 matching lines @@
 }
 
 
 void BytecodeGenerator::VisitSloppyBlockFunctionStatement(
     SloppyBlockFunctionStatement* stmt) {
   Visit(stmt->statement());
 }
 
 
 void BytecodeGenerator::VisitContinueStatement(ContinueStatement* stmt) {
-  control_scope()->Continue(stmt->target());
+  execution_control()->Continue(stmt->target());
 }
 
 
 void BytecodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
-  control_scope()->Break(stmt->target());
+  execution_control()->Break(stmt->target());
 }
 
 
 void BytecodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   Visit(stmt->expression());
   builder()->Return();
 }
 
 
 void BytecodeGenerator::VisitWithStatement(WithStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitSwitchStatement(SwitchStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
 void BytecodeGenerator::VisitCaseClause(CaseClause* clause) { UNIMPLEMENTED(); }
 
 
 void BytecodeGenerator::VisitDoWhileStatement(DoWhileStatement* stmt) {
   LoopBuilder loop_builder(builder());
-  ControlScopeForIteration control_scope(this, stmt, &loop_builder);
+  ControlScopeForIteration execution_control(this, stmt, &loop_builder);
 
   BytecodeLabel body_label, condition_label, done_label;
   builder()->Bind(&body_label);
   Visit(stmt->body());
   builder()->Bind(&condition_label);
   Visit(stmt->cond());
   builder()->JumpIfTrue(&body_label);
   builder()->Bind(&done_label);
 
   loop_builder.SetBreakTarget(done_label);
   loop_builder.SetContinueTarget(condition_label);
 }
 
 
 void BytecodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
   LoopBuilder loop_builder(builder());
-  ControlScopeForIteration control_scope(this, stmt, &loop_builder);
+  ControlScopeForIteration execution_control(this, stmt, &loop_builder);
 
   BytecodeLabel body_label, condition_label, done_label;
   builder()->Jump(&condition_label);
   builder()->Bind(&body_label);
   Visit(stmt->body());
   builder()->Bind(&condition_label);
   Visit(stmt->cond());
   builder()->JumpIfTrue(&body_label);
   builder()->Bind(&done_label);
 
   loop_builder.SetBreakTarget(done_label);
   loop_builder.SetContinueTarget(condition_label);
 }
 
 
 void BytecodeGenerator::VisitForStatement(ForStatement* stmt) {
   LoopBuilder loop_builder(builder());
-  ControlScopeForIteration control_scope(this, stmt, &loop_builder);
+  ControlScopeForIteration execution_control(this, stmt, &loop_builder);
 
   if (stmt->init() != nullptr) {
     Visit(stmt->init());
   }
 
   BytecodeLabel body_label, condition_label, next_label, done_label;
   if (stmt->cond() != nullptr) {
     builder()->Jump(&condition_label);
   }
   builder()->Bind(&body_label);
@@ skipping 183 matching lines @@
         }
         break;
       case ObjectLiteral::Property::SETTER:
         if (property->emit_store()) {
           accessor_table.lookup(literal_key)->second->setter = property;
         }
         break;
     }
   }
 
-  // Create nodes to define accessors, using only a single call to the runtime
-  // for each pair of corresponding getters and setters.
+  // Define accessors, using only a single call to the runtime for each pair of
+  // corresponding getters and setters.
   for (AccessorTable::Iterator it = accessor_table.begin();
        it != accessor_table.end(); ++it) {
     TemporaryRegisterScope inner_temporary_register_scope(builder());
     Register name = inner_temporary_register_scope.NewRegister();
     Register getter = inner_temporary_register_scope.NewRegister();
     Register setter = inner_temporary_register_scope.NewRegister();
     Register attr = inner_temporary_register_scope.NewRegister();
     DCHECK(Register::AreContiguous(literal, name, getter, setter, attr));
     Visit(it->first);
     builder()->StoreAccumulatorInRegister(name);
@@ skipping 81 matching lines @@
 
 void BytecodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   // Deep-copy the literal boilerplate.
   builder()
       ->LoadLiteral(expr->constant_elements())
       .CreateArrayLiteral(expr->literal_index(), expr->ComputeFlags(true));
 
   TemporaryRegisterScope temporary_register_scope(builder());
   Register index, literal;
 
-  // Create nodes to evaluate all the non-constant subexpressions and to store
-  // them into the newly cloned array.
+  // Evaluate all the non-constant subexpressions and store them into the
+  // newly cloned array.
   bool literal_in_accumulator = true;
   for (int array_index = 0; array_index < expr->values()->length();
        array_index++) {
     Expression* subexpr = expr->values()->at(array_index);
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
     if (subexpr->IsSpread()) {
       // TODO(rmcilroy): Deal with spread expressions.
       UNIMPLEMENTED();
     }
 
@@ skipping 24 matching lines @@
   VisitVariableLoad(proxy->var(), proxy->VariableFeedbackSlot());
 }
 
 
 void BytecodeGenerator::VisitVariableLoad(Variable* variable,
                                           FeedbackVectorSlot slot) {
   switch (variable->location()) {
     case VariableLocation::LOCAL: {
       Register source(variable->index());
       builder()->LoadAccumulatorWithRegister(source);
+      // TODO(rmcilroy): Perform check for uninitialized legacy const, const and
+      // let variables.
       break;
     }
     case VariableLocation::PARAMETER: {
       // The parameter indices are shifted by 1 (receiver is variable
       // index -1 but is parameter index 0 in BytecodeArrayBuilder).
       Register source(builder()->Parameter(variable->index() + 1));
       builder()->LoadAccumulatorWithRegister(source);
       break;
     }
     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());
       Register obj = temporary_register_scope.NewRegister();
-      builder()->LoadContextSlot(current_context(),
+      builder()->LoadContextSlot(execution_context()->reg(),
                                  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::CONTEXT: {
+      ContextScope* context = execution_context()->Previous(variable->scope());
+      if (context) {
+        builder()->LoadContextSlot(context->reg(), variable->index());
+      } else {
+        UNIMPLEMENTED();
+      }
+      // TODO(rmcilroy): Perform check for uninitialized legacy const, const and
+      // let variables.
+      break;
+    }
     case VariableLocation::LOOKUP:
       UNIMPLEMENTED();
   }
 }
 
 
 void BytecodeGenerator::VisitVariableAssignment(Variable* variable,
                                                 FeedbackVectorSlot slot) {
   switch (variable->location()) {
     case VariableLocation::LOCAL: {
@@ skipping 19 matching lines @@
       break;
     }
     case VariableLocation::UNALLOCATED: {
       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(),
+      builder()->LoadContextSlot(execution_context()->reg(),
                                  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::CONTEXT: {
+      // TODO(rmcilroy): support const mode initialization.
+      ContextScope* context = execution_context()->Previous(variable->scope());
+      if (context) {
+        builder()->StoreContextSlot(context->reg(), variable->index());
+      } else {
+        UNIMPLEMENTED();
+      }
+      break;
+    }
     case VariableLocation::LOOKUP:
       UNIMPLEMENTED();
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
   DCHECK(expr->target()->IsValidReferenceExpression());
   TemporaryRegisterScope temporary_register_scope(builder());
   Register object, key;
@@ skipping 298 matching lines @@
     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);
   }
+}
+
+
+void BytecodeGenerator::VisitBuildLocalActivationContext() {
+  Scope* scope = this->scope();
 
   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();
-    }
+    if (!variable->IsContextSlot()) continue;
+
+    // The parameter indices are shifted by 1 (receiver is variable
+    // index -1 but is parameter index 0 in BytecodeArrayBuilder).
+    Register parameter(builder()->Parameter(i + 1));
+    // Context variable (at bottom of the context chain).
+    DCHECK_EQ(0, scope->ContextChainLength(variable->scope()));
+    builder()->LoadAccumulatorWithRegister(parameter)
+        .StoreContextSlot(execution_context()->reg(), variable->index());
   }
 }
 
 
+void BytecodeGenerator::VisitNewLocalBlockContext(Scope* scope) {
+  DCHECK(scope->is_block_scope());
+
+  // Allocate a new local block context.
+  TemporaryRegisterScope temporary_register_scope(builder());
+  Register scope_info = temporary_register_scope.NewRegister();
+  Register closure = temporary_register_scope.NewRegister();
+  DCHECK(Register::AreContiguous(scope_info, closure));
+  builder()
+      ->LoadLiteral(scope->GetScopeInfo(isolate()))
+      .StoreAccumulatorInRegister(scope_info);
+  VisitFunctionClosureForContext();
+  builder()
+      ->StoreAccumulatorInRegister(closure)
+      .CallRuntime(Runtime::kPushBlockContext, scope_info, 2);
+}
+
+
 void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* binop) {
   Token::Value op = binop->op();
   Expression* left = binop->left();
   Expression* right = binop->right();
 
   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());
 }
 
 
-void BytecodeGenerator::VisitObjectLiteralAccessor(
-    Register home_object, ObjectLiteralProperty* property, Register value_out) {
-  // TODO(rmcilroy): Replace value_out with VisitForRegister();
-  if (property == nullptr) {
-    builder()->LoadNull().StoreAccumulatorInRegister(value_out);
-  } else {
-    Visit(property->value());
-    builder()->StoreAccumulatorInRegister(value_out);
-    VisitSetHomeObject(value_out, home_object, property);
-  }
-}
-
-
-void BytecodeGenerator::VisitSetHomeObject(Register value, Register home_object,
-                                           ObjectLiteralProperty* property,
-                                           int slot_number) {
-  Expression* expr = property->value();
-  if (!FunctionLiteral::NeedsHomeObject(expr)) return;
-
-  // TODO(rmcilroy): Remove UNIMPLEMENTED once we have tests for setting the
-  // home object.
-  UNIMPLEMENTED();
-
-  TemporaryRegisterScope temporary_register_scope(builder());
-  Register name = temporary_register_scope.NewRegister();
-  isolate()->factory()->home_object_symbol();
-  builder()
-      ->LoadLiteral(isolate()->factory()->home_object_symbol())
-      .StoreAccumulatorInRegister(name)
-      .StoreNamedProperty(home_object, name,
-                          feedback_index(property->GetSlot(slot_number)),
-                          language_mode());
-}
-
-
 void BytecodeGenerator::VisitCommaExpression(BinaryOperation* binop) {
   Expression* left = binop->left();
   Expression* right = binop->right();
 
   Visit(left);
   Visit(right);
 }
 
 
 void BytecodeGenerator::VisitLogicalOrExpression(BinaryOperation* binop) {
@@ skipping 27 matching lines @@
     BytecodeLabel end_label;
 
     Visit(left);
     builder()->JumpIfToBooleanFalse(&end_label);
     Visit(right);
     builder()->Bind(&end_label);
   }
 }
 
 
+void BytecodeGenerator::VisitObjectLiteralAccessor(
+    Register home_object, ObjectLiteralProperty* property, Register value_out) {
+  // TODO(rmcilroy): Replace value_out with VisitForRegister();
+  if (property == nullptr) {
+    builder()->LoadNull().StoreAccumulatorInRegister(value_out);
+  } else {
+    Visit(property->value());
+    builder()->StoreAccumulatorInRegister(value_out);
+    VisitSetHomeObject(value_out, home_object, property);
+  }
+}
+
+
+void BytecodeGenerator::VisitSetHomeObject(Register value, Register home_object,
+                                           ObjectLiteralProperty* property,
+                                           int slot_number) {
+  Expression* expr = property->value();
+  if (!FunctionLiteral::NeedsHomeObject(expr)) return;
+
+  // TODO(rmcilroy): Remove UNIMPLEMENTED once we have tests for setting the
+  // home object.
+  UNIMPLEMENTED();
+
+  TemporaryRegisterScope temporary_register_scope(builder());
+  Register name = temporary_register_scope.NewRegister();
+  isolate()->factory()->home_object_symbol();
+  builder()
+      ->LoadLiteral(isolate()->factory()->home_object_symbol())
+      .StoreAccumulatorInRegister(name)
+      .StoreNamedProperty(home_object, name,
+                          feedback_index(property->GetSlot(slot_number)),
+                          language_mode());
+}
+
+
+void BytecodeGenerator::VisitFunctionClosureForContext() {
+  Scope* closure_scope = execution_context()->scope()->ClosureScope();
+  if (closure_scope->is_script_scope() ||
+      closure_scope->is_module_scope()) {
+    // Contexts nested in the native context have a canonical empty function as
+    // their closure, not the anonymous closure containing the global code.
+    // Pass a SMI sentinel and let the runtime look up the empty function.
+    builder()->LoadLiteral(Smi::FromInt(0));
+  } else {
+    DCHECK(closure_scope->is_function_scope());
+    builder()->LoadAccumulatorWithRegister(Register::function_closure());
+  }
+}
+
+
+Register BytecodeGenerator::NextContextRegister() const {
+  if (execution_context() == nullptr) {
+    // Return the incoming function context for the outermost execution context.
+    return Register::function_context();
+  }
+  Register previous = execution_context()->reg();
+  if (previous == Register::function_context()) {
+    // If the previous context was the incoming function context, then the next
+    // context register is the first local context register.
+    return builder_.first_context_register();
+  } else {
+    // Otherwise use the next local context register.
+    DCHECK_LT(previous.index(), builder_.last_context_register().index());
+    return Register(previous.index() + 1);
+  }
+}
+
+
 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);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8