Use type propagation for removing Smi checks in binary operations and comparisons. Regis will adapt…

runtime/vm/intermediate_language_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 429 matching lines @@
   __ jmp(&done);
   __ Bind(&non_null_compare);  // Receiver is not null.
   __ pushq(left);
   __ pushq(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
                                 deopt_id, token_pos, try_index);
   __ Bind(&done);
 }
 
 
+static intptr_t GetCid(const Value& v) {
+  const AbstractType& type = AbstractType::Handle(v.CompileType());
+  return Class::Handle(type.type_class()).id();
+}
+
+
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch,
                                 intptr_t deopt_id,
                                 intptr_t token_pos,
                                 intptr_t try_index) {
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
-  Register temp = locs.temp(0).reg();
-  Label* deopt = compiler->AddDeoptStub(deopt_id,
-                                        try_index,
-                                        kDeoptSmiCompareSmi,
-                                        left,
-                                        right);
-  __ movq(temp, left);
-  __ orq(temp, right);
-  __ testq(temp, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, deopt);
+  const bool left_is_smi = (branch == NULL) ?
+      false : (GetCid(*branch->left()) == kSmiCid);
+  const bool right_is_smi = (branch == NULL) ?
+      false : (GetCid(*branch->right()) == kSmiCid);
+  if (!left_is_smi || !right_is_smi) {
+    Register temp = locs.temp(0).reg();
+    Label* deopt = compiler->AddDeoptStub(deopt_id,
+                                          try_index,
+                                          kDeoptSmiCompareSmi,
+                                          left,
+                                          right);
+    __ movq(temp, left);
+    __ orq(temp, right);
+    __ testq(temp, Immediate(kSmiTagMask));
+    __ j(NOT_ZERO, deopt);
+  }
 
   Condition true_condition = TokenKindToSmiCondition(kind);
   __ cmpq(left, right);
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
     __ j(true_condition, &is_true);
@@ skipping 954 matching lines @@
   }
 }
 
 
 static void EmitSmiBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register result = comp->locs()->out().reg();
   Register temp = comp->locs()->temp(0).reg();
   ASSERT(left == result);
-  Label* deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
-                                        comp->instance_call()->try_index(),
-                                        kDeoptSmiBinaryOp,
-                                        temp,
-                                        right);
-  // TODO(vegorov): for many binary operations this pattern can be rearranged
-  // to save one move.
-  __ movq(temp, left);
-  __ orq(left, right);
-  __ testq(left, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, deopt);
-  __ movq(left, temp);
+  const bool left_is_smi = (GetCid(*comp->left()) == kSmiCid);
+  const bool right_is_smi = (GetCid(*comp->right()) == kSmiCid);
+  bool can_deopt;
+  switch (comp->op_kind()) {
+    case Token::kBIT_AND:
+    case Token::kBIT_OR:
+    case Token::kBIT_XOR:
+      can_deopt = !(right_is_smi && left_is_smi);
+      break;
+    default:
+      can_deopt = true;
+  }
+  Label* deopt = NULL;
+  if (can_deopt) {
+    deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
+                                   comp->instance_call()->try_index(),
+                                   kDeoptSmiBinaryOp,
+                                   temp,
+                                   right);
+  }
+  if (left_is_smi && right_is_smi) {
+    if (can_deopt) {
+      // Preserve left for deopt.
+      __ movq(temp, left);
+    }
+  } else {
+    // TODO(vegorov): for many binary operations this pattern can be rearranged
+    // to save one move.
+    __ movq(temp, left);
+    __ orq(left, right);
+    __ testq(left, Immediate(kSmiTagMask));
+    __ j(NOT_ZERO, deopt);
+    __ movq(left, temp);
+  }
   switch (comp->op_kind()) {
     case Token::kADD: {
       __ addq(left, right);
       __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kSUB: {
       __ subq(left, right);
       __ j(OVERFLOW, deopt);
       break;
@@ skipping 604 matching lines @@
                                  kNumArgsChecked);
   __ CompareObject(RAX, compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64