For instanceof inline check against right hand class id possible and interface String for OneByte...

runtime/vm/code_generator_ia32.cc

 // Copyright (c) 2011, 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 1397 matching lines @@
   __ PushObject(negate_result ? bool_true : bool_false);
   __ jmp(&done, Assembler::kNearJump);
 
   __ Bind(&non_null);
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
     const Class& type_class = Class::ZoneHandle(type.type_class());
     const bool requires_type_arguments = type_class.HasTypeArguments();
     // A Smi object cannot be the instance of a parameterized class.
-    // A class equality check is only applicable to a non-parameterized class.
-    // TODO(regis): Should we still inline a Smi type check when checking for a
-    // parameterized type and return false for a Smi's without calling the
-    // runtime?
-    if (!requires_type_arguments) {
+    // A class equality check is only applicable with a dst type of a
+    // non-parameterized class or with a raw dst type of a parameterized class.
+    if (requires_type_arguments) {
+      const TypeArguments& type_arguments =
+          TypeArguments::Handle(type.arguments());
+      const bool is_raw_type = type_arguments.IsNull() ||
+          type_arguments.IsDynamicTypes(type_arguments.Length());
+      Label runtime_call;
+      __ testl(EAX, Immediate(kSmiTagMask));
+      __ j(ZERO, &runtime_call, Assembler::kNearJump);
+      // Object not Smi.
+      if (is_raw_type) {
+        if (!type_class.is_interface()) {
+          __ 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 {
       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.
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 type_class,
                                 TypeArguments::Handle())) {
         __ 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);
-      // If type is an interface, we can skip the class equality check,
-      // because instances cannot be of an interface type.
-      if (!type_class.is_interface()) {
+      if (type_class.is_interface()) {
+        if (type.IsStringInterface()) {
+          Label runtime_call;
+          __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
+          const Class& one_byte_string_class = Class::ZoneHandle(
+              Isolate::Current()->object_store()->one_byte_string_class());
+          __ CompareObject(ECX, one_byte_string_class);
+          __ j(NOT_EQUAL, &runtime_call, Assembler::kNearJump);
+          __ PushObject(negate_result ? bool_false : bool_true);
+          __ jmp(&done, Assembler::kNearJump);
+          __ Bind(&runtime_call);
+        }
+      } else {  // type_class is not an interface.
         Label runtime_call;
         __ 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);
       }
     }
   }
@@ skipping 105 matching lines @@
           TestClassAndJump(*CoreClass("ObjectArray"), &done);
           TestClassAndJump(*CoreClass("GrowableObjectArray"), &done);
         } else if (!dst_type_class.is_interface()) {
           __ testl(EAX, Immediate(kSmiTagMask));
           __ j(ZERO, &runtime_call, Assembler::kNearJump);
           __ movl(ECX, FieldAddress(EAX, Object::class_offset()));
           TestClassAndJump(dst_type_class, &done);
         }
         // Fall through to runtime class.
       }
-    } else {
+    } else {  // dst_type has NO type arguments.
       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.
       if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                                 dst_type_class,
                                 TypeArguments::Handle())) {
         // Successful assignable type check: return object in EAX.
@@ skipping 1129 matching lines @@
   const Class& cls = Class::Handle(parsed_function_.function().owner());
   const Script& script = Script::Handle(cls.script());
   Parser::ReportMsg(script, token_index, "Error", error_msg, format, args);
   Isolate::Current()->long_jump_base()->Jump(1, error_msg);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32