Add FOR_INT32_SHIFTS to value-helper.h

test/cctest/compiler/test-run-machops.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 <functional>
 #include <limits>
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
@@ skipping 555 matching lines @@
 
 
 TEST(RunInt32AddAndWord32SarP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Sar(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i + (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Add(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) + *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32ShlP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Shl(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i + (*j << shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Add(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i << shift) + *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32AddAndWord32ShrP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Add(m.Parameter(0),
                         m.Word32Shr(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i + (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Add(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) + *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
@@ skipping 81 matching lines @@
                                         m.NewNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
@@ skipping 64 matching lines @@
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                            kMachineWord32);
       m.Return(m.Word32Equal(
           m.Int32Add(m.Parameter(0),
                      m.NewNode(shops[n], m.Parameter(1), m.Parameter(2))),
           m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
@@ skipping 54 matching lines @@
 
 
 TEST(RunInt32SubAndWord32SarP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Sub(m.Parameter(0),
                         m.Word32Sar(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i - (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Sub(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32ShlP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Sub(m.Parameter(0),
                         m.Word32Shl(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i - (*j << shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Sub(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i << shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunInt32SubAndWord32ShrP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Sub(m.Parameter(0),
                         m.Word32Shr(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = *i - (*j >> shift);
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
                         m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           // Use uint32_t because signed overflow is UB in C.
           int32_t expected = (*i >> shift) - *k;
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
@@ skipping 81 matching lines @@
                                         m.NewNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
@@ skipping 64 matching lines @@
                          m.machine()->Word32Shr()};
     for (size_t n = 0; n < ARRAY_SIZE(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                            kMachineWord32);
       m.Return(m.Word32Equal(
           m.Int32Sub(m.Parameter(0),
                      m.NewNode(shops[n], m.Parameter(1), m.Parameter(2))),
           m.Int32Constant(0)));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
@@ skipping 520 matching lines @@
                                          m.NewNode(shops[n], m.Parameter(1),
                                                    m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
@@ skipping 206 matching lines @@
                                         m.NewNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
@@ skipping 203 matching lines @@
                                          m.NewNode(shops[n], m.Parameter(1),
                                                    m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
         FOR_INT32_INPUTS(j) {
-          FOR_UINT32_INPUTS(k) {
-            uint32_t shift = *k & 0x1F;
+          FOR_UINT32_SHIFTS(shift) {
             int32_t right;
             switch (shops[n]->opcode()) {
               default:
                 UNREACHABLE();
               case IrOpcode::kWord32Sar:
                 right = *j >> shift;
                 break;
               case IrOpcode::kWord32Shl:
                 right = *j << shift;
                 break;
               case IrOpcode::kWord32Shr:
                 right = static_cast<uint32_t>(*j) >> shift;
                 break;
             }
             int32_t expected = ((*i ^ right) == 0) ? constant : 0 - constant;
             CHECK_EQ(expected, m.Call(*i, *j, shift));
           }
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32ShlP) {
   {
-    FOR_UINT32_INPUTS(i) {
-      uint32_t shift = *i & 0x1F;
+    FOR_UINT32_SHIFTS(shift) {
       RawMachineAssemblerTester<int32_t> m(kMachineWord32);
       m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *j << shift;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(m.Word32Shl(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
-        uint32_t shift = *j & 0x1F;
+      FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = *i << shift;
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
   }
 }
 
 
 TEST(RunWord32ShrP) {
   {
-    FOR_UINT32_INPUTS(i) {
-      uint32_t shift = *i & 0x1F;
+    FOR_UINT32_SHIFTS(shift) {
       RawMachineAssemblerTester<int32_t> m(kMachineWord32);
       m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = *j >> shift;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(m.Word32Shr(bt.param0, bt.param1));
     FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
-        uint32_t shift = *j & 0x1F;
+      FOR_UINT32_SHIFTS(shift) {
         uint32_t expected = *i >> shift;
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
     CHECK_EQ(0x00010000, bt.call(0x80000000, 15));
   }
 }
 
 
 TEST(RunWord32SarP) {
   {
-    FOR_INT32_INPUTS(i) {
-      int32_t shift = *i & 0x1F;
+    FOR_INT32_SHIFTS(shift) {
       RawMachineAssemblerTester<int32_t> m(kMachineWord32);
       m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)));
       FOR_INT32_INPUTS(j) {
         int32_t expected = *j >> shift;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
     bt.AddReturn(m.Word32Sar(bt.param0, bt.param1));
     FOR_INT32_INPUTS(i) {
-      FOR_INT32_INPUTS(j) {
-        int32_t shift = *j & 0x1F;
+      FOR_INT32_SHIFTS(shift) {
         int32_t expected = *i >> shift;
         CHECK_EQ(expected, bt.call(*i, shift));
       }
     }
     CHECK_EQ(0xFFFF0000, bt.call(0x80000000, 15));
   }
 }
 
 
 TEST(RunWord32NotP) {
@@ skipping 17 matching lines @@
 
 
 TEST(RunWord32EqualAndWord32SarP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Word32Equal(m.Parameter(0),
                            m.Word32Sar(m.Parameter(1), m.Parameter(2))));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           int32_t expected = (*i == (*j >> shift));
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
                            m.Parameter(2)));
     FOR_INT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_INT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           int32_t expected = ((*i >> shift) == *k);
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32EqualAndWord32ShlP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Word32Equal(m.Parameter(0),
                            m.Word32Shl(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           int32_t expected = (*i == (*j << shift));
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
                            m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           int32_t expected = ((*i << shift) == *k);
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunWord32EqualAndWord32ShrP) {
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Word32Equal(m.Parameter(0),
                            m.Word32Shr(m.Parameter(1), m.Parameter(2))));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
-        FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *k & 0x1F;
+        FOR_UINT32_SHIFTS(shift) {
           int32_t expected = (*i == (*j >> shift));
           CHECK_EQ(expected, m.Call(*i, *j, shift));
         }
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m(kMachineWord32, kMachineWord32,
                                          kMachineWord32);
     m.Return(m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
                            m.Parameter(2)));
     FOR_UINT32_INPUTS(i) {
-      FOR_UINT32_INPUTS(j) {
+      FOR_UINT32_SHIFTS(shift) {
         FOR_UINT32_INPUTS(k) {
-          uint32_t shift = *j & 0x1F;
           int32_t expected = ((*i >> shift) == *k);
           CHECK_EQ(expected, m.Call(*i, shift, *k));
         }
       }
     }
   }
 }
 
 
 TEST(RunDeadNodes) {
@@ skipping 1635 matching lines @@
   FOR_UINT32_INPUTS(i) {
     FOR_UINT32_INPUTS(j) {
       int32_t expected;
       if (ssub_overflow(*i, *j, &expected)) expected = constant;
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET