- Canonicalize array bounds checks to avoid deopting when comparing

runtime/vm/intermediate_language_mips.cc

Index: runtime/vm/intermediate_language_mips.cc
===================================================================
--- runtime/vm/intermediate_language_mips.cc	(revision 22689)
+++ runtime/vm/intermediate_language_mips.cc	(working copy)
@@ -2480,37 +2480,41 @@
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  locs->set_in(0, Location::RegisterOrSmiConstant(length()));
-  locs->set_in(1, Location::RegisterOrSmiConstant(index()));
+  locs->set_in(kLengthPos, Location::RegisterOrSmiConstant(length()));
+  locs->set_in(kIndexPos, Location::RegisterOrSmiConstant(index()));
   return locs;
 }
 
 
 void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        kDeoptCheckArrayBound);
-  if (locs()->in(0).IsConstant() && locs()->in(1).IsConstant()) {
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptCheckArrayBound);
+
+  Location length_loc = locs()->in(kLengthPos);
+  Location index_loc = locs()->in(kIndexPos);
+
+  if (length_loc.IsConstant() && index_loc.IsConstant()) {
+    ASSERT((Smi::Cast(length_loc.constant()).Value() <=
+            Smi::Cast(index_loc.constant()).Value()) ||
+           (Smi::Cast(index_loc.constant()).Value() < 0));
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ b(deopt);
     return;
   }
 
-  if (locs()->in(1).IsConstant()) {
-    Register length = locs()->in(0).reg();
-    const Object& constant = locs()->in(1).constant();
-    ASSERT(constant.IsSmi());
+  if (index_loc.IsConstant()) {
+    Register length = length_loc.reg();
+    const Smi& index = Smi::Cast(index_loc.constant());
     __ BranchUnsignedLessEqual(
-        length, reinterpret_cast<int32_t>(constant.raw()), deopt);
-  } else if (locs()->in(0).IsConstant()) {
-    ASSERT(locs()->in(0).constant().IsSmi());
-    const Smi& smi_const = Smi::Cast(locs()->in(0).constant());
-    Register index = locs()->in(1).reg();
+        length, reinterpret_cast<int32_t>(index.raw()), deopt);
+  } else if (length_loc.IsConstant()) {
+    const Smi& length = Smi::Cast(length_loc.constant());
+    Register index = index_loc.reg();
     __ BranchUnsignedGreaterEqual(
-        index, reinterpret_cast<int32_t>(smi_const.raw()), deopt);
+        index, reinterpret_cast<int32_t>(length.raw()), deopt);
   } else {
-    Register length = locs()->in(0).reg();
-    Register index = locs()->in(1).reg();
+    Register length = length_loc.reg();
+    Register index = index_loc.reg();
     __ BranchUnsignedGreaterEqual(index, length, deopt);
   }
 }