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

runtime/vm/code_generator_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 1292 matching lines @@
       Type::Handle(Isolate::Current()->object_store()->object_type());
   Error& malformed_error = Error::Handle();
   if (type.IsInstantiated() &&
       object_type.IsSubtypeOf(type, &malformed_error)) {
     __ PushObject(negate_result ? bool_false : bool_true);
     return;
   }
 
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  Label done;
+  Label done, check_negate_done;
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
     // A null object is only an instance of Object and Dynamic, which has
     // already been checked above (if the type is instantiated). So we can
     // return false here if the instance is null (and if the type is
     // instantiated).
     // We can only inline this null check if the type is instantiated at compile
     // time, since an uninstantiated type at compile time could be Object or
     // Dynamic at run time.
@@ skipping 35 matching lines @@
           __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
           __ CompareObject(ECX, type_class);
           __ j(NOT_EQUAL, &runtime_call, Assembler::kNearJump);
           __ PushObject(negate_result ? bool_false : bool_true);
           __ jmp(&done, Assembler::kNearJump);
         }
       }
       __ Bind(&runtime_call);
       // Fall through to runtime call.
     } else {
+      ASSERT(!requires_type_arguments);
+      // Test if object is Smi and for a couple known test-classes.
       Label compare_classes;
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, &compare_classes, Assembler::kNearJump);
       // Object is Smi.
       const Class& smi_class = Class::Handle(Smi::Class());
       // TODO(regis): We should introduce a SmiType.
       Error& malformed_error = Error::Handle();
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 type_class,
                                 TypeArguments::Handle(),
                                 &malformed_error)) {
         __ PushObject(negate_result ? bool_false : bool_true);
       } else {
         __ PushObject(negate_result ? bool_true : bool_false);
       }
       __ jmp(&done, Assembler::kNearJump);
 
       // Compare if the classes are equal.
       __ Bind(&compare_classes);
       const Class* compare_class = NULL;
       if (type.IsStringInterface()) {
         compare_class = &Class::ZoneHandle(
             Isolate::Current()->object_store()->one_byte_string_class());
       } else if (type.IsBoolInterface()) {
         compare_class = &Class::ZoneHandle(
             Isolate::Current()->object_store()->bool_class());
       } else if (!type_class.is_interface()) {
-        compare_class = &type_class;
+        // Use equality test in prolog of cache test.
+        compare_class = NULL;
       }
-      if (compare_class != NULL) {
+      // EAX: instance being tested.
+      if (compare_class == NULL) {
+        // Optional quick equality check and then the type test cache test.
+        Label loop, runtime_call, found_in_cache, cache_test;
+        __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
+        if (!type_class.is_interface()) {
+          // Class equality test first.
+          __ CompareObject(ECX, type_class);
+          __ j(NOT_EQUAL, &cache_test, Assembler::kNearJump);
+          // Equal!
+          __ PushObject(negate_result ? bool_false : bool_true);
+          __ jmp(&done, Assembler::kNearJump);
+        }
+        __ Bind(&cache_test);
+        // TODO(srdjan): Convert other tests to this simple form.
+        // Class we are testing against has no type arguments.
+        // TODO(srdjan): Canonicalize initial array?
+        // TODO(srdjan): Account for 'negate_result' in cache.
+        // The type test array is null-terminated. Two consecutive
+        // array elements correspond to one test:
+        //   array[i + 0] : class.
+        //   array[i + 1] : result for the class.
+        AddCurrentDescriptor(PcDescriptors::kTypeTest, node_id, token_index);
+        __ LoadObject(EDX, Array::ZoneHandle(Array::New(2)));
+        __ addl(EDX, Immediate(Array::data_offset() - kHeapObjectTag));
+        __ Bind(&loop);
+        __ movl(EBX, Address(EDX, 0));
+        __ cmpl(ECX, EBX);
+        __ j(EQUAL, &found_in_cache, Assembler::kNearJump);
+        __ addl(EDX, Immediate(kWordSize * 2));
+        __ cmpl(EBX, raw_null);
+        __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
+        __ jmp(&runtime_call, Assembler::kNearJump);
+        __ Bind(&found_in_cache);
+        __ pushl(Address(EDX, kWordSize));
+        __ jmp(&check_negate_done);
+        __ Bind(&runtime_call);
+      } else {
         Label runtime_call;
         __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
         __ CompareObject(ECX, *compare_class);
         __ j(NOT_EQUAL, &runtime_call, Assembler::kNearJump);
         __ PushObject(negate_result ? bool_false : bool_true);
         __ jmp(&done, Assembler::kNearJump);
         __ Bind(&runtime_call);
       }
     }
   }
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   const Immediate location =
       Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
+  const Immediate node_id_as_smi =
+      Immediate(reinterpret_cast<int32_t>(Smi::New(node_id)));
   __ pushl(location);  // Push the source location.
+  __ pushl(node_id_as_smi);  // node-id.
   __ pushl(EAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (!type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushl(raw_null);  // Null instantiator.
   }
   GenerateCallRuntime(node_id, token_index, kInstanceofRuntimeEntry);
   // Pop the two parameters supplied to the runtime entry. The result of the
   // instanceof runtime call will be left as the result of the operation.
-  __ addl(ESP, Immediate(4 * kWordSize));
+  __ addl(ESP, Immediate(5 * kWordSize));
+  __ Bind(&check_negate_done);
   if (negate_result) {
     Label negate_done;
     __ popl(EDX);
     __ LoadObject(EAX, bool_true);
     __ cmpl(EDX, EAX);
     __ j(NOT_EQUAL, &negate_done, Assembler::kNearJump);
     __ LoadObject(EAX, bool_false);
     __ Bind(&negate_done);
     __ pushl(EAX);
   }
@@ skipping 1355 matching lines @@
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32