Shorter code for simple type comparisons.

runtime/vm/flow_graph_compiler_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 200 matching lines @@
     __ j(EQUAL, is_equal_lbl);
   }
   __ jmp(is_not_equal_lbl);
 }
 
 
 // Testing against an instantiated type with no arguments, without
 // SubtypeTestCache.
 // RAX: instance to test against (preserved).
 // Clobbers R10, R13.
-void FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
+// Returns true if there is a fallthrough.
+bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
     intptr_t cid,
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::Handle(type.type_class());
   ASSERT(!type_class.HasTypeArguments());
 
   const Register kInstanceReg = RAX;
@@ skipping 19 matching lines @@
   if (!type_class.is_interface()) {
     __ cmpl(kClassIdReg, Immediate(type_class.id()));
     __ j(EQUAL, is_instance_lbl);
   }
   // Bool interface can be implemented only by core class Bool.
   // (see ClassFinalizer::ResolveInterfaces for list of restricted interfaces).
   if (type.IsBoolInterface()) {
     __ cmpl(kClassIdReg, Immediate(kBool));
     __ j(EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
-    return;
+    return false;
   }
   if (type.IsFunctionInterface()) {
     // Check if instance is a closure.
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ LoadClassById(R13, kClassIdReg);
     __ movq(R13, FieldAddress(R13, Class::signature_function_offset()));
     __ cmpq(R13, raw_null);
     __ j(NOT_EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
-    return;
+    return false;
   }
   // Custom checking for numbers (Smi, Mint, Bigint and Double).
-  // Note that instance is not Smi(checked above).
+  // Note that instance is not Smi (checked above).
   if (type.IsSubtypeOf(
           Type::Handle(Type::NumberInterface()), &malformed_error)) {
     GenerateNumberTypeCheck(
         kClassIdReg, type, is_instance_lbl, is_not_instance_lbl);
-    return;
+    return false;
   }
   if (type.IsStringInterface()) {
     GenerateStringTypeCheck(kClassIdReg, is_instance_lbl, is_not_instance_lbl);
-    return;
+    return false;
   }
   // Otherwise fallthrough.
+  return true;
 }
 
 
 // Uses SubtypeTestCache to store instance class and result.
 // RAX: instance to test.
 // Clobbers R10, R13.
 // Immediate class test already done.
 // TODO(srdjan): Implement a quicker subtype check, as type test
 // arrays can grow too high, but they may be useful when optimizing
 // code (type-feedback).
@@ skipping 135 matching lines @@
     // 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 (type_class.HasTypeArguments()) {
       return GenerateInstantiatedTypeWithArgumentsTest(cid,
                                                        token_pos,
                                                        type,
                                                        is_instance_lbl,
                                                        is_not_instance_lbl);
       // Fall through to runtime call.
     }
-    GenerateInstantiatedTypeNoArgumentsTest(cid,
-                                            token_pos,
-                                            type,
-                                            is_instance_lbl,
-                                            is_not_instance_lbl);
-    // If test non-conclusive so far, try the inlined type-test cache.
-    // 'type' is known at compile time.
-    return GenerateSubtype1TestCacheLookup(
-        cid, token_pos, type_class,
-        is_instance_lbl, is_not_instance_lbl);
+    const bool has_fall_through =
+        GenerateInstantiatedTypeNoArgumentsTest(cid,
+                                                token_pos,
+                                                type,
+                                                is_instance_lbl,
+                                                is_not_instance_lbl);
+    if (has_fall_through) {
+      // If test non-conclusive so far, try the inlined type-test cache.
+      // 'type' is known at compile time.
+      return GenerateSubtype1TestCacheLookup(
+          cid, token_pos, type_class,
+          is_instance_lbl, is_not_instance_lbl);
+    } else {
+      return SubtypeTestCache::null();
+    }
   }
   return GenerateUninstantiatedTypeTest(cid,
                                         token_pos,
                                         type,
                                         is_instance_lbl,
                                         is_not_instance_lbl);
 }
 
 
 // If instanceof type test cannot be performed successfully at compile time and
@@ skipping 32 matching lines @@
     // Dynamic at run time.
     __ cmpq(RAX, raw_null);
     __ j(EQUAL, &is_not_instance);
   }
 
   // Generate inline instanceof test.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
   test_cache = GenerateInlineInstanceof(cid, token_pos, type,
                                         &is_instance, &is_not_instance);
 
-  // Generate runtime call.
-  __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
-  __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
-  __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  __ pushq(Immediate(Smi::RawValue(cid)));  // Computation id.
-  __ pushq(RAX);  // Push the instance.
-  __ PushObject(type);  // Push the type.
-  __ pushq(RCX);  // TODO(srdjan): Pass instantiator instead of null.
-  __ pushq(RDX);  // Instantiator type arguments.
-  __ LoadObject(RAX, test_cache);
-  __ pushq(RAX);
-  GenerateCallRuntime(cid, token_pos, try_index, kInstanceofRuntimeEntry);
-  // Pop the parameters supplied to the runtime entry. The result of the
-  // instanceof runtime call will be left as the result of the operation.
-  __ Drop(6);
+  // test_cache is null if there is no fall-through.
   Label done;
-  if (negate_result) {
-    __ popq(RDX);
-    __ LoadObject(RAX, bool_true());
-    __ cmpq(RDX, RAX);
-    __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-    __ LoadObject(RAX, bool_false());
-  } else {
-    __ popq(RAX);
+  if (!test_cache.IsNull()) {
+    // Generate runtime call.
+    __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
+    __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
+    __ PushObject(Object::ZoneHandle());  // Make room for the result.
+    __ pushq(Immediate(Smi::RawValue(cid)));  // Computation id.
+    __ pushq(RAX);  // Push the instance.
+    __ PushObject(type);  // Push the type.
+    __ pushq(RCX);  // TODO(srdjan): Pass instantiator instead of null.
+    __ pushq(RDX);  // Instantiator type arguments.
+    __ LoadObject(RAX, test_cache);
+    __ pushq(RAX);
+    GenerateCallRuntime(cid, token_pos, try_index, kInstanceofRuntimeEntry);
+    // Pop the parameters supplied to the runtime entry. The result of the
+    // instanceof runtime call will be left as the result of the operation.
+    __ Drop(6);
+    if (negate_result) {
+      __ popq(RDX);
+      __ LoadObject(RAX, bool_true());
+      __ cmpq(RDX, RAX);
+      __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+      __ LoadObject(RAX, bool_false());
+    } else {
+      __ popq(RAX);
+    }
+    __ jmp(&done, Assembler::kNearJump);
   }
-  __ jmp(&done, Assembler::kNearJump);
-
   __ Bind(&is_not_instance);
   __ LoadObject(RAX, negate_result ? bool_true() : bool_false());
   __ jmp(&done, Assembler::kNearJump);
 
   __ Bind(&is_instance);
   __ LoadObject(RAX, negate_result ? bool_false() : bool_true());
   __ Bind(&done);
   __ popq(RDX);  // Remove pushed instantiator type arguments.
   __ popq(RCX);  // Remove pushed instantiator.
 }
@@ skipping 601 matching lines @@
     }
   }
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64