[wasm] Int64Lowering of Word64Ror and Word64Rol.

test/cctest/wasm/test-run-wasm-64.cc

 // Copyright 2015 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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "src/base/bits.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/test-signatures.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 
 #define CHECK_TRAP32(x) \
   CHECK_EQ(0xdeadbeef, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
 #define CHECK_TRAP64(x) \
@@ skipping 59 matching lines @@
   V(I64UConvertF32, true)       \
   V(I64UConvertF64, true)       \
   V(I64SConvertI32, true)       \
   V(I64UConvertI32, true)       \
   V(F32SConvertI64, true)       \
   V(F32UConvertI64, true)       \
   V(F64SConvertI64, true)       \
   V(F64UConvertI64, true)       \
   V(F64ReinterpretI64, true)    \
   V(I64ReinterpretF64, true)    \
-  V(I64Ror, false)              \
-  V(I64Rol, false)
+  V(I64Ror, true)               \
+  V(I64Rol, true)
 
 #define DECLARE_CONST(name, cond) static const bool kSupported_##name = cond;
 FOREACH_I64_OPERATOR(DECLARE_CONST)
 #undef DECLARE_CONST
 
 #define REQUIRE(name) \
   if (!WASM_64 && !kSupported_##name) return
 
 TEST(Run_Wasm_I64Const) {
   REQUIRE(I64Const);
@@ skipping 210 matching lines @@
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) { CHECK_EQ((*i) ^ (*j), r.Call(*i, *j)); }
   }
 }
 // kExprI64Shl:
 TEST(Run_Wasm_I64Shl) {
   REQUIRE(I64Shl);
   {
-    WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+    WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+
     FOR_UINT64_INPUTS(i) {
-      for (int64_t j = 1; j < 64; j++) {
-        CHECK_EQ(*i << j, r.Call(*i, j));
+      FOR_UINT64_INPUTS(j) {
+        uint64_t expected = (*i) << (*j & 0x3f);
+        CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); }
   }
 }
 // kExprI64ShrU:
 TEST(Run_Wasm_I64ShrU) {
   REQUIRE(I64ShrU);
   {
-    WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+    WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+
     FOR_UINT64_INPUTS(i) {
-      for (int64_t j = 1; j < 64; j++) {
-        CHECK_EQ(*i >> j, r.Call(*i, j));
+      FOR_UINT64_INPUTS(j) {
+        uint64_t expected = (*i) >> (*j & 0x3f);
+        CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
@@ skipping 10 matching lines @@
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
     FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
   }
 }
 // kExprI64ShrS:
 TEST(Run_Wasm_I64ShrS) {
   REQUIRE(I64ShrS);
   {
     WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+
     FOR_INT64_INPUTS(i) {
-      for (int64_t j = 1; j < 64; j++) {
-        CHECK_EQ(*i >> j, r.Call(*i, j));
+      FOR_INT64_INPUTS(j) {
+        int64_t expected = (*i) >> (*j & 0x3f);
+        CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
     FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
@@ skipping 898 matching lines @@
               WASM_ZERO));
 
   *global = 0xFFFFFFFFFFFFFFFFLL;
   for (int i = 9; i < 444444; i += 111111) {
     int64_t expected = *global & i;
     r.Call(i);
     CHECK_EQ(expected, *global);
   }
 }
 
-TEST(Run_WasmI64Eqz) {
+TEST(Run_Wasm_I64Eqz) {
   REQUIRE(I64Eq);
 
   WasmRunner<int32_t> r(MachineType::Int64());
   BUILD(r, WASM_I64_EQZ(WASM_GET_LOCAL(0)));
 
   FOR_INT64_INPUTS(i) {
     int32_t result = *i == 0 ? 1 : 0;
     CHECK_EQ(result, r.Call(*i));
   }
 }
 
-TEST(Run_WasmI64Shl) {
-  REQUIRE(I64Shl);
-  WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
-  BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+TEST(Run_Wasm_I64Ror) {
+  REQUIRE(I64Ror);
+  WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+  BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
-      uint64_t expected = (*i) << (*j & 0x3f);
+      int64_t expected = bits::RotateRight64(*i, *j & 0x3f);
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }
 
-TEST(Run_WasmI64Shr) {
-  REQUIRE(I64ShrU);
-  WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
-  BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+TEST(Run_Wasm_I64Rol) {
+  REQUIRE(I64Rol);
+  WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+  BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
-      uint64_t expected = (*i) >> (*j & 0x3f);
+      int64_t expected = bits::RotateLeft64(*i, *j & 0x3f);
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
-}
-
-TEST(Run_WasmI64Sar) {
-  REQUIRE(I64ShrS);
-  WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
-  BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
-
-  FOR_INT64_INPUTS(i) {
-    FOR_INT64_INPUTS(j) {
-      int64_t expected = (*i) >> (*j & 0x3f);
-      CHECK_EQ(expected, r.Call(*i, *j));
-    }
-  }
 }