More inlined type checking for x64.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/code_generator.h"
@@ skipping 1746 matching lines @@
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
 // TOS + 1: instantiator type arguments (can be NULL).
 // TOS + 2: instance.
 // TOS + 3: SubtypeTestCache.
 // Result in RCX: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
   ASSERT((1 <= n) && (n <= 3));
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  // const intptr_t kInstantiatorTypeArgumentsInBytes = 1 * kWordSize;
+  const intptr_t kInstantiatorTypeArgumentsInBytes = 1 * kWordSize;
   const intptr_t kInstanceOffsetInBytes = 2 * kWordSize;
   const intptr_t kCacheOffsetInBytes = 3 * kWordSize;
   __ movq(RAX, Address(RSP, kInstanceOffsetInBytes));
   __ movq(R10, FieldAddress(RAX, Object::class_offset()));
   // RAX: instance, R10: instance class.
   if (n > 1) {
-    __ Unimplemented("GenerateSubtypeNTestCacheStub n > 1");
+    // Compute instance type arguments into R13.
+    Label has_no_type_arguments;
+    __ movq(R13, raw_null);
+    __ movq(RDI, FieldAddress(R10,
+        Class::type_arguments_instance_field_offset_offset()));
+    __ cmpq(RDI, Immediate(Class::kNoTypeArguments));
+    __ j(EQUAL, &has_no_type_arguments, Assembler::kNearJump);
+    __ movq(R13, FieldAddress(RAX, RDI, TIMES_1, 0));
+    __ Bind(&has_no_type_arguments);
   }
-  // TODO(srdjan): R13: instance type arguments or null, used only if n > 1.
+  // R13: instance type arguments or null, used only if n > 1.
   __ movq(RDX, Address(RSP, kCacheOffsetInBytes));
   // RDX: SubtypeTestCache.
   __ movq(RDX, FieldAddress(RDX, SubtypeTestCache::cache_offset()));
   __ addq(RDX, Immediate(Array::data_offset() - kHeapObjectTag));
   // RDX: Entry start.
   // R10: instance class.
   // R13: instance type arguments
   Label loop, found, not_found, next_iteration;
   __ Bind(&loop);
   __ movq(RDI, Address(RDX, kWordSize * SubtypeTestCache::kInstanceClass));
   __ cmpq(RDI, raw_null);
   __ j(EQUAL, &not_found, Assembler::kNearJump);
   __ cmpq(RDI, R10);
   if (n == 1) {
     __ j(EQUAL, &found, Assembler::kNearJump);
   } else {
-    __ Unimplemented("GenerateSubtypeNTestCacheStub n > 1");
+    __ j(NOT_EQUAL, &next_iteration, Assembler::kNearJump);
+    __ movq(RDI,
+        Address(RDX, kWordSize * SubtypeTestCache::kInstanceTypeArguments));
+    __ cmpq(RDI, R13);
+    if (n == 2) {
+      __ j(EQUAL, &found, Assembler::kNearJump);
+    } else {
+      __ j(NOT_EQUAL, &next_iteration, Assembler::kNearJump);
+      __ movq(RDI,
+          Address(RDX,
+                  kWordSize * SubtypeTestCache::kInstantiatorTypeArguments));
+      __ cmpq(RDI, Address(RSP, kInstantiatorTypeArgumentsInBytes));
+      __ j(EQUAL, &found, Assembler::kNearJump);
+    }
   }
 
   __ Bind(&next_iteration);
   __ addq(RDX, Immediate(kWordSize * SubtypeTestCache::kTestEntryLength));
   __ jmp(&loop, Assembler::kNearJump);
   // Fall through to not found.
   __ Bind(&not_found);
   __ movq(RCX, raw_null);
   __ ret();
 
@@ skipping 31 matching lines @@
 // TOS + 2: instance.
 // TOS + 3: cache array.
 // Result in RCX: null -> not found, otherwise result (true or false).
 void StubCode::GenerateSubtype3TestCacheStub(Assembler* assembler) {
   GenerateSubtypeNTestCacheStub(assembler, 3);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64