Store IC data instead of array of classes in AST node, so that we can easier access targets and f...

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 250 matching lines @@
     deoptimization_blobs_[i]->Generate(this);
   }
 }
 
 
 bool OptimizingCodeGenerator::IsResultInEaxRequested(AstNode* node) const {
   return (node->info() != NULL) && node->info()->request_result_in_eax();
 }
 
 
+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]);
+  }
+  return result;
+}
+
+
 // Debugging helper function.
 void OptimizingCodeGenerator::PrintCollectedClasses(AstNode* node) {
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   for (intptr_t i = 0; i < classes->length(); i++) {
     OS::Print("- %s\n", (*classes)[i]->ToCString());
   }
 }
 
 
 void OptimizingCodeGenerator::TraceOpt(AstNode* node, const char* message) {
   if (FLAG_trace_optimization) {
     OS::Print("Opt node ix: %d; %s\n", node->token_index(), message);
   }
@@ skipping 222 matching lines @@
     if (!value_info.result_returned_in_eax()) {
       __ popl(EAX);
     }
     CodeGenerator::GenerateStoreVariable(node->local(), EAX, EDX);
   }
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
+
 static bool NodeHasBothClasses(AstNode* node,
                                const Class& cls1,
                                const Class& cls2) {
   ASSERT(node != NULL);
   ASSERT(!cls1.IsNull() && !cls2.IsNull());
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if ((classes == NULL) || (classes->length() != 2)) {
     return false;
   }
   if ((cls1.raw() != (*classes)[0]->raw()) &&
       (cls1.raw() != (*classes)[1]->raw())) {
     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) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   return (classes != NULL) &&
          (classes->length() == 1) &&
          ((*classes)[0]->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;
@@ skipping 565 matching lines @@
     }
   }
   return true;
 }
 
 
 // Emits code for an instance getter that has one or more collected classes,
 // all with the same target.
 void OptimizingCodeGenerator::InlineInstanceGettersWithSameTarget(
     InstanceGetterNode* node, const Function& target) {
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   ASSERT(classes->length() > 0);
   Label load_field;
   VisitLoadOne(node->receiver(), EBX);
   DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
   if (NodeMayBeSmi(node->receiver())) {
     __ testl(EBX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
   __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
   const int num_classes = classes->length();
@@ skipping 51 matching lines @@
   }
   return false;
 }
 
 
 // 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 =
-      node->CollectedClassesAtId(node->id());
+  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);
     return;
   }
@@ skipping 39 matching lines @@
 
 // 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) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitInstanceSetterNode(node);
     return;
   }
   const char* kMessage = "Inline instance setter";
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if ((classes == NULL) || classes->is_empty()) {
     // Type feedback not yet collected.
     TraceNotOpt(node, kMessage);
     CodeGenerator::VisitInstanceSetterNode(node);
     return;
   }
   const int num_classes = classes->length();
   bool all_inlineable = true;
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
@@ skipping 199 matching lines @@
 
 
 // Checks if an inlined equality/non-equality operation can be emitted:
 // - type feedback must exist.
 // - no class in type feedback list overrides '=='.
 // - no Smi class in type feedback class list.
 bool OptimizingCodeGenerator::GenerateEqualityComparison(ComparisonNode* node) {
   ASSERT((node->kind() == Token::kEQ) || (node->kind() == Token::kNE));
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if (classes == NULL) {
     return false;
   }
   const int num_classes = classes->length();
   // 'num_classes' can be 0 if the receiver was always null.
   const String& operator_name = String::Handle(String::NewSymbol("=="));
   // Check that all classes resolve to Object.==. Object.!= is not overridable
   // and is based on Object.==.
   ObjectStore* object_store = Isolate::Current()->object_store();
   Function& function = Function::Handle();
@@ skipping 461 matching lines @@
   __ 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 =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if ((classes == NULL) || classes->is_empty()) {
     return false;
   }
 
   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;
@@ skipping 70 matching lines @@
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Returns true if an instance call was replaced with its intrinsic.
 // Returns result in EAX.
 bool OptimizingCodeGenerator::TryInlineInstanceCall(InstanceCallNode* node) {
-  const ZoneGrowableArray<const Class*>* classes =
-      node->CollectedClassesAtId(node->id());
+  const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if ((classes != NULL) && (classes->length() == 1)) {
     const int num_arguments = 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(*(*classes)[0],
                                                  node->function_name(),
                                                  num_arguments,
                                                  num_named_arguments));
     Recognizer::Kind recognized = Recognizer::RecognizeKind(target);
@@ skipping 76 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