Split BinaryOp into BinarySmiOp and BinaryMintOp.

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 234 matching lines @@
     }
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(BindInstr* instr,
                                                 InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
-  BinaryOpComp::OperandsType operands_type = BinaryOpComp::kDynamicOperands;
+  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 = BinaryOpComp::kSmiOperands;
+        operands_type = kSmiCid;
       } else if (HasOnlyTwoDouble(ic_data)) {
-        operands_type = BinaryOpComp::kDoubleOperands;
+        operands_type = kDoubleCid;
       } else {
         return false;
       }
       break;
     case Token::kDIV:
     case Token::kMOD:
       if (HasOnlyTwoDouble(ic_data)) {
-        operands_type = BinaryOpComp::kDoubleOperands;
+        operands_type = kDoubleCid;
       } else {
         return false;
       }
     case Token::kBIT_AND:
       if (HasOnlyTwoSmi(ic_data)) {
-        operands_type = BinaryOpComp::kSmiOperands;
+        operands_type = kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data)) {
-        operands_type = BinaryOpComp::kMintOperands;
+        operands_type = kMintCid;
       } 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;
+        operands_type = kSmiCid;
       } else {
         return false;
       }
       break;
     default:
       UNREACHABLE();
   };
 
   ASSERT(comp->ArgumentCount() == 2);
-  if (operands_type == BinaryOpComp::kDoubleOperands) {
-    DoubleBinaryOpComp* double_bin_op = new DoubleBinaryOpComp(op_kind, comp);
+  if (operands_type == kDoubleCid) {
+    BinaryDoubleOpComp* double_bin_op = new BinaryDoubleOpComp(op_kind, comp);
     double_bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(double_bin_op);
-  } else {
+  } else if (operands_type == kMintCid) {
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
-    BinaryOpComp* bin_op =
-        new BinaryOpComp(op_kind,
-                         operands_type,
-                         comp,
-                         left,
-                         right);
+    BinaryMintOpComp* bin_op = new BinaryMintOpComp(op_kind,
+                                                    comp,
+                                                    left,
+                                                    right);
     bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
+  } else {
+    ASSERT(operands_type == kSmiCid);
+    Value* left = comp->ArgumentAt(0)->value();
+    Value* right = comp->ArgumentAt(1)->value();
+    BinarySmiOpComp* bin_op = new BinarySmiOpComp(op_kind,
+                                                  comp,
+                                                  left,
+                                                  right);
+    bin_op->set_ic_data(comp->ic_data());
+    instr->set_computation(bin_op);
+    RemovePushArguments(comp);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
   if (comp->ic_data()->NumberOfChecks() != 1) {
     // TODO(srdjan): Not yet supported.
@@ skipping 616 matching lines @@
         OS::Print("Replacing v%d with v%d\n",
                   instr->ssa_temp_index(),
                   result->ssa_temp_index());
       }
     }
   }
 }
 
 
 }  // namespace dart