Replace class with class ids inside ICData

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 309 matching lines @@
     CollectedClassesAtNode(AstNode* node) {
   ZoneGrowableArray<const Class*>* result =
       new ZoneGrowableArray<const Class*>();
   const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     return result;
   }
   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);
+    intptr_t class_id;
+    ic_data.GetOneClassCheckAt(i, &class_id, &target);
+    result->Add(&Class::ZoneHandle(
+        Isolate::Current()->class_table()->At(class_id)));
   }
   return result;
 }
 
 
-// Debugging helper function.
+// Debugging helper function. TODO(srdjan): Remove
 void OptimizingCodeGenerator::PrintCollectedClasses(AstNode* node) {
   const ICData& ic_data = node->ic_data();
   OS::Print("Collected classes id %d num: %d\n",
       node->id(), ic_data.NumberOfChecks());
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    Function& target = Function::Handle();
-    GrowableArray<const Class*> classes;
-    ic_data.GetCheckAt(i, &classes, &target);
-    OS::Print("[");
-    for (intptr_t c = 0; c < classes.length(); c++) {
-      OS::Print("%s%s", (c > 0) ? ", " : "", classes[c]->ToCString());
-    }
-    OS::Print("] -> %s\n", target.ToFullyQualifiedCString());
-  }
 }
 
 
 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 177 matching lines @@
 
 static bool NodeHasBothReceiverClasses(AstNode* node,
                                        const Class& cls1,
                                        const Class& cls2) {
   ASSERT(node != NULL);
   ASSERT(!cls1.IsNull() && !cls2.IsNull());
   const ICData& ic_data = node->ic_data();
   bool cls1_found = false;
   bool cls2_found = false;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    GrowableArray<const Class*> classes;
+    GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
-    ic_data.GetCheckAt(i, &classes, &target);
-    if (!classes.is_empty()) {
-      if (classes[0]->raw() == cls1.raw()) {
+    ic_data.GetCheckAt(i, &class_ids, &target);
+    if (!class_ids.is_empty()) {
+      if (class_ids[0] == cls1.id()) {
         cls1_found = true;
       }
-      if (classes[0]->raw() == cls2.raw()) {
+      if (class_ids[0] == cls2.id()) {
         cls2_found = true;
       }
       if (cls1_found && cls2_found) {
         return true;
       }
     }
   }
   return false;
 }
 
 
 // Look only at the first class in all check groups. Returns true if all
 // receiver classes are 'cls'.
 static bool NodeHasClassAt(AstNode* node,
                            const Class& cls,
                            intptr_t arg_index) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
   const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     return false;
   }
   ASSERT(ic_data.num_args_tested() > arg_index);
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    GrowableArray<const Class*> classes;
+    GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
-    ic_data.GetCheckAt(i, &classes, &target);
-    if (classes.is_empty()) {
+    ic_data.GetCheckAt(i, &class_ids, &target);
+    if (class_ids.is_empty()) {
       return false;
     }
-    if (classes[arg_index]->raw() != cls.raw()) {
+    if (class_ids[arg_index] != cls.id()) {
       return false;
     }
   }
   return true;
 }
 
 
 // IC data may have only one check, and it has to contain the two classes in
 // specified order.
 static bool NodeHasTwoClasses(AstNode* node,
                               const Class& cls0,
                               const Class& cls1) {
   ASSERT(node != NULL);
   ASSERT(!cls0.IsNull() && !cls1.IsNull());
   const ICData& ic_data = node->ic_data();
   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())) {
+  GrowableArray<intptr_t> class_ids;
+  ic_data.GetCheckAt(0, &class_ids, &target);
+  if ((cls0.id() == class_ids[0]) && (cls1.id() == class_ids[1])) {
     return true;
   }
   return false;
 }
 
 
 // SHL: Implement with slow case so that it works both with Smi and Mint types.
 // Result is in EAX. Mangles ECX, EBX, EDX.
 void OptimizingCodeGenerator::GenerateSmiShiftBinaryOp(BinaryOpNode* node) {
   if (node->kind() == Token::kSHR) {
@@ skipping 213 matching lines @@
       (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->ic_data();
     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);
+    GrowableArray<intptr_t> class_ids;
+    ic_data.GetCheckAt(0, &class_ids, &target);
     ASSERT(ic_data.NumberOfChecks() == 1);
-    ASSERT((classes[0]->raw() == smi_class_.raw()) &&
-        (classes[1]->raw() == smi_class_.raw()));
+    ASSERT((class_ids[0] == kSmi) && (class_ids[1] == kSmi));
     CodeGenInfo left_info(node->left());
     CodeGenInfo right_info(node->right());
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     Label two_smis, call_operator;
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, ECX, EDX, kDeoptSmiBinaryOp);
     __ movl(ECX, EAX);  // Save if overflow (needs original value).
 
     if (left_info.IsClass(smi_class_) || right_info.IsClass(smi_class_)) {
       if (!left_info.IsClass(smi_class_)) {
@@ skipping 546 matching lines @@
   if (NodeMayBeSmi(receiver)) {
     __ testl(EBX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
 
   __ LoadClassId(EAX, EBX);
   const ICData& ic_data = node->ic_data();
   Function& target = Function::Handle();
   Label load_field;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    Class& cls = Class::Handle();
-    ic_data.GetOneClassCheckAt(i, &cls, &target);
-    __ cmpl(EAX, Immediate(cls.id()));
+    intptr_t class_id = -1;

[Vyacheslav Egorov (Google), 2012/06/19 12:01:06]

kIllegalObjectKind instead of -1?

[srdjan, 2012/06/19 15:19:16]

Done.

+    ic_data.GetOneClassCheckAt(i, &class_id, &target);
+    __ cmpl(EAX, Immediate(class_id));
     if (i == (ic_data.NumberOfChecks() - 1)) {
       __ j(NOT_EQUAL, deopt_blob->label());
     } else {
       __ j(EQUAL, &load_field);
     }
   }
-  Class& cls = Class::Handle();
-  ic_data.GetOneClassCheckAt(0, &cls, &target);
+  intptr_t class_id = -1;
+  ic_data.GetOneClassCheckAt(0, &class_id, &target);
 
   __ Bind(&load_field);
   // EBX: receiver.
   if (target.kind() == RawFunction::kImplicitGetter) {
     TraceOpt(node, "Inlines instance getter with same target");
+    const Class& cls =
+        Class::Handle(Isolate::Current()->class_table()->At(class_id));
     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");
@@ skipping 28 matching lines @@
     return true;
   }
   return false;
 }
 
 
 // Return the unique target of all checks or null.
 static RawFunction* GetUniqueTarget(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);
+    intptr_t class_id;
+    ic_data.GetOneClassCheckAt(i, &class_id, &target);
     ASSERT(!target.IsNull());
     if (!prev_target.IsNull() && (prev_target.raw() != target.raw())) {
       return Function::null();
     }
     prev_target = target.raw();
   }
   return target.raw();
 }
 
 
@@ skipping 97 matching lines @@
   // 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->ic_data();
     ASSERT(ic_data.NumberOfChecks() > 0);
     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);
+      intptr_t class_id;
+      ic_data.GetOneClassCheckAt(i, &class_id, &target);
+      Class& cls =
+          Class::ZoneHandle(Isolate::Current()->class_table()->At(class_id));
       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;
         break;
       }
     }
   }
@@ skipping 904 matching lines @@
 // - If Smi class exists, make it the first one.
 // - If 'null_target' not null, append null-class/'null_target'
 void OptimizingCodeGenerator::NormalizeClassChecks(
     const ICData& ic_data,
     const Function& null_target,
     GrowableArray<const Class*>* classes,
     GrowableArray<const Function*>* targets) {
   ASSERT(classes != NULL);
   ASSERT(targets != NULL);
   // Check if we can add Smi class in front.
-  Class& smi_test_class = Class::Handle();
   Function& smi_target = Function::ZoneHandle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    GrowableArray<const Class*> test_classes;
-    ic_data.GetCheckAt(i, &test_classes, &smi_target);
-    smi_test_class = test_classes[0]->raw();
-    if (smi_test_class.raw() == smi_class_.raw()) {
+    GrowableArray<intptr_t> test_class_ids;
+    ic_data.GetCheckAt(i, &test_class_ids, &smi_target);
+    if (test_class_ids[0] == kSmi) {
       classes->Add(&Class::ZoneHandle(smi_class_.raw()));
       targets->Add(&Function::ZoneHandle(smi_target.raw()));
       break;
     }
   }
   // Add all classes except Smi.
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Function& target = Function::ZoneHandle();
-    Class& cls = Class::ZoneHandle();
-    GrowableArray<const Class*> test_classes;
-    ic_data.GetCheckAt(i, &test_classes, &target);
-    cls = test_classes[0]->raw();
-    ASSERT(!cls.IsNullClass());
-    if (cls.raw() != smi_class_.raw()) {
+    GrowableArray<intptr_t> test_class_ids;
+    ic_data.GetCheckAt(i, &test_class_ids, &target);
+    ASSERT(test_class_ids[0] != kNullClassId);
+    if (test_class_ids[0] != kSmi) {
+      const Class& cls =
+          Class::Handle(Isolate::Current()->class_table()->At(
+              test_class_ids[0]));
       ASSERT(!cls.IsNull());
       ASSERT(!target.IsNull());
       classes->Add(&cls);
       targets->Add(&target);
     }
   }
   // 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()));
@@ skipping 329 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32