MIPS: [turbofan] Improve matching for And(Shr(x, imm), mask).

src/compiler/mips/instruction-selector-mips.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/base/adapters.h"
 #include "src/base/bits.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 
@@ skipping 242 matching lines @@
 
 
 void InstructionSelector::VisitWord32And(Node* node) {
   MipsOperandGenerator g(this);
   Int32BinopMatcher m(node);
   if (m.left().IsWord32Shr() && CanCover(node, m.left().node()) &&
       m.right().HasValue()) {
     uint32_t mask = m.right().Value();
     uint32_t mask_width = base::bits::CountPopulation32(mask);
     uint32_t mask_msb = base::bits::CountLeadingZeros32(mask);
-    if ((mask_width != 0) && (mask_msb + mask_width == 32)) {
-      // The mask must be contiguous, and occupy the least-significant bits.
-      DCHECK_EQ(0u, base::bits::CountTrailingZeros32(mask));
-
-      // Select Ext for And(Shr(x, imm), mask) where the mask is in the least
-      // significant bits.
+    uint32_t mask_lsb = base::bits::CountTrailingZeros32(mask);
+    if ((mask_width != 0) && (mask_msb + mask_width + mask_lsb == 32)) {
+      // The mask must be contiguous.
+      // Select Ext for And(Shr(x, imm), mask) where the mask may be in
+      // the least-significant bits or elsewhere.
       Int32BinopMatcher mleft(m.left().node());
       if (mleft.right().HasValue()) {
         // Any shift value can match; int32 shifts use `value % 32`.
         uint32_t lsb = mleft.right().Value() & 0x1f;
-
+        lsb = lsb + mask_lsb;
         // Ext cannot extract bits past the register size, however since
         // shifting the original value would have introduced some zeros we can
         // still use Ext with a smaller mask and the remaining bits will be
         // zeros.
         if (lsb + mask_width > 32) mask_width = 32 - lsb;
 
         Emit(kMipsExt, g.DefineAsRegister(node),
              g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
              g.TempImmediate(mask_width));

[akos.palfi.imgtec, 2015/12/30 00:32:53]

When the mask_lsb > 0, the result will be incorrect. The Ext instr will
right-shift the result by 'lsb + mask_lsb', but it must be shifted by 'lsb', so
after the Ext you should shift left the result by 'mask_lsb' to get the correct
result.
Something like this could make it work, but this is a hacky solution and I don't
really like it:

        if (mask_lsb > 0) {
          Emit(kMipsShl, g.DefineAsRegister(node), g.DefineAsRegister(node),
g.TempImmediate(mask_lsb));
        }

Same for mips64.

         return;
       }
       // Other cases fall through to the normal And operation.
     }
   }
   if (m.right().HasValue()) {
     uint32_t mask = m.right().Value();
     uint32_t shift = base::bits::CountPopulation32(~mask);
     uint32_t msb = base::bits::CountLeadingZeros32(~mask);
     if (shift != 0 && shift != 32 && msb + shift == 32) {
@@ skipping 1034 matching lines @@
          MachineOperatorBuilder::kFloat32Max |
          MachineOperatorBuilder::kFloat32RoundDown |
          MachineOperatorBuilder::kFloat32RoundUp |
          MachineOperatorBuilder::kFloat32RoundTruncate |
          MachineOperatorBuilder::kFloat32RoundTiesEven;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8