In generated code for x64 don't load object's class directly from class_ field.

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 118 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
-static const Class* CoreClass(const char* c_name) {
+static RawClass* CoreClass(const char* c_name) {
   const String& class_name = String::Handle(String::NewSymbol(c_name));
-  const Class& cls = Class::ZoneHandle(Library::Handle(
-      Library::CoreImplLibrary()).LookupClass(class_name));
-  ASSERT(!cls.IsNull());
-  return &cls;
+  RawClass* raw_class = Library::Handle(
+      Library::CoreImplLibrary()).LookupClass(class_name);
+  ASSERT(raw_class != Class::null());
+  return raw_class;
 }
 
 
 #define __ assembler_->
 
 
 // Jumps to labels 'is_instance' or 'is_not_instance' respectively, if
 // type test is conclusive, otherwise fallthrough if a type test could not
 // be completed.
 // RAX: instance (must survive),
@@ skipping 10 matching lines @@
   // A Smi object cannot be the instance of a parameterized class.
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, is_not_instance_lbl);
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
   const bool is_raw_type = type_arguments.IsNull() ||
       type_arguments.IsRaw(type_arguments.Length());
   if (is_raw_type) {
     // Dynamic type argument, check only classes.
     // List is a very common case.
-    __ movq(R10, FieldAddress(RAX, Object::class_offset()));
+    __ LoadClassIndexOfObject(R10, RAX);
     if (!type_class.is_interface()) {
-      __ CompareObject(R10, type_class);
+      __ cmpl(R10, Immediate(type_class.index()));
       __ j(EQUAL, is_instance_lbl);
     }
     if (type.IsListInterface()) {
       Label unknown;
       GrowableArray<const Class*> args;
-      args.Add(CoreClass("ObjectArray"));
-      args.Add(CoreClass("GrowableObjectArray"));
-      args.Add(CoreClass("ImmutableArray"));
+      args.Add(&Class::Handle(CoreClass("ObjectArray")));
+      args.Add(&Class::Handle(CoreClass("GrowableObjectArray")));
+      args.Add(&Class::Handle(CoreClass("ImmutableArray")));
       CheckClasses(args, is_instance_lbl, &unknown);
       __ Bind(&unknown);
     }
     return GenerateSubtype1TestCacheLookup(
         cid, token_index, type_class, is_instance_lbl, is_not_instance_lbl);
   }
   // 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));
@@ skipping 32 matching lines @@
   __ j(EQUAL, &runtime_call, Assembler::kNearJump);
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   __ CompareObject(RCX, bool_true);
   __ j(EQUAL, is_instance_lbl);
   __ jmp(is_not_instance_lbl);
   __ Bind(&runtime_call);
   return type_test_cache.raw();
 }
 
 
 // R10: instance class to check.

[Ivan Posva, 2012/05/30 18:15:19]

// R10: instance class id to check.

 void FlowGraphCompiler::CheckClasses(const GrowableArray<const Class*>& classes,

[Ivan Posva, 2012/05/30 18:15:19]

How about CheckClassIds and passing a GrowableArray<int> instead? That way you
are certain that the handles are not surviving past the assembly stage.

                                      Label* is_instance_lbl,
                                      Label* is_not_instance_lbl) {
   for (intptr_t i = 0; i < classes.length(); i++) {
-    __ CompareObject(R10, *classes[i]);
+    __ cmpl(R10, Immediate(classes[i]->index()));
     __ j(EQUAL, is_instance_lbl);
   }
   __ jmp(is_not_instance_lbl);
 }
 
 
 
 // Testing against an instantiated type with no arguments, without
 // SubtypeTestCache.
 // RAX: instance to test against (preserved).
@@ skipping 19 matching lines @@
                             TypeArguments::Handle(),
                             &malformed_error)) {
     __ jmp(is_instance_lbl);
   } else {
     __ jmp(is_not_instance_lbl);
   }
 
   ObjectStore* object_store = Isolate::Current()->object_store();
   // Compare if the classes are equal. Instance is not Smi.
   __ Bind(&compare_classes);
-  __ movq(R10, FieldAddress(RAX, Object::class_offset()));
+  __ LoadClassIndexOfObject(R10, RAX);
   // If type is an interface, we can skip the class equality check.
   if (!type_class.is_interface()) {
-    __ CompareObject(R10, type_class);
+    __ cmpl(R10, Immediate(type_class.index()));
     __ j(EQUAL, is_instance_lbl);
   }
   // Check for interfaces that cannot be implemented by user.
   // (see ClassFinalizer::ResolveInterfaces for list of restricted interfaces).
   // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolInterface()) {
-    const Class& bool_class = Class::ZoneHandle(object_store->bool_class());
-    __ CompareObject(R10, bool_class);
+    __ cmpl(R10, Immediate(kBool));
     __ j(EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
     return;
   }
   if (type.IsFunctionInterface()) {
     // Check if instance is a closure.
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
-    __ movq(R10, FieldAddress(R10, Class::signature_function_offset()));
-    __ cmpq(R10, raw_null);
+    __ LoadClassByIndex(R13, R10);
+    __ movq(R13, FieldAddress(R13, Class::signature_function_offset()));
+    __ cmpq(R13, raw_null);
     __ j(NOT_EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
     return;
   }
   // 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)) {
-    const Class& mint_class = Class::ZoneHandle(object_store->mint_class());
-    const Class& bigint_class = Class::ZoneHandle(object_store->bigint_class());
-    const Class& double_class = Class::ZoneHandle(object_store->double_class());
+    const Class& mint_class = Class::Handle(object_store->mint_class());

[Ivan Posva, 2012/05/30 18:15:19]

kMint

+    const Class& bigint_class = Class::Handle(object_store->bigint_class());

[Ivan Posva, 2012/05/30 18:15:19]

kBigInt

+    const Class& double_class = Class::Handle(object_store->double_class());

[Ivan Posva, 2012/05/30 18:15:19]

kDouble

     GrowableArray<const Class*> args;
     if (type.IsNumberInterface()) {
       args.Add(&double_class);
       args.Add(&mint_class);
       args.Add(&bigint_class);
     } else if (type.IsIntInterface()) {
       args.Add(&mint_class);
       args.Add(&bigint_class);
     } else if (type.IsDoubleInterface()) {
       args.Add(&double_class);
     }
     CheckClasses(args, is_instance_lbl, is_not_instance_lbl);
     return;
   }
   if (type.IsStringInterface()) {
     const Class& one_byte_string_class =

[Ivan Posva, 2012/05/30 18:15:19]

ditto, here and below...

-        Class::ZoneHandle(object_store->one_byte_string_class());
+        Class::Handle(object_store->one_byte_string_class());
     const Class& two_byte_string_class =
-        Class::ZoneHandle(object_store->two_byte_string_class());
+        Class::Handle(object_store->two_byte_string_class());
     const Class& four_byte_string_class =
-        Class::ZoneHandle(object_store->four_byte_string_class());
+        Class::Handle(object_store->four_byte_string_class());
     const Class& external_one_byte_string_class =
-        Class::ZoneHandle(object_store->external_one_byte_string_class());
+        Class::Handle(object_store->external_one_byte_string_class());
     const Class& external_two_byte_string_class =
-        Class::ZoneHandle(object_store->external_two_byte_string_class());
+        Class::Handle(object_store->external_two_byte_string_class());
     const Class& external_four_byte_string_class =
-        Class::ZoneHandle(object_store->external_four_byte_string_class());
+        Class::Handle(object_store->external_four_byte_string_class());
     GrowableArray<const Class*> args;
     args.Add(&one_byte_string_class);
     args.Add(&two_byte_string_class);
     args.Add(&four_byte_string_class);
     args.Add(&external_one_byte_string_class);
     args.Add(&external_two_byte_string_class);
     args.Add(&external_four_byte_string_class);
     CheckClasses(args, is_instance_lbl, is_not_instance_lbl);
     return;
   }
   // Otherwise fallthrough.
 }
 
 
 // Uses SubtypeTestCache to store instance class and result.
 // RAX: instance to test.
 // Immediate class test already done.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateSubtype1TestCacheLookup(
     intptr_t cid,
     intptr_t token_index,
     const Class& type_class,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  __ movq(R10, FieldAddress(RAX, Object::class_offset()));
+  __ LoadClassOfObject(R10, RAX);
   // Check immediate superclass equality.
   __ movq(R13, FieldAddress(R10, Class::super_type_offset()));
   __ movq(R13, FieldAddress(R13, Type::type_class_offset()));
   __ CompareObject(R13, type_class);
   __ j(EQUAL, is_instance_lbl);
 
   __ LoadObject(R10, type_test_cache);
   __ pushq(R10);  // Cache array.
   __ pushq(RAX);  // Instance.
   __ pushq(raw_null);  // Unused
@@ skipping 28 matching lines @@
   if (type.IsTypeParameter()) {
      // Load instantiator (or null) and instantiator type arguments on stack.
     __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
     // RDX: instantiator type arguments.
     // Check if type argument is Dynamic.
     __ cmpq(RDX, raw_null);
     __ j(EQUAL, is_instance_lbl);
     // Can handle only type arguments that are instances of TypeArguments.
     // (runtime checks canonicalize type arguments).
     Label fall_through;
-    __ movq(R10, FieldAddress(RDX, Object::class_offset()));
-    __ CompareObject(R10, Object::ZoneHandle(Object::type_arguments_class()));
+    __ CompareClassOfObject(RDX,
+                            Class::Handle(Object::type_arguments_class()));
     __ j(NOT_EQUAL, &fall_through);
     __ movq(RDI,
         FieldAddress(RDX, TypeArguments::type_at_offset(type.Index())));
     // RDI: Concrete type.
     // Check if it is Dynamic,
     __ CompareObject(RDI, Type::ZoneHandle(Type::DynamicType()));
     __ j(EQUAL,  is_instance_lbl);
     __ cmpq(RDI, raw_null);
     __ j(EQUAL,  is_instance_lbl);
     // For Smi check quickly against int and num interface types.
@@ skipping 577 matching lines @@
     __ cmpq(RAX, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (comp->type_arguments().IsUninstantiatedIdentity()) {
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check the instantiator (RAX) for null here, because a null
     // instantiator will have the wrong class (Null instead of TypeArguments).
     Label type_arguments_uninstantiated;
-    __ LoadObject(RCX, Class::ZoneHandle(Object::type_arguments_class()));
-    __ cmpq(RCX, FieldAddress(RAX, Object::class_offset()));
+    __ CompareClassOfObject(RAX,
+                            Class::Handle(Object::type_arguments_class()));
     __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
     Immediate arguments_length =
         Immediate(Smi::RawValue(comp->type_arguments().Length()));
     __ cmpq(FieldAddress(RAX, TypeArguments::length_offset()),
         arguments_length);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
@@ skipping 691 matching lines @@
 
 void FlowGraphCompiler::FinalizeComments(const Code& code) {
   code.set_comments(assembler_->GetCodeComments());
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64