1. Restructure reusable handles to make individual Scopes for each handle type

runtime/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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 1790 matching lines @@
   new_arr.SetAt(arr.Length(), function);
   SetFunctions(new_arr);
 }
 
 
 intptr_t Class::FindFunctionIndex(const Function& needle) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return -1;
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& funcs = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FUNCTION_HANDLESCOPE(isolate);
+  Array& funcs = isolate->ArrayHandle();
+  Function& function = isolate->FunctionHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
-  Function& function = reused_handles.FunctionHandle();
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     if (function.raw() == needle.raw()) {
       return i;
     }
   }
   // No function found.
   return -1;
 }
@@ skipping 27 matching lines @@
   ASSERT(!closure_func.IsNull());
   return closure_func.raw();
 }
 
 
 intptr_t Class::FindImplicitClosureFunctionIndex(const Function& needle) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return -1;
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& funcs = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FUNCTION_HANDLESCOPE(isolate);
+  Array& funcs = isolate->ArrayHandle();
+  Function& function = isolate->FunctionHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
-  Function& function = reused_handles.FunctionHandle();
-  Function& implicit_closure = Function::Handle();
+  Function& implicit_closure = Function::Handle(isolate);
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     implicit_closure ^= function.implicit_closure_function();
     if (implicit_closure.IsNull()) {
       // Skip non-implicit closure functions.
       continue;
     }
     if (needle.raw() == implicit_closure.raw()) {
       return i;
     }
   }
   // No function found.
   return -1;
 }
 
 
 
 intptr_t Class::FindInvocationDispatcherFunctionIndex(
     const Function& needle) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return -1;
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& funcs = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_OBJECT_HANDLESCOPE(isolate);
+  Array& funcs = isolate->ArrayHandle();
+  Object& object = isolate->ObjectHandle();
   funcs ^= invocation_dispatcher_cache();
   ASSERT(!funcs.IsNull());
-  Object& object = reused_handles.ObjectHandle();
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     object = funcs.At(i);
     // The invocation_dispatcher_cache is a table with some entries that
     // are functions.
     if (object.IsFunction()) {
       if (Function::Cast(object).raw() == needle.raw()) {
-      return i;
+        return i;
       }
     }
   }
   // No function found.
   return -1;
 }
 
 
 
 RawFunction* Class::InvocationDispatcherFunctionFromIndex(intptr_t idx) const {
-  ReusableHandleScope reused_handles(Isolate::Current());
-  Array& dispatcher_cache = reused_handles.ArrayHandle();
+  Isolate* isolate = Isolate::Current();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_OBJECT_HANDLESCOPE(isolate);
+  Array& dispatcher_cache = isolate->ArrayHandle();
+  Object& object = isolate->ObjectHandle();
   dispatcher_cache ^= invocation_dispatcher_cache();
-  Object& object = reused_handles.ObjectHandle();
   object = dispatcher_cache.At(idx);
   if (!object.IsFunction()) {
     return Function::null();
   }
   return Function::Cast(object).raw();
 }
 
 
 void Class::AddClosureFunction(const Function& function) const {
   GrowableObjectArray& closures =
@@ skipping 33 matching lines @@
     closure ^= closures.At(best_fit_index);
   }
   return closure.raw();
 }
 
 intptr_t Class::FindClosureIndex(const Function& needle) const {
   if (closures() == GrowableObjectArray::null()) {
     return -1;
   }
   Isolate* isolate = Isolate::Current();
-  ReusableHandleScope reused_handles(isolate);
   const GrowableObjectArray& closures_array =
       GrowableObjectArray::Handle(isolate, closures());
-  Function& closure = reused_handles.FunctionHandle();
+  REUSABLE_FUNCTION_HANDLESCOPE(isolate);
+  Function& closure = isolate->FunctionHandle();
   intptr_t num_closures = closures_array.Length();
   for (intptr_t i = 0; i < num_closures; i++) {
     closure ^= closures_array.At(i);
     ASSERT(!closure.IsNull());
     if (closure.raw() == needle.raw()) {
       return i;
     }
   }
   return -1;
 }
@@ skipping 33 matching lines @@
 }
 
 
 intptr_t Class::NumTypeParameters(Isolate* isolate) const {
   if (IsMixinApplication() && !is_mixin_type_applied()) {
     ClassFinalizer::ApplyMixinType(*this);
   }
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
-  ReusableHandleScope reused_handles(isolate);
-  TypeArguments& type_params = reused_handles.TypeArgumentsHandle();
+  REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(isolate);
+  TypeArguments& type_params = isolate->TypeArgumentsHandle();
   type_params = type_parameters();
   return type_params.Length();
 }
 
 
 intptr_t Class::NumOwnTypeArguments() const {
   // Return cached value if already calculated.
   if (num_own_type_arguments() != kUnknownNumTypeArguments) {
     return num_own_type_arguments();
   }
@@ skipping 119 matching lines @@
          value.IsMixinAppType());
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 // Return a TypeParameter if the type_name is a type parameter of this class.
 // Return null otherwise.
 RawTypeParameter* Class::LookupTypeParameter(const String& type_name) const {
   ASSERT(!type_name.IsNull());
   Isolate* isolate = Isolate::Current();
-  ReusableHandleScope reused_handles(isolate);
-  TypeArguments& type_params = reused_handles.TypeArgumentsHandle();
+  REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(isolate);
+  REUSABLE_TYPE_PARAMETER_HANDLESCOPE(isolate);
+  REUSABLE_STRING_HANDLESCOPE(isolate);
+  TypeArguments& type_params = isolate->TypeArgumentsHandle();
+  TypeParameter&  type_param = isolate->TypeParameterHandle();
+  String& type_param_name = isolate->StringHandle();
+
   type_params ^= type_parameters();
-  TypeParameter& type_param = reused_handles.TypeParameterHandle();
-  String& type_param_name = reused_handles.StringHandle();
   if (!type_params.IsNull()) {
     const intptr_t num_type_params = type_params.Length();
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
       type_param_name = type_param.name();
       if (type_param_name.Equals(type_name)) {
         return type_param.raw();
       }
     }
   }
@@ skipping 514 matching lines @@
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 intptr_t Class::FindFieldIndex(const Field& needle) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return -1;
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& fields_array = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FIELD_HANDLESCOPE(isolate);
+  REUSABLE_STRING_HANDLESCOPE(isolate);
+  Array& fields_array = isolate->ArrayHandle();
+  Field& field = isolate->FieldHandle();
+  String& field_name = isolate->StringHandle();
   fields_array ^= fields();
   ASSERT(!fields_array.IsNull());
-  Field& field = reused_handles.FieldHandle();
-  String& field_name = reused_handles.StringHandle();
   String& needle_name = String::Handle(isolate);
   needle_name ^= needle.name();
   const intptr_t len = fields_array.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= fields_array.At(i);
     field_name ^= field.name();
     if (field_name.Equals(needle_name)) {
       return i;
     }
   }
@@ skipping 815 matching lines @@
   }
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunction(const String& name, intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& funcs = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FUNCTION_HANDLESCOPE(isolate);
+  Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
-  Function& function = reused_handles.FunctionHandle();
   const intptr_t len = funcs.Length();
+  Function& function = isolate->FunctionHandle();
   if (name.IsSymbol()) {
     // Quick Symbol compare.
     NoGCScope no_gc;
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       if (function.name() == name.raw()) {
         return CheckFunctionType(function, type);
       }
     }
   } else {
-    String& function_name = reused_handles.StringHandle();
+    REUSABLE_STRING_HANDLESCOPE(isolate);
+    String& function_name = isolate->StringHandle();
     for (intptr_t i = 0; i < len; i++) {
       function ^= funcs.At(i);
       function_name ^= function.name();
       if (function_name.Equals(name)) {
         return CheckFunctionType(function, type);
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name,
                                                intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& funcs = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FUNCTION_HANDLESCOPE(isolate);
+  REUSABLE_STRING_HANDLESCOPE(isolate);
+  Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
-  Function& function = reused_handles.FunctionHandle();
-  String& function_name = reused_handles.StringHandle();
   intptr_t len = funcs.Length();
+  Function& function = isolate->FunctionHandle();
+  String& function_name = isolate->StringHandle();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (String::EqualsIgnoringPrivateKey(function_name, name)) {
       return CheckFunctionType(function, type);
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupGetterFunction(const String& name) const {
   return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
 }
 
 
 RawFunction* Class::LookupSetterFunction(const String& name) const {
   return LookupAccessorFunction(kSetterPrefix, kSetterPrefixLength, name);
 }
 
 
 RawFunction* Class::LookupAccessorFunction(const char* prefix,
                                            intptr_t prefix_length,
                                            const String& name) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Function::null();
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& funcs = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FUNCTION_HANDLESCOPE(isolate);
+  REUSABLE_STRING_HANDLESCOPE(isolate);
+  Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
-  Function& function = reused_handles.FunctionHandle();
-  String& function_name = reused_handles.StringHandle();
   intptr_t len = funcs.Length();
+  Function& function = isolate->FunctionHandle();
+  String& function_name = isolate->StringHandle();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (MatchesAccessorName(function_name, prefix, prefix_length, name)) {
       return function.raw();
     }
   }
 
   // No function found.
   return Function::null();
@@ skipping 39 matching lines @@
 RawField* Class::LookupField(const String& name) const {
   return LookupField(name, kAny);
 }
 
 
 RawField* Class::LookupField(const String& name, intptr_t type) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return Field::null();
   }
-  ReusableHandleScope reused_handles(isolate);
-  Array& flds = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_FIELD_HANDLESCOPE(isolate);
+  REUSABLE_STRING_HANDLESCOPE(isolate);
+  Array& flds = isolate->ArrayHandle();
   flds ^= fields();
   ASSERT(!flds.IsNull());
-  Field& field = reused_handles.FieldHandle();
-  String& field_name = reused_handles.StringHandle();
   intptr_t len = flds.Length();
+  Field& field = isolate->FieldHandle();
+  String& field_name = isolate->StringHandle();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     field_name ^= field.name();
     if (String::EqualsIgnoringPrivateKey(field_name, name)) {
       if (type == kInstance) {
         if (!field.is_static()) {
           return field.raw();
         }
       } else if (type == kStatic) {
         if (field.is_static()) {
@@ skipping 4296 matching lines @@
     }
     StorePointer(&raw_ptr()->exports_, exports.raw());
     return obj.raw();
   }
   return Object::null();
 }
 
 
 RawObject* Library::LookupEntry(const String& name, intptr_t *index) const {
   Isolate* isolate = Isolate::Current();
-  ReusableHandleScope reused_handles(isolate);
-  Array& dict = reused_handles.ArrayHandle();
+  REUSABLE_ARRAY_HANDLESCOPE(isolate);
+  REUSABLE_OBJECT_HANDLESCOPE(isolate);
+  REUSABLE_STRING_HANDLESCOPE(isolate);
+  Array& dict = isolate->ArrayHandle();
   dict ^= dictionary();
   intptr_t dict_size = dict.Length() - 1;
   *index = name.Hash() % dict_size;
-
-  Object& entry = reused_handles.ObjectHandle();
-  String& entry_name = reused_handles.StringHandle();
+  Object& entry = isolate->ObjectHandle();
+  String& entry_name = isolate->StringHandle();
   entry = dict.At(*index);
   // Search the entry in the hash set.
   while (!entry.IsNull()) {
     entry_name = entry.DictionaryName();
     ASSERT(!entry_name.IsNull());
      if (entry_name.Equals(name)) {
       return entry.raw();
     }
     *index = (*index + 1) % dict_size;
     entry = dict.At(*index);
@@ skipping 9469 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart