Simplify generated code for object allocation with type arguments.

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 1084 matching lines @@
   __ movl(Address(ESP, 0), EAX);  // Push the isolate as the only argument.
   __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
-//   ESP + 8 : type arguments object (only if class is parameterized).
-//   ESP + 4 : type arguments of instantiator (only if class is parameterized).
+//   ESP + 4 : type arguments object (only if class is parameterized).
 //   ESP : points to return address.
 // Uses EAX, EBX, ECX, EDX, EDI as temporary registers.
 void StubCode::GenerateAllocationStubForClass(Assembler* assembler,
                                               const Class& cls) {
-  const intptr_t kObjectTypeArgumentsOffset = 2 * kWordSize;
-  const intptr_t kInstantiatorTypeArgumentsOffset = 1 * kWordSize;
+  const intptr_t kObjectTypeArgumentsOffset = 1 * kWordSize;
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // The generated code is different if the class is parameterized.
   const bool is_cls_parameterized = cls.NumTypeArguments() > 0;
   ASSERT(!is_cls_parameterized ||
          (cls.type_arguments_field_offset() != Class::kNoTypeArguments));
   // kInlineInstanceSize is a constant used as a threshold for determining
   // when the object initialization should be done as a loop or as
   // straight line code.
   const int kInlineInstanceSize = 12;  // In words.
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
   Label slow_case_with_type_arguments;
   if (FLAG_inline_alloc && Heap::IsAllocatableInNewSpace(instance_size)) {
     Label slow_case_reload_type_arguments;
     if (is_cls_parameterized) {
-      // Instantiation of the type arguments vector is only required if an
-      // instantiator is provided (not kNoInstantiator, but may be null).
       __ movl(EDX, Address(ESP, kObjectTypeArgumentsOffset));
-      __ movl(EDI, Address(ESP, kInstantiatorTypeArgumentsOffset));
-      Label type_arguments_ready;
-      __ cmpl(EDI, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
-      __ j(EQUAL, &type_arguments_ready, Assembler::kNearJump);
-      // Lookup instantiator EDI in instantiations array of type arguments EDX
-      // and, if found, use cached instantiated type arguments.
-      __ movl(EAX, FieldAddress(EDX, TypeArguments::instantiations_offset()));
-      __ movl(EBX, FieldAddress(EAX, Array::length_offset()));
-      __ leal(EAX, FieldAddress(EAX, Array::data_offset()));
-      __ leal(EBX, Address(EAX, EBX, TIMES_2, 0));  // EBX is smi.
-      Label loop, found;
-      __ Bind(&loop);
-      __ cmpl(EAX, EBX);
-      __ j(ABOVE_EQUAL, &slow_case_reload_type_arguments);
-      __ movl(EDX, Address(EAX, 0 * kWordSize));  // Cached instantiator.
-      __ cmpl(EDX, EDI);
-      __ j(EQUAL, &found, Assembler::kNearJump);
-      __ cmpl(EDX, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
-      __ j(EQUAL, &slow_case_reload_type_arguments);
-      __ addl(EAX, Immediate(2 * kWordSize));
-      __ jmp(&loop, Assembler::kNearJump);
-      __ Bind(&found);
-      __ movl(EDX, Address(EAX, 1 * kWordSize));  // Cached instantiated args.
-      __ movl(EDI, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
-      __ Bind(&type_arguments_ready);
       // EDX: instantiated type arguments.
-      // EDI: kNoInstantiator.
     }
     // Allocate the object and update top to point to
     // next object start and initialize the allocated object.
     // EDX: instantiated type arguments (if is_cls_parameterized).
-    // EDI: kNoInstantiator (if is_cls_parameterized).
     Heap* heap = Isolate::Current()->heap();
     __ movl(EAX, Address::Absolute(heap->TopAddress()));
     __ leal(EBX, Address(EAX, instance_size));
     // Check if the allocation fits into the remaining space.
     // EAX: potential new object start.
     // EBX: potential next object start.
     __ cmpl(EBX, Address::Absolute(heap->EndAddress()));
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case_with_type_arguments);
     } else {
@@ skipping 52 matching lines @@
     }
     // Done allocating and initializing the instance.
     // EAX: new object.
     __ addl(EAX, Immediate(kHeapObjectTag));
     __ ret();
 
     __ Bind(&slow_case_reload_type_arguments);
   }
   if (is_cls_parameterized) {
     __ movl(EDX, Address(ESP, kObjectTypeArgumentsOffset));
-    __ movl(EDI, Address(ESP, kInstantiatorTypeArgumentsOffset));
   }
   __ Bind(&slow_case_with_type_arguments);
   // If is_cls_parameterized:
-  // EDX: new object type arguments (instantiated or not).
-  // EDI: instantiator type arguments or kNoInstantiator.
+  // EDX: new object type arguments.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushl(EDX);  // Push type arguments of object to be allocated.
-    __ pushl(EDI);  // Push type arguments of instantiator.
   } else {
     __ pushl(raw_null);  // Push null type arguments.
-    __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
-  __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
-  __ popl(EAX);  // Pop argument (instantiator).
+  __ CallRuntime(kAllocateObjectRuntimeEntry, 2);  // Allocate object.
   __ popl(EAX);  // Pop argument (type arguments of object).
   __ popl(EAX);  // Pop argument (class of object).
   __ popl(EAX);  // Pop result (newly allocated object).
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
 }
 
 
@@ skipping 891 matching lines @@
   const Register temp = ECX;
   __ movl(left, Address(ESP, 2 * kWordSize));
   __ movl(right, Address(ESP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32