Improve static type propagation.

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 174 matching lines @@
   }
   // If one type argument only, check if type argument is Object or Dynamic.
   if (type_arguments.Length() == 1) {
     const AbstractType& tp_argument = AbstractType::ZoneHandle(
         type_arguments.TypeAt(0));
     ASSERT(!tp_argument.IsMalformed());
     if (tp_argument.IsType()) {
       ASSERT(tp_argument.HasResolvedTypeClass());
       // Check if type argument is dynamic or Object.
       const Type& object_type = Type::Handle(Type::ObjectType());
-      Error& malformed_error = Error::Handle();
-      if (object_type.IsSubtypeOf(tp_argument, &malformed_error)) {
+      if (object_type.IsSubtypeOf(tp_argument, NULL)) {
         // Instance class test only necessary.
         return GenerateSubtype1TestCacheLookup(
             cid, token_pos, type_class, is_instance_lbl, is_not_instance_lbl);
       }
     }
   }
   // Regular subtype test cache involving instance's type arguments.
   const Register kTypeArgumentsReg = kNoRegister;
   const Register kTempReg = R10;
   return GenerateCallSubtypeTestStub(kTestTypeTwoArgs,
@@ skipping 31 matching lines @@
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::Handle(type.type_class());
   ASSERT(!type_class.HasTypeArguments());
 
   const Register kInstanceReg = RAX;
   Label compare_classes;
   __ testq(kInstanceReg, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &compare_classes, Assembler::kNearJump);
   // Instance is Smi, check directly.
   const Class& smi_class = Class::Handle(Smi::Class());
-  Error& malformed_error = Error::Handle();
   if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                             type_class,
                             TypeArguments::Handle(),
-                            &malformed_error)) {
+                            NULL)) {
     __ jmp(is_instance_lbl);
   } else {
     __ jmp(is_not_instance_lbl);
   }
   // Compare if the classes are equal.
   __ Bind(&compare_classes);
   const Register kClassIdReg = R10;
   __ LoadClassId(kClassIdReg, kInstanceReg);
   // If type is an interface, we can skip the class equality check.
   if (!type_class.is_interface()) {
@@ skipping 14 matching lines @@
         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 false;
   }
   // Custom checking for numbers (Smi, Mint, Bigint and Double).
   // Note that instance is not Smi (checked above).
-  if (type.IsSubtypeOf(
-          Type::Handle(Type::NumberInterface()), &malformed_error)) {
+  if (type.IsSubtypeOf(Type::Handle(Type::NumberInterface()), NULL)) {
     GenerateNumberTypeCheck(
         kClassIdReg, type, is_instance_lbl, is_not_instance_lbl);
     return false;
   }
   if (type.IsStringInterface()) {
     GenerateStringTypeCheck(kClassIdReg, is_instance_lbl, is_not_instance_lbl);
     return false;
   }
   // Otherwise fallthrough.
   return true;
@@ skipping 933 matching lines @@
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   __ Exchange(mem1, mem2);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64