Implement eager instantiation and canonicalization of type arguments at run

runtime/vm/stub_code_x64.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_X64)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/heap.h"
 #include "vm/instructions.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:
 //   RSP : points to return address.
 //   RSP + 8 : address of last argument in argument array.
 //   RSP + 8*R10 : address of first argument in argument array.
 //   RSP + 8*R10 + 8 : address of return value.
 //   RBX : address of the runtime function to call.
 //   R10 : number of arguments to the call.
 // Must preserve callee saved registers R12 and R13.
@@ skipping 1067 matching lines @@
   // 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);
-  const intptr_t type_args_size = InstantiatedTypeArguments::InstanceSize();
   __ LoadObject(R12, Object::null_object(), PP);
-  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).
+      __ movq(RDX, Address(RSP, kObjectTypeArgumentsOffset));
+      __ movq(RDI, Address(RSP, kInstantiatorTypeArgumentsOffset));
+      Label type_arguments_ready;
+      __ cmpq(RDI, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
+      __ j(EQUAL, &type_arguments_ready, Assembler::kNearJump);
+      // Lookup instantiator RDI in instantiations array of type arguments RDX
+      // and, if found, use cached instantiated type arguments.
+      __ movq(RAX, FieldAddress(RDX, TypeArguments::instantiations_offset()));
+      __ movq(RBX, FieldAddress(RAX, Array::length_offset()));
+      __ leaq(RAX, FieldAddress(RAX, Array::data_offset()));
+      __ leaq(RBX, Address(RAX, RBX, TIMES_4, 0));  // RBX is smi.
+      Label loop, found;
+      __ Bind(&loop);
+      __ cmpq(RAX, RBX);
+      __ j(ABOVE_EQUAL, &slow_case_reload_type_arguments);
+      __ movq(RDX, Address(RAX, 0 * kWordSize));  // Cached instantiator.
+      __ cmpq(RDX, RDI);
+      __ j(EQUAL, &found, Assembler::kNearJump);
+      __ cmpq(RDX, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
+      __ j(EQUAL, &slow_case_reload_type_arguments);
+      __ addq(RAX, Immediate(2 * kWordSize));
+      __ jmp(&loop, Assembler::kNearJump);
+      __ Bind(&found);
+      __ movq(RDX, Address(RAX, 1 * kWordSize));  // Cached instantiated args.
+      __ movq(RDI, Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
+      __ Bind(&type_arguments_ready);
+      // RDX: instantiated type arguments.
+      // RDI: kNoInstantiator.
+    }
+    // Allocate the object and update top to point to
+    // next object start and initialize the allocated object.
+    // RDX: instantiated type arguments (if is_cls_parameterized).
+    // RDI: kNoInstantiator (if is_cls_parameterized).
     Heap* heap = Isolate::Current()->heap();
-    __ movq(RAX, Immediate(heap->TopAddress()));
-    __ movq(RAX, Address(RAX, 0));
+    __ movq(RCX, Immediate(heap->TopAddress()));
+    __ movq(RAX, Address(RCX, 0));
     __ leaq(RBX, Address(RAX, instance_size));
-    if (is_cls_parameterized) {
-      __ movq(RCX, RBX);
-      // A new InstantiatedTypeArguments object only needs to be allocated if
-      // the instantiator is provided (not kNoInstantiator, but may be null).
-      Label no_instantiator;
-      __ cmpq(Address(RSP, kInstantiatorTypeArgumentsOffset),
-              Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
-      __ j(EQUAL, &no_instantiator, Assembler::kNearJump);
-      __ addq(RBX, Immediate(type_args_size));
-      __ Bind(&no_instantiator);
-      // RCX: potential new object end and, if RCX != RBX, potential new
-      // InstantiatedTypeArguments object start.
-    }
     // Check if the allocation fits into the remaining space.
     // RAX: potential new object start.
     // RBX: potential next object start.
-    __ movq(RDI, Immediate(heap->EndAddress()));
-    __ cmpq(RBX, Address(RDI, 0));
+    // RCX: heap top address.
+    __ movq(R13, Immediate(heap->EndAddress()));
+    __ cmpq(RBX, Address(R13, 0));
     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.
-    __ movq(RDI, Immediate(heap->TopAddress()));
-    __ movq(Address(RDI, 0), RBX);
+    __ movq(Address(RCX, 0), RBX);
     __ UpdateAllocationStats(cls.id());
 
-    if (is_cls_parameterized) {
-      // Initialize the type arguments field in the object.
-      // RAX: new object start.
-      // RCX: potential new object end and, if RCX != RBX, potential new
-      // InstantiatedTypeArguments object start.
-      // RBX: next object start.
-      Label type_arguments_ready;
-      __ movq(RDI, Address(RSP, kObjectTypeArgumentsOffset));
-      __ cmpq(RCX, RBX);
-      __ j(EQUAL, &type_arguments_ready, Assembler::kNearJump);
-      // Initialize InstantiatedTypeArguments object at RCX.
-      __ movq(Address(RCX,
-          InstantiatedTypeArguments::uninstantiated_type_arguments_offset()),
-              RDI);
-      __ movq(RDX, Address(RSP, kInstantiatorTypeArgumentsOffset));
-      __ movq(Address(RCX,
-          InstantiatedTypeArguments::instantiator_type_arguments_offset()),
-              RDX);
-      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);
-      __ movq(Address(RCX, Instance::tags_offset()), Immediate(tags));
-      // Set the new InstantiatedTypeArguments object (RCX) as the type
-      // arguments (RDI) of the new object (RAX).
-      __ movq(RDI, RCX);
-      __ addq(RDI, Immediate(kHeapObjectTag));
-      // Set RBX to new object end.
-      __ movq(RBX, RCX);
-      __ Bind(&type_arguments_ready);
-      // RAX: new object.
-      // RDI: new object type arguments.
-    }
-
     // RAX: new object start.
     // RBX: next object start.
-    // RDI: new object type arguments (if is_cls_parameterized).
+    // RDX: 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);
     __ movq(Address(RAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the remaining words of the object.
     // RAX: new object start.
     // RBX: next object start.
-    // RDI: new object type arguments (if is_cls_parameterized).
+    // RDX: new object type arguments (if is_cls_parameterized).
+    // R12: raw null.
     // 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) {
         __ movq(Address(RAX, current_offset), R12);
       }
     } else {
       __ leaq(RCX, Address(RAX, Instance::NextFieldOffset()));
       // Loop until the whole object is initialized.
       // RAX: new object.
       // RBX: next object start.
       // RCX: next word to be initialized.
-      // RDI: new object type arguments (if is_cls_parameterized).
+      // RDX: new object type arguments (if is_cls_parameterized).
       Label init_loop;
       Label done;
       __ Bind(&init_loop);
       __ cmpq(RCX, RBX);
       __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
       __ movq(Address(RCX, 0), R12);
       __ addq(RCX, Immediate(kWordSize));
       __ jmp(&init_loop, Assembler::kNearJump);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
-      // RDI: new object type arguments.
+      // RDX: new object type arguments.
       // Set the type arguments in the new object.
-      __ movq(Address(RAX, cls.type_arguments_field_offset()), RDI);
+      __ movq(Address(RAX, cls.type_arguments_field_offset()), RDX);
     }
     // Done allocating and initializing the instance.
     // RAX: new object.
     __ addq(RAX, Immediate(kHeapObjectTag));
     __ ret();
 
-    __ Bind(&slow_case);
+    __ Bind(&slow_case_reload_type_arguments);
   }
   if (is_cls_parameterized) {
-    __ movq(RAX, Address(RSP, kObjectTypeArgumentsOffset));
-    __ movq(RDX, Address(RSP, kInstantiatorTypeArgumentsOffset));
+    __ movq(RDX, Address(RSP, kObjectTypeArgumentsOffset));
+    __ movq(RDI, Address(RSP, kInstantiatorTypeArgumentsOffset));
   }
+  __ Bind(&slow_case_with_type_arguments);
+  // If is_cls_parameterized:
+  // RDX: new object type arguments (instantiated or not).
+  // RDI: instantiator type arguments or kNoInstantiator.
   // Create a stub frame.
   __ EnterStubFrame(true);  // Uses PP to access class object.
   __ pushq(R12);  // Setup space on stack for return value.
   __ PushObject(cls, PP);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
-    __ pushq(RAX);  // Push type arguments of object to be allocated.
-    __ pushq(RDX);  // Push type arguments of instantiator.
+    __ pushq(RDX);  // Push type arguments of object to be allocated.
+    __ pushq(RDI);  // Push type arguments of instantiator.
   } else {
     __ pushq(R12);  // Push null type arguments.
     __ pushq(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ popq(RAX);  // Pop argument (instantiator).
   __ popq(RAX);  // Pop argument (type arguments of object).
   __ popq(RAX);  // Pop argument (class of object).
   __ popq(RAX);  // Pop result (newly allocated object).
   // RAX: new object
@@ skipping 362 matching lines @@
   __ addq(Address(R12, count_offset), Immediate(Smi::RawValue(1)));
   __ j(NO_OVERFLOW, &call_target_function, Assembler::kNearJump);
   __ movq(Address(R12, count_offset),
           Immediate(Smi::RawValue(Smi::kMaxValue)));
 
   __ Bind(&call_target_function);
   // RAX: Target function.
   Label is_compiled;
   __ movq(RCX, FieldAddress(RAX, Function::code_offset()));
   if (FLAG_collect_code) {
-    // If code might be GC'd, then EBX might be null. If it is, recompile.
+    // If code might be GC'd, then RBX might be null. If it is, recompile.
     __ CompareObject(RCX, Object::null_object(), PP);
     __ j(NOT_EQUAL, &is_compiled, Assembler::kNearJump);
     __ EnterStubFrame();
     __ pushq(R10);  // Preserve arguments descriptor array.
     __ pushq(RBX);  // Preserve IC data object.
     __ pushq(RAX);  // Pass function.
     __ CallRuntime(kCompileFunctionRuntimeEntry, 1);
     __ popq(RAX);  // Restore function.
     __ popq(RBX);  // Restore IC data array.
     __ popq(R10);  // Restore arguments descriptor array.
@@ skipping 500 matching lines @@
 
   __ movq(left, Address(RSP, 2 * kWordSize));
   __ movq(right, Address(RSP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64