Replace class with class ids inside ICData

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, 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/flow_graph_optimizer.h"
 
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
@@ skipping 19 matching lines @@
     // Optimize all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
   }
 }
 
 
 static bool ICDataHasReceiverClass(const ICData& ic_data, intptr_t class_id) {
   ASSERT(ic_data.num_args_tested() > 0);
-  Class& test_class = Class::Handle();
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetOneClassCheckAt(i, &test_class, &target);
-    if (test_class.id() == class_id) {
+    intptr_t test_class_id;
+    ic_data.GetOneClassCheckAt(i, &test_class_id, &target);
+    if (test_class_id == class_id) {
       return true;
     }
   }
   return false;
 }
 
 
 static bool ICDataHasReceiverArgumentClasses(const ICData& ic_data,
                                              intptr_t receiver_class_id,
                                              intptr_t argument_class_id) {
   if (ic_data.num_args_tested() != 2) {
     return false;
   }
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    GrowableArray<const Class*> classes;
-    ic_data.GetCheckAt(i, &classes, &target);
-    ASSERT(classes.length() == 2);
-    if (classes[0]->id() == receiver_class_id) {
-      if (classes[1]->id() == argument_class_id) {
+    GrowableArray<intptr_t> class_ids;
+    ic_data.GetCheckAt(i, &class_ids, &target);
+    ASSERT(class_ids.length() == 2);
+    if (class_ids[0] == receiver_class_id) {
+      if (class_ids[1] == argument_class_id) {
         return true;
       }
     }
   }
   return false;
 }
 
 
 static bool HasOneSmi(const ICData& ic_data) {
   return ICDataHasReceiverClass(ic_data, kSmi);
@@ skipping 100 matching lines @@
   }
   return false;
 }
 
 
 // Returns true if all targets are the same.
 // TODO(srdjan): if targets are native use their C_function to compare.
 static bool HasOneTarget(const ICData& ic_data) {
   ASSERT(ic_data.NumberOfChecks() > 0);
   Function& prev_target = Function::Handle();
-  GrowableArray<const Class*> classes;
-  ic_data.GetCheckAt(0, &classes, &prev_target);
+  GrowableArray<intptr_t> class_ids;
+  ic_data.GetCheckAt(0, &class_ids, &prev_target);
   ASSERT(!prev_target.IsNull());
   Function& target = Function::Handle();
   for (intptr_t i = 1; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetCheckAt(i, &classes, &target);
+    ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(!target.IsNull());
     if (prev_target.raw() != target.raw()) {
       return false;
     }
     prev_target = target.raw();
   }
   return true;
 }
 
 
 // Using field class
-static RawField* GetField(const Class& field_class, const String& field_name) {
-  Class& cls = Class::Handle(field_class.raw());
+static RawField* GetField(intptr_t class_id, const String& field_name) {
+  Class& cls = Class::Handle(Isolate::Current()->class_table()->At(class_id));
   Field& field = Field::Handle();
   while (!cls.IsNull()) {
     field = cls.LookupInstanceField(field_name);
     if (!field.IsNull()) {
       return field.raw();
     }
     cls = cls.SuperClass();
   }
   return Field::null();
 }
 
 
 // Returns all receiver class-ids and corresponding tagets for the given
 // 'ic_data', sorted so that a smi class id is at index[0] if it exists.
 // 'targets' can be NULL in which case it is not collected,
 static void ExtractClassIdsAndTargets(const ICData& ic_data,
                                       ZoneGrowableArray<intptr_t>* class_ids,
                                       ZoneGrowableArray<Function*>* targets) {
   ASSERT(class_ids != NULL);
   class_ids->Clear();
   if (targets != NULL) {
     targets->Clear();
   }
   intptr_t smi_index = -1;
   Function& target = Function::Handle();
-  GrowableArray<const Class*> classes;
+  GrowableArray<intptr_t> unsorted_class_ids;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetCheckAt(i, &classes, &target);
+    ic_data.GetCheckAt(i, &unsorted_class_ids, &target);
     // Collect receiver class only.
-    const intptr_t class_id = (*classes[0]).id();
+    const intptr_t class_id = unsorted_class_ids[0];
     if (ic_data.num_args_tested() > 1) {
       // Check if we have not already entered the class-id.
       intptr_t duplicate_class_id = -1;
       for (intptr_t k = 0; k < class_ids->length(); k++) {
         if ((*class_ids)[k] == class_id) {
           duplicate_class_id = k;
           break;
         }
       }
       if (duplicate_class_id >= 0)  {
@@ skipping 38 matching lines @@
 
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallComp* comp) {
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle();
-  GrowableArray<const Class*> classes;
-  ic_data.GetCheckAt(0, &classes, &target);
-  ASSERT(classes.length() == 1);
+  GrowableArray<intptr_t> class_ids;
+  ic_data.GetCheckAt(0, &class_ids, &target);
+  ASSERT(class_ids.length() == 1);
 
   if (target.kind() == RawFunction::kImplicitGetter) {
     if (!HasOneTarget(ic_data)) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     // Inline implicit instance getter.
     const String& field_name =
         String::Handle(Field::NameFromGetter(comp->function_name()));
-    const Field& field = Field::Handle(GetField(*classes[0], field_name));
+    const Field& field = Field::Handle(GetField(class_ids[0], field_name));
     ASSERT(!field.IsNull());
     LoadInstanceFieldComp* load = new LoadInstanceFieldComp(
         field, comp->InputAt(0), comp, ExtractClassIds(ic_data));
     comp->ReplaceWith(load);
     return true;
   }
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
@@ skipping 45 matching lines @@
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallComp* comp) {
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !HasOneTarget(ic_data)) {
     // No type feedback collected.
     return false;
   }
   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);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   ObjectKind from_kind;
   if (recognized_kind == MethodRecognizer::kDoubleToDouble) {
     from_kind = kDouble;
   } else if (recognized_kind == MethodRecognizer::kIntegerToDouble) {
     from_kind = kSmi;
   } else {
     return false;
   }
 
-  if (classes[0]->id() != from_kind) {
+  if (class_ids[0] != from_kind) {
     return false;
   }
   ToDoubleComp* coerce = new ToDoubleComp(
       comp->InputAt(0), from_kind, comp);
   coerce->set_instr(comp->instr());
   comp->instr()->replace_computation(coerce);
   return true;
 }
 
 
@@ skipping 44 matching lines @@
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   if (!HasOneTarget(ic_data)) {
     // TODO(srdjan): Implement when not all targets are the sa,e.
     return false;
   }
   Function& target = Function::Handle();
-  Class& cls = Class::Handle();
-  ic_data.GetOneClassCheckAt(0, &cls, &target);
+  intptr_t class_id;
+  ic_data.GetOneClassCheckAt(0, &class_id, &target);
   if (target.kind() != RawFunction::kImplicitSetter) {
     // Not an implicit setter.
     // TODO(srdjan): Inline special setters.
     return false;
   }
   // Inline implicit instance setter.
-  const Field& field = Field::Handle(GetField(cls, comp->field_name()));
+  const Field& field = Field::Handle(GetField(class_id, comp->field_name()));
   ASSERT(!field.IsNull());
   StoreInstanceFieldComp* store = new StoreInstanceFieldComp(
       field,
       comp->InputAt(0),
       comp->InputAt(1),
       comp,
       ExtractClassIds(ic_data));
   comp->ReplaceWith(store);
   return true;
 }
@@ skipping 18 matching lines @@
   if (!comp->HasICData()) return kIllegalObjectKind;
 
   const ICData& ic_data = *comp->ic_data();
 
   if (ic_data.NumberOfChecks() == 0) return kIllegalObjectKind;
   // TODO(vegorov): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return kIllegalObjectKind;
   ASSERT(HasOneTarget(ic_data));
 
   Function& target = Function::Handle();
-  Class& cls = Class::Handle();
-  ic_data.GetOneClassCheckAt(0, &cls, &target);
-
-  return cls.id();
+  intptr_t class_id;
+  ic_data.GetOneClassCheckAt(0, &class_id, &target);
+  return class_id;
 }
 
 
 void FlowGraphOptimizer::VisitLoadIndexed(LoadIndexedComp* comp) {
   const intptr_t class_id = ReceiverClassId(comp);
   switch (class_id) {
     case kArray:
     case kImmutableArray:
     case kGrowableObjectArray:
       comp->set_receiver_type(static_cast<ObjectKind>(class_id));
@@ skipping 81 matching lines @@
   instr->computation()->Accept(this);
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this);
 }
 
 
 }  // namespace dart