First part of new ICData infrastructure: use a wrapper object instead of an array.

runtime/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 306 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);
+  ASSERT(ic_data.num_args_tested() == 1);
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Class& cls = Class::ZoneHandle();
     ic_data.GetOneClassCheckAt(i, &cls, &target);
     result->Add(&cls);
   }
   return result;
 }
 
 
@@ skipping 292 matching lines @@
 static bool AtIdNodeHasClassAt(AstNode* node,
                                intptr_t id,
                                const Class& cls,
                                intptr_t arg_index) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
   const ICData& ic_data = node->ICDataAtId(id);
   if (ic_data.NumberOfChecks() == 0) {
     return false;
   }
-  ASSERT(ic_data.NumberOfArgumentsChecked() > arg_index);
+  ASSERT(ic_data.num_args_tested() > arg_index);
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<const Class*> classes;
     Function& target = Function::Handle();
     ic_data.GetCheckAt(i, &classes, &target);
     if (classes.is_empty()) {
       return false;
     }
     if (classes[arg_index]->raw() != cls.raw()) {
       return false;
     }
   }
   return true;
 }
 
 
 // IC data may have only one check, and it has to contain the two classes in
 // specified order.
 static bool AtIdNodeHasTwoClasses(AstNode* node,
                                   intptr_t id,
                                   const Class& cls0,
                                   const Class& cls1) {
   ASSERT(node != NULL);
   ASSERT(!cls0.IsNull() && !cls1.IsNull());
   const ICData& ic_data = node->ICDataAtId(id);
-  ASSERT(ic_data.NumberOfArgumentsChecked() == 2);
+  ASSERT(ic_data.num_args_tested() == 2);
   if (ic_data.NumberOfChecks() != 1) {
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<const Class*> classes;
   ic_data.GetCheckAt(0, &classes, &target);
   if ((cls0.raw() == classes[0]->raw()) && (cls1.raw() == classes[1]->raw())) {
     return true;
   }
   return false;
@@ skipping 113 matching lines @@
                                node->token_index(),
                                number_of_arguments,
                                no_optional_argument_names);
   __ Bind(&done);
 }
 
 
 // Implement Token::kSUB and Token::kBIT_NOT.
 void OptimizingCodeGenerator::GenerateSmiUnaryOp(UnaryOpNode* node) {
   const ICData& ic_data = node->ICDataAtId(node->id());
-  ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+  ASSERT(ic_data.num_args_tested() == 1);
   DeoptReasonId deopt_reason_id = ic_data.NumberOfChecks() == 0 ?
       kDeoptNoTypeFeedback : kDeoptUnaryOp;
   DeoptimizationBlob* deopt_blob =
       AddDeoptimizationBlob(node, EAX, deopt_reason_id);
   CodeGenInfo info(node->operand());
   VisitLoadOne(node->operand(), EAX);
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback.
     __ jmp(deopt_blob->label());
     return;
@@ skipping 83 matching lines @@
   if ((kind == Token::kADD) ||
       (kind == Token::kSUB) ||
       (kind == Token::kMUL) ||
       (kind == Token::kTRUNCDIV) ||
       (kind == Token::kBIT_AND) ||
       (kind == Token::kBIT_OR) ||
       (kind == Token::kBIT_XOR)) {
     TraceOpt(node, kOptMessage);
     // Check if both arguments are expected to be Smi.
     const ICData& ic_data = node->ICDataAtId(node->id());
-    ASSERT(ic_data.NumberOfArgumentsChecked() == 2);
+    ASSERT(ic_data.num_args_tested() == 2);
     ASSERT(ic_data.NumberOfChecks() > 0);
     Function& target = Function::Handle();
     GrowableArray<const Class*> classes;
     ic_data.GetCheckAt(0, &classes, &target);
     ASSERT(ic_data.NumberOfChecks() == 1);
     ASSERT((classes[0]->raw() == smi_class_.raw()) &&
         (classes[1]->raw() == smi_class_.raw()));
     CodeGenInfo left_info(node->left());
     CodeGenInfo right_info(node->right());
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
@@ skipping 437 matching lines @@
 
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EDX, kDeoptNoTypeFeedback);
     __ jmp(deopt_blob->label());
     return;
   }
 
-  ASSERT(ic_data.NumberOfArgumentsChecked() == 2);
+  ASSERT(ic_data.num_args_tested() == 2);
 
   if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, smi_class_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
   if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
     const bool receiver_can_be_smi = false;
     GenerateDoubleBinaryOp(node, receiver_can_be_smi);
     return;
@@ skipping 88 matching lines @@
 
 
 // Debugging helper method, used in assert only.
 static bool HaveSameClassesInICData(const ICData& a, const ICData& b) {
   if (a.NumberOfChecks() != b.NumberOfChecks()) {
     return false;
   }
   if (a.NumberOfChecks() == 0) {
     return true;
   }
-  if (a.NumberOfArgumentsChecked() != b.NumberOfArgumentsChecked()) {
+  if (a.num_args_tested() != b.num_args_tested()) {
     return false;
   }
   // Only one-argument checks implemented.
-  ASSERT(a.NumberOfArgumentsChecked() == 1);
+  ASSERT(a.num_args_tested() == 1);
   Function& a_target = Function::Handle();
   Function& b_target = Function::Handle();
   Class& a_class = Class::Handle();
   Class& b_class = Class::Handle();
   for (intptr_t i = 0; i < a.NumberOfChecks(); i++) {
     a.GetOneClassCheckAt(i, &a_class, &a_target);
     bool found = false;
     for (intptr_t n = 0; n < b.NumberOfChecks(); n++) {
       b.GetOneClassCheckAt(n, &b_class, &b_target);
       if ((a_class.raw() == b_class.raw())) {
@@ skipping 343 matching lines @@
                                                    Register recv_reg,
                                                    Register value_reg) {
   // EBX is used as temporary register for class.
   ASSERT((recv_reg != EBX) && (value_reg != EBX));
   GrowableArray<Class*> classes;
   GrowableArray<Function*> targets;
   bool unique_target = true;
   {
     const ICData& ic_data = node->ICDataAtId(id);
     ASSERT(ic_data.NumberOfChecks() > 0);
-    ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+    ASSERT(ic_data.num_args_tested() == 1);
     for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
       Class& cls = Class::ZoneHandle();
       Function& target = Function::ZoneHandle();
       ic_data.GetOneClassCheckAt(i, &cls, &target);
       classes.Add(&cls);
       targets.Add(&target);
     }
     for (intptr_t i = 1; i < targets.length(); i++) {
       if (targets[i - 1]->raw() != targets[i]->raw()) {
         unique_target = false;
@@ skipping 903 matching lines @@
 // provided.
 // TODO(srdjan): Recompilation framework should recognize active IC calls
 // in optimized code and mark them for reoptimization since type feedback was
 // collected in the meantime.
 void OptimizingCodeGenerator::GenerateInlineCacheCall(
     intptr_t node_id,
     intptr_t token_index,
     const ICData& ic_data,
     intptr_t num_args,
     const Array& optional_arguments_names) {
-  __ LoadObject(ECX, Array::ZoneHandle(ic_data.data()));
+  __ LoadObject(ECX, ic_data);
   __ LoadObject(EDX, ArgumentsDescriptor(num_args, optional_arguments_names));
   ExternalLabel target_label(
       "InlineCache", StubCode::OneArgCheckInlineCacheEntryPoint());
 
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kIcCall,
                        node_id,
                        token_index);
   __ addl(ESP, Immediate(num_args * kWordSize));
 }
@@ skipping 39 matching lines @@
   }
   // Do not add a target that has not been compiled yet.
   if (!null_target.IsNull() && null_target.HasCode()) {
     ASSERT(null_target.IsZoneHandle());
     classes->Add(&Class::ZoneHandle(Object::null_class()));
     targets->Add(&null_target);
   }
 }
 
 
-// Use ICData in 'node' to issues checks and calls.
+// Use IC data in 'node' to issues checks and calls.
 // IC data can contain one or more argument checks.
 void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
     AstNode* node,
     AstNode* receiver,
     intptr_t node_id,
     intptr_t token_index,
     intptr_t num_args,
     const Array& optional_arguments_names) {
   ASSERT(node != NULL);
   ASSERT(receiver != NULL);
   ASSERT(num_args > 0);
   const ICData& ic_data = node->ICDataAtId(node_id);
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback means node was never executed. However that can be
     // a common case especially in case of large switch statements.
     // Use a special inline cache call which can help us decide when to
     // re-optimize this optiumized function.
     GenerateInlineCacheCall(
         node_id, token_index, ic_data, num_args, optional_arguments_names);
     return;
   }
 
   Function& target_for_null = Function::ZoneHandle();
   ObjectStore* object_store = Isolate::Current()->object_store();
   int num_optional_args =
       optional_arguments_names.IsNull() ? 0 : optional_arguments_names.Length();
   target_for_null = Resolver::ResolveDynamicForReceiverClass(
       Class::Handle(object_store->object_class()),
-      String::Handle(ic_data.FunctionName()),
+      String::Handle(ic_data.target_name()),
       num_args,
       num_optional_args);
   GrowableArray<const Class*> classes;
   GrowableArray<const Function*> targets;
   // Make Smi class the first one, if it is in the list.
   NormalizeClassChecks(ic_data, target_for_null, &classes, &targets);
   ASSERT(!classes.is_empty());
   ASSERT(classes.length() == targets.length());
   intptr_t start_ix = 0;
 
@@ skipping 263 matching lines @@
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     __ LoadObject(EAX, Bool::ZoneHandle(Bool::False()));
     __ Bind(&done);
     HandleResult(node, EAX);
     return;
   }
 
   if ((node->kind() == Token::kSUB) || (node->kind() == Token::kBIT_NOT)) {
     if (AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
       const ICData& ic_data = node->ICDataAtId(node->id());
-      ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+      ASSERT(ic_data.num_args_tested() == 1);
       GenerateSmiUnaryOp(node);
       return;
     }
   }
   if (node->kind() == Token::kSUB) {
     if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
       const ICData& ic_data = node->ICDataAtId(node->id());
-      ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+      ASSERT(ic_data.num_args_tested() == 1);
       GenerateDoubleUnaryOp(node);
       return;
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32