- Create isolate specific resuable handles and use them in the hot lookup paths.

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 1596 matching lines @@
   }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   return type_params.Length();
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the SuperClass() call.
   Isolate* isolate = Isolate::Current();
-  Class& cls = Class::Handle(isolate, raw());
+  ReusableHandleScope reused_handles(isolate);
+  Class& cls = reused_handles.ClassHandle();
+  TypeArguments& type_params = reused_handles.TypeArgumentsHandle();
+  AbstractType& sup_type = reused_handles.AbstractTypeHandle();
+  cls ^= raw();
   intptr_t num_type_args = 0;
 
   do {
     if (cls.IsSignatureClass()) {
-      const Function& signature_fun =
-          Function::Handle(isolate, cls.signature_function());
+      Function& signature_fun = reused_handles.FunctionHandle();
+      signature_fun ^= cls.signature_function();
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
-    num_type_args += cls.NumTypeParameters();
+    if (cls.type_parameters() != TypeArguments::null()) {
+      type_params ^= cls.type_parameters();
+      num_type_args += type_params.Length();
+    }
+
     // Super type of Object class is null.
     if (cls.super_type() == AbstractType::null() ||
         cls.super_type() == isolate->object_store()->object_type()) {
       break;
     }
-    cls = cls.SuperClass();
+    sup_type ^= cls.super_type();
+    cls = sup_type.type_class();
   } while (true);
   return num_type_args;
 }
 
 
 bool Class::HasTypeArguments() const {
   if (!IsSignatureClass() && (is_type_finalized() || is_prefinalized())) {
     // More efficient than calling NumTypeArguments().
     return type_arguments_field_offset() != kNoTypeArguments;
   } else {
     // No need to check NumTypeArguments() if class has type parameters.
     return (NumTypeParameters() > 0) || (NumTypeArguments() > 0);
   }
 }
 
 
 RawClass* Class::SuperClass() const {
   if (super_type() == AbstractType::null()) {
     return Class::null();
   }
-  const AbstractType& sup_type = AbstractType::Handle(super_type());
+  Isolate* isolate = Isolate::Current();
+  ReusableHandleScope reused_handles(isolate);
+  AbstractType& sup_type = reused_handles.AbstractTypeHandle();
+  sup_type ^= super_type();
   return sup_type.type_class();
 }
 
 
 void Class::set_super_type(const AbstractType& value) const {
   ASSERT(value.IsNull() ||
          value.IsType() ||
          value.IsBoundedType() ||
          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,
                                              intptr_t token_pos) const {
   ASSERT(!type_name.IsNull());
-  const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
+  Isolate* isolate = Isolate::Current();
+  ReusableHandleScope reused_handles(isolate);
+  TypeArguments& type_params = reused_handles.TypeArgumentsHandle();
+  type_params ^= type_parameters();
+  TypeParameter& type_param = reused_handles.TypeParameterHandle();
+  String& type_param_name = reused_handles.StringHandle();
   if (!type_params.IsNull()) {
     intptr_t num_type_params = type_params.Length();
-    TypeParameter& type_param = TypeParameter::Handle();
-    String& type_param_name = String::Handle();
     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();
       }
     }
   }
   return TypeParameter::null();
 }
@@ skipping 752 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();
   }
-  Array& funcs = Array::Handle(isolate, functions());
+  ReusableHandleScope reused_handles(isolate);
+  Array& funcs = reused_handles.ArrayHandle();
+  funcs ^= functions();
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
-  Function& function = Function::Handle(isolate);
+  Function& function = reused_handles.FunctionHandle();
   const intptr_t len = funcs.Length();
   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 = String::Handle(isolate);
+    String& function_name = reused_handles.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();
   }
-  Array& funcs = Array::Handle(isolate, functions());
+  ReusableHandleScope reused_handles(isolate);
+  Array& funcs = reused_handles.ArrayHandle();
+  funcs ^= functions();
   if (funcs.IsNull()) {
     // This can occur, e.g., for Null classes.
     return Function::null();
   }
-  Function& function = Function::Handle(isolate);
-  String& function_name = String::Handle(isolate);
+  Function& function = reused_handles.FunctionHandle();
+  String& function_name = reused_handles.StringHandle();
   intptr_t len = funcs.Length();
   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();
@@ skipping 10 matching lines @@
 }
 
 
 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();
   }
-  Array& funcs = Array::Handle(isolate, functions());
-  Function& function = Function::Handle(isolate, Function::null());
-  String& function_name = String::Handle(isolate, String::null());
+  ReusableHandleScope reused_handles(isolate);
+  Array& funcs = reused_handles.ArrayHandle();
+  funcs ^= functions();
+  Function& function = reused_handles.FunctionHandle();
+  String& function_name = reused_handles.StringHandle();
   intptr_t len = funcs.Length();
   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.
@@ skipping 40 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();
   }
-  const Array& flds = Array::Handle(isolate, fields());
-  Field& field = Field::Handle(isolate, Field::null());
-  String& field_name = String::Handle(isolate, String::null());
+  ReusableHandleScope reused_handles(isolate);
+  Array& flds = reused_handles.ArrayHandle();
+  flds ^= fields();
+  Field& field = reused_handles.FieldHandle();
+  String& field_name = reused_handles.StringHandle();
   intptr_t len = flds.Length();
   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) {
@@ skipping 3586 matching lines @@
         return obj.raw();
       }
     }
   }
   return Object::null();
 }
 
 
 RawObject* Library::LookupEntry(const String& name, intptr_t *index) const {
   Isolate* isolate = Isolate::Current();
-  const Array& dict = Array::Handle(isolate, dictionary());
+  ReusableHandleScope reused_handles(isolate);
+  Array& dict = reused_handles.ArrayHandle();
+  dict ^= dictionary();
   intptr_t dict_size = dict.Length() - 1;
   *index = name.Hash() % dict_size;
 
-  Object& entry = Object::Handle(isolate);
-  String& entry_name = String::Handle(isolate);
+  Object& entry = reused_handles.ObjectHandle();
+  String& entry_name = reused_handles.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 7409 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart