Improve function compilation times for swarm application startup.

vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1549 matching lines @@
   for (intptr_t i = 0; i < private_len; i++) {
     if (name.CharAt(i) != private_name.CharAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawFunction* Class::LookupFunction(const String& name) const {
-  Array& funcs = Array::Handle(functions());
-  Function& function = Function::Handle();
-  String& function_name = String::Handle();
+  Isolate* isolate = Isolate::Current();
+  Array& funcs = Array::Handle(isolate, functions());
+  Function& function = Function::Handle(isolate, Function::null());
+  String& function_name = String::Handle(isolate, String::null());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (function_name.Equals(name) || MatchesPrivateName(function_name, name)) {
       return function.raw();
     }
   }
 
   // No function found.
@@ skipping 25 matching lines @@
       return Field::null();
     }
     return field.raw();
   }
   // No field found.
   return Field::null();
 }
 
 
 RawField* Class::LookupField(const String& name) const {
-  const Array& flds = Array::Handle(fields());
-  Field& field = Field::Handle();
-  String& field_name = String::Handle();
+  Isolate* isolate = Isolate::Current();
+  const Array& flds = Array::Handle(isolate, fields());
+  Field& field = Field::Handle(isolate, Field::null());
+  String& field_name = String::Handle(isolate, String::null());
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
     if (field_name.Equals(name) || MatchesPrivateName(field_name, name)) {
       return field.raw();
     }
   }
   // No field found.
   return Field::null();
 }
 
 
 RawLibraryPrefix* Class::LookupLibraryPrefix(const String& name) const {
-  LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
-  const Library& lib = Library::Handle(library());
-  Object& obj = Object::Handle(lib.LookupLocalObject(name));
+  Isolate* isolate = Isolate::Current();
+  LibraryPrefix& lib_prefix = LibraryPrefix::Handle(isolate,
+                                                    LibraryPrefix::null());
+  const Library& lib = Library::Handle(isolate, library());
+  Object& obj = Object::Handle(isolate, lib.LookupLocalObject(name));
   if (!obj.IsNull()) {
     if (obj.IsLibraryPrefix()) {
       lib_prefix ^= obj.raw();
     }
   }
   return lib_prefix.raw();
 }
 
 
 const char* Class::ToCString() const {
@@ skipping 2324 matching lines @@
 
 
 void Library::AddClass(const Class& cls) const {
   AddObject(cls, String::Handle(cls.Name()));
   // Link class to this library.
   cls.set_library(*this);
 }
 
 
 RawObject* Library::LookupLocalObject(const String& name) const {
-  const Array& dict = Array::Handle(dictionary());
+  Isolate* isolate = Isolate::Current();
+  const Array& dict = Array::Handle(isolate, dictionary());
   intptr_t dict_size = dict.Length() - 1;
   intptr_t index = name.Hash() % dict_size;
 
-  Object& entry = Object::Handle();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-  Field& field = Field::Handle();
-  LibraryPrefix& library_prefix = LibraryPrefix::Handle();
-  String& entry_name = String::Handle();
+  Object& entry = Object::Handle(isolate, Object::null());
+  Class& cls = Class::Handle(isolate, Class::null());
+  Function& func = Function::Handle(isolate, Function::null());
+  Field& field = Field::Handle(isolate, Field::null());
+  LibraryPrefix& library_prefix = LibraryPrefix::Handle(isolate,
+                                                        LibraryPrefix::null());
+  String& entry_name = String::Handle(isolate, String::null());
   entry = dict.At(index);
   // Search the entry in the hash set.
   while (!entry.IsNull()) {
     // TODO(hausner): find a better way to handle this polymorphism.
     // Either introduce a common base class for Class, Function, Field
     // and LibraryPrefix or make the name() function virtual in Object.
     if (entry.IsClass()) {
       cls ^= entry.raw();
       entry_name = cls.Name();
     } else if (entry.IsFunction()) {
@@ skipping 42 matching lines @@
   return Object::null();
 }
 
 
 RawObject* Library::LookupObject(const String& name) const {
   return LookupObjectFiltered(name, Library::Handle());
 }
 
 
 RawLibrary* Library::LookupObjectInImporter(const String& name) const {
-  const Array& imported_into_libs = Array::Handle(this->imported_into());
-  Library& lib = Library::Handle();
-  Object& obj = Object::Handle();
+  Isolate* isolate = Isolate::Current();
+  const Array& imported_into_libs = Array::Handle(isolate,
+                                                  this->imported_into());
+  Library& lib = Library::Handle(isolate, Library::null());
+  Object& obj = Object::Handle(isolate, Object::null());
   for (intptr_t i = 0; i < this->num_imported_into(); i++) {
     lib ^= imported_into_libs.At(i);
     obj = lib.LookupObjectFiltered(name, *this);
     if (!obj.IsNull()) {
       // If the object found is a class, field or function extract the
       // library in which it is defined as it might be defined in one of
       // the imported libraries.
-      Class& cls = Class::Handle();
-      Function& func = Function::Handle();
-      Field& field = Field::Handle();
+      Class& cls = Class::Handle(isolate, Class::null());
+      Function& func = Function::Handle(isolate, Function::null());
+      Field& field = Field::Handle(isolate, Field::null());
       if (obj.IsClass()) {
         cls ^= obj.raw();
         lib ^= cls.library();
       } else if (obj.IsFunction()) {
         func ^= obj.raw();
         cls ^= func.owner();
         lib ^= cls.library();
       } else if (obj.IsField()) {
         field ^= obj.raw();
         cls ^= field.owner();
@@ skipping 91 matching lines @@
     anon_array = Array::Grow(anon_array, new_len);
     StorePointer(&raw_ptr()->anonymous_classes_, anon_array.raw());
   }
   anon_array.SetAt(num_anonymous, cls);
   num_anonymous++;
   raw_ptr()->num_anonymous_ = num_anonymous;
 }
 
 
 RawLibrary* Library::LookupImport(const String& url) const {
-  const Array& imports = Array::Handle(this->imports());
+  Isolate* isolate = Isolate::Current();
+  const Array& imports = Array::Handle(isolate, this->imports());
   intptr_t num_imports = this->num_imports();
-  Library& lib = Library::Handle();
-  String& import_url = String::Handle();
+  Library& lib = Library::Handle(isolate, Library::null());
+  String& import_url = String::Handle(isolate, String::null());
   for (int i = 0; i < num_imports; i++) {
     lib ^= imports.At(i);
     import_url = lib.url();
     if (url.Equals(import_url)) {
       return lib.raw();
     }
   }
   return Library::null();
 }
 
@@ skipping 133 matching lines @@
                 "%s%d",
                 kNativeWrappersClass,
                 fld_cnt);
     cls_name = String::NewSymbol(name_buffer);
     Class::NewNativeWrapper(&native_flds_lib, cls_name, fld_cnt);
   }
 }
 
 
 RawLibrary* Library::LookupLibrary(const String &url) {
-  Library& lib = Library::Handle();
-  String& lib_url = String::Handle();
-  lib = Isolate::Current()->object_store()->registered_libraries();
+  Isolate* isolate = Isolate::Current();
+  Library& lib = Library::Handle(isolate, Library::null());
+  String& lib_url = String::Handle(isolate, String::null());
+  lib = isolate->object_store()->registered_libraries();
   while (!lib.IsNull()) {
     lib_url = lib.url();
     if (lib_url.Equals(url)) {
       return lib.raw();
     }
     lib = lib.next_registered();
   }
   return Library::null();
 }
 
@@ skipping 3265 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart