Minor VM performance improvements based on profiling.

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 3248 matching lines @@
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
 bool Class::TypeTestNonRecursive(const Class& cls,
                                  Class::TypeTestKind test_kind,
                                  const TypeArguments& type_arguments,
                                  const Class& other,
                                  const TypeArguments& other_type_arguments,
                                  Error* bound_error) {
   // Use the thsi object as if it was the receiver of this method, but instead
   // of recursing reset it to the super class and loop.
-  Class& thsi = Class::Handle(cls.raw());
+  Isolate* isolate = Isolate::Current();
+  Class& thsi = Class::Handle(isolate, cls.raw());
   while (true) {
     ASSERT(!thsi.IsVoidClass());
     // Check for DynamicType.
     // Each occurrence of DynamicType in type T is interpreted as the dynamic
     // type, a supertype of all types.
     if (other.IsDynamicClass()) {
       return true;
     }
     // In the case of a subtype test, each occurrence of DynamicType in type S
     // is interpreted as the bottom type, a subtype of all types.
@@ skipping 36 matching lines @@
         return test_kind == Class::kIsSubtypeOf;
       }
       return type_arguments.TypeTest(test_kind,
                                      other_type_arguments,
                                      from_index,
                                      num_type_params,
                                      bound_error);
     }
     const bool other_is_function_class = other.IsFunctionClass();
     if (other.IsSignatureClass() || other_is_function_class) {
-      const Function& other_fun = Function::Handle(other.signature_function());
+      const Function& other_fun = Function::Handle(isolate,
+                                                   other.signature_function());
       if (thsi.IsSignatureClass()) {
         if (other_is_function_class) {
           return true;
         }
         // Check for two function types.
-        const Function& fun = Function::Handle(thsi.signature_function());
+        const Function& fun =
+            Function::Handle(isolate, thsi.signature_function());
         return fun.TypeTest(test_kind,
                             type_arguments,
                             other_fun,
                             other_type_arguments,
                             bound_error);
       }
       // Check if type S has a call() method of function type T.
       Function& function =
-      Function::Handle(thsi.LookupDynamicFunction(Symbols::Call()));
+          Function::Handle(isolate,
+                           thsi.LookupDynamicFunction(Symbols::Call()));
       if (function.IsNull()) {
         // Walk up the super_class chain.
-        Class& cls = Class::Handle(thsi.SuperClass());
+        Class& cls = Class::Handle(isolate, thsi.SuperClass());
         while (!cls.IsNull() && function.IsNull()) {
           function = cls.LookupDynamicFunction(Symbols::Call());
           cls = cls.SuperClass();
         }
       }
       if (!function.IsNull()) {
         if (other_is_function_class ||
             function.TypeTest(test_kind,
                               type_arguments,
                               other_fun,
                               other_type_arguments,
                               bound_error)) {
               return true;
             }
       }
     }
     // Check for 'direct super type' specified in the implements clause
     // and check for transitivity at the same time.
-    Array& interfaces = Array::Handle(thsi.interfaces());
-    AbstractType& interface = AbstractType::Handle();
-    Class& interface_class = Class::Handle();
-    TypeArguments& interface_args = TypeArguments::Handle();
-    Error& error = Error::Handle();
+    Array& interfaces = Array::Handle(isolate, thsi.interfaces());
+    AbstractType& interface = AbstractType::Handle(isolate);
+    Class& interface_class = Class::Handle(isolate);
+    TypeArguments& interface_args = TypeArguments::Handle(isolate);
+    Error& error = Error::Handle(isolate);
     for (intptr_t i = 0; i < interfaces.Length(); i++) {
       interface ^= interfaces.At(i);
       if (!interface.IsFinalized()) {
         // We may be checking bounds at finalization time and can encounter
         // a still unfinalized interface.
         ClassFinalizer::FinalizeType(
             thsi, interface, ClassFinalizer::kCanonicalize);
         interfaces.SetAt(i, interface);
       }
       if (interface.IsMalbounded()) {
@@ skipping 12860 matching lines @@
 }
 
 
 RawArray* Array::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->array_class() != Class::null());
   return New(kClassId, len, space);
 }
 
 
 RawArray* Array::New(intptr_t class_id, intptr_t len, Heap::Space space) {
-  if (len < 0 || len > Array::kMaxElements) {
+  if ((len < 0) || (len > Array::kMaxElements)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %" Pd "\n", len);
   }
-  Array& result = Array::Handle();
   {
-    RawObject* raw = Object::Allocate(class_id,
-                                      Array::InstanceSize(len),
-                                      space);
+    RawArray* raw = reinterpret_cast<RawArray*>(
+        Object::Allocate(class_id,
+                         Array::InstanceSize(len),
+                         space));
     NoGCScope no_gc;
-    result ^= raw;
-    result.SetLength(len);
+    raw->ptr()->length_ = Smi::New(len);
+    return raw;
   }
-  return result.raw();
 }
 
 
 void Array::MakeImmutable() const {
   NoGCScope no_gc;
   uword tags = raw_ptr()->tags_;
   tags = RawObject::ClassIdTag::update(kImmutableArrayCid, tags);
   raw_ptr()->tags_ = tags;
 }
 
@@ skipping 1226 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart