Canonicalize CheckedSmiOp if compile type turns out to be smi.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 1744 matching lines @@
   if (representation() != kTagged) {
     result_defn = UnboxInstr::Create(representation(),
                                      new Value(result_defn),
                                      GetDeoptId());
     flow_graph->InsertBefore(this, result_defn, env(), FlowGraph::kValue);
   }
   return result_defn;
 }
 
 
+Definition* CheckedSmiOpInstr::Canonicalize(FlowGraph* flow_graph) {
+  if ((left()->Type()->ToCid() == kSmiCid) &&
+      (right()->Type()->ToCid() == kSmiCid)) {
+    Definition* replacement = NULL;
+    // Operations that can't deoptimize are specialized here: These include
+    // bit-wise operators and comparisons. Other arithmetic operations can
+    // overflow or divide by 0 and can't be specialized unless we have extra
+    // range information.
+    switch (op_kind()) {
+      case Token::kBIT_AND:
+      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
   // have already been run.
   if (left()->BindsToConstant() &&
       left()->BoundConstant().IsInteger() &&
       right()->BindsToConstant() &&
       right()->BoundConstant().IsInteger()) {
     const Integer& result = Integer::Handle(
         Evaluate(Integer::Cast(left()->BoundConstant()),
@@ skipping 2107 matching lines @@
   set_native_c_function(native_function);
   function().SetIsNativeAutoSetupScope(auto_setup_scope);
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   set_is_bootstrap_native(is_bootstrap_native);
 }
 
 #undef __
 
 }  // namespace dart