Restructure instance calls in optimizing compiler.

vm/opt_code_generator_ia32.cc

 // Copyright (c) 2011, 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"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 260 matching lines @@
 static const ZoneGrowableArray<const Class*>*
     CollectedClassesAtNode(AstNode* node) {
   ZoneGrowableArray<const Class*>* result =
       new ZoneGrowableArray<const Class*>();
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     return result;
   }
   ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
   Function& target = Function::Handle();
-  GrowableArray<const Class*> classes;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetCheckAt(i, &classes, &target);
-    ASSERT(classes.length() == 1);
-    result->Add(classes[0]);
+    Class& cls = Class::ZoneHandle();
+    ic_data.GetOneClassCheckAt(i, &cls, &target);
+    result->Add(&cls);
   }
   return result;
 }
 
 
 // Debugging helper function.
 void OptimizingCodeGenerator::PrintCollectedClasses(AstNode* node) {
   const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   for (intptr_t i = 0; i < classes->length(); i++) {
     OS::Print("- %s\n", (*classes)[i]->ToCString());
@@ skipping 383 matching lines @@
       // Operator is called either if one of the arguments is not Smi or
       // if we hit an overflow in an arithmetic operation.
       __ Bind(&call_operator);
       // Restore arguments on stack, and dispatch to operator, thus preventing
       // deoptimization in case of smi/non-smi operations. At exit we do not
       // know the result is Smi or not.
       // TODO(srdjan): Handle type feedback for both arguments instead of for
       // receiver only, deoptimize if the type changes.
       __ pushl(ECX);
       __ pushl(EDX);
-      GenerateBinaryOperatorCall(node->id(), node->token_index(), node->Name());
+      GenerateBinaryOperatorCall(node->id(),
+                                 node->token_index(),
+                                 node->Name());
       __ jmp(&done);
       __ Bind(&two_smis);
       // Restore left operand. EAX will be 'destroyed', ECX holds the left
       // argument, which may be needed for deoptimization.
       __ movl(EAX, ECX);
     }
     switch (kind) {
       case Token::kADD: {
         __ addl(EAX, EDX);
         __ j(OVERFLOW, overflow_label);
@@ skipping 549 matching lines @@
       all_same_target = false;
     }
     if (!IsInlineableInstanceGetter(target)) {
       all_inlineable = false;
     }
   }
   // TODO(srdjan): implement other variants.
   if (all_inlineable && all_same_target) {
     InlineInstanceGettersWithSameTarget(node, *targets[0]);
   } else {
+    // TODO(srdjan): Inline access.
     TraceNotOpt(node, kMessage);
     node->receiver()->Visit(this);
-    GenerateInstanceGetterCall(node->id(),
-                               node->token_index(),
-                               node->field_name());
+    const int kNumberOfArguments = 1;
+    const Array& kNoArgumentNames = Array::Handle();
+    GenerateCheckedInstanceCalls(node,
+                                 node->receiver(),
+                                 node->id(),
+                                 node->token_index(),
+                                 kNumberOfArguments,
+                                 kNoArgumentNames);
   }
   if (CodeGenerator::IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // The call to the instance setter implements the assignment to a field.
 // The result of the assignment to a field is the value being stored.
 void OptimizingCodeGenerator::VisitInstanceSetterNode(
@@ skipping 653 matching lines @@
     __ Bind(&false_label);
     node->false_branch()->Visit(this);
     __ Bind(&done);
   } else {
     __ Bind(&false_label);
   }
   __ Bind(&done);
 }
 
 
-// Return index where 'cls' is contained within 'classes' or -1 if not found.
-static intptr_t IndexOfClassInArray(
-    const ZoneGrowableArray<const Class*>& classes,
-    const Class& cls) {
-  for (int i = 0; i < classes.length(); i++) {
-    if (classes[i]->raw() == cls.raw()) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-
-// Use static call pattern to call an instance method directly.
-void OptimizingCodeGenerator::GenerateDirectInstanceCall(
-    InstanceCallNode* node, const Class& cls) {
-  ASSERT(node != NULL);
-  ASSERT(!cls.IsNull());
-  intptr_t arg_count = node->arguments()->length() + 1;
-  const int num_named_arguments = node->arguments()->names().IsNull() ?
-      0 : node->arguments()->names().Length();
-  const Function& target = Function::ZoneHandle(
-      Resolver::ResolveDynamicForReceiverClass(
-          cls, node->function_name(), arg_count, num_named_arguments));
+void OptimizingCodeGenerator::GenerateDirectCall(
+    intptr_t node_id,
+    intptr_t token_index,
+    Function& target,
+    intptr_t arg_count,
+    const Array& optional_argument_names) {
   ASSERT(!target.IsNull());
   const Code& code = Code::Handle(target.code());
   ASSERT(!code.IsNull());
   ExternalLabel target_label("DirectInstanceCall", code.EntryPoint());
 
   __ LoadObject(ECX, target);
-  __ LoadObject(EDX, ArgumentsDescriptor(arg_count,
-                                         node->arguments()->names()));
-
+  __ LoadObject(EDX, ArgumentsDescriptor(arg_count, optional_argument_names));
   __ call(&target_label);
-  AddCurrentDescriptor(PcDescriptors::kOther, node->id(), node->token_index());
+  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
   __ addl(ESP, Immediate(arg_count * kWordSize));
 }
 
 
-// Using collected type feedback, inline class checks and call the targets
-// directly instead of via inline cache stub. TODO(srdjan): Use type propagation
-// and CHA to eliminate checks.
-// Return false if no code was generated (because no type feedback was found).
-bool OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
-    InstanceCallNode* node) {
-  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
-  if ((classes == NULL) || classes->is_empty()) {
-    return false;
+// Use ICData in 'node' to issues checks and calls.
+void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
+    AstNode* node,
+    AstNode* receiver,
+    intptr_t node_id,
+    intptr_t token_index,
+    intptr_t num_args,
+    const Array& optional_argument_names) {
+  ASSERT(node != NULL);
+  ASSERT(receiver != NULL);
+  ASSERT(num_args > 0);
+  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node);
+  const ICData& ic_data = node->ICDataAtId(node_id);
+  if (ic_data.NumberOfChecks() == 0) {
+    // No type feedback means node was never executed.
+    __ jmp(deopt_blob->label());
+    return;
+  }
+  ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+
+  // First test for Smi. Null object will cause deoptimization.
+  intptr_t smi_class_index = -1;
+  Class& smi_test_class = Class::Handle();
+  Function& smi_target = Function::ZoneHandle();
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    ic_data.GetOneClassCheckAt(i, &smi_test_class, &smi_target);
+    if (smi_test_class.raw() == smi_class_.raw()) {
+      smi_class_index = i;
+      break;
+    }
   }
 
-  const int arg_count = node->arguments()->length() + 1;  // With receiver.
-  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node);
-  ASSERT(arg_count > 0);
-  __ movl(EAX, Address(ESP, (arg_count - 1) * kWordSize));  // Load receiver.
-
   Label done;
-  // If needed, Smi test must come first.
-  const intptr_t smi_class_index = IndexOfClassInArray(*classes, smi_class_);
+  __ movl(EAX, Address(ESP, (num_args - 1) * kWordSize));  // Load receiver.
   if (smi_class_index >= 0) {
     // Smi test is needed.
     __ testl(EAX, Immediate(kSmiTagMask));
-    if (classes->length() == 1) {
+    if (ic_data.NumberOfChecks() == 1) {
       // Only the Smi test.
       __ j(NOT_ZERO, deopt_blob->label());
-      GenerateDirectInstanceCall(node, smi_class_);
-      return true;
+      GenerateDirectCall(node_id,
+                         token_index,
+                         smi_target,
+                         num_args,
+                         optional_argument_names);
+      return;
     }
     Label not_smi;
     __ j(NOT_ZERO, &not_smi);
-    GenerateDirectInstanceCall(node, smi_class_);
+    GenerateDirectCall(node_id,
+                       token_index,
+                       smi_target,
+                       num_args,
+                       optional_argument_names);
     __ jmp(&done);
     __ Bind(&not_smi);  // Continue with other test below.
-  } else if (NodeMayBeSmi(node->receiver())) {
+  } else if (NodeMayBeSmi(receiver)) {
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
+  } else {
+    // Receiver cannot be Smi, no need to test it.
   }
 
-  // We need to generate special test for last class exclusive Smi class.
-  intptr_t last_check_at = (smi_class_index == classes->length() - 1) ?
-      classes->length() - 2 : classes->length() - 1;
+  intptr_t last_check_at = (smi_class_index == ic_data.NumberOfChecks() - 1) ?
+      ic_data.NumberOfChecks() - 2 : ic_data.NumberOfChecks() - 1;
   // Every class may appear only once in the 'classes' array. Therefore, if
   // Smi class is last, it cannot be the second to last.
-  ASSERT(!(*classes)[last_check_at]->IsSmi());
   __ movl(EAX, FieldAddress(EAX, Object::class_offset()));  // Receiver's class.
   for (intptr_t i = 0; i <= last_check_at; i++) {
-    const Class& test_class = *((*classes)[i]);
-    ASSERT(!test_class.IsNullClass());
-    if (test_class.raw() == smi_class_.raw()) {
+    Function& target = Function::ZoneHandle();
+    Class& cls = Class::ZoneHandle();
+    ic_data.GetOneClassCheckAt(i, &cls, &target);
+    ASSERT(!cls.IsNullClass());
+    if (cls.raw() == smi_class_.raw()) {
+      ASSERT(i < last_check_at);  // Smi class may not be last.
       continue;  // Skip Smi test.
     }
-    __ CompareObject(EAX, test_class);
+    __ CompareObject(EAX, cls);
     if (i == last_check_at) {
       __ j(NOT_EQUAL, deopt_blob->label());
-      GenerateDirectInstanceCall(node, test_class);
+      GenerateDirectCall(node_id,
+                         token_index,
+                         target,
+                         num_args,
+                         optional_argument_names);
     } else {
       Label next;
       __ j(NOT_EQUAL, &next);
-      GenerateDirectInstanceCall(node, test_class);
+      GenerateDirectCall(node_id,
+                         token_index,
+                         target,
+                         num_args,
+                         optional_argument_names);
       __ jmp(&done);
       __ Bind(&next);
     }
   }
   __ Bind(&done);
-
-  return true;
 }
 
 
 void OptimizingCodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
   // Compute the receiver object and pass it as first argument to call.
   node->receiver()->Visit(this);
   // Now compute rest of the arguments to the call.
   node->arguments()->Visit(this);
   if (TryInlineInstanceCall(node)) {
     // Instance call is inlined.
   } else {
-    // Inline checks if possible and call function directly.
-    if (!GenerateCheckedInstanceCalls(node)) {
-      GenerateInstanceCall(node->id(),
-                           node->token_index(),
-                           node->function_name(),
-                           number_of_arguments,
-                           node->arguments()->names());
-    }
+    GenerateCheckedInstanceCalls(node,
+                                 node->receiver(),
+                                 node->id(),
+                                 node->token_index(),
+                                 number_of_arguments,
+                                 node->arguments()->names());
   }
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Returns true if an instance call was replaced with its intrinsic.
 // Returns result in EAX.
@@ skipping 88 matching lines @@
   __ addl(ESP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32