Allow smi comparisons to have constant operands.

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 261 matching lines @@
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
   if (receiver_class_id() == kDoubleCid) {
     const intptr_t kNumTemps =  0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresXmmRegister());
     locs->set_in(1, Location::RequiresXmmRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
-  if ((receiver_class_id() == kSmiCid) || is_checked_strict_equal) {
-    const intptr_t kNumTemps =  1;
+  if (receiver_class_id() == kSmiCid) {
+    const intptr_t kNumTemps = 0;
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    locs->set_in(0, Location::RegisterOrConstant(left()));
+    locs->set_in(1, Location::RegisterOrConstant(right()));
+    locs->set_out(Location::RequiresRegister());
+    return locs;
+  }
+  if (is_checked_strict_equal) {
+    const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     const intptr_t kNumTemps = 1;
@@ skipping 260 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);
   __ Bind(&done);
 }
 
 
+Immediate SmiConstantToImmediate(const Object& constant) {
+  ASSERT(constant.IsSmi());
+  return Immediate(reinterpret_cast<int64_t>(constant.raw()));
+}
+
+
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch) {
-  Register left = locs.in(0).reg();
-  Register right = locs.in(1).reg();
+  Location left = locs.in(0);
+  Location right = locs.in(1);
 
   Condition true_condition = TokenKindToSmiCondition(kind);
-  __ cmpq(left, right);
+
+  if (left.IsConstant() && right.IsConstant()) {
+    // TODO(vegorov): should be eliminated earlier by constant propagation.
+    const bool result = FlowGraphCompiler::EvaluateCondition(
+        true_condition,
+        Smi::Cast(left.constant()).Value(),
+        Smi::Cast(right.constant()).Value());
+
+    if (branch != NULL) {
+      branch->EmitBranchOnValue(compiler, result);
+    } else {
+      __ LoadObject(locs.out().reg(), result ? compiler->bool_true()
+                                             : compiler->bool_false());
+    }
+
+    return;
+  }
+
+  if (left.IsConstant()) {
+    __ cmpq(right.reg(), SmiConstantToImmediate(left.constant()));
+    true_condition = FlowGraphCompiler::FlipCondition(true_condition);
+  } else if (right.IsConstant()) {
+    __ cmpq(left.reg(), SmiConstantToImmediate(right.constant()));
+  } else {
+    __ cmpq(left.reg(), right.reg());
+  }
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
     __ j(true_condition, &is_true);
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
     __ Bind(&is_true);
@@ skipping 109 matching lines @@
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs());
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(RAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
   if (operands_class_id() == kDoubleCid) {
-    const intptr_t kNumTemps = 0;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresXmmRegister());
     summary->set_in(1, Location::RequiresXmmRegister());
     summary->set_out(Location::RequiresRegister());
     return summary;
   } else if (operands_class_id() == kSmiCid) {
-    const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    summary->set_in(0, Location::RequiresRegister());
-    summary->set_in(1, Location::RequiresRegister());
+    summary->set_in(0, Location::RegisterOrConstant(left()));
+    summary->set_in(1, Location::RegisterOrConstant(right()));
     summary->set_out(Location::RequiresRegister());
-    summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
-  const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   // Pick arbitrary fixed input registers because this is a call.
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
@@ skipping 1544 matching lines @@
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64