Use type information to eliminate unnecessary bitwise-and operations.

src/compiler/machine-operator-reducer.cc

 // Copyright 2014 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 "src/compiler/machine-operator-reducer.h"
 
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/codegen.h"
 #include "src/compiler/diamond.h"
@@ skipping 814 matching lines @@
   Int32BinopMatcher m(node);
   if (m.right().Is(0)) return Replace(m.right().node());  // x & 0  => 0
   if (m.right().Is(-1)) return Replace(m.left().node());  // x & -1 => x
   if (m.left().IsComparison() && m.right().Is(1)) {       // CMP & 1 => CMP
     return Replace(m.left().node());
   }
   if (m.IsFoldable()) {                                   // K & K  => K
     return ReplaceInt32(m.left().Value() & m.right().Value());
   }
   if (m.LeftEqualsRight()) return Replace(m.left().node());  // x & x => x
+  if (m.right().HasValue()) {
+    int32_t const mask = m.right().Value();
+    Type* left_type = NodeProperties::GetBounds(m.left().node()).upper;
+    if (left_type->IsRange() && left_type->Min() >= kMinInt &&
+        left_type->Max() <= kMaxInt) {
+      // If the left hand side known one bits and unknown bits are preserve by
+      // the mask then the bitwise-and operation can be eliminated.
+      uint32_t left_min = left_type->Min(), left_max = left_type->Max();
+      uint32_t changes = left_min ^ left_max;
+      unsigned known_count = base::bits::CountLeadingZeros32(changes);
+      uint32_t known_mask = known_count > 0 ? -1 << (32 - known_count) : 0;
+      uint32_t known_ones = left_min & known_mask;
+      if ((known_ones & mask) == known_ones &&
+          (~known_mask & mask) == ~known_mask) {  // x & K => x
+        return Replace(m.left().node());
+      }
+    }
+  }
   if (m.left().IsWord32And() && m.right().HasValue()) {
     Int32BinopMatcher mleft(m.left().node());
     if (mleft.right().HasValue()) {  // (x & K) & K => x & K
       node->ReplaceInput(0, mleft.left().node());
       node->ReplaceInput(
           1, Int32Constant(m.right().Value() & mleft.right().Value()));
       Reduction const reduction = ReduceWord32And(node);
       return reduction.Changed() ? reduction : Changed(node);
     }
   }
@@ skipping 168 matching lines @@
 MachineOperatorBuilder* MachineOperatorReducer::machine() const {
   return jsgraph()->machine();
 }
 
 
 Graph* MachineOperatorReducer::graph() const { return jsgraph()->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8