Optimize 2/3 of instance field increment operation.

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 537 matching lines @@
     return false;
   }
   if ((cls2.raw() != (*classes)[0]->raw()) &&
       (cls2.raw() != (*classes)[1]->raw())) {
     return false;
   }
   return true;
 }
 
 
-static bool NodeHasOnlyClass(AstNode* node, const Class& cls) {
+static bool AtIdNodeHasOnlyClass(AstNode* node, intptr_t id, const Class& cls) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
-  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
-  return (classes != NULL) &&
-         (classes->length() == 1) &&
-         ((*classes)[0]->raw() == cls.raw());
+  const ICData& ic_data = node->ICDataAtId(id);
+  if ((ic_data.NumberOfArgumentsChecked() != 1) ||
+      (ic_data.NumberOfChecks() != 1)) {
+    return false;
+  }
+  Class& target_cls = Class::Handle();
+  Function& target = Function::Handle();
+  ic_data.GetOneClassCheckAt(0, &target_cls, &target);
+  return target_cls.raw() == cls.raw();
 }
 
 
+
 // Implement with slow case so that it can work both with Smi and Mint types.
 void OptimizingCodeGenerator::GenerateSmiShiftBinaryOp(BinaryOpNode* node) {
   ASSERT(node->kind() == Token::kSHL);
   Label done;
   bool shift_generated = false;
   if (node->right()->IsLiteralNode() &&
       node->right()->AsLiteralNode()->literal().IsSmi()) {
     // Shift count is a Smi literal.
     Smi& smi = Smi::Handle();
     smi ^= node->right()->AsLiteralNode()->literal().raw();
@@ skipping 444 matching lines @@
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     if (FLAG_enable_type_checks) {
       CodeGenerator::VisitBinaryOpNode(node);
       return;
     }
     GenerateLogicalBinaryOp(node);
     return;
   }
 
   ObjectStore* object_store = Isolate::Current()->object_store();
-  if (NodeHasOnlyClass(node, smi_class_)) {
+  if (AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
-  if (NodeHasOnlyClass(node, double_class_)) {
+  if (AtIdNodeHasOnlyClass(node, node->id(), double_class_)) {
     GenerateDoubleBinaryOp(node);
     return;
   }
 
-  if (NodeHasOnlyClass(node, Class::Handle(object_store->mint_class()))) {
+  if (AtIdNodeHasOnlyClass(node,
+                           node->id(),
+                           Class::Handle(object_store->mint_class()))) {
     GenerateMintBinaryOp(node, false);
     return;
   }
 
   if (NodeHasBothClasses(node,
       smi_class_, Class::Handle(object_store->mint_class()))) {
     GenerateMintBinaryOp(node, true);
     return;
   }
 
   // Type feedback tells this is not a Smi or Double operation.
   TraceNotOpt(node,
       "BinaryOp: type feedback tells this is not a Smi or Double op");
   CodeGenerator::VisitBinaryOpNode(node);
   return;
 }
 
 
 void OptimizingCodeGenerator::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
   const char* kOptMessage = "Inlines IncrOpLocal";
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
-  if (!NodeHasOnlyClass(node, smi_class_)) {
+  if (!AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
     TraceNotOpt(node, kOptMessage);
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
   TraceOpt(node, kOptMessage);
 
   GenerateLoadVariable(EAX, node->local());
   if (!node->prefix() && IsResultNeeded(node)) {
     // Preserve as result.
     __ movl(ECX, EAX);
@@ skipping 13 matching lines @@
     }
     if (node->prefix()) {
       __ pushl(EAX);
     } else {
       __ pushl(ECX);
     }
   }
 }
 
 
+void OptimizingCodeGenerator::VisitIncrOpInstanceFieldNode(
+    IncrOpInstanceFieldNode* node) {
+  ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
+  VisitLoadOne(node->receiver(), EBX);
+  __ pushl(EBX);  // Duplicate receiver (preserve for setter).
+  const ICData& ic_data = node->ICDataAtId(node->id());
+  if (ic_data.NumberOfChecks() == 0) {
+    // Deoptimization point for this node is after receiver has been
+    // pushed twice on stack and before the getter (above) was executed.
+    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
+    __ jmp(deopt_blob->label());
+    return;
+  }
+  InlineInstanceGetter(node,
+                       node->getter_id(),
+                       node->receiver(),
+                       node->field_name(),
+                       EBX);
+  // result is in EAX.
+  __ popl(EDX);   // Get receiver.
+  const bool return_original_value = !node->prefix() && IsResultNeeded(node);
+  const Immediate one_value = Immediate(Smi::RawValue(1));
+  // EAX: Value.
+  // EDX: Receiver.
+  if (AtIdNodeHasOnlyClass(node, node->operator_id(), smi_class_)) {
+    // Deoptimization point for this node is after receiver has been
+    // pushed twice on stack and before the getter (above) was executed.
+    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EDX, EDX);
+    if (return_original_value) {
+      // Preserve pre increment result.
+      __ movl(ECX, EAX);
+    }
+    __ testl(EAX, Immediate(kSmiTagMask));
+    __ j(NOT_ZERO, deopt_blob->label());
+    if (node->kind() == Token::kINCR) {
+      __ addl(EAX, one_value);
+    } else {
+      __ subl(EAX, one_value);
+    }
+    __ j(OVERFLOW, deopt_blob->label());
+    if (return_original_value) {
+      // Preserve as result.
+      __ pushl(ECX);  // Preserve pre-increment value as result.
+    }
+  } else {
+    if (return_original_value) {
+      // Preserve as result.
+      __ pushl(EAX);  // Preserve value as result.
+    }
+    __ pushl(EDX);  // Preserve receiver.
+    __ pushl(EAX);  // Left operand.
+    __ pushl(one_value);  // Right operand.
+    const char* operator_name = (node->kind() == Token::kINCR) ? "+" : "-";
+    GenerateBinaryOperatorCall(node->operator_id(),
+                               node->token_index(),
+                               operator_name);
+    __ popl(EDX);  // Restore receiver.
+  }
+  // EAX: Result of binary operation.
+  // EDX: receiver
+  if (IsResultNeeded(node) && node->prefix()) {
+    // Value stored into field is the result.
+    __ pushl(EAX);
+  }
+
+  // TODO(srdjan): Inline instance setter.
+  __ pushl(EDX);  // Receiver.
+  __ pushl(EAX);  // Value.
+  // It is not necessary to generate a type test of the assigned value here,
+  // because the setter will check the type of its incoming arguments.
+  GenerateInstanceSetterCall(node->setter_id(),
+                             node->token_index(),
+                             node->field_name());
+}
+
+
+
+
+
 // Return offset of a field or -1 if field is not found.
 static intptr_t GetFieldOffset(const Class& field_class,
                                const String& field_name) {
   Class& cls = Class::Handle(field_class.raw());
   Field& field = Field::Handle();
   while (!cls.IsNull()) {
     field = cls.LookupInstanceField(field_name);
     if (!field.IsNull()) {
       return field.Offset();
     }
@@ skipping 24 matching lines @@
     if (!function_owner.IsSmi() &&
         (function_owner.raw() != integer_implementation_class.raw())) {
       return false;
     }
   }
   return true;
 }
 
 
 // Emits code for an instance getter that has one or more collected classes,
-// all with the same target.
+// all with the same target. Deoptimizes for Smi or unexpected class.
+//  EBX: loaded receiver.
+// Result is returned in EAX.
 void OptimizingCodeGenerator::InlineInstanceGettersWithSameTarget(
-    InstanceGetterNode* node, const Function& target) {
-  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
-  ASSERT(classes->length() > 0);
-  Label load_field;
-  VisitLoadOne(node->receiver(), EBX);
+    AstNode* node,
+    AstNode* receiver,
+    const String& field_name,
+    Register recv_reg) {
+  if (recv_reg != EBX) {
+    // TODO(srdjan): Do not hardwire register.
+    UNIMPLEMENTED();
+  }
   DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
-  if (NodeMayBeSmi(node->receiver())) {
+  if (NodeMayBeSmi(receiver)) {
     __ testl(EBX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
+
   __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
-  const int num_classes = classes->length();
-  for (intptr_t i = 0; i < num_classes; i++) {
-    const Class& cls = *(*classes)[i];
+  const ICData& ic_data = node->ICDataAtId(node->id());
+  Function& target = Function::Handle();
+  Label load_field;
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    Class& cls = Class::ZoneHandle();
+    ic_data.GetOneClassCheckAt(i, &cls, &target);
     __ CompareObject(EAX, cls);
-    if (i == (num_classes - 1)) {
+    if (i == (ic_data.NumberOfChecks() - 1)) {
       __ j(NOT_EQUAL, deopt_blob->label());
     } else {
       __ j(EQUAL, &load_field, Assembler::kNearJump);
     }
   }
+  Class& cls = Class::Handle();
+  ic_data.GetOneClassCheckAt(0, &cls, &target);
+
   __ Bind(&load_field);
-
   // EBX: receiver.
   if (target.kind() == RawFunction::kImplicitGetter) {
     TraceOpt(node, "Inlines instance getter with same target");
-    // Inlineable load field.
-    intptr_t field_offset = GetFieldOffset(*(*classes)[0],
-                                           node->field_name());
+    intptr_t field_offset = GetFieldOffset(cls, field_name);
     ASSERT(field_offset >= 0);
     __ movl(EAX, FieldAddress(EBX, field_offset));
     return;
   }
+
   Recognizer::Kind recognized_kind = Recognizer::RecognizeKind(target);
   switch (recognized_kind) {
     case Recognizer::kObjectArrayLength: {
       TraceOpt(node, "Inlines ObjectArray.length");
       __ movl(EAX, FieldAddress(EBX, Array::length_offset()));
       return;
     }
     case Recognizer::kGrowableArrayLength: {
       TraceOpt(node, "Inlines GrowableObjectArray.length");
       intptr_t field_offset = GetFieldOffset(
-          *(*classes)[0],
+          cls,
           String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName)));
       __ movl(EAX, FieldAddress(EBX, field_offset));
       return;
     }
     default:
       UNIMPLEMENTED();
   }
 }
 
 
 bool OptimizingCodeGenerator::IsInlineableInstanceGetter(
     const Function& function) {
   if (function.kind() == RawFunction::kImplicitGetter) {
     return true;
   }
   Recognizer::Kind recognized = Recognizer::RecognizeKind(function);
   if ((recognized == Recognizer::kObjectArrayLength) ||
       (recognized == Recognizer::kGrowableArrayLength)) {
     return true;
   }
   return false;
 }
 
 
+// Return true if all targets in 'ic_data' point to same
+// inlineable getter target.
+bool OptimizingCodeGenerator::ICDataToSameInlineableInstanceGetter(
+    const ICData& ic_data) {
+  Function& prev_target = Function::Handle();
+  Function& target = Function::Handle();
+  Class& cls = Class::Handle();
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    ic_data.GetOneClassCheckAt(i, &cls, &target);
+    ASSERT(!target.IsNull());
+    if (!prev_target.IsNull() && (prev_target.raw() != target.raw())) {
+      return false;
+    }
+    prev_target = target.raw();
+    if (!IsInlineableInstanceGetter(target)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
+void OptimizingCodeGenerator::InlineInstanceGetter(AstNode* node,
+                                                   intptr_t id,
+                                                   AstNode* receiver,
+                                                   const String& field_name,
+                                                   Register recv_reg) {
+  if (ICDataToSameInlineableInstanceGetter(node->ICDataAtId(id))) {
+    InlineInstanceGettersWithSameTarget(node, receiver, field_name, recv_reg);
+  } else {
+    // TODO(srdjan): Inline access.
+    __ pushl(recv_reg);
+    const int kNumberOfArguments = 1;
+    const Array& kNoArgumentNames = Array::Handle();
+    GenerateCheckedInstanceCalls(node,
+                                 receiver,
+                                 node->id(),
+                                 node->token_index(),
+                                 kNumberOfArguments,
+                                 kNoArgumentNames);
+  }
+}
+
+
 // TODO(srdjan): Implement for multiple getter targets.
 // For every class inline its implicit getter, or call the instance getter.
 void OptimizingCodeGenerator::VisitInstanceGetterNode(
     InstanceGetterNode* node) {
-  const char* kMessage = "Inline instance getter";
-  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
-  const String& getter_name =
-      String::Handle(Field::GetterName(node->field_name()));
-  if (FLAG_trace_optimization) {
-    OS::Print("Getter %s ", getter_name.ToCString());
-  }
-  if ((classes == NULL) || classes->is_empty()) {
-    TraceNotOpt(node, kMessage);
-    CodeGenerator::VisitInstanceGetterNode(node);
+  const ICData& ic_data = node->ICDataAtId(node->id());
+  if (ic_data.NumberOfChecks() == 0) {
+    // No type feedback collected.
+    node->receiver()->Visit(this);
+    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node);
+    __ jmp(deopt_blob->label());
     return;
   }
-  // Collect all targets and identify if they are all inlineable and
-  // all same. Use 'targets' for case when not all targets are inlineable.
-  const intptr_t num_classes = classes->length();
-  GrowableArray<const Function*> targets(num_classes);
-  bool all_inlineable = true;
-  bool all_same_target = true;
-  for (intptr_t i = 0; i < num_classes; i++) {
-    const Class& cls = *(*classes)[i];
-    const int kNumArguments = 1;
-    const int kNumNamedArguments = 0;
-    const Function& target = Function::ZoneHandle(
-        Resolver::ResolveDynamicForReceiverClass(cls,
-                                                 getter_name,
-                                                 kNumArguments,
-                                                 kNumNamedArguments));
-    ASSERT(!target.IsNull());
-    targets.Add(&target);
-    if (targets[0]->raw() != target.raw()) {
-      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);
-    const int kNumberOfArguments = 1;
-    const Array& kNoArgumentNames = Array::Handle();
-    GenerateCheckedInstanceCalls(node,
-                                 node->receiver(),
-                                 node->id(),
-                                 node->token_index(),
-                                 kNumberOfArguments,
-                                 kNoArgumentNames);
-  }
+
+  VisitLoadOne(node->receiver(), EBX);
+  InlineInstanceGetter(node,
+                       node->id(),
+                       node->receiver(),
+                       node->field_name(),
+                       EBX);
+  // Result is in EAX.
   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(
     InstanceSetterNode* node) {
@@ skipping 481 matching lines @@
       __ j(condition, &is_true);
       __ PushObject(bool_false);
       __ jmp(&done);
       __ Bind(&is_true);
       __ PushObject(bool_true);
       __ Bind(&done);
     }
     return;
   }
 
-  if (NodeHasOnlyClass(node, smi_class_)) {
+  if (AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
     if (GenerateSmiComparison(node)) {
       return;
     }
     // Fall through if condition is not supported.
-  } else if (NodeHasOnlyClass(node, double_class_)) {
+  } else if (AtIdNodeHasOnlyClass(node, node->id(), double_class_)) {
     // Double comparison
     if (GenerateDoubleComparison(node)) {
       return;
     }
   } else if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     // Equality, not-equality comparison of any other type.
     if (GenerateEqualityComparison(node)) {
       return;
     }
   }
 
   // Fall through here if a comparison was not implemented.
   CodeGenerator::VisitComparisonNode(node);
 }
 
 
 void OptimizingCodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
   const char* kMessage = "Inline indexed access";
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
   const Class& immutable_object_array_class =
       Class::ZoneHandle(object_store->immutable_array_class());
-  if (NodeHasOnlyClass(node, object_array_class) ||
-      NodeHasOnlyClass(node, immutable_object_array_class)) {
+  if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class) ||
+      AtIdNodeHasOnlyClass(node, node->id(), immutable_object_array_class)) {
     VisitLoadTwo(node->array(), node->index_expr(), EBX, EDX);
     DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX, EDX);
-    const Class& test_class = NodeHasOnlyClass(node, object_array_class) ?
-        object_array_class : immutable_object_array_class;
+    const Class& test_class =
+        AtIdNodeHasOnlyClass(node, node->id(), object_array_class) ?
+            object_array_class : immutable_object_array_class;
     // Type checks of array.
     __ testl(EBX, Immediate(kSmiTagMask));  // Deoptimize if Smi.
     __ j(ZERO, deopt_blob->label());
     __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
     __ CompareObject(EAX, test_class);
     __ j(NOT_EQUAL, deopt_blob->label());
 
     // Type check of index.
     __ testl(EDX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     // Range check.
     __ cmpl(EDX, FieldAddress(EBX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     // Note that EDX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EBX, EDX, TIMES_2, sizeof(RawArray)));
     if (CodeGenerator::IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     TraceOpt(node, kMessage);
     return;
   }
 
   const String& growable_object_array_class_name = String::Handle(
       String::NewSymbol(kGrowableArrayClassName));
   const Class& growable_array_class = Class::ZoneHandle(
       Library::Handle(Library::CoreImplLibrary()).
           LookupClass(growable_object_array_class_name));
-  if (NodeHasOnlyClass(node, growable_array_class)) {
+  if (AtIdNodeHasOnlyClass(node, node->id(), growable_array_class)) {
     const String& growable_array_length_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName));
     const String& growable_array_array_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayArrayFieldName));
     intptr_t length_offset = GetFieldOffset(growable_array_class,
                                             growable_array_length_field_name);
     intptr_t array_offset = GetFieldOffset(growable_array_class,
                                            growable_array_array_field_name);
     VisitLoadTwo(node->array(), node->index_expr(), EDX, EAX);
     DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EDX, EAX);
@@ skipping 28 matching lines @@
 void OptimizingCodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitStoreIndexedNode(node);
     return;
   }
   node->array()->Visit(this);
   // TODO(srdjan): Use VisitLoadTwo and check if index is smi (CodeGenInfo).
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
-  if (NodeHasOnlyClass(node, object_array_class)) {
+  if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class)) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX, EBX, ECX);
     __ popl(EAX);  // array.
     // ECX: value, EBX:index, EAX: array.
     // Check type of array.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
     __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
     __ CompareObject(EDX, object_array_class);
     __ j(NOT_EQUAL, deopt_blob->label());  // Not ObjectArray -> deopt.
@@ skipping 295 matching lines @@
                                                  node->function_name(),
                                                  num_arguments,
                                                  num_named_arguments));
     Recognizer::Kind recognized = Recognizer::RecognizeKind(target);
     if (FLAG_trace_optimization) {
       OS::Print("Monomorphic inline candidate: %s -> %s\n",
           target.ToFullyQualifiedCString(),
           Recognizer::KindToCString(recognized));
     }
     if ((recognized == Recognizer::kIntegerToDouble) &&
-        NodeHasOnlyClass(node, smi_class_)) {
+        AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
       // TODO(srdjan): Check if we could use temporary double instead of
       // allocating a new object every time.
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
       GenerateCall(node->token_index(), &label);
       // EAX is double object.
       DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
       __ popl(EBX);  // Receiver
       __ testl(EBX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Deoptimize if not Smi.
       __ SmiUntag(EBX);
       __ cvtsi2sd(XMM0, EBX);
       __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
       return true;
     }
 
     if ((recognized == Recognizer::kDoubleToDouble) &&
-        NodeHasOnlyClass(node, double_class_)) {
+        AtIdNodeHasOnlyClass(node, node->id(), double_class_)) {
       DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX);
       __ popl(EAX);
       CheckIfDoubleOrSmi(EAX, EBX, deopt_blob->label(), deopt_blob->label());
       return true;
     }
   }
   return false;
 }
 
 
@@ skipping 40 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