Support IfThenElse instruction pattern for arbitrary smi constants.

runtime/vm/intermediate_language_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 3706 matching lines @@
 }
 
 
 // Detect pattern when one value is zero and another is a power of 2.
 static bool IsPowerOfTwoKind(intptr_t v1, intptr_t v2) {
   return (Utils::IsPowerOfTwo(v1) && (v2 == 0)) ||
          (Utils::IsPowerOfTwo(v2) && (v1 == 0));
 }
 
 
-// Detect pattern when one value is increment of another.
-static bool IsIncrementKind(intptr_t v1, intptr_t v2) {
-  return ((v1 == v2 + 1) || (v1 + 1 == v2));
-}
-
-
 bool IfThenElseInstr::IsSupported() {
   return true;
 }
 
 
 bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
                                Value* v1,
                                Value* v2) {
   if (!(comparison->IsStrictCompare() &&
         !comparison->AsStrictCompare()->needs_number_check()) &&
       !(comparison->IsEqualityCompare() &&
         (comparison->AsEqualityCompare()->receiver_class_id() == kSmiCid))) {
     return false;
   }
 
   intptr_t v1_value, v2_value;
 
   if (!BindsToSmiConstant(v1, &v1_value) ||
       !BindsToSmiConstant(v2, &v2_value)) {
     return false;
   }
 
-  if (IsPowerOfTwoKind(v1_value, v2_value) ||
-      IsIncrementKind(v1_value, v2_value)) {
-    return true;
-  }
-
-  return false;
+  return true;
 }
 
 
 LocationSummary* IfThenElseInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   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()));
@@ skipping 25 matching lines @@
   } else {
     __ cmpl(left.reg(), right.reg());
   }
 
   Condition true_condition =
       ((kind_ == Token::kEQ_STRICT) || (kind_ == Token::kEQ)) ? EQUAL
                                                               : NOT_EQUAL;
 
   const bool is_power_of_two_kind = IsPowerOfTwoKind(if_true_, if_false_);
 
-  const intptr_t base = Utils::Minimum(if_true_, if_false_);
+  intptr_t true_value = if_true_;
+  intptr_t false_value = if_false_;
 
-  if (if_true_ == base) {
-    // We need to have zero in EDX on true_condition.
-    true_condition = NegateCondition(true_condition);
+  if (is_power_of_two_kind) {
+    if (true_value == 0) {
+      // We need to have zero in EDX on true_condition.
+      true_condition = NegateCondition(true_condition);
+    }
+  } else {
+    if (true_value == 0) {
+      // Swap values so that false_value is zero.
+      intptr_t temp = true_value;
+      true_value = false_value;
+      false_value = temp;
+    } else {
+      true_condition = NegateCondition(true_condition);
+    }
   }
 
   __ setcc(true_condition, DL);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
-        Utils::ShiftForPowerOfTwo(Utils::Maximum(if_true_, if_false_));
+        Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ shll(EDX, Immediate(shift + kSmiTagSize));
   } else {
-    ASSERT(kSmiTagSize == 1);
-    __ leal(EDX, Address(EDX, TIMES_2, base << kSmiTagSize));
+    __ subl(EDX, Immediate(1));
+    __ andl(EDX, Immediate(
+        Smi::RawValue(true_value) - Smi::RawValue(false_value)));
+    if (false_value != 0) {
+      __ addl(EDX, Immediate(Smi::RawValue(false_value)));
+    }
   }
 }
 
 
 void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The arguments to the stub include the closure, as does the arguments
   // descriptor.
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
@@ skipping 107 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32