Move type check elimination from backend to graph builder in new compiler.

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 111 matching lines @@
           __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
           __ CompareObject(RCX, *CoreClass("ObjectArray"));
           __ j(EQUAL, is_instance);
           __ CompareObject(RCX, *CoreClass("GrowableObjectArray"));
           __ j(EQUAL, is_instance);
         } else if (!type_class.is_interface()) {
           __ movq(RCX, FieldAddress(RAX, Object::class_offset()));
           __ CompareObject(RCX, type_class);
           __ j(EQUAL, is_instance);
         }
-        // Fall through to runtime class.
+        // Fall through to runtime call.
       }
     } else {  // type has NO type arguments.
       Label compare_classes;
       __ testq(RAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, &compare_classes);
       // 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(),
@@ skipping 145 matching lines @@
 // - RAX: object.
 // - RDX: optional instantiator type arguments.
 // Destroys RCX and RDX.
 // Returns:
 // - object in RAX for successful assignable check (or throws TypeError).
 // Performance notes: positive checks must be quick, negative checks can be slow
 // as they throw an exception.
 void FlowGraphCompiler::GenerateAssertAssignable(intptr_t node_id,
                                                  intptr_t token_index,
                                                  intptr_t try_index,
-                                                 Value* value,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(token_index >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
-
-  // Any expression is assignable to the Dynamic type and to the Object type.
-  // Skip the test.
-  if (!dst_type.IsMalformed() &&
-      (dst_type.IsDynamicType() || dst_type.IsObjectType())) {
-    return;
-  }
-
-  // It is a compile-time error to explicitly return a value (including null)
-  // from a void function. However, functions that do not explicitly return a
-  // value, implicitly return null. This includes void functions. Therefore, we
-  // skip the type test here and trust the parser to only return null in void
-  // function.
-  if (dst_type.IsVoidType()) {
-    return;
-  }
-
-  // TODO(regis): Move this compile time check to the graph builder.
-  // Eliminate the test if it can be performed successfully at compile time.
-  if ((value != NULL) && value->IsConstant()) {
-    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()));
-      return;
-    }
-    Error& malformed_error = Error::Handle();
-    if (!dst_type.IsMalformed() &&
-        dst_type.IsInstantiated() &&
-        literal_value.IsInstanceOf(dst_type,
-                                   TypeArguments::Handle(),
-                                   &malformed_error)) {
-      return;
-    }
-  }
+  ASSERT(dst_type.IsMalformed() ||
+         (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
+  ASSERT(!dst_type.IsVoidType());
 
   // A null object is always assignable and is returned as result.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_assignable, runtime_call;
   __ cmpq(RAX, raw_null);
   __ j(EQUAL, &is_assignable);
 
   // Generate throw new TypeError() if the type is malformed.
   if (dst_type.IsMalformed()) {
@@ skipping 67 matching lines @@
   LoadValue(RAX, val);
 }
 
 
 void FlowGraphCompiler::VisitConstant(ConstantVal* val) {
   LoadValue(RAX, val);
 }
 
 
 void FlowGraphCompiler::VisitAssertAssignable(AssertAssignableComp* comp) {
-  if (comp->type_arguments() != NULL) {
+  if (comp->instantiator_type_arguments() != NULL) {
     __ popq(RDX);
   }
   LoadValue(RAX, comp->value());
   GenerateAssertAssignable(comp->node_id(),
                            comp->token_index(),
                            comp->try_index(),
-                           comp->value(),
                            comp->dst_type(),
                            comp->dst_name());
 }
 
 
 void FlowGraphCompiler::VisitAssertBoolean(AssertBooleanComp* comp) {
   LoadValue(RAX, comp->value());
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   Label done;
@@ skipping 385 matching lines @@
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // - RDX: optional instantiator type arguments.
 // Destroys RCX and RDX.
 // 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());
 
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_instance, is_not_instance;
   // If type is instantiated and non-parameterized, we can inline code
@@ skipping 55 matching lines @@
 
 
 void FlowGraphCompiler::VisitInstanceOf(InstanceOfComp* comp) {
   if (comp->type_arguments() != NULL) {
     __ popq(RDX);
   }
   LoadValue(RAX, comp->value());
   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 820 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