Implement eager instantiation and canonicalization of type arguments at run

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"
 #include "vm/flow_graph_compiler.h"
 #include "vm/instructions.h"
 #include "vm/heap.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/scavenger.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 
 
 #define __ assembler->
 
 namespace dart {
 
 DEFINE_FLAG(bool, inline_alloc, true, "Inline allocation of objects.");
 DEFINE_FLAG(bool, use_slow_path, false,
     "Set to true for debugging & verifying the slow paths.");
+DECLARE_FLAG(bool, trace_optimized_ic_calls);
 DECLARE_FLAG(int, optimization_counter_threshold);
-DECLARE_FLAG(bool, trace_optimized_ic_calls);
+
 
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : address of last argument in argument array.
 //   ESP + 4*EDX : address of first argument in argument array.
 //   ESP + 4*EDX + 4 : address of return value.
 //   ECX : address of the runtime function to call.
 //   EDX : number of arguments to the call.
 // Must preserve callee saved registers EDI and EBX.
 void StubCode::GenerateCallToRuntimeStub(Assembler* assembler) {
@@ skipping 1071 matching lines @@
   const intptr_t kInstantiatorTypeArgumentsOffset = 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;
+  const int kInlineInstanceSize = 12;  // In words.
   const intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
-  const intptr_t type_args_size = InstantiatedTypeArguments::InstanceSize();
-  if (FLAG_inline_alloc &&
-      Heap::IsAllocatableInNewSpace(instance_size + type_args_size)) {
-    Label slow_case;
+  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));
-    if (is_cls_parameterized) {
-      __ movl(ECX, EBX);
-      // A new InstantiatedTypeArguments object only needs to be allocated if
-      // the instantiator is provided (not kNoInstantiator, but may be null).
-      Label no_instantiator;
-      __ cmpl(Address(ESP, kInstantiatorTypeArgumentsOffset),
-              Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
-      __ j(EQUAL, &no_instantiator, Assembler::kNearJump);
-      __ addl(EBX, Immediate(type_args_size));
-      __ Bind(&no_instantiator);
-      // ECX: potential new object end and, if ECX != EBX, potential new
-      // InstantiatedTypeArguments object start.
-    }
     // 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);
+      __ jmp(&slow_case_with_type_arguments);
     } else {
-      __ j(ABOVE_EQUAL, &slow_case);
+      __ j(ABOVE_EQUAL, &slow_case_with_type_arguments);
     }
-
-    // Successfully allocated the object(s), now update top to point to
-    // next object start and initialize the object.
     __ movl(Address::Absolute(heap->TopAddress()), EBX);
-    __ UpdateAllocationStats(cls.id(), EDI);
-
-    if (is_cls_parameterized) {
-      // Initialize the type arguments field in the object.
-      // EAX: new object start.
-      // ECX: potential new object end and, if ECX != EBX, potential new
-      // InstantiatedTypeArguments object start.
-      // EBX: next object start.
-      Label type_arguments_ready;
-      __ movl(EDI, Address(ESP, kObjectTypeArgumentsOffset));
-      __ cmpl(ECX, EBX);
-      __ j(EQUAL, &type_arguments_ready, Assembler::kNearJump);
-      // Initialize InstantiatedTypeArguments object at ECX.
-      __ movl(Address(ECX,
-          InstantiatedTypeArguments::uninstantiated_type_arguments_offset()),
-              EDI);
-      __ movl(EDX, Address(ESP, kInstantiatorTypeArgumentsOffset));
-      __ movl(Address(ECX,
-          InstantiatedTypeArguments::instantiator_type_arguments_offset()),
-              EDX);
-      const Class& ita_cls =
-          Class::ZoneHandle(Object::instantiated_type_arguments_class());
-      // Set the tags.
-      uword tags = 0;
-      tags = RawObject::SizeTag::update(type_args_size, tags);
-      tags = RawObject::ClassIdTag::update(ita_cls.id(), tags);
-      __ movl(Address(ECX, Instance::tags_offset()), Immediate(tags));
-      // Set the new InstantiatedTypeArguments object (ECX) as the type
-      // arguments (EDI) of the new object (EAX).
-      __ movl(EDI, ECX);
-      __ addl(EDI, Immediate(kHeapObjectTag));
-      // Set EBX to new object end.
-      __ movl(EBX, ECX);
-      __ Bind(&type_arguments_ready);
-      // EAX: new object.
-      // EDI: new object type arguments.
-    }
+    __ UpdateAllocationStats(cls.id(), ECX);
 
     // EAX: new object start.
     // EBX: next object start.
-    // EDI: new object type arguments (if is_cls_parameterized).
+    // EDX: new object type arguments (if is_cls_parameterized).
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     __ movl(Address(EAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the remaining words of the object.
     const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
     // EAX: new object start.
     // EBX: next object start.
-    // EDI: new object type arguments (if is_cls_parameterized).
+    // EDX: new object type arguments (if is_cls_parameterized).
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
       for (intptr_t current_offset = Instance::NextFieldOffset();
            current_offset < instance_size;
            current_offset += kWordSize) {
         __ movl(Address(EAX, current_offset), raw_null);
       }
     } else {
       __ leal(ECX, Address(EAX, Instance::NextFieldOffset()));
       // Loop until the whole object is initialized.
       // EAX: new object.
       // EBX: next object start.
       // ECX: next word to be initialized.
-      // EDI: new object type arguments (if is_cls_parameterized).
+      // EDX: new object type arguments (if is_cls_parameterized).
       Label init_loop;
       Label done;
       __ Bind(&init_loop);
       __ cmpl(ECX, EBX);
       __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
       __ movl(Address(ECX, 0), raw_null);
       __ addl(ECX, Immediate(kWordSize));
       __ jmp(&init_loop, Assembler::kNearJump);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
-      // EDI: new object type arguments.
+      // EDX: new object type arguments.
       // Set the type arguments in the new object.
-      __ movl(Address(EAX, cls.type_arguments_field_offset()), EDI);
+      __ movl(Address(EAX, cls.type_arguments_field_offset()), EDX);
     }
     // Done allocating and initializing the instance.
     // EAX: new object.
     __ addl(EAX, Immediate(kHeapObjectTag));
     __ ret();
 
-    __ Bind(&slow_case);
+    __ Bind(&slow_case_reload_type_arguments);
   }
   if (is_cls_parameterized) {
-    __ movl(EAX, Address(ESP, kObjectTypeArgumentsOffset));
-    __ movl(EDX, Address(ESP, kInstantiatorTypeArgumentsOffset));
+    __ 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.
   // 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(EAX);  // Push type arguments of object to be allocated.
-    __ pushl(EDX);  // Push type arguments of instantiator.
+    __ 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).
   __ 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
@@ skipping 897 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