[wasm] New implementation of popcnt and ctz.

test/cctest/compiler/test-run-calls-to-external-references.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/wasm/wasm-external-refs.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 namespace v8 {
@@ skipping 30 matching lines @@
                     m->PointerConstant(&param1), m->PointerConstant(&param2));
   m->Return(m->Int32Constant(4356));
 
   m->Call();
   comparison(&comparison_param1, &comparison_param2);
 
   CHECK_EQ(comparison_param1, param1);
   CHECK_EQ(comparison_param2, param2);
 }
 
+template <typename R, typename P>
+void TestExternalReference(BufferedRawMachineAssemblerTester<R>* m,
+                           ExternalReference ref, R (*comparison)(P*),
+                           P param) {
+  P comparison_param = param;
+
+  Node* function = m->ExternalConstant(ref);
+  m->Return(m->CallCFunction1(MachineType::Pointer(), MachineType::Pointer(),
+                              function, m->PointerConstant(&param)));
+
+  CHECK_EQ(comparison(&comparison_param), m->Call());
+
+  CHECK_EQ(comparison_param, param);
+}
+
 template <typename R, typename P1, typename P2>
 void TestExternalReference(BufferedRawMachineAssemblerTester<R>* m,
                            ExternalReference ref, R (*comparison)(P1*, P2*),
                            P1 param1, P2 param2) {
   P1 comparison_param1 = param1;
   P2 comparison_param2 = param2;
 
   Node* function = m->ExternalConstant(ref);
   m->Return(m->CallCFunction2(
       MachineType::Pointer(), MachineType::Pointer(), MachineType::Pointer(),
@@ skipping 133 matching lines @@
   TestExternalReference(&m, ref, wasm::uint64_div_wrapper, uint64_t(1774),
                         uint64_t(21));
 }
 
 TEST(RunCallUint64Mod) {
   BufferedRawMachineAssemblerTester<int32_t> m;
   ExternalReference ref = ExternalReference::wasm_uint64_mod(m.isolate());
   TestExternalReference(&m, ref, wasm::uint64_mod_wrapper, uint64_t(1774),
                         uint64_t(21));
 }
+
+TEST(RunCallWord32Ctz) {
+  BufferedRawMachineAssemblerTester<uint32_t> m;
+  ExternalReference ref = ExternalReference::wasm_word32_ctz(m.isolate());
+  TestExternalReference(&m, ref, wasm::word32_ctz_wrapper, uint32_t(1774));
+}
+
+TEST(RunCallWord64Ctz) {
+  BufferedRawMachineAssemblerTester<uint32_t> m;
+  ExternalReference ref = ExternalReference::wasm_word64_ctz(m.isolate());
+  TestExternalReference(&m, ref, wasm::word64_ctz_wrapper, uint64_t(1774));
+}
+
+TEST(RunCallWord32Popcnt) {
+  BufferedRawMachineAssemblerTester<uint32_t> m;
+  ExternalReference ref = ExternalReference::wasm_word32_popcnt(m.isolate());
+  TestExternalReference(&m, ref, wasm::word32_popcnt_wrapper, uint32_t(1774));
+}
+
+TEST(RunCallWord64Popcnt) {
+  BufferedRawMachineAssemblerTester<uint32_t> m;
+  ExternalReference ref = ExternalReference::wasm_word64_popcnt(m.isolate());
+  TestExternalReference(&m, ref, wasm::word64_popcnt_wrapper, uint64_t(1774));
+}
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8