Collect closure functions in isolate

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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/isolate.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
@@ skipping 1499 matching lines @@
   if ((*a)->usage_counter() > (*b)->usage_counter()) {
     return -1;
   } else if ((*a)->usage_counter() < (*b)->usage_counter()) {
     return 1;
   } else {
     return 0;
   }
 }
 
 
+void Isolate::AddClosureFunction(const Function& function) const {
+  GrowableObjectArray& closures =
+      GrowableObjectArray::Handle(object_store()->closure_functions());
+  ASSERT(!closures.IsNull());
+  ASSERT(function.IsNonImplicitClosureFunction());
+  closures.Add(function, Heap::kOld);
+}
+
+
+// If the linear lookup turns out to be too expensive, the list
+// of closures could be maintained in a hash map, with the key
+// being the token position of the closure. There are almost no
+// collisions with this simple hash value. However, iterating over
+// all closure functions becomes more difficult, especially when
+// the list/map changes while iterating over it.
+RawFunction* Isolate::LookupClosureFunction(const Function& parent,
+                                            intptr_t token_pos) const {
+  const GrowableObjectArray& closures =
+      GrowableObjectArray::Handle(object_store()->closure_functions());
+  ASSERT(!closures.IsNull());
+  Function& closure = Function::Handle();
+  intptr_t num_closures = closures.Length();
+  for (intptr_t i = 0; i < num_closures; i++) {
+    closure ^= closures.At(i);
+    if ((closure.token_pos() == token_pos) &&
+        (closure.parent_function() == parent.raw())) {
+      return closure.raw();
+    }
+  }
+  return Function::null();
+}
+
+
+intptr_t Isolate::FindClosureIndex(const Function& needle) const {
+  const GrowableObjectArray& closures_array =
+      GrowableObjectArray::Handle(object_store()->closure_functions());
+  intptr_t num_closures = closures_array.Length();
+  for (intptr_t i = 0; i < num_closures; i++) {
+    if (closures_array.At(i) == needle.raw()) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+
+RawFunction* Isolate::ClosureFunctionFromIndex(intptr_t idx) const {
+  const GrowableObjectArray& closures_array =
+      GrowableObjectArray::Handle(object_store()->closure_functions());
+  if ((idx < 0) || (idx >= closures_array.Length())) {
+    return Function::null();
+  }
+  return Function::RawCast(closures_array.At(idx));
+}
+
+
 static void AddFunctionsFromClass(const Class& cls,
                                   GrowableArray<const Function*>* functions) {
   const Array& class_functions = Array::Handle(cls.functions());
   // Class 'dynamic' is allocated/initialized in a special way, leaving
   // the functions field NULL instead of empty.
   const int func_len = class_functions.IsNull() ? 0 : class_functions.Length();
   for (int j = 0; j < func_len; j++) {
     Function& function = Function::Handle();
     function ^= class_functions.At(j);
     if (function.usage_counter() > 0) {
@@ skipping 1000 matching lines @@
 }
 
 
 RawInstance* IsolateSpawnState::BuildMessage(Thread* thread) {
   return DeserializeObject(thread,
                            serialized_message_, serialized_message_len_);
 }
 
 
 }  // namespace dart