Use class id instead of class in subtype test cache.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 333 matching lines @@
     const AbstractType& type,
     const AbstractTypeArguments& instantiator_type_arguments,
     const Bool& result) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const Type& instance_type = Type::Handle(instance.GetType());
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
-    OS::Print("%s: '%s' %s '%s' (pc: 0x%x).\n",
+    OS::Print("%s: '%s' %d %s '%s' %d (pc: 0x%x).\n",
               message,
               String::Handle(instance_type.Name()).ToCString(),
+              Class::Handle(instance_type.type_class()).id(),
               (result.raw() == Bool::True()) ? "is" : "is !",
               String::Handle(type.Name()).ToCString(),
+              Class::Handle(type.type_class()).id(),
               caller_frame->pc());
   } else {
     // Instantiate type before printing.
     const AbstractType& instantiated_type =
         AbstractType::Handle(type.InstantiateFrom(instantiator_type_arguments));
     OS::Print("%s: '%s' %s '%s' instantiated from '%s' (pc: 0x%x).\n",
               message,
               String::Handle(instance_type.Name()).ToCString(),
               (result.raw() == Bool::True()) ? "is" : "is !",
               String::Handle(instantiated_type.Name()).ToCString(),
@@ skipping 99 matching lines @@
             instance, type, instantiator_type_arguments, result);
       }
       return;
     }
     if (replaced) {
       type_arguments_replaced = true;
     }
     instantiator_type_arguments = instantiator.GetTypeArguments();
   }
 
-  Class& last_instance_class = Class::Handle();
+  intptr_t last_instance_class_id = -1;
   AbstractTypeArguments& last_instance_type_arguments =
       AbstractTypeArguments::Handle();
   AbstractTypeArguments& last_instantiator_type_arguments =
       AbstractTypeArguments::Handle();
   Bool& last_result = Bool::Handle();
   intptr_t len = new_cache.NumberOfChecks();
   for (intptr_t i = 0; i < len; ++i) {
     new_cache.GetCheck(
         i,
-        &last_instance_class,
+        &last_instance_class_id,
         &last_instance_type_arguments,
         &last_instantiator_type_arguments,
         &last_result);
-    if ((last_instance_class.raw() == instance_class.raw()) &&
+    if ((last_instance_class_id == instance_class.id()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
       if (FLAG_trace_type_checks) {
         OS::Print("%d ", i);
         if (type_arguments_replaced) {
           PrintTypeCheck("Duplicate cache entry (canonical.)", instance, type,
               instantiator_type_arguments, result);
         } else {
           PrintTypeCheck("WARNING Duplicate cache entry", instance, type,
               instantiator_type_arguments, result);
         }
       }
       // Can occur if we have canonicalized arguments.
       // TODO(srdjan): Investigate why this assert can fail.
       // ASSERT(type_arguments_replaced);
       return;
     }
   }
-  new_cache.AddCheck(instance_class,
+  new_cache.AddCheck(instance_class.id(),
                      instance_type_arguments,
                      instantiator_type_arguments,
                      result);
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       test_type = type.InstantiateFrom(instantiator_type_arguments);
     }
     OS::Print("  Updated test cache 0x%x ix:%d:\n"
-        "    [0x%x %s, 0x%x %s]\n"
-        "    [0x%x %s, 0x%x %s] %s\n",
+        "    [0x%x %s %d, 0x%x %s]\n"
+        "    [0x%x %s %d, 0x%x %s] %s\n",
         new_cache.raw(),
         len,
         instance_class.raw(),
         instance_class.ToCString(),
+        instance_class.id(),
         instance_type_arguments.raw(),
         instance_type_arguments.ToCString(),
         test_type.type_class(),
         Class::Handle(test_type.type_class()).ToCString(),
+        Class::Handle(test_type.type_class()).id(),
         instantiator_type_arguments.raw(),
         instantiator_type_arguments.ToCString(),
         result.ToCString());
   }
 }
 
 
 // Check that the given instance is an instance of the given type.
 // Tested instance may not be null, because the null test is inlined.
 // Arg0: node id of the instanceof node.
@@ skipping 990 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart