When checking against non-parametrized types use a cache to hold result tuples (class, result). Tha…

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_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 288 matching lines @@
   for (int i = 0; i < ctx.num_variables(); i++) {
     cloned_ctx.SetAt(i, Instance::Handle(ctx.At(i)));
   }
   arguments.SetReturn(cloned_ctx);
 }
 
 
 // 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: instance being checked.
-// Arg2: type.
-// Arg3: type arguments of the instantiator of the type.
+// Arg1: node id of the instanceof node.
+// Arg2: instance being checked.
+// Arg3: type.
+// Arg4: type arguments of the instantiator of the type.
 // Return value: true or false, or may throw a type error in checked mode.
-DEFINE_RUNTIME_ENTRY(Instanceof, 4) {
+DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
   ASSERT(arguments.Count() == kInstanceofRuntimeEntry.argument_count());
   // TODO(regis): Get the token index from the PcDesc (via DartFrame).
   intptr_t location = Smi::CheckedHandle(arguments.At(0)).Value();
-  const Instance& instance = Instance::CheckedHandle(arguments.At(1));
-  const AbstractType& type = AbstractType::CheckedHandle(arguments.At(2));
+  intptr_t node_id = Smi::CheckedHandle(arguments.At(1)).Value();
+  const Instance& instance = Instance::CheckedHandle(arguments.At(2));
+  const AbstractType& type = AbstractType::CheckedHandle(arguments.At(3));
   const AbstractTypeArguments& type_instantiator =
-      AbstractTypeArguments::CheckedHandle(arguments.At(3));
+      AbstractTypeArguments::CheckedHandle(arguments.At(4));
   ASSERT(type.IsFinalized());
   Error& malformed_error = Error::Handle();
   const Bool& result = Bool::Handle(
       instance.IsInstanceOf(type, type_instantiator, &malformed_error) ?
       Bool::True() : Bool::False());
   if (FLAG_trace_type_checks) {
     const Type& instance_type = Type::Handle(instance.GetType());
     ASSERT(instance_type.IsInstantiated());
     if (type.IsInstantiated()) {
       OS::Print("InstanceOf: '%s' %s '%s'.\n",
@@ skipping 20 matching lines @@
   if (!result.value() && !malformed_error.IsNull()) {
     ASSERT(FLAG_enable_type_checks);
     // Throw a dynamic type error only if the instanceof test fails.
     String& malformed_error_message =  String::Handle(
         String::New(malformed_error.ToErrorCString()));
     const String& no_name = String::Handle(String::NewSymbol(""));
     Exceptions::CreateAndThrowTypeError(
         location, no_name, no_name, no_name, malformed_error_message);
     UNREACHABLE();
   }
+  // Update cache: add class of instance and result.
+  if (type.IsInstantiated() &&
+      !Class::Handle(type.type_class()).HasTypeArguments()) {
+    DartFrameIterator iterator;
+    DartFrame* 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);
+    // TODO(srdjan): Check when 'loc' can be 0, once implemented everywhere.
+    if (loc != 0) {
+      // Found type test cache.
+      Array& value = Array::Handle(CodePatcher::GetTypeTestArray(loc));
+      const Class& instance_class = Class::Handle(instance.clazz());
+
+#if defined(DEBUG)
+      // Check for duplicate entries.
+      Class& last_checked = Class::Handle();
+      for (intptr_t i = 0; i < value.Length(); i += 2) {
+        last_checked ^= value.At(i);
+        ASSERT(last_checked.raw() != instance_class.raw());
+      }
+      // Array must be null terminated.
+      ASSERT(last_checked.IsNull());
+#endif
+
+      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, result);
+      CodePatcher::SetTypeTestArray(loc, value);
+    }
+  }
   arguments.SetReturn(result);
 }
 
 
 // For error reporting simplify type name, e.g, all integer types (Smi, Mint,
 // Bigint) a re reported as 'int'.
 static RawString* GetSimpleTypeName(const Instance& value) {
   if (value.IsInteger()) {
     return String::NewSymbol("int");
   } else {
@@ skipping 1025 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart