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

src/interpreter/bytecode-generator.h

Index: src/interpreter/bytecode-generator.h
diff --git a/src/interpreter/bytecode-generator.h b/src/interpreter/bytecode-generator.h
index 6ea4cd75aec25f2b5f567929c149c13ad118115c..b3cff072a1bd06dbe2c1d14b27dc14fa93b53aaa 100644
--- a/src/interpreter/bytecode-generator.h
+++ b/src/interpreter/bytecode-generator.h
@@ -33,6 +33,7 @@ class BytecodeGenerator : public AstVisitor {
   class ControlScopeForIteration;
 
   void MakeBytecodeBody();
+  Register NextContextRegister() const;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
@@ -44,6 +45,7 @@ class BytecodeGenerator : public AstVisitor {
   void VisitVariableLoad(Variable* variable, FeedbackVectorSlot slot);
   void VisitVariableAssignment(Variable* variable, FeedbackVectorSlot slot);
   void VisitNewLocalFunctionContext();
+  void VisitNewLocalBlockContext(Scope* scope);
   void VisitSetHomeObject(Register value, Register home_object,
                           ObjectLiteralProperty* property, int slot_number = 0);
   void VisitObjectLiteralAccessor(Register home_object,
@@ -65,11 +67,13 @@ class BytecodeGenerator : public AstVisitor {
   inline CompilationInfo* info() const { return info_; }
   inline void set_info(CompilationInfo* info) { info_ = info; }
 
-  inline ControlScope* control_scope() const { return control_scope_; }
-  inline void set_control_scope(ControlScope* scope) { control_scope_ = scope; }
-  inline Register current_context() const { return current_context_; }
-  inline void set_current_context(Register context) {
-    current_context_ = context;
+  inline ControlScope* execution_control() const { return execution_control_; }

[oth, 2015/10/16 09:30:43]

Previously the name gave a hint to the likely type. Now it's unrelated. 

Would be better to sed -i s/ControlScope/ExecutionControl/g and
s/ContextScope/ExecutionContext/g or leave as-is.

[rmcilroy, 2015/10/16 11:19:04]

I was going with consistency with AstGraphBuilder which has them named this way.
I think the type should have Scope in it to make it obvious the type has scoped
behaviour, but this isn't necessary when you want to get the current control
object, so execution_control makes sense there. Personally I don't think it's
necessary that the getter is called the same as the type (this is often the
case, e.g., globals() returns ZoneVector<Handle<Object>>*) happy to chat if you
feel strongly about this though.

+  inline void set_execution_control(ControlScope* scope) {
+    execution_control_ = scope;
+  }
+  inline ContextScope* execution_context() const { return execution_context_; }
+  inline void set_execution_context(ContextScope* context) {
+    execution_context_ = context;
   }
 
   ZoneVector<Handle<Object>>* globals() { return &globals_; }
@@ -83,9 +87,8 @@ class BytecodeGenerator : public AstVisitor {
   CompilationInfo* info_;
   Scope* scope_;
   ZoneVector<Handle<Object>> globals_;
-  ControlScope* control_scope_;
-
-  Register current_context_;
+  ControlScope* execution_control_;
+  ContextScope* execution_context_;
 };
 
 }  // namespace interpreter