Canonicalize CheckedSmiOp if compile type turns out to be smi.

runtime/vm/intermediate_language.cc

Index: runtime/vm/intermediate_language.cc
diff --git a/runtime/vm/intermediate_language.cc b/runtime/vm/intermediate_language.cc
index 85bae296698dc527504a9513dc504f10bef454db..59de80b0d36dde3a0722a106fec66e949eb28552 100644
--- a/runtime/vm/intermediate_language.cc
+++ b/runtime/vm/intermediate_language.cc
@@ -1762,6 +1762,44 @@ Definition* BinaryIntegerOpInstr::CreateConstantResult(FlowGraph* flow_graph,
 }
 
 
+Definition* CheckedSmiOpInstr::Canonicalize(FlowGraph* flow_graph) {
+  if ((left()->Type()->ToCid() == kSmiCid) &&
+      (right()->Type()->ToCid() == kSmiCid)) {
+    Definition* replacement = NULL;
+    switch (op_kind()) {
+      case Token::kBIT_AND:

[Vyacheslav Egorov (Google), 2016/06/23 17:17:57]

Please add a comment here about deoptimizations - why bitwise operations are
covered and not anything else.

[Florian Schneider, 2016/06/23 17:35:04]

Done.

+      case Token::kBIT_OR:
+      case Token::kBIT_XOR:
+        replacement =
+            new BinarySmiOpInstr(op_kind(),
+                                 new Value(left()->definition()),
+                                 new Value(right()->definition()),
+                                 Thread::kNoDeoptId);
+      default:
+        break;
+    }
+    if (Token::IsRelationalOperator(op_kind())) {
+      replacement = new RelationalOpInstr(token_pos(), op_kind(),
+                                          new Value(left()->definition()),
+                                          new Value(right()->definition()),
+                                          kSmiCid,
+                                          Thread::kNoDeoptId);
+    } else if (Token::IsEqualityOperator(op_kind())) {
+      replacement = new EqualityCompareInstr(token_pos(), op_kind(),
+                                             new Value(left()->definition()),
+                                             new Value(right()->definition()),
+                                             kSmiCid,
+                                             Thread::kNoDeoptId);
+    }
+    if (replacement != NULL) {
+      flow_graph->InsertBefore(this, replacement, env(), FlowGraph::kValue);
+      return replacement;
+    }
+  }
+  return this;
+}
+
+
 Definition* BinaryIntegerOpInstr::Canonicalize(FlowGraph* flow_graph) {
   // If both operands are constants evaluate this expression. Might
   // occur due to load forwarding after constant propagation pass