Allow comparison in UINT32 mode.

src/hydrogen-uint32-analysis.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "hydrogen-uint32-analysis.h"
 
 namespace v8 {
 namespace internal {
 
 
+static bool IsUnsignedLoad(HLoadKeyed* instr) {
+  switch (instr->elements_kind()) {
+    case EXTERNAL_UINT8_ELEMENTS:
+    case EXTERNAL_UINT16_ELEMENTS:
+    case EXTERNAL_UINT32_ELEMENTS:
+    case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
+    case UINT8_ELEMENTS:
+    case UINT16_ELEMENTS:
+    case UINT32_ELEMENTS:
+    case UINT8_CLAMPED_ELEMENTS:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+static bool IsUint32Operation(HValue* instr) {
+  return instr->IsShr() ||
+      (instr->IsLoadKeyed() && IsUnsignedLoad(HLoadKeyed::cast(instr))) ||
+      (instr->IsInteger32Constant() && instr->GetInteger32Constant() >= 0);
+}
+
+
 bool HUint32AnalysisPhase::IsSafeUint32Use(HValue* val, HValue* use) {
   // Operations that operate on bits are safe.
   if (use->IsBitwise() || use->IsShl() || use->IsSar() || use->IsShr()) {
     return true;
   } else if (use->IsSimulate()) {
     // Deoptimization has special support for uint32.
     return true;
   } else if (use->IsChange()) {
     // Conversions have special support for uint32.
     // This ASSERT guards that the conversion in question is actually
     // implemented. Do not extend the whitelist without adding
     // support to LChunkBuilder::DoChange().
     ASSERT(HChange::cast(use)->to().IsDouble() ||
            HChange::cast(use)->to().IsSmi() ||
            HChange::cast(use)->to().IsTagged());
     return true;
   } else if (use->IsStoreKeyed()) {
     HStoreKeyed* store = HStoreKeyed::cast(use);
     if (store->is_external()) {
       // Storing a value into an external integer array is a bit level
       // operation.
       if (store->value() == val) {
         // Clamping or a conversion to double should have beed inserted.
         ASSERT(store->elements_kind() != EXTERNAL_UINT8_CLAMPED_ELEMENTS);
         ASSERT(store->elements_kind() != EXTERNAL_FLOAT32_ELEMENTS);
         ASSERT(store->elements_kind() != EXTERNAL_FLOAT64_ELEMENTS);
         return true;
       }
     }
+  } else if (use->IsCompareNumericAndBranch()) {
+    HCompareNumericAndBranch* c = HCompareNumericAndBranch::cast(use);
+    return IsUint32Operation(c->left()) && IsUint32Operation(c->right());
   }
 
   return false;
 }
 
 
 // Iterate over all uses and verify that they are uint32 safe: either don't
 // distinguish between int32 and uint32 due to their bitwise nature or
 // have special support for uint32 values.
 // Encountered phis are optimistically treated as safe uint32 uses,
@@ skipping 154 matching lines @@
 
   // Some phis might have been optimistically marked with kUint32 flag.
   // Remove this flag from those phis that are unsafe and propagate
   // this information transitively potentially clearing kUint32 flag
   // from some non-phi operations that are used as operands to unsafe phis.
   UnmarkUnsafePhis();
 }
 
 
 } }  // namespace v8::internal