[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode

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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/ieee754.h"
@@ skipping 63 matching lines @@
   CHECK_EQ(uint32_t(0x00000000), m.Call(uint32_t(0x00000000)));
   CHECK_EQ(uint32_t(0x12345678), m.Call(uint32_t(0x1e6a2c48)));
   CHECK_EQ(uint32_t(0xfedcba09), m.Call(uint32_t(0x905d3b7f)));
   CHECK_EQ(uint32_t(0x01010101), m.Call(uint32_t(0x80808080)));
   CHECK_EQ(uint32_t(0x01020408), m.Call(uint32_t(0x10204080)));
   CHECK_EQ(uint32_t(0xf0703010), m.Call(uint32_t(0x080c0e0f)));
   CHECK_EQ(uint32_t(0x1f8d0a3a), m.Call(uint32_t(0x5c50b1f8)));
   CHECK_EQ(uint32_t(0xffffffff), m.Call(uint32_t(0xffffffff)));
 }
 
+TEST(RunWord32ReverseBytes) {
+  BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
+  if (!m.machine()->Word32ReverseBytes().IsSupported()) {
+    // We can only test the operator if it exists on the testing platform.
+    return;
+  }
+  m.Return(m.AddNode(m.machine()->Word32ReverseBytes().op(), m.Parameter(0)));
+
+  CHECK_EQ(uint32_t(0x00000000), m.Call(uint32_t(0x00000000)));
+  CHECK_EQ(uint32_t(0x12345678), m.Call(uint32_t(0x78563412)));
+  CHECK_EQ(uint32_t(0xfedcba09), m.Call(uint32_t(0x09badcfe)));
+  CHECK_EQ(uint32_t(0x01010101), m.Call(uint32_t(0x01010101)));
+  CHECK_EQ(uint32_t(0x01020408), m.Call(uint32_t(0x08040201)));
+  CHECK_EQ(uint32_t(0xf0703010), m.Call(uint32_t(0x103070f0)));
+  CHECK_EQ(uint32_t(0x1f8d0a3a), m.Call(uint32_t(0x3a0a8d1f)));
+  CHECK_EQ(uint32_t(0xffffffff), m.Call(uint32_t(0xffffffff)));
+}
 
 TEST(RunWord32Ctz) {
   BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32());
   if (!m.machine()->Word32Ctz().IsSupported()) {
     // We can only test the operator if it exists on the testing platform.
     return;
   }
   m.Return(m.AddNode(m.machine()->Word32Ctz().op(), m.Parameter(0)));
 
   CHECK_EQ(32, m.Call(uint32_t(0x00000000)));
@@ skipping 102 matching lines @@
   CHECK_EQ(uint64_t(0x0000000000000000), m.Call(uint64_t(0x0000000000000000)));
   CHECK_EQ(uint64_t(0x1234567890abcdef), m.Call(uint64_t(0xf7b3d5091e6a2c48)));
   CHECK_EQ(uint64_t(0xfedcba0987654321), m.Call(uint64_t(0x84c2a6e1905d3b7f)));
   CHECK_EQ(uint64_t(0x0101010101010101), m.Call(uint64_t(0x8080808080808080)));
   CHECK_EQ(uint64_t(0x0102040803060c01), m.Call(uint64_t(0x803060c010204080)));
   CHECK_EQ(uint64_t(0xf0703010e060200f), m.Call(uint64_t(0xf0040607080c0e0f)));
   CHECK_EQ(uint64_t(0x2f8a6df01c21fa3b), m.Call(uint64_t(0xdc5f84380fb651f4)));
   CHECK_EQ(uint64_t(0xffffffffffffffff), m.Call(uint64_t(0xffffffffffffffff)));
 }
 
+TEST(RunWord64ReverseBytes) {
+  RawMachineAssemblerTester<uint64_t> m(MachineType::Uint64());

[ahaas, 2016/07/29 04:15:18]

Did you intentionally use the RawMachineAssemblerTester instead of the
BufferedRawMachineAssemblerTester here? I think you should use the same for both
tests, and I would prefer the BufferedRawMachineAssemblerTester if you do not
have special reasons for using the RawMachineAssemblerTester because the
BufferedRawMachineAssemblerTester is more robust.

[john.yan, 2016/07/29 17:12:03]

No. The test case was modified based on RunWord64ReverseBits above. I don't know
why RunWord64ReverseBits uses unbuffered version but RunWord32ReverseBits uses
buffered version.

+  if (!m.machine()->Word64ReverseBytes().IsSupported()) {
+    return;
+  }
+
+  m.Return(m.AddNode(m.machine()->Word64ReverseBytes().op(), m.Parameter(0)));
+
+  CHECK_EQ(uint64_t(0x0000000000000000), m.Call(uint64_t(0x0000000000000000)));
+  CHECK_EQ(uint64_t(0x1234567890abcdef), m.Call(uint64_t(0xefcdab9078563412)));
+  CHECK_EQ(uint64_t(0xfedcba0987654321), m.Call(uint64_t(0x2143658709badcfe)));
+  CHECK_EQ(uint64_t(0x0101010101010101), m.Call(uint64_t(0x0101010101010101)));
+  CHECK_EQ(uint64_t(0x0102040803060c01), m.Call(uint64_t(0x010c060308040201)));
+  CHECK_EQ(uint64_t(0xf0703010e060200f), m.Call(uint64_t(0x0f2060e0103070f0)));
+  CHECK_EQ(uint64_t(0x2f8a6df01c21fa3b), m.Call(uint64_t(0x3bfa211cf06d8a2f)));
+  CHECK_EQ(uint64_t(0xffffffffffffffff), m.Call(uint64_t(0xffffffffffffffff)));
+}
 
 TEST(RunWord64Clz) {
   BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64());
   m.Return(m.Word64Clz(m.Parameter(0)));
 
   CHECK_EQ(0, m.Call(uint64_t(0x8000100000000000)));
   CHECK_EQ(1, m.Call(uint64_t(0x4000050000000000)));
   CHECK_EQ(2, m.Call(uint64_t(0x2000030000000000)));
   CHECK_EQ(3, m.Call(uint64_t(0x1000000300000000)));
   CHECK_EQ(4, m.Call(uint64_t(0x0805000000000000)));
@@ skipping 6334 matching lines @@
   r.Goto(&merge);
   r.Bind(&merge);
   Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb);
   r.Return(phi);
   CHECK_EQ(1, r.Call(1));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8