Add range to kBIT_AND with positive constants. Use that range to eliminate compares in left shifts.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 2169 matching lines @@
       new_min =
         RangeBoundary::Sub(Range::ConstantMin(left_range),
                            Range::ConstantMax(right_range),
                            RangeBoundary::OverflowedMinSmi());
       new_max =
         RangeBoundary::Sub(Range::ConstantMax(left_range),
                            Range::ConstantMin(right_range),
                            RangeBoundary::OverflowedMaxSmi());
       break;
 
+    case Token::kBIT_AND:
+      if (Range::ConstantMin(right_range).value() >= 0) {
+        new_min = RangeBoundary::FromConstant(0);
+        new_max = Range::ConstantMax(right_range);
+        break;
+      }
+      if (Range::ConstantMin(left_range).value() >= 0) {
+        new_min = RangeBoundary::FromConstant(0);
+        new_max = Range::ConstantMax(left_range);
+        break;
+      }
+      if (range_ == NULL) {

[Vyacheslav Egorov (Google), 2012/10/19 20:05:28]

I sense a problem here. Range of a phi can start like [0, 0] but be later
expanded due to the flow of information on the back edge. However we will loose
this fact and stop updating the range correctly.

Please test it on the code:

var j, k = -0xff;
for (var i = 0; i >= -10; i--) {
  print(k & i); // range of this & should not be [0, 0].
}

+        range_ = Range::Unknown();
+        return true;
+      }
+      return false;
+
     default:
       if (range_ == NULL) {
         range_ = Range::Unknown();
         return true;
       }
       return false;
   }
 
   ASSERT(!new_min.IsUnknown() && !new_max.IsUnknown());
   set_overflow(new_min.Overflowed() || new_max.Overflowed());
 
   if (op == Definition::kRangeNarrow) {
     new_min = new_min.Clamp();
     new_max = new_max.Clamp();
   }
 
   return Range::Update(&range_, new_min, new_max);
 }
 
 
+// Inclusive.
+bool Range::IsWithin(intptr_t min_int, intptr_t max_int) const {
+  if (!min().IsConstant() || (min().value() < min_int)) return false;
+  if (!max().IsConstant() || (max().value() > max_int)) return false;
+  return true;
+}
+
+
 #undef __
 
 }  // namespace dart