Save the entry context for a function that has captured loop variables.

runtime/vm/scopes.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/scopes.h"
 
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ skipping 134 matching lines @@
     ASSERT(variable->owner()->context_level() == context_level());
   }
   variable->set_index(num_context_variables_++);
 }
 
 
 int LocalScope::AllocateVariables(int first_parameter_index,
                                   int num_parameters,
                                   int first_frame_index,
                                   LocalScope* loop_owner,
-                                  LocalScope** context_owner) {
+                                  LocalScope** context_owner,
+                                  bool* found_captured_variables) {
   // We should not allocate variables of nested functions while compiling an
   // enclosing function.
   ASSERT(function_level() == 0);
   ASSERT(num_parameters >= 0);
 
   // Keep track of the current loop owner scope, that is of the highest parent
   // scope at the same loop level as this scope.
   if (loop_level() > loop_owner->loop_level()) {
     loop_owner = this;
   }
   // Parameters must be listed first and must all appear in the top scope.
   ASSERT(num_parameters <= num_variables());
   int pos = 0;  // Current variable position.
   int frame_index = first_parameter_index;  // Current free frame index.
   while (pos < num_parameters) {
     LocalVariable* parameter = VariableAt(pos);
     pos++;
     ASSERT(parameter->owner() == this);
     if (parameter->is_captured()) {
       // A captured parameter has a slot allocated in the frame and one in the
       // context, where it gets copied to. The parameter index reflects the
       // context allocation index.
       frame_index--;
       loop_owner->AllocateContextVariable(parameter, context_owner);
+      *found_captured_variables = true;
     } else {
       parameter->set_index(frame_index--);
     }
   }
   // No overlapping of parameters and locals.
   ASSERT(frame_index >= first_frame_index);
   frame_index = first_frame_index;
   while (pos < num_variables()) {
     LocalVariable* variable = VariableAt(pos);
     pos++;
     if (variable->owner() == this) {
       if (variable->is_captured()) {
         loop_owner->AllocateContextVariable(variable, context_owner);
+        *found_captured_variables = true;
       } else {
         variable->set_index(frame_index--);
       }
     }
   }
   // Allocate variables of all children.
   int min_frame_index = frame_index;
   LocalScope* child = this->child();
   while (child != NULL) {
     LocalScope* child_context_owner = *context_owner;
     int const dummy_parameter_index = 0;  // Ignored, since no parameters.
     int const num_parameters_in_child = 0;  // No parameters in children scopes.
     int child_frame_index = child->AllocateVariables(dummy_parameter_index,
                                                      num_parameters_in_child,
                                                      frame_index,
                                                      loop_owner,
-                                                     &child_context_owner);
+                                                     &child_context_owner,
+                                                     found_captured_variables);
     if (child_frame_index < min_frame_index) {
       min_frame_index = child_frame_index;
     }
     // A context allocated at a deeper loop level than the current loop level is
     // not shared between children.
     if ((child_context_owner != *context_owner) &&
         (child_context_owner->loop_level() <= loop_owner->loop_level())) {
       *context_owner = child_context_owner;  // Share context between siblings.
     }
     child = child->sibling();
@@ skipping 407 matching lines @@
     return fixed_parameter_count - (index() - kParamEndSlotFromFp);
   } else {
     // Shift negative indexes so that the lowest one is 0 (they are still
     // non-positive).
     return fixed_parameter_count - (index() - kFirstLocalSlotFromFp);
   }
 }
 
 
 }  // namespace dart