Fix bug in optimization in the presence of externalized strings.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 329 matching lines @@
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Definition* def = it.Current()->AsDefinition();
       if (def != NULL) {
         InsertConversionsFor(def);
       }
     }
   }
 }
 
 
-static bool ICDataHasReceiverClassId(const ICData& ic_data, intptr_t class_id) {
-  ASSERT(ic_data.num_args_tested() > 0);
-  const intptr_t len = ic_data.NumberOfChecks();
-  for (intptr_t i = 0; i < len; i++) {
-    const intptr_t test_class_id = ic_data.GetReceiverClassIdAt(i);
-    if (test_class_id == class_id) {
-      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 != kIllegalCid);
   ASSERT(argument_class_id != kIllegalCid);
   if (ic_data.num_args_tested() != 2) return false;
 
   Function& target = Function::Handle();
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 37 matching lines @@
         !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
       return false;
     }
   }
   return true;
 }
 
 
 static bool HasOnlyOneSmi(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1)
-      && ICDataHasReceiverClassId(ic_data, kSmiCid);
+      && ic_data.HasReceiverClassId(kSmiCid);
 }
 
 
 static bool HasOnlySmiOrMint(const ICData& ic_data) {
   if (ic_data.NumberOfChecks() == 1) {
-    return ICDataHasReceiverClassId(ic_data, kSmiCid)
-        || ICDataHasReceiverClassId(ic_data, kMintCid);
+    return ic_data.HasReceiverClassId(kSmiCid)
+        || ic_data.HasReceiverClassId(kMintCid);
   }
   return (ic_data.NumberOfChecks() == 2)
-      && ICDataHasReceiverClassId(ic_data, kSmiCid)
-      && ICDataHasReceiverClassId(ic_data, kMintCid);
+      && ic_data.HasReceiverClassId(kSmiCid)
+      && ic_data.HasReceiverClassId(kMintCid);
 }
 
 
 static bool HasOnlyTwoSmis(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       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(2);
   class_ids.Add(kSmiCid);
   class_ids.Add(kMintCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
 
 static bool HasOnlyOneDouble(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1)
-      && ICDataHasReceiverClassId(ic_data, kDoubleCid);
+      && ic_data.HasReceiverClassId(kDoubleCid);
 }
 
 
 static bool ShouldSpecializeForDouble(const ICData& ic_data) {
   // Unboxed double operation can't handle case of two smis.
   if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
     return false;
   }
 
   // Check that it have seen only smis and doubles.
@@ skipping 4094 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart