Eliminate type checks that can successfully be performed at compile time.

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 "vm/ast_printer.h"
@@ skipping 431 matching lines @@
 }
 
 
 void FlowGraphCompiler::GenerateInstantiatorTypeArguments(
     intptr_t token_index) {
   Bailout("FlowGraphCompiler::GenerateInstantiatorTypeArguments");
 }
 
 
 // Copied from CodeGenerator.
-// Optimize instanceof type test by adding inlined tests for:
+// If instanceof type test cannot be performed successfully at compile time and
+// therefore eliminated, optimize it by adding inlined tests for:
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // Destroys RCX.
 // Returns:
 // - true or false in RAX.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t node_id,
                                            intptr_t token_index,
                                            intptr_t try_index,
+                                           Value* value,
                                            const AbstractType& type,
                                            bool negate_result) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
-  // All instances are of a subtype of the Object type.
+  // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
   Error& malformed_error = Error::Handle();
   if (type.IsInstantiated() &&
       object_type.IsSubtypeOf(type, &malformed_error)) {
     __ LoadObject(RAX, negate_result ? bool_false : bool_true);
     return;
   }
 
+  // Eliminate the test if it can be performed successfully at compile time.
+  if ((value != NULL) && value->IsConstant() && type.IsInstantiated()) {
+    // TODO(regis): A constant value should be an instance, not an object.
+    Instance& literal_value = Instance::Handle();
+    literal_value ^= value->AsConstant()->value().raw();
+    const Class& cls = Class::Handle(literal_value.clazz());
+    if (cls.IsNullClass()) {
+      ASSERT(literal_value.IsNull() ||
+             (literal_value.raw() == Object::sentinel()) ||
+             (literal_value.raw() == Object::transition_sentinel()));
+      // 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).
+      __ PushObject(negate_result ? bool_true : bool_false);
+    } else {
+      Error& malformed_error = Error::Handle();
+      if (literal_value.IsInstanceOf(type,
+                                     TypeArguments::Handle(),
+                                     &malformed_error)) {
+        __ PushObject(negate_result ? bool_false : bool_true);
+      } else {
+        ASSERT(malformed_error.IsNull());
+        __ PushObject(negate_result ? bool_true : bool_false);
+      }
+    }
+    return;
+  }
+
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label 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).
@@ skipping 38 matching lines @@
           __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
           __ CompareObject(RCX, type_class);
           __ j(NOT_EQUAL, &runtime_call, Assembler::kNearJump);
           __ PushObject(negate_result ? bool_false : bool_true);
           __ jmp(&done);
         }
       }
       __ 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;
       __ testq(RAX, 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(),
@@ skipping 58 matching lines @@
   __ Bind(&done);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceOf(InstanceOfComp* comp) {
   __ popq(RAX);
   GenerateInstanceOf(comp->node_id(),
                      comp->token_index(),
                      comp->try_index(),
+                     comp->value(),
                      comp->type(),
                      comp->negate_result());
 }
 
 
 void FlowGraphCompiler::VisitAllocateObject(AllocateObjectComp* comp) {
   const Class& cls = Class::ZoneHandle(comp->constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   GenerateCall(comp->token_index(), comp->try_index(), &label,
@@ skipping 735 matching lines @@
   ASSERT(exception_handlers_list_ != NULL);
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64