Move code for accessing captured variables into the IL.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 126 matching lines @@
     join->SetSuccessor(test_fragment.entry());
     body_exit->SetSuccessor(join);
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
   exit_ = *test_fragment.false_successor_address() = new TargetEntryInstr();
 }
 
 
+Computation* EffectGraphVisitor::BuildStoreLocal(
+    const LocalVariable& local, Value* value) {
+  if (local.is_captured()) {
+    intptr_t delta = owner()->context_level() -
+                     local.owner()->context_level();
+    ASSERT(delta >= 0);
+    BindInstr* context = new BindInstr(new CurrentContextComp());
+    AddInstruction(context);
+    Value* context_value = new UseVal(context);
+    while (delta-- > 0) {
+      BindInstr* load = new BindInstr(new NativeLoadFieldComp(
+          context_value, Context::parent_offset()));
+      AddInstruction(load);
+      context_value = new UseVal(load);
+    }
+    Computation* store = new NativeStoreFieldComp(
+        context_value, Context::variable_offset(local.index()), value);
+    return store;
+  } else {
+    return new StoreLocalComp(local, value, owner()->context_level());
+  }
+}
+
+
+Computation* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local) {
+  if (local.is_captured()) {
+    intptr_t delta = owner()->context_level() -
+                     local.owner()->context_level();
+    ASSERT(delta >= 0);
+    BindInstr* context = new BindInstr(new CurrentContextComp());
+    AddInstruction(context);
+    Value* context_value = new UseVal(context);
+    while (delta-- > 0) {
+      BindInstr* load = new BindInstr(new NativeLoadFieldComp(
+          context_value, Context::parent_offset()));
+      AddInstruction(load);
+      context_value = new UseVal(load);
+    }
+    Computation* store = new NativeLoadFieldComp(
+        context_value, Context::variable_offset(local.index()));
+    return store;
+  } else {
+    return new LoadLocalComp(local, owner()->context_level());
+  }
+}
+
+
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
   BindInstr* context = new BindInstr(new CurrentContextComp());
   AddInstruction(context);
-  StoreLocalComp* store_context =
-      new StoreLocalComp(variable, new UseVal(context),
-                         owner()->context_level());
+  Computation* store_context = BuildStoreLocal(variable, new UseVal(context));
   AddInstruction(new DoInstr(store_context));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
-  BindInstr* load_saved_context =
-      new BindInstr(new LoadLocalComp(variable, owner()->context_level()));
+  BindInstr* load_saved_context = new BindInstr(BuildLoadLocal(variable));
   AddInstruction(load_saved_context);
   DoInstr* store_context =
       new DoInstr(new StoreContextComp(new UseVal(load_saved_context)));
   AddInstruction(store_context);
 }
 
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
@@ skipping 228 matching lines @@
       right_value = new UseVal(assert_boolean);
     }
     BindInstr* constant_true = new BindInstr(new ConstantVal(bool_true));
     for_right.AddInstruction(constant_true);
     BindInstr* comp =
         new BindInstr(new StrictCompareComp(Token::kEQ_STRICT,
                                             right_value,
                                             new UseVal(constant_true)));
     for_right.AddInstruction(comp);
     for_right.AddInstruction(
-        new DoInstr(new StoreLocalComp(
+        new DoInstr(BuildStoreLocal(
             *owner()->parsed_function().expression_temp_var(),
-            new UseVal(comp),
-            owner()->context_level())));
+            new UseVal(comp))));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
       BindInstr* constant_false = new BindInstr(new ConstantVal(bool_false));
       for_false.AddInstruction(constant_false);
       for_false.AddInstruction(
-          new DoInstr(new StoreLocalComp(
+          new DoInstr(BuildStoreLocal(
               *owner()->parsed_function().expression_temp_var(),
-              new UseVal(constant_false),
-              owner()->context_level())));
+              new UseVal(constant_false))));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
       BindInstr* constant_true = new BindInstr(new ConstantVal(bool_true));
       for_true.AddInstruction(constant_true);
       for_true.AddInstruction(
-          new DoInstr(new StoreLocalComp(
+          new DoInstr(BuildStoreLocal(
               *owner()->parsed_function().expression_temp_var(),
-              new UseVal(constant_true),
-              owner()->context_level())));
+              new UseVal(constant_true))));
       Join(for_test, for_true, for_right);
     }
     ReturnComputation(
-        new LoadLocalComp(*owner()->parsed_function().expression_temp_var(),
-                          owner()->context_level()));
+        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::CompiletimeStringInterpolation(
     const Function& interpol_func, const Array& literals) {
   // Do nothing.
 }
@@ skipping 314 matching lines @@
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
 
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
-  for_true.AddInstruction(
-      new DoInstr(
-          new StoreLocalComp(*owner()->parsed_function().expression_temp_var(),
-                             for_true.value(),
-                             owner()->context_level())));
+  for_true.AddInstruction(new DoInstr(BuildStoreLocal(
+      *owner()->parsed_function().expression_temp_var(), for_true.value())));
 
   ValueGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
-  for_false.AddInstruction(
-      new DoInstr(
-          new StoreLocalComp(*owner()->parsed_function().expression_temp_var(),
-                             for_false.value(),
-                             owner()->context_level())));
+  for_false.AddInstruction(new DoInstr(BuildStoreLocal(
+      *owner()->parsed_function().expression_temp_var(), for_false.value())));
 
   Join(for_test, for_true, for_false);
   ReturnComputation(
-      new LoadLocalComp(*owner()->parsed_function().expression_temp_var(),
-                        owner()->context_level()));
+      BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_index());
@@ skipping 703 matching lines @@
     args->Add(new UseVal(type_args));
     args->Add(new UseVal(no_instantiator));
     return;
   }
   // The type arguments are uninstantiated. The generated pseudo code:
   //   t1 = InstantiatorTypeArguments();
   //   t2 = ExtractConstructorTypeArguments(t1);
   //   t1 = ExtractConstructorInstantiator(t1, t2);
   //   t_n   <- t2
   //   t_n+1 <- t1
-  const intptr_t context_level = owner()->context_level();
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& t1 = *owner()->parsed_function().expression_temp_var();
   const LocalVariable& t2 = node->allocated_object_var();
-
   Value* instantiator = BuildInstantiatorTypeArguments(node->token_index());
   ASSERT(instantiator->IsUse());
-  Definition* stored_instantiator = new BindInstr(new StoreLocalComp(
-      t1, instantiator, context_level));
+  Definition* stored_instantiator = new BindInstr(
+      BuildStoreLocal(t1, instantiator));
   AddInstruction(stored_instantiator);
   // t1: instantiator type arguments.
 
   BindInstr* extract_type_arguments = new BindInstr(
       new ExtractConstructorTypeArgumentsComp(
           node->token_index(),
           owner()->try_index(),
           node->type_arguments(),
           new UseVal(stored_instantiator)));
   AddInstruction(extract_type_arguments);
 
-  Instruction* stored_type_arguments = new DoInstr(new StoreLocalComp(
-      t2, new UseVal(extract_type_arguments), context_level));
+  Instruction* stored_type_arguments = new DoInstr(
+      BuildStoreLocal(t2, new UseVal(extract_type_arguments)));
   AddInstruction(stored_type_arguments);
   // t2: extracted constructor type arguments.
-  Definition* load_instantiator = new BindInstr(
-      new LoadLocalComp(t1, context_level));
+  Definition* load_instantiator = new BindInstr(BuildLoadLocal(t1));
   AddInstruction(load_instantiator);
-  Definition* load_type_arguments = new BindInstr(
-      new LoadLocalComp(t2, context_level));
+  Definition* load_type_arguments = new BindInstr(BuildLoadLocal(t2));
   AddInstruction(load_type_arguments);
 
   BindInstr* extract_instantiator =
       new BindInstr(new ExtractConstructorInstantiatorComp(
                         node,
                         new UseVal(load_instantiator),
                         new UseVal(load_type_arguments)));
   AddInstruction(extract_instantiator);
-  AddInstruction(new DoInstr(new StoreLocalComp(
-      t1, new UseVal(extract_instantiator), context_level)));
+  AddInstruction(new DoInstr(
+      BuildStoreLocal(t1, new UseVal(extract_instantiator))));
   // t2: extracted constructor type arguments.
   // t1: extracted constructor instantiator.
-  Definition* load_0 = new BindInstr(new LoadLocalComp(t2, context_level));
+  Definition* load_0 = new BindInstr(BuildLoadLocal(t2));
   AddInstruction(load_0);
-  Definition* load_1 = new BindInstr(new LoadLocalComp(t1, context_level));
+  Definition* load_1 = new BindInstr(BuildLoadLocal(t1));
   AddInstruction(load_1);
   args->Add(new UseVal(load_0));
   args->Add(new UseVal(load_1));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
   Definition* allocate = BuildObjectAllocation(node);
-  StoreLocalComp* store_allocated = new StoreLocalComp(
+  Computation* store_allocated = BuildStoreLocal(
       node->allocated_object_var(),
-      new UseVal(allocate),
-      owner()->context_level());
+      new UseVal(allocate));
   Definition* allocated_value = new BindInstr(store_allocated);
   AddInstruction(allocated_value);
   BuildConstructorCall(node, new UseVal(allocated_value));
-  LoadLocalComp* load_allocated = new LoadLocalComp(
-      node->allocated_object_var(),
-      owner()->context_level());
+  Computation* load_allocated = BuildLoadLocal(
+      node->allocated_object_var());
   allocated_value = new BindInstr(load_allocated);
   AddInstruction(allocated_value);
   ReturnValue(new UseVal(allocated_value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
@@ skipping 76 matching lines @@
   if (node->HasPseudo()) {
     EffectGraphVisitor for_pseudo(owner(), temp_index());
     node->pseudo()->Visit(&for_pseudo);
     Append(for_pseudo);
   }
 }
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   EffectGraphVisitor::VisitLoadLocalNode(node);
-  LoadLocalComp* load = new LoadLocalComp(node->local(),
-                                          owner()->context_level());
+  Computation* load = BuildLoadLocal(node->local());
   ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
-  StoreLocalComp* store =
-      new StoreLocalComp(node->local(), store_value, owner()->context_level());
+  Computation* store = BuildStoreLocal(node->local(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadInstanceFieldComp* load =
@@ skipping 123 matching lines @@
                                               num_context_variables));
     AddInstruction(allocated_context);
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
       BindInstr* current_context = new BindInstr(new CurrentContextComp());
       AddInstruction(current_context);
-      StoreLocalComp* store_local = new StoreLocalComp(
+      Computation* store_local = BuildStoreLocal(
           *owner()->parsed_function().saved_context_var(),
-          new UseVal(current_context),
-          0);
+          new UseVal(current_context));
       AddInstruction(new DoInstr(store_local));
       BindInstr* null_context =
           new BindInstr(new ConstantVal(Object::ZoneHandle()));
       AddInstruction(null_context);
       StoreContextComp* store_context =
           new StoreContextComp(new UseVal(null_context));
       AddInstruction(new DoInstr(store_context));
     }
 
     ChainContextComp* chain_context =
@@ skipping 16 matching lines @@
           // Create a temporary local describing the original position.
           const String& temp_name = String::ZoneHandle(String::Concat(
               parameter.name(), String::Handle(String::NewSymbol("-orig"))));
           LocalVariable* temp_local = new LocalVariable(
               0,  // Token index.
               temp_name,
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
-          BindInstr* load =
-              new BindInstr(new LoadLocalComp(*temp_local,
-                                              owner()->context_level()));
+          BindInstr* load = new BindInstr(BuildLoadLocal(*temp_local));
           AddInstruction(load);
-          StoreLocalComp* store_local = new StoreLocalComp(
-              parameter,
-              new UseVal(load),
-              owner()->context_level());
+          Computation* store_local =
+              BuildStoreLocal(parameter, new UseVal(load));
           AddInstruction(new DoInstr(store_local));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
           BindInstr* null_constant =
               new BindInstr(new ConstantVal(Object::ZoneHandle()));
           AddInstruction(null_constant);
-          StoreLocalComp* clear_local = new StoreLocalComp(
-              *temp_local,
-              new UseVal(null_constant),
-              owner()->context_level());
+          Computation* clear_local =
+              BuildStoreLocal(*temp_local, new UseVal(null_constant));
           AddInstruction(new DoInstr(clear_local));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     const int num_params =
         owner()->parsed_function().function().NumberOfParameters();
     for (int pos = 0; pos < num_params; pos++) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(NULL, parameter.type())) {
-        BindInstr* load =
-            new BindInstr(new LoadLocalComp(parameter,
-                                            owner()->context_level()));
+        BindInstr* load = new BindInstr(BuildLoadLocal(parameter));
         AddInstruction(load);
         BuildAssertAssignable(parameter.token_index(),
                               new UseVal(load),
                               parameter.type(),
                               parameter.name());
       }
     }
   }
 
   intptr_t i = 0;
@@ skipping 296 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart