Request for comments on overall approach.

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 106 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()));
+    __ GetClassOf(R10, RAX);
     if (!type_class.is_interface()) {
       __ CompareObject(R10, type_class);
       __ 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"));
@@ skipping 87 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()));
+  __ GetClassOf(R10, RAX);
   // If type is an interface, we can skip the class equality check.
   if (!type_class.is_interface()) {
     __ CompareObject(R10, type_class);
     __ 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());
@@ skipping 67 matching lines @@
     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()));
+  __ GetClassOf(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()));
+    __ GetClassOf(R10, RDX);
     __ CompareObject(R10, Object::ZoneHandle(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);
@@ skipping 755 matching lines @@
     __ cmpq(RAX, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (comp->type_arguments().IsUninstantiatedIdentity()) {
     Label type_arguments_uninstantiated;
     // 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).
-    __ LoadObject(RCX, Class::ZoneHandle(Object::type_arguments_class()));
-    __ cmpq(RCX, FieldAddress(RAX, Object::class_offset()));
+    __ GetClassOf(R10, RAX);
+    __ CompareObject(R10, Class::ZoneHandle(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);
   }
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
@@ skipping 27 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()));
+    __ GetClassOf(R10, RAX);
+    __ CompareObject(R10, Class::ZoneHandle(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 32 matching lines @@
     // TODO(regis): The following emitted code is duplicated in
     // VisitExtractConstructorTypeArguments above. The reason is that the code
     // is split between two computations, so that each one produces a
     // single value, rather than producing a pair of values.
     // If this becomes an issue, we should expose these tests at the IL level.
 
     // 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).
-    __ LoadObject(RCX, Class::ZoneHandle(Object::type_arguments_class()));
-    __ cmpq(RCX, FieldAddress(RAX, Object::class_offset()));
+    __ GetClassOf(R10, RAX);
+    __ CompareObject(R10, Class::ZoneHandle(Object::type_arguments_class()));
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     Immediate arguments_length =
         Immediate(Smi::RawValue(comp->type_arguments().Length()));
     __ cmpq(FieldAddress(RAX, TypeArguments::length_offset()),
         arguments_length);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     // The instantiator was used in VisitExtractConstructorTypeArguments as the
     // instantiated type arguments, no proper instantiator needed.
     __ movq(RAX, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
@@ skipping 668 matching lines @@
 
 
 void FlowGraphCompiler::FinalizeComments(const Code& code) {
   code.set_comments(assembler_->GetCodeComments());
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64