Specialize binary operations with mixed Smi-Double feedback as Double ones.

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/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
@@ skipping 227 matching lines @@
   class_ids.Add(kMintCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
 
 static bool HasOneDouble(const ICData& ic_data) {
   return ICDataHasReceiverClassId(ic_data, kDoubleCid);
 }
 
 
-static bool HasOnlyTwoDouble(const ICData& ic_data) {
-  return (ic_data.NumberOfChecks() == 1) &&
-      ICDataHasReceiverArgumentClassIds(ic_data, kDoubleCid, kDoubleCid);
+static bool ShouldSpecializeForDouble(const ICData& ic_data) {
+  if (ic_data.NumberOfChecks() != 1) return false;
+  if (ic_data.num_args_tested() != 2) return false;
+
+  Function& target = Function::Handle();
+  GrowableArray<intptr_t> class_ids;
+  ic_data.GetCheckAt(0, &class_ids, &target);
+  ASSERT(class_ids.length() == 2);
+
+  const bool seen_double =
+      (class_ids[0] == kDoubleCid) || (class_ids[1] == kDoubleCid);
+
+  const bool seen_only_smi_or_double =
+      ((class_ids[0] == kDoubleCid) || (class_ids[0] == kSmiCid)) &&
+      ((class_ids[1] == kDoubleCid) || (class_ids[1] == kSmiCid));
+
+  return seen_double && seen_only_smi_or_double;
 }
 
 
 static void RemovePushArguments(InstanceCallComp* comp) {
   // Remove original push arguments.
   for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     PushArgumentInstr* push = comp->ArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
@@ skipping 128 matching lines @@
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = kSmiCid;
-      } else if (HasOnlyTwoDouble(ic_data)) {
+      } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else {
         return false;
       }
       break;
     case Token::kDIV:
-    case Token::kMOD:
-      if (HasOnlyTwoDouble(ic_data)) {
+      if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else {
         return false;
       }
+      break;
+    case Token::kMOD:
+      // TODO(vegorov): implement fast path code for modulo.
+      return false;
     case Token::kBIT_AND:
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data)) {
         operands_type = kMintCid;
       } else {
         return false;
       }
       break;
     case Token::kBIT_OR:
@@ skipping 361 matching lines @@
   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(kSmiCid);
-  } else if (HasOnlyTwoDouble(ic_data)) {
+  } else if (ShouldSpecializeForDouble(ic_data)) {
     comp->set_operands_class_id(kDoubleCid);
   } else if (comp->ic_data()->AllReceiversAreNumbers()) {
     comp->set_operands_class_id(kNumberCid);
   }
 }
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareComp* comp,
                                               BindInstr* instr) {
   // If one of the inputs is null, no ICdata will be collected.
@@ skipping 344 matching lines @@
       DirectChainedHashMap<BindInstr*> child_map(*map);  // Copy map.
       OptimizeRecursive(child, &child_map);
     } else {
       OptimizeRecursive(child, map);  // Reuse map for the last child.
     }
   }
 }
 
 
 }  // namespace dart