Unify class ids and snapshot object ids list so that we don't have disparate and sometimes confusin…

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 17 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 
 static bool ICDataHasReceiverArgumentClassIds(const ICData& ic_data,
                                               intptr_t receiver_class_id,
                                               intptr_t argument_class_id) {
-  ASSERT(receiver_class_id != kIllegalObjectKind);
-  ASSERT(argument_class_id != kIllegalObjectKind);
+  ASSERT(receiver_class_id != kIllegalCid);
+  ASSERT(argument_class_id != kIllegalCid);
   if (ic_data.num_args_tested() != 2) return false;
 
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(class_ids.length() == 2);
     if ((class_ids[0] == receiver_class_id) &&
         (class_ids[1] == argument_class_id)) {
       return true;
@@ skipping 28 matching lines @@
     if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
         !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
       return false;
     }
   }
   return true;
 }
 
 
 static bool HasOneSmi(const ICData& ic_data) {
-  return ICDataHasReceiverClassId(ic_data, kSmi);
+  return ICDataHasReceiverClassId(ic_data, kSmiCid);
 }
 
 
 static bool HasOnlyTwoSmi(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
-      ICDataHasReceiverArgumentClassIds(ic_data, kSmi, kSmi);
+      ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid);
 }
 
 
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Mint and Smi for the receiver and argument classes.
 static bool HasTwoMintOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> class_ids;
-  class_ids.Add(kSmi);
-  class_ids.Add(kMint);
+  class_ids.Add(kSmiCid);
+  class_ids.Add(kMintCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, &class_ids, &class_ids);
 }
 
 
 static bool HasOneDouble(const ICData& ic_data) {
-  return ICDataHasReceiverClassId(ic_data, kDouble);
+  return ICDataHasReceiverClassId(ic_data, kDoubleCid);
 }
 
 
 static bool HasOnlyTwoDouble(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
-      ICDataHasReceiverArgumentClassIds(ic_data, kDouble, kDouble);
+      ICDataHasReceiverArgumentClassIds(ic_data, kDoubleCid, kDoubleCid);
 }
 
 
 static void RemovePushArguments(InstanceCallComp* comp) {
   // Remove original push arguments.
   for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     comp->ArgumentAt(i)->RemoveFromGraph();
   }
 }
 
@@ skipping 218 matching lines @@
   if ((ic_data.NumberOfChecks() == 0) || !HasOneTarget(ic_data)) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
-  ObjectKind from_kind;
+  intptr_t from_class_id;
   if (recognized_kind == MethodRecognizer::kDoubleToDouble) {
-    from_kind = kDouble;
+    from_class_id = kDoubleCid;
   } else if (recognized_kind == MethodRecognizer::kIntegerToDouble) {
-    from_kind = kSmi;
+    from_class_id = kSmiCid;
   } else {
     return false;
   }
 
-  if (class_ids[0] != from_kind) {
+  if (class_ids[0] != from_class_id) {
     return false;
   }
   ToDoubleComp* coerce = new ToDoubleComp(
-      comp->ArgumentAt(0)->value(), from_kind, comp);
+      comp->ArgumentAt(0)->value(), from_class_id, comp);
   instr->set_computation(coerce);
   RemovePushArguments(comp);
   return true;
 }
 
 
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallComp* comp,
                                            BindInstr* instr) {
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() > 0)) {
     const Token::Kind op_kind = comp->token_kind();
@@ skipping 80 matching lines @@
 }
 
 
 enum IndexedAccessType {
   kIndexedLoad,
   kIndexedStore
 };
 
 
 static intptr_t ReceiverClassId(Computation* comp) {
-  if (!comp->HasICData()) return kIllegalObjectKind;
+  if (!comp->HasICData()) return kIllegalCid;
 
   const ICData& ic_data = *comp->ic_data();
 
-  if (ic_data.NumberOfChecks() == 0) return kIllegalObjectKind;
+  if (ic_data.NumberOfChecks() == 0) return kIllegalCid;
   // TODO(vegorov): Add multiple receiver type support.
-  if (ic_data.NumberOfChecks() != 1) return kIllegalObjectKind;
+  if (ic_data.NumberOfChecks() != 1) return kIllegalCid;
   ASSERT(HasOneTarget(ic_data));
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
 void FlowGraphOptimizer::VisitLoadIndexed(LoadIndexedComp* comp,
                                           BindInstr* instr) {
   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));
+    case kArrayCid:
+    case kImmutableArrayCid:
+    case kGrowableObjectArrayCid:
+      comp->set_receiver_type(class_id);
   }
 }
 
 
 void FlowGraphOptimizer::VisitStoreIndexed(StoreIndexedComp* comp,
                                            BindInstr* instr) {
   if (FLAG_enable_type_checks) return;
 
   const intptr_t class_id = ReceiverClassId(comp);
   switch (class_id) {
-    case kArray:
-    case kGrowableObjectArray:
-      comp->set_receiver_type(static_cast<ObjectKind>(class_id));
+    case kArrayCid:
+    case kGrowableObjectArrayCid:
+      comp->set_receiver_type(class_id);
   }
 }
 
 
 void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp,
                                            BindInstr* instr) {
   if (!comp->HasICData()) return;
 
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) return;
   // TODO(srdjan): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return;
   ASSERT(HasOneTarget(ic_data));
 
   if (HasOnlyTwoSmi(ic_data)) {
-    comp->set_operands_class_id(kSmi);
+    comp->set_operands_class_id(kSmiCid);
   } else if (HasOnlyTwoDouble(ic_data)) {
-    comp->set_operands_class_id(kDouble);
+    comp->set_operands_class_id(kDoubleCid);
   }
 }
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareComp* comp,
                                               BindInstr* instr) {
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() == 1)) {
     ASSERT(comp->ic_data()->num_args_tested() == 2);
     GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
     comp->ic_data()->GetCheckAt(0, &class_ids, &target);
     // TODO(srdjan): allow for mixed mode comparison.
-    if ((class_ids[0] == kSmi) && (class_ids[1] == kSmi)) {
-      comp->set_receiver_class_id(kSmi);
-    } else if ((class_ids[0] == kDouble) && (class_ids[1] == kDouble)) {
-      comp->set_receiver_class_id(kDouble);
+    if ((class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
+      comp->set_receiver_class_id(kSmiCid);
+    } else if ((class_ids[0] == kDoubleCid) && (class_ids[1] == kDoubleCid)) {
+      comp->set_receiver_class_id(kDoubleCid);
     }
   }
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this, instr);
 }
 
 
@@ skipping 34 matching lines @@
     }
   }
 }
 
 
 void FlowGraphTypePropagator::PropagateTypes() {
   VisitBlocks();
 }
 
 }  // namespace dart