Simpler and better inlined type checks as discussed. Changed inline type test cache arrays to conta…

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 351 matching lines @@
         }
         new_type_arguments.SetTypeAt(i, type_at);
       }
       new_type_arguments ^= new_type_arguments.Canonicalize();
       instance.SetTypeArguments(new_type_arguments);
     }
   }
 }
 
 
 // This updates the type test cache, an array containing tuples (instance class,

[regis, 2012/04/27 23:27:48]

The tuple contains 4 entries, right?

[srdjan, 2012/04/27 23:43:19]

Done.

 // test result_. It can be applied to classes with type arguments in which
 // case it contains just the result of the class subtype test, not including
 // the evaluation of type arguments.
-// Note that the 'result' contains the whole type test (including type
-// arguments), but the type test cache contains only the result of the
-// class test. Therefore we may need to recompute the 'result'.
 // This operation is currently very slow (lookup of code is not efficient yet).
 static void UpdateTypeTestCache(intptr_t node_id,
                                 const Instance& instance,
                                 const AbstractType& type,
                                 const AbstractTypeArguments& type_instantiator,
                                 const Bool& result) {
   // Since the test is expensive, don't do it unless necessary.
   // The list of disallowed cases will decrease as they are implemented in
   // inlined assembly.
   if (!type.IsInstantiated()) return;
-  // TODO(srdjan): Implement assembly code for checking type arguments then
-  // remove this check.
   if (Class::Handle(type.type_class()).HasTypeArguments()) {
     const AbstractTypeArguments& type_arguments =
         AbstractTypeArguments::Handle(type.arguments());
     const bool is_raw_type = type_arguments.IsNull() ||
         type_arguments.IsRaw(type_arguments.Length());
     if (!is_raw_type) {
       // We cannot inline tests for instances with more than one type argument
       // or if its class has not been resolved (malformed type).
       if (type_arguments.Length() != 1) {
         // We can handle only one argument so far.
         return;
       }
       const AbstractType& tp_argument =
           AbstractType::ZoneHandle(type_arguments.TypeAt(0));
       if (!tp_argument.IsType()) {
         // E.g, it is TypeParameter.
         return;
       }
-      const Type& list_type =
-          Type::Handle(Isolate::Current()->object_store()->list_interface());
-      Error& malformed_error = Error::Handle();
-      if (!list_type.IsSubtypeOf(type, &malformed_error)) {
-        return;
-      }
-      // The type argument at index 0 must be instantiated and not malformed.
-      // A malformed type would have caused a type error earlier.
       ASSERT(tp_argument.HasResolvedTypeClass());
     }
   }
+  AbstractTypeArguments& instance_type_arguments =
+      AbstractTypeArguments::Handle();
+  const Class& instance_class = Class::Handle(instance.clazz());
+  if (instance_class.HasTypeArguments()) {
+    OptimizeTypeArguments(instance);
+    instance_type_arguments = instance.GetTypeArguments();
+  }
+
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(!code.IsNull());
   uword loc = code.GetTypeTestAtNodeId(node_id);
   if (loc != 0) {
     // Found type test cache.
-    Array& value = Array::Handle(CodePatcher::GetTypeTestArray(loc));
+    Array& cache = Array::Handle(CodePatcher::GetTypeTestArray(loc));
     // TODO(srdjan): Prevent type test cache from growing too much, it has been
     // observed to grow to 100 elements.
-    const Class& instance_class = Class::Handle(instance.clazz());
     // Don't enter duplicate entries.
-    Class& last_checked = Class::Handle();
-    for (intptr_t i = 0; i < value.Length(); i += 2) {
-      last_checked ^= value.At(i);
-      if (last_checked.raw() == instance_class.raw()) {
+    // TODO(srdjan): Check instantiator type arguments as well.
+    Object& last_instance_class = Object::Handle();
+    Object& last_instance_type_arguments = Object::Handle();
+    for (intptr_t i = 0; i < cache.Length();
+         i += SubTypeTestCache::kNumEntries) {
+      last_instance_class = cache.At(i + SubTypeTestCache::kInstanceClass);
+      last_instance_type_arguments =
+          cache.At(i + SubTypeTestCache::kInstanceTypeArguments);
+      if ((last_instance_class.raw() == instance_class.raw()) &&
+          (last_instance_type_arguments.raw() ==
+              instance_type_arguments.raw())) {
         if (FLAG_trace_type_checks) {
-          PrintTypeCheck("WARING duplicate cache entry", instance, type,
+          PrintTypeCheck("WARNING duplicate cache entry", instance, type,
               type_instantiator, result);
         }
         return;
       }
     }
 
     // Array must be null terminated.
-    ASSERT(last_checked.IsNull());
-
-    // Check if the result for cache needs to be recomputed.
-    const Class& cls =  Class::Handle(type.type_class());
-    Bool& class_test_result = Bool::Handle(result.raw());
-    if (!result.value() && cls.HasTypeArguments()) {
-      Error& malformed_error = Error::Handle();
-      if (instance_class.IsSubtypeOf(TypeArguments::Handle(),
-                                     cls,
-                                     TypeArguments::Handle(),
-                                     &malformed_error)) {
-        class_test_result = Bool::True();
-      }
+    ASSERT(last_instance_class.IsNull());
+    ASSERT(!cache.IsNull());
+    // Cache is null terminate, i.e., the last entry contains all null elements.
+    intptr_t old_len = cache.Length();
+    cache = cache.Grow(cache, old_len + SubTypeTestCache::kNumEntries);
+    intptr_t last_start = old_len - SubTypeTestCache::kNumEntries;
+    cache.SetAt(last_start + SubTypeTestCache::kInstanceClass, instance_class);
+    cache.SetAt(last_start + SubTypeTestCache::kInstanceTypeArguments,
+        instance_type_arguments);
+    // TODO(srdjan): Store instantiator arguments instead of null.
+    cache.SetAt(last_start + SubTypeTestCache::kInstantiatorArguments,
+        AbstractTypeArguments::Handle());
+    cache.SetAt(last_start + SubTypeTestCache::kTestResult , result);
+    if (FLAG_trace_type_checks) {
+      OS::Print("  Updated test cache: [0x%x %s, 0x%x %s]\n"
+                "                      [0x%x %s] %s\n",
+           instance_class.raw(),
+           instance_class.ToCString(),
+           instance_type_arguments.raw(),
+           instance_type_arguments.ToCString(),
+           type.type_class(),
+           Class::Handle(type.type_class()).ToCString(),
+           result.ToCString());
     }
-    ASSERT(!value.IsNull());
-    intptr_t old_len = value.Length();
-    value = value.Grow(value, old_len + 2);
-    value.SetAt(old_len - 2, instance_class);
-    value.SetAt(old_len - 1, class_test_result);
-    CodePatcher::SetTypeTestArray(loc, value);
-    OptimizeTypeArguments(instance);
+    CodePatcher::SetTypeTestArray(loc, cache);
   }
 }
 
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: index of the token of the instanceof test (source location).
 // Arg1: node id of the instanceof node.
 // Arg2: instance being checked.
 // Arg3: type.
@@ skipping 1009 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart