Pass a second type argument vector to all type instantiation calls in the VM.

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2013, 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_IA32)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 1662 matching lines @@
   __ Bind(&stepping);
   __ EnterStubFrame();
   __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
   __ LeaveFrame();
   __ jmp(&done_stepping, Assembler::kNearJump);
 }
 
 
 // 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.
+// TOS + 1: function type arguments (only if n == 4, can be raw_null).
+// TOS + 2: instantiator type arguments (only if n == 4, can be raw_null).
+// TOS + 3: instance.
+// TOS + 4: SubtypeTestCache.
 // Result in ECX: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
-  ASSERT((1 <= n) && (n <= 3));
-  const intptr_t kInstantiatorTypeArgumentsInBytes = 1 * kWordSize;
-  const intptr_t kInstanceOffsetInBytes = 2 * kWordSize;
-  const intptr_t kCacheOffsetInBytes = 3 * kWordSize;
+  ASSERT((n == 1) || (n == 2) || (n == 4));
+  const intptr_t kFunctionTypeArgumentsInBytes = 1 * kWordSize;
+  const intptr_t kInstantiatorTypeArgumentsInBytes = 2 * kWordSize;
+  const intptr_t kInstanceOffsetInBytes = 3 * kWordSize;
+  const intptr_t kCacheOffsetInBytes = 4 * kWordSize;
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(EAX, Address(ESP, kInstanceOffsetInBytes));
   if (n > 1) {
-    // Get instance type arguments.
     __ LoadClass(ECX, EAX, EBX);
     // Compute instance type arguments into EBX.
     Label has_no_type_arguments;
     __ movl(EBX, raw_null);
     __ movl(EDI,
             FieldAddress(ECX,
                          Class::type_arguments_field_offset_in_words_offset()));
     __ cmpl(EDI, Immediate(Class::kNoTypeArguments));
     __ j(EQUAL, &has_no_type_arguments, Assembler::kNearJump);
     __ movl(EBX, FieldAddress(EAX, EDI, TIMES_4, 0));
@@ skipping 31 matching lines @@
             Address(EDX, kWordSize * SubtypeTestCache::kInstanceTypeArguments));
     __ cmpl(EDI, EBX);
     if (n == 2) {
       __ j(EQUAL, &found, Assembler::kNearJump);
     } else {
       __ j(NOT_EQUAL, &next_iteration, Assembler::kNearJump);
       __ movl(EDI,
               Address(EDX, kWordSize *
                                SubtypeTestCache::kInstantiatorTypeArguments));
       __ cmpl(EDI, Address(ESP, kInstantiatorTypeArgumentsInBytes));
+      __ j(NOT_EQUAL, &next_iteration, Assembler::kNearJump);
+      __ movl(EDI, Address(EDX, kWordSize *
+                                    SubtypeTestCache::kFunctionTypeArguments));
+      __ cmpl(EDI, Address(ESP, kFunctionTypeArgumentsInBytes));
       __ j(EQUAL, &found, Assembler::kNearJump);
     }
   }
   __ Bind(&next_iteration);
   __ addl(EDX, Immediate(kWordSize * SubtypeTestCache::kTestEntryLength));
   __ jmp(&loop, Assembler::kNearJump);
   // Fall through to not found.
   __ Bind(&not_found);
   __ movl(ECX, raw_null);
   __ ret();
 
   __ Bind(&found);
   __ movl(ECX, Address(EDX, kWordSize * SubtypeTestCache::kTestResult));
   __ ret();
 }
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
-// TOS + 1: instantiator type arguments or NULL.
-// TOS + 2: instance.
-// TOS + 3: cache array.
+// TOS + 1: raw_null.
+// TOS + 2: raw_null.
+// TOS + 3: instance.
+// TOS + 4: SubtypeTestCache.
 // Result in ECX: null -> not found, otherwise result (true or false).
 void StubCode::GenerateSubtype1TestCacheStub(Assembler* assembler) {
   GenerateSubtypeNTestCacheStub(assembler, 1);
 }
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
-// TOS + 1: instantiator type arguments or NULL.
-// TOS + 2: instance.
-// TOS + 3: cache array.
+// TOS + 1: raw_null.
+// TOS + 2: raw_null.
+// TOS + 3: instance.
+// TOS + 4: SubtypeTestCache.
 // Result in ECX: null -> not found, otherwise result (true or false).
 void StubCode::GenerateSubtype2TestCacheStub(Assembler* assembler) {
   GenerateSubtypeNTestCacheStub(assembler, 2);
 }
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
-// TOS + 1: instantiator type arguments.
-// TOS + 2: instance.
-// TOS + 3: cache array.
+// TOS + 1: function type arguments (can be raw_null).
+// TOS + 2: instantiator type arguments (can be raw_null).
+// TOS + 3: instance.
+// TOS + 4: SubtypeTestCache.
 // Result in ECX: null -> not found, otherwise result (true or false).
-void StubCode::GenerateSubtype3TestCacheStub(Assembler* assembler) {
-  GenerateSubtypeNTestCacheStub(assembler, 3);
+void StubCode::GenerateSubtype4TestCacheStub(Assembler* assembler) {
+  GenerateSubtypeNTestCacheStub(assembler, 4);
 }
 
 
 // Return the current stack pointer address, used to do stack alignment checks.
 // TOS + 0: return address
 // Result in EAX.
 void StubCode::GenerateGetStackPointerStub(Assembler* assembler) {
   __ leal(EAX, Address(ESP, kWordSize));
   __ ret();
 }
@@ skipping 298 matching lines @@
 }
 
 
 void StubCode::GenerateAsynchronousGapMarkerStub(Assembler* assembler) {
   __ int3();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32