Do not issue Mint/Smi code sequence if we have only Smi/Smi comnbination.

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 86 matching lines @@
   }
   return true;
 }
 
 
 static bool HasOneSmi(const ICData& ic_data) {
   return ICDataHasReceiverClassId(ic_data, kSmi);
 }
 
 
-static bool HasTwoSmi(const ICData& ic_data) {
-  return ICDataHasReceiverArgumentClassIds(ic_data, kSmi, kSmi);
+static bool HasOnlyTwoSmi(const ICData& ic_data) {
+  return (ic_data.NumberOfChecks() == 1) &&
+      ICDataHasReceiverArgumentClassIds(ic_data, kSmi, kSmi);
 }
 
 
 // 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);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, &class_ids, &class_ids);
 }
 
 
 static bool HasOneDouble(const ICData& ic_data) {
   return ICDataHasReceiverClassId(ic_data, kDouble);
 }
 
 
-static bool HasTwoDouble(const ICData& ic_data) {
-  return ICDataHasReceiverArgumentClassIds(ic_data, kDouble, kDouble);
+static bool HasOnlyTwoDouble(const ICData& ic_data) {
+  return (ic_data.NumberOfChecks() == 1) &&
+      ICDataHasReceiverArgumentClassIds(ic_data, kDouble, kDouble);
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
-  BinaryOpComp::OperandsType operands_type;
-  if ((op_kind == Token::kBIT_AND) && HasTwoMintOrSmi(*comp->ic_data())) {
-    operands_type = BinaryOpComp::kMintOperands;
-  } else if (comp->ic_data()->NumberOfChecks() != 1) {
-    // TODO(srdjan): Not yet supported.
-    return false;
-  } else if (HasTwoSmi(*comp->ic_data())) {
-    if (op_kind == Token::kDIV ||
-        op_kind == Token::kMOD) {
-      // TODO(srdjan): Not yet supported.
-      return false;
-    }
-    operands_type = BinaryOpComp::kSmiOperands;
-  } else if (HasTwoDouble(*comp->ic_data())) {
-    if (op_kind != Token::kADD &&
-        op_kind != Token::kSUB &&
-        op_kind != Token::kMUL &&
-        op_kind != Token::kDIV) {
-      // TODO(vegorov): Not yet supported.
-      return false;
-    }
-    operands_type = BinaryOpComp::kDoubleOperands;
-  } else {
-    // TODO(srdjan): Not yet supported.
-    return false;
-  }
+  BinaryOpComp::OperandsType operands_type = BinaryOpComp::kIllegalOperands;
+  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 = BinaryOpComp::kSmiOperands;
+      } else if (HasOnlyTwoDouble(ic_data)) {
+        operands_type = BinaryOpComp::kDoubleOperands;
+      } else {
+        return false;
+      }
+      break;
+    case Token::kDIV:
+    case Token::kMOD:
+      if (HasOnlyTwoDouble(ic_data)) {
+        operands_type = BinaryOpComp::kDoubleOperands;
+      } else {
+        return false;
+      }
+    case Token::kBIT_AND:
+      if (HasOnlyTwoSmi(ic_data)) {
+        operands_type = BinaryOpComp::kSmiOperands;
+      } else if (HasTwoMintOrSmi(ic_data)) {
+        operands_type = BinaryOpComp::kMintOperands;
+      } else {
+        return false;
+      }
+      break;
+    case Token::kBIT_OR:
+    case Token::kBIT_XOR:
+    case Token::kTRUNCDIV:
+    case Token::kSHR:
+    case Token::kSHL:
+      if (HasOnlyTwoSmi(ic_data)) {
+        operands_type = BinaryOpComp::kSmiOperands;
+      } else {
+        return false;
+      }
+      break;
+    default:
+      UNREACHABLE();
+  };
 
   ASSERT(comp->instr() != NULL);
   ASSERT(comp->InputCount() == 2);
   Value* left = comp->InputAt(0);
   Value* right = comp->InputAt(1);
   BinaryOpComp* bin_op =
       new BinaryOpComp(op_kind,
                        operands_type,
                        comp,
                        left,
@@ skipping 374 matching lines @@
 
 void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp) {
   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 (HasTwoSmi(ic_data)) {
+  if (HasOnlyTwoSmi(ic_data)) {
     comp->set_operands_class_id(kSmi);
-  } else if (HasTwoDouble(ic_data)) {
+  } else if (HasOnlyTwoDouble(ic_data)) {
     comp->set_operands_class_id(kDouble);
   } else {
     return;
   }
 
   // For smi and double comparisons if the next instruction is a conditional
   // branch that uses the value of this comparison mark them as fused together
   // to avoid materializing a boolean value.
   TryFuseComparisonWithBranch(comp);
 }
@@ skipping 20 matching lines @@
   instr->computation()->Accept(this);
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this);
 }
 
 
 }  // namespace dart