diff --git a/.gitignore b/.gitignore
index 975557746738fc77d8bdca381c015a2859f6f806..7ef41e831869f9e4faf8e1a0e9656a826b031688 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,6 +30,7 @@ test/unit/rope_avl
test/unit/rope_basic
test/unit/rope_stress
test/unit/rlist
+test/unit/bit_test
Makefile
CMakeFiles
CMakeCache.txt
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 55774f891b0a575670b077c00ebb176b6bc718c3..999465d6dcdd59218febe8b3eb10caf5130b9f54 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,9 +9,12 @@ include(CheckLibraryExists)
include(CheckIncludeFile)
include(CheckCCompilerFlag)
include(CheckSymbolExists)
+include(CheckCSourceRuns)
include(CheckCXXSourceRuns)
include(TestBigEndian)
include(CheckFunctionExists)
+include(CheckBuiltInFunctionExists)
+include(CheckPrototypeDefinition)
find_program(ECHO echo)
find_program(XSLTPROC xsltproc)
diff --git a/cmake/CheckBuiltInFunctionExists.cmake b/cmake/CheckBuiltInFunctionExists.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6b4128f129f2f3effa521edcd17508964b3a03bd
--- /dev/null
+++ b/cmake/CheckBuiltInFunctionExists.cmake
@@ -0,0 +1,7 @@
+include(CheckCSourceCompiles)
+
+macro(check_builtin_function_exists function variable)
+ set(CMAKE_REQUIRED_FLAGS "-Wno-unused-value -Wno-error")
+ check_c_source_compiles("int main(void) { ${function}; return 0; }"
+ ${variable})
+endmacro(check_builtin_function_exists)
diff --git a/include/config.h.cmake b/include/config.h.cmake
index 407b4d8fc7a542980df123b1e5516b90af9725d0..e782061b1c31fddcd431d5000de8f8aff92b840f 100644
--- a/include/config.h.cmake
+++ b/include/config.h.cmake
@@ -74,6 +74,20 @@
*/
#cmakedefine HAVE_BYTE_ORDER_BIG_ENDIAN 1
+/*
+ * Set if compiler has __builtin_XXX methods.
+ */
+#cmakedefine HAVE_BUILTIN_CTZ 1
+#cmakedefine HAVE_BUILTIN_CTZLL 1
+#cmakedefine HAVE_BUILTIN_CLZ 1
+#cmakedefine HAVE_BUILTIN_CLZLL 1
+#cmakedefine HAVE_BUILTIN_POPCOUNT 1
+#cmakedefine HAVE_BUILTIN_POPCOUNTLL 1
+#cmakedefine HAVE_BUILTIN_BSWAP32 1
+#cmakedefine HAVE_BUILTIN_BSWAP64 1
+#cmakedefine HAVE_FFSL 1
+#cmakedefine HAVE_FFSLL 1
+
/*
* pthread have problems with -std=c99
*/
diff --git a/include/lib/bit/bit.h b/include/lib/bit/bit.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e6f853f0a65c7b9f8ff367f57cf8f1aaff98115
--- /dev/null
+++ b/include/lib/bit/bit.h
@@ -0,0 +1,306 @@
+#ifndef TARANTOOL_LIB_BIT_BIT_H_INCLUDED
+#define TARANTOOL_LIB_BIT_BIT_H_INCLUDED
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the
+ * following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/**
+ * @file
+ * @brief Bit manipulation library
+ */
+#include "config.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#if defined(HAVE_FFSL) || defined(HAVE_FFSLL)
+#include <string.h>
+#include <strings.h>
+#endif /* defined(HAVE_FFSL) || defined(HAVE_FFSLL) */
+#include <limits.h>
+
+/**
+ * @cond false
+ * @brief Naive implementation of ctz.
+ */
+#define CTZ_NAIVE(x, bitsize) { \
+ if (x == 0) { \
+ return (bitsize); \
+ } \
+ \
+ int r = 0; \
+ for (; (x & 1) == 0; r++) { \
+ x >>= 1; \
+ } \
+ \
+ return r; \
+}
+/** @endcond */
+
+/**
+ * @brief Count Trailing Zeros.
+ * Returns the number of trailing 0-bits in @a x, starting at the least
+ * significant bit position. If @a x is 0, the result is undefined.
+ * @param x integer
+ * @see __builtin_ctz()
+ * @return the number trailing 0-bits
+ */
+ __attribute__((const)) inline int
+bit_ctz_u32(uint32_t x)
+{
+#if defined(HAVE_BUILTIN_CTZ)
+ return __builtin_ctz(x);
+#elif defined(HAVE_FFSL)
+ return ffsl(x) - 1;
+#else
+ CTZ_NAIVE(x, sizeof(uint32_t) * CHAR_BIT);
+#endif
+}
+
+#include <stdio.h>
+#include <inttypes.h>
+
+/**
+ * @copydoc bit_ctz_u32
+ */
+ __attribute__((const)) inline int
+bit_ctz_u64(uint64_t x)
+{
+#if defined(HAVE_BUILTIN_CTZLL)
+ return __builtin_ctzll(x);
+#elif defined(HAVE_FFSLL)
+ return ffsll(x) - 1;
+#else
+ CTZ_NAIVE(x, sizeof(uint64_t) * CHAR_BIT);
+#endif
+}
+
+#undef CTZ_NAIVE
+
+/**
+ * @cond false
+ * @brief Naive implementation of clz.
+ */
+#define CLZ_NAIVE(x, bitsize) { \
+ if (x == 0) { \
+ return (bitsize); \
+ } \
+ \
+ int r = (bitsize); \
+ for (; x; r--) { \
+ x >>= 1; \
+ } \
+ \
+ return r; \
+}
+/** @endcond */
+
+/**
+ * @brief Count Leading Zeros.
+ * Returns the number of leading 0-bits in @a x, starting at the most
+ * significant bit position. If @a x is 0, the result is undefined.
+ * @param x integer
+ * @see __builtin_clz()
+ * @return the number of leading 0-bits
+ */
+ __attribute__((const)) inline int
+bit_clz_u32(uint32_t x)
+{
+#if defined(HAVE_BUILTIN_CLZ)
+ return __builtin_clz(x);
+#else /* !defined(HAVE_BUILTIN_CLZ) */
+ CLZ_NAIVE(x, sizeof(uint32_t) * CHAR_BIT);
+#endif
+}
+
+/**
+ * @copydoc bit_clz_u32
+ */
+__attribute__((const)) inline int
+bit_clz_u64(uint64_t x)
+{
+#if defined(HAVE_BUILTIN_CLZLL)
+ return __builtin_clzll(x);
+#else /* !defined(HAVE_BUILTIN_CLZLL) */
+ CLZ_NAIVE(x, sizeof(uint64_t) * CHAR_BIT);
+#endif
+}
+
+#undef CLZ_NAIVE
+
+/**
+ * @cond false
+ * @brief Naive implementation of popcount.
+ */
+#define POPCOUNT_NAIVE(x, bitsize) { \
+ int r; \
+ for (r = 0; x; r++) { \
+ x &= (x-1); \
+ } \
+ \
+ return r; \
+}
+/** @endcond */
+
+/**
+ * @brief Returns the number of 1-bits in @a x.
+ * @param x integer
+ * @see __builtin_popcount()
+ * @return the number of 1-bits in @a x
+ */
+__attribute__((const)) inline int
+bit_count_u32(uint32_t x)
+{
+#if defined(HAVE_BUILTIN_POPCOUNT)
+ return __builtin_popcount(x);
+#else /* !defined(HAVE_BUILTIN_POPCOUNT) */
+ POPCOUNT_NAIVE(x, sizeof(uint32_t) * CHAR_BIT);
+#endif
+}
+
+/**
+ * @copydoc bit_count_u32
+ */
+__attribute__((const)) inline int
+bit_count_u64(uint64_t x)
+{
+#if defined(HAVE_BUILTIN_POPCOUNTLL)
+ return __builtin_popcountll(x);
+#else /* !defined(HAVE_BUILTIN_POPCOUNTLL) */
+ POPCOUNT_NAIVE(x, sizeof(uint64_t) * CHAR_BIT);
+#endif
+}
+
+#undef POPCOUNT_NAIVE
+
+/**
+ * @brief Rotate @a x left by @a r bits
+ * @param x integer
+ * @param r number for bits to rotate
+ * @return @a x rotated left by @a r bits
+ */
+__attribute__ ((const)) inline uint32_t
+bit_rotl_u32(uint32_t x, int r)
+{
+ /* gcc recognises this code and generates a rotate instruction */
+ return ((x << r) | (x >> (32 - r)));
+}
+
+/**
+ * @copydoc bit_rotl_u32
+ */
+__attribute__ ((const)) inline uint64_t
+bit_rotl_u64(uint64_t x, int r)
+{
+ /* gcc recognises this code and generates a rotate instruction */
+ return ((x << r) | (x >> (64 - r)));
+}
+
+/**
+ * @brief Rotate @a x right by @a r bits
+ * @param x integer
+ * @param r number for bits to rotate
+ * @return @a x rotated right by @a r bits
+ * @todo Move this method to bit.h
+ */
+__attribute__ ((const)) inline uint32_t
+bit_rotr_u32(uint32_t x, int r)
+{
+ /* gcc recognises this code and generates a rotate instruction */
+ return ((x >> r) | (x << (32 - r)));
+}
+
+/**
+ * @copydoc bit_rotr_u32
+ */
+__attribute__ ((const)) inline uint64_t
+bit_rotr_u64(uint64_t x, int r)
+{
+ /* gcc recognises this code and generates a rotate instruction */
+ return ((x >> r) | (x << (64 - r)));
+}
+
+/**
+ * @brief Returns a byte order swapped integer @a x.
+ * This function does not take into account host architecture
+ * (as it done by htonl / ntohl functions) and always returns @a x
+ * with byte order swapped (BE -> LE if @a x is in BE and vice versa).
+ * @param x integer
+ * @return @a x with swapped bytes
+ */
+__attribute__ ((const)) inline uint32_t
+bswap_u32(uint32_t x)
+{
+#if defined(HAVE_BUILTIN_BSWAP32)
+ return __builtin_bswap32(x);
+#else /* !defined(HAVE_BUILTIN_BSWAP32) */
+ return ((x << 24) & UINT32_C(0xff000000)) |
+ ((x << 8) & UINT32_C(0x00ff0000)) |
+ ((x >> 8) & UINT32_C(0x0000ff00)) |
+ ((x >> 24) & UINT32_C(0x000000ff));
+#endif
+}
+
+/**
+ * @copydoc bswap_u32
+ */
+__attribute__ ((const)) inline uint64_t
+bswap_u64(uint64_t x)
+{
+#if defined(HAVE_BUILTIN_BSWAP64)
+ return __builtin_bswap64(x);
+#else /* !defined(HAVE_BUILTIN_BSWAP64) */
+ return ( (x << 56) & UINT64_C(0xff00000000000000)) |
+ ( (x << 40) & UINT64_C(0x00ff000000000000)) |
+ ( (x << 24) & UINT64_C(0x0000ff0000000000)) |
+ ( (x << 8) & UINT64_C(0x000000ff00000000)) |
+ ( (x >> 8) & UINT64_C(0x00000000ff000000)) |
+ ( (x >> 24) & UINT64_C(0x0000000000ff0000)) |
+ ( (x >> 40) & UINT64_C(0x000000000000ff00)) |
+ ( (x >> 56) & UINT64_C(0x00000000000000ff));
+#endif
+}
+
+/**
+ * @brief Index bits in the @a x, i.e. find all positions where bits are set.
+ * This method fills @a indexes array with found positions in increasing order.
+ * @a offset is added to each index before putting it into @a indexes.
+ * @param x integer
+ * @param indexes memory array where found indexes are stored
+ * @param offset a number added to each index
+ * @return pointer to last+1 element in indexes array
+ */
+int *
+bit_index_u32(uint32_t x, int *indexes, int offset);
+
+/**
+ * @copydoc bit_index_u32
+ */
+int *
+bit_index_u64(uint64_t x, int *indexes, int offset);
+
+#endif /* TARANTOOL_LIB_BIT_BIT_H_INCLUDED */
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d4dbfa486100af95f324917bda3e0c979bbab80d..6d4a02ce73c1eada33d14ed67336b59b7ad8bb74 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -143,6 +143,8 @@ endif()
set (common_libraries ${common_libraries} PARENT_SCOPE)
+add_subdirectory(lib)
+
function(tarantool_module mod)
set (module_sources ${ARGN})
set(cfg_c_flags "-Wno-unused -Wno-unused-parameter")
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b272b19473065f527ddd9c8fb0afdba7bfcd5e11
--- /dev/null
+++ b/src/lib/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(bit)
+
diff --git a/src/lib/bit/CMakeLists.txt b/src/lib/bit/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..96df0b6ba7d5d9d36ff7df3890428107b5b25605
--- /dev/null
+++ b/src/lib/bit/CMakeLists.txt
@@ -0,0 +1,40 @@
+check_builtin_function_exists("__builtin_ctz" HAVE_BUILTIN_CTZ)
+check_builtin_function_exists("__builtin_ctzll" HAVE_BUILTIN_CTZLL)
+check_builtin_function_exists("__builtin_clz" HAVE_BUILTIN_CLZ)
+check_builtin_function_exists("__builtin_clzll" HAVE_BUILTIN_CLZLL)
+check_builtin_function_exists("__builtin_popcount" HAVE_BUILTIN_POPCOUNT)
+check_builtin_function_exists("__builtin_popcountll" HAVE_BUILTIN_POPCOUNTLL)
+check_builtin_function_exists("__builtin_bswap32" HAVE_BUILTIN_BSWAP32)
+check_builtin_function_exists("__builtin_bswap64" HAVE_BUILTIN_BSWAP64)
+
+if (NOT HAVE_BUILTIN_CTZ OR NOT HAVE_BUILTIN_CTZLL)
+ # Check if -D_GNU_SOURCE has been defined and add this flag to
+ # CMAKE_REQUIRED_DEFINITIONS in order to get check_prototype_definition work
+ get_property(var DIRECTORY PROPERTY COMPILE_DEFINITIONS)
+ list(FIND var "_GNU_SOURCE" var)
+ if (NOT var EQUAL -1)
+ set(CMAKE_REQUIRED_FLAGS "-Wno-error")
+ set(CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE")
+ check_prototype_definition("ffsl" "int ffsl(long int i);" "0"
+ "string.h;strings.h" HAVE_FFSL)
+ check_prototype_definition("ffsll" "int ffsll(long long int i);" "0"
+ "string.h;strings.h" HAVE_FFSLL)
+ endif()
+endif()
+
+if ((HAVE_BUILTIN_CTZ OR HAVE_FFSL) AND
+ (HAVE_BUILTIN_CTZLL OR HAVE_FFSLL) AND
+ HAVE_BUILTIN_CLZ AND HAVE_BUILTIN_CLZLL AND
+ HAVE_BUILTIN_POPCOUNT AND HAVE_BUILTIN_POPCOUNTLL AND
+ HAVE_BUILTIN_BSWAP32 AND HAVE_BUILTIN_BSWAP64)
+ message(STATUS "Using compiler version of bit operations")
+else()
+ message(WARNING "Using slow implementation of bit operations")
+endif()
+
+set(lib_sources
+ bit.c
+)
+
+set_source_files_compile_flags(${lib_sources})
+add_library(bit STATIC ${lib_sources})
diff --git a/src/lib/bit/bit.c b/src/lib/bit/bit.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6af67a1522c0db96a5dae266513aad7e59a0345
--- /dev/null
+++ b/src/lib/bit/bit.c
@@ -0,0 +1,144 @@
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the
+ * following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <lib/bit/bit.h>
+
+__attribute__((const)) extern inline int
+bit_ctz_u32(uint32_t x);
+
+__attribute__((const)) extern inline int
+bit_ctz_u64(uint64_t x);
+
+__attribute__((const)) extern inline int
+bit_clz_u32(uint32_t x);
+
+__attribute__((const)) extern inline int
+bit_clz_u64(uint64_t x);
+
+__attribute__((const)) extern inline int
+bit_count_u32(uint32_t x);
+
+__attribute__((const)) extern inline int
+bit_count_u64(uint64_t x);
+
+__attribute__ ((const)) extern inline uint32_t
+bit_rotl_u32(uint32_t x, int r);
+
+__attribute__ ((const)) extern inline uint64_t
+bit_rotl_u64(uint64_t x, int r);
+
+__attribute__ ((const)) extern inline uint32_t
+bit_rotr_u32(uint32_t x, int r);
+
+__attribute__ ((const)) extern inline uint64_t
+bit_rotr_u64(uint64_t x, int r);
+
+__attribute__ ((const)) extern inline uint32_t
+bswap_u32(uint32_t x);
+
+__attribute__ ((const)) extern inline uint64_t
+bswap_u64(uint64_t x);
+
+#define BITINDEX_NAIVE(x, bitsize) { \
+ /* naive generic implementation, worst case */ \
+ typeof(x) bit = 1; \
+ int i = 0; \
+ for (int k = 0; k < bitsize; k++) { \
+ if (x & bit) { \
+ indexes[i++] = offset + k + 1; \
+ } \
+ bit <<= 1; \
+ } \
+ \
+ indexes[i] = 0; \
+ return indexes + i; \
+}
+
+int *
+bit_index_u32(uint32_t x, int *indexes, int offset)
+{
+#if defined(HAVE_BUILTIN_CTZ)
+ int prev_pos = 0;
+ int i = 0;
+
+#if defined(HAVE_BUILTIN_POPCOUNT)
+ /* fast implementation using built-in popcount function */
+ const int count = bit_count_u32(x);
+ while (i < count) {
+#else
+ /* sligtly slower implementation without using built-in popcount */
+ while(x) {
+#endif
+ /* use ctz */
+ const int a = bit_ctz_u32(x);
+
+ prev_pos += a + 1;
+ x >>= a;
+ x >>= 1;
+ indexes[i++] = offset + prev_pos;
+ }
+
+ indexes[i] = 0;
+ return indexes + i;
+#else /* !defined(HAVE_BUILTIN_CTZ) */
+ BITINDEX_NAIVE(x, sizeof(uint32_t) * CHAR_BIT);
+#endif
+}
+
+int *
+bit_index_u64(uint64_t x, int *indexes, int offset) {
+#if defined(HAVE_CTZLL)
+ int prev_pos = 0;
+ int i = 0;
+
+#if defined(HAVE_POPCOUNTLL)
+ /* fast implementation using built-in popcount function */
+ const int count = bit_count_u64(x);
+ while (i < count) {
+#else
+ /* sligtly slower implementation without using built-in popcount */
+ while(x) {
+#endif
+ /* use ctz */
+ const int a = bit_ctz_u64(x);
+
+ prev_pos += a + 1;
+ x >>= a;
+ x >>= 1;
+ indexes[i++] = offset + prev_pos;
+ }
+
+ indexes[i] = 0;
+ return indexes + i;
+#else /* !defined(HAVE_CTZ) */
+ BITINDEX_NAIVE(x, sizeof(uint64_t) * CHAR_BIT);
+#endif
+}
+
+#undef BITINDEX_NAIVE
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index 08db175ca2e9dc6a77421c081cf15077f6cdfc8c..0c84afb8971efb330bc5426e7c0476707d79bba6 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -8,6 +8,8 @@ add_executable(rope_basic rope_basic.c ${CMAKE_SOURCE_DIR}/src/rope.c)
add_executable(rope_avl rope_avl.c ${CMAKE_SOURCE_DIR}/src/rope.c)
add_executable(rope_stress rope_stress.c ${CMAKE_SOURCE_DIR}/src/rope.c)
add_executable(rope rope.c ${CMAKE_SOURCE_DIR}/src/rope.c)
+add_executable(bit_test bit.c bit.c)
+target_link_libraries(bit_test bit)
add_executable(objc_finally objc_finally.m)
add_executable(objc_catchcxx objc_catchcxx.m)
add_dependencies(objc_finally build_bundled_libs)
diff --git a/test/unit/bit.c b/test/unit/bit.c
new file mode 100644
index 0000000000000000000000000000000000000000..21aad1de313677613bfed5ad0a9ffa16aedd267e
--- /dev/null
+++ b/test/unit/bit.c
@@ -0,0 +1,169 @@
+#include <lib/bit/bit.h>
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <assert.h>
+
+#include "unit.h"
+
+static uint64_t vals[] = {
+ 0UL, 1UL, 2UL, 32768UL, 65535UL, 65536UL, 726075912UL, 858993459UL,
+ 1073741824UL, 1245250552UL, 1431655765UL, 1656977767UL, 2147483648UL,
+ 2283114629UL, 2502548245UL, 4294967295UL, 708915120906848425UL,
+ 1960191741125985428UL, 3689348814741910323UL, 5578377670650038654UL,
+ 9223372036854775808UL, 10755112315580060033UL, 11163782031541429823UL,
+ 13903686156871869732UL, 14237897302422917095UL, 14302190498657618739UL,
+ 15766411510232741269UL, 15984546468465238145UL, 18446744073709551615UL
+};
+
+static void
+test_ctz_clz(void)
+{
+ header();
+
+ for (size_t i = 0; i < sizeof(vals) / sizeof(vals[0]); i++) {
+ if (vals[i] == 0)
+ continue;
+
+ uint64_t val64 = vals[i];
+ uint32_t val32 = (uint32_t) vals[i];
+
+ printf("bit_ctz_u64(%" PRIu64 ") => %d\n", val64,
+ bit_ctz_u64(val64));
+ printf("bit_clz_u64(%" PRIu64 ") => %d\n", val64,
+ bit_clz_u64(val64));
+
+ if (vals[i] > UINT32_MAX)
+ continue;
+
+ printf("bit_ctz_u32(%" PRIu32 ") => %d\n", val32,
+ bit_ctz_u32(val32));
+ printf("bit_clz_u32(%" PRIu32 ") => %d\n", val32,
+ bit_clz_u32(val32));
+ }
+
+ footer();
+}
+
+static void
+test_count(void)
+{
+ header();
+
+ for (size_t i = 0; i < sizeof(vals) / sizeof(vals[0]); i++) {
+ uint64_t val64 = vals[i];
+ uint32_t val32 = (uint32_t) vals[i];
+
+ printf("bit_count_u64(%" PRIu64 ") => %d\n", val64,
+ bit_count_u64(val64));
+
+ if (vals[i] > UINT32_MAX)
+ continue;
+
+ printf("bit_count_u32(%" PRIu32 ") => %d\n", val32,
+ bit_count_u32(val32));
+ }
+
+ footer();
+}
+
+static void
+test_rotl_rotr_one(int rot)
+{
+ for (size_t i = 0; i < sizeof(vals) / sizeof(vals[0]); i++) {
+ uint64_t val64 = vals[i];
+ uint32_t val32 = (uint32_t) vals[i];
+
+ printf("bit_rotl_u64(%" PRIu64 ", %d) => %" PRIu64 "\n",
+ val64, rot, bit_rotl_u64(val64, rot));
+ printf("bit_rotr_u64(%" PRIu64 ", %d) => %" PRIu64 "\n",
+ val64, rot, bit_rotr_u64(val64, rot));
+
+ if (vals[i] > UINT32_MAX || rot > 32)
+ continue;
+
+ printf("bit_rotl_u32(%" PRIu32 ", %d) => %" PRIu32 "\n",
+ val32, rot, bit_rotl_u32(val32, rot));
+ printf("bit_rotr_u32(%" PRIu32 ", %d) => %" PRIu32 "\n",
+ val32, rot, bit_rotr_u32(val32, rot));
+ }
+}
+
+static void
+test_rotl_rotr(void)
+{
+ header();
+
+ int rots[] = { 0, 1, 15, 16, 31, 32, 63, 64 };
+ for (int r = 0; r < sizeof(rots) / sizeof(rots[0]); r++) {
+ test_rotl_rotr_one(rots[r]);
+ }
+
+ footer();
+}
+
+static void
+test_bswap(void)
+{
+ header();
+
+ for (size_t i = 0; i < sizeof(vals) / sizeof(vals[0]); i++) {
+ uint64_t val64 = vals[i];
+ uint32_t val32 = (uint32_t) vals[i];
+
+ printf("bswap_u64(%" PRIu64 ") => %" PRIu64 "\n", val64,
+ bswap_u64(val64));
+
+ if (vals[i] > UINT32_MAX)
+ continue;
+
+ printf("bswap_u32(%" PRIu32 ") => %" PRIu32 "\n", val32,
+ bswap_u32(val32));
+ }
+
+ footer();
+}
+
+static inline void
+test_index_print(const int *start, const int *end)
+{
+ for (const int *cur = start; cur < end; cur++) {
+ printf("%d ", *cur);
+ }
+}
+
+static void
+test_index(void)
+{
+ header();
+
+ int indexes[sizeof(int64_t) * CHAR_BIT];
+
+ for (size_t i = 0; i < sizeof(vals) / sizeof(vals[0]); i++) {
+ uint64_t val64 = vals[i];
+ uint32_t val32 = (uint32_t) vals[i];
+
+ printf("bit_index_u64(%" PRIu64 ", *, -1) => ", val64);
+ test_index_print(indexes, bit_index_u64(val64, indexes, -1));
+ printf("\n");
+
+ if (vals[i] > UINT32_MAX)
+ continue;
+
+ printf("bit_index_u32(%" PRIu32 ", *, -1) => ", val32);
+ test_index_print(indexes, bit_index_u32(val32, indexes, -1));
+ printf("\n");
+ }
+
+ footer();
+}
+
+int
+main(void)
+{
+ test_ctz_clz();
+ test_count();
+ test_rotl_rotr();
+ test_bswap();
+ test_index();
+}
diff --git a/test/unit/bit.result b/test/unit/bit.result
new file mode 100644
index 0000000000000000000000000000000000000000..dbb0193faa774c2eb6923ffb2742b5f5e52f994a
--- /dev/null
+++ b/test/unit/bit.result
@@ -0,0 +1,888 @@
+ *** test_ctz_clz ***
+bit_ctz_u64(1) => 0
+bit_clz_u64(1) => 63
+bit_ctz_u32(1) => 0
+bit_clz_u32(1) => 31
+bit_ctz_u64(2) => 1
+bit_clz_u64(2) => 62
+bit_ctz_u32(2) => 1
+bit_clz_u32(2) => 30
+bit_ctz_u64(32768) => 15
+bit_clz_u64(32768) => 48
+bit_ctz_u32(32768) => 15
+bit_clz_u32(32768) => 16
+bit_ctz_u64(65535) => 0
+bit_clz_u64(65535) => 48
+bit_ctz_u32(65535) => 0
+bit_clz_u32(65535) => 16
+bit_ctz_u64(65536) => 16
+bit_clz_u64(65536) => 47
+bit_ctz_u32(65536) => 16
+bit_clz_u32(65536) => 15
+bit_ctz_u64(726075912) => 3
+bit_clz_u64(726075912) => 34
+bit_ctz_u32(726075912) => 3
+bit_clz_u32(726075912) => 2
+bit_ctz_u64(858993459) => 0
+bit_clz_u64(858993459) => 34
+bit_ctz_u32(858993459) => 0
+bit_clz_u32(858993459) => 2
+bit_ctz_u64(1073741824) => 30
+bit_clz_u64(1073741824) => 33
+bit_ctz_u32(1073741824) => 30
+bit_clz_u32(1073741824) => 1
+bit_ctz_u64(1245250552) => 3
+bit_clz_u64(1245250552) => 33
+bit_ctz_u32(1245250552) => 3
+bit_clz_u32(1245250552) => 1
+bit_ctz_u64(1431655765) => 0
+bit_clz_u64(1431655765) => 33
+bit_ctz_u32(1431655765) => 0
+bit_clz_u32(1431655765) => 1
+bit_ctz_u64(1656977767) => 0
+bit_clz_u64(1656977767) => 33
+bit_ctz_u32(1656977767) => 0
+bit_clz_u32(1656977767) => 1
+bit_ctz_u64(2147483648) => 31
+bit_clz_u64(2147483648) => 32
+bit_ctz_u32(2147483648) => 31
+bit_clz_u32(2147483648) => 0
+bit_ctz_u64(2283114629) => 0
+bit_clz_u64(2283114629) => 32
+bit_ctz_u32(2283114629) => 0
+bit_clz_u32(2283114629) => 0
+bit_ctz_u64(2502548245) => 0
+bit_clz_u64(2502548245) => 32
+bit_ctz_u32(2502548245) => 0
+bit_clz_u32(2502548245) => 0
+bit_ctz_u64(4294967295) => 0
+bit_clz_u64(4294967295) => 32
+bit_ctz_u32(4294967295) => 0
+bit_clz_u32(4294967295) => 0
+bit_ctz_u64(708915120906848425) => 0
+bit_clz_u64(708915120906848425) => 4
+bit_ctz_u64(1960191741125985428) => 2
+bit_clz_u64(1960191741125985428) => 3
+bit_ctz_u64(3689348814741910323) => 0
+bit_clz_u64(3689348814741910323) => 2
+bit_ctz_u64(5578377670650038654) => 1
+bit_clz_u64(5578377670650038654) => 1
+bit_ctz_u64(9223372036854775808) => 63
+bit_clz_u64(9223372036854775808) => 0
+bit_ctz_u64(10755112315580060033) => 0
+bit_clz_u64(10755112315580060033) => 0
+bit_ctz_u64(11163782031541429823) => 0
+bit_clz_u64(11163782031541429823) => 0
+bit_ctz_u64(13903686156871869732) => 2
+bit_clz_u64(13903686156871869732) => 0
+bit_ctz_u64(14237897302422917095) => 0
+bit_clz_u64(14237897302422917095) => 0
+bit_ctz_u64(14302190498657618739) => 0
+bit_clz_u64(14302190498657618739) => 0
+bit_ctz_u64(15766411510232741269) => 0
+bit_clz_u64(15766411510232741269) => 0
+bit_ctz_u64(15984546468465238145) => 0
+bit_clz_u64(15984546468465238145) => 0
+bit_ctz_u64(18446744073709551615) => 0
+bit_clz_u64(18446744073709551615) => 0
+ *** test_ctz_clz: done ***
+ *** test_count ***
+bit_count_u64(0) => 0
+bit_count_u32(0) => 0
+bit_count_u64(1) => 1
+bit_count_u32(1) => 1
+bit_count_u64(2) => 1
+bit_count_u32(2) => 1
+bit_count_u64(32768) => 1
+bit_count_u32(32768) => 1
+bit_count_u64(65535) => 16
+bit_count_u32(65535) => 16
+bit_count_u64(65536) => 1
+bit_count_u32(65536) => 1
+bit_count_u64(726075912) => 11
+bit_count_u32(726075912) => 11
+bit_count_u64(858993459) => 16
+bit_count_u32(858993459) => 16
+bit_count_u64(1073741824) => 1
+bit_count_u32(1073741824) => 1
+bit_count_u64(1245250552) => 14
+bit_count_u32(1245250552) => 14
+bit_count_u64(1431655765) => 16
+bit_count_u32(1431655765) => 16
+bit_count_u64(1656977767) => 17
+bit_count_u32(1656977767) => 17
+bit_count_u64(2147483648) => 1
+bit_count_u32(2147483648) => 1
+bit_count_u64(2283114629) => 10
+bit_count_u32(2283114629) => 10
+bit_count_u64(2502548245) => 16
+bit_count_u32(2502548245) => 16
+bit_count_u64(4294967295) => 32
+bit_count_u32(4294967295) => 32
+bit_count_u64(708915120906848425) => 29
+bit_count_u64(1960191741125985428) => 19
+bit_count_u64(3689348814741910323) => 32
+bit_count_u64(5578377670650038654) => 31
+bit_count_u64(9223372036854775808) => 1
+bit_count_u64(10755112315580060033) => 24
+bit_count_u64(11163782031541429823) => 35
+bit_count_u64(13903686156871869732) => 28
+bit_count_u64(14237897302422917095) => 33
+bit_count_u64(14302190498657618739) => 37
+bit_count_u64(15766411510232741269) => 33
+bit_count_u64(15984546468465238145) => 25
+bit_count_u64(18446744073709551615) => 64
+ *** test_count: done ***
+ *** test_rotl_rotr ***
+bit_rotl_u64(0, 0) => 0
+bit_rotr_u64(0, 0) => 0
+bit_rotl_u32(0, 0) => 0
+bit_rotr_u32(0, 0) => 0
+bit_rotl_u64(1, 0) => 1
+bit_rotr_u64(1, 0) => 1
+bit_rotl_u32(1, 0) => 1
+bit_rotr_u32(1, 0) => 1
+bit_rotl_u64(2, 0) => 2
+bit_rotr_u64(2, 0) => 2
+bit_rotl_u32(2, 0) => 2
+bit_rotr_u32(2, 0) => 2
+bit_rotl_u64(32768, 0) => 32768
+bit_rotr_u64(32768, 0) => 32768
+bit_rotl_u32(32768, 0) => 32768
+bit_rotr_u32(32768, 0) => 32768
+bit_rotl_u64(65535, 0) => 65535
+bit_rotr_u64(65535, 0) => 65535
+bit_rotl_u32(65535, 0) => 65535
+bit_rotr_u32(65535, 0) => 65535
+bit_rotl_u64(65536, 0) => 65536
+bit_rotr_u64(65536, 0) => 65536
+bit_rotl_u32(65536, 0) => 65536
+bit_rotr_u32(65536, 0) => 65536
+bit_rotl_u64(726075912, 0) => 726075912
+bit_rotr_u64(726075912, 0) => 726075912
+bit_rotl_u32(726075912, 0) => 726075912
+bit_rotr_u32(726075912, 0) => 726075912
+bit_rotl_u64(858993459, 0) => 858993459
+bit_rotr_u64(858993459, 0) => 858993459
+bit_rotl_u32(858993459, 0) => 858993459
+bit_rotr_u32(858993459, 0) => 858993459
+bit_rotl_u64(1073741824, 0) => 1073741824
+bit_rotr_u64(1073741824, 0) => 1073741824
+bit_rotl_u32(1073741824, 0) => 1073741824
+bit_rotr_u32(1073741824, 0) => 1073741824
+bit_rotl_u64(1245250552, 0) => 1245250552
+bit_rotr_u64(1245250552, 0) => 1245250552
+bit_rotl_u32(1245250552, 0) => 1245250552
+bit_rotr_u32(1245250552, 0) => 1245250552
+bit_rotl_u64(1431655765, 0) => 1431655765
+bit_rotr_u64(1431655765, 0) => 1431655765
+bit_rotl_u32(1431655765, 0) => 1431655765
+bit_rotr_u32(1431655765, 0) => 1431655765
+bit_rotl_u64(1656977767, 0) => 1656977767
+bit_rotr_u64(1656977767, 0) => 1656977767
+bit_rotl_u32(1656977767, 0) => 1656977767
+bit_rotr_u32(1656977767, 0) => 1656977767
+bit_rotl_u64(2147483648, 0) => 2147483648
+bit_rotr_u64(2147483648, 0) => 2147483648
+bit_rotl_u32(2147483648, 0) => 2147483648
+bit_rotr_u32(2147483648, 0) => 2147483648
+bit_rotl_u64(2283114629, 0) => 2283114629
+bit_rotr_u64(2283114629, 0) => 2283114629
+bit_rotl_u32(2283114629, 0) => 2283114629
+bit_rotr_u32(2283114629, 0) => 2283114629
+bit_rotl_u64(2502548245, 0) => 2502548245
+bit_rotr_u64(2502548245, 0) => 2502548245
+bit_rotl_u32(2502548245, 0) => 2502548245
+bit_rotr_u32(2502548245, 0) => 2502548245
+bit_rotl_u64(4294967295, 0) => 4294967295
+bit_rotr_u64(4294967295, 0) => 4294967295
+bit_rotl_u32(4294967295, 0) => 4294967295
+bit_rotr_u32(4294967295, 0) => 4294967295
+bit_rotl_u64(708915120906848425, 0) => 708915120906848425
+bit_rotr_u64(708915120906848425, 0) => 708915120906848425
+bit_rotl_u64(1960191741125985428, 0) => 1960191741125985428
+bit_rotr_u64(1960191741125985428, 0) => 1960191741125985428
+bit_rotl_u64(3689348814741910323, 0) => 3689348814741910323
+bit_rotr_u64(3689348814741910323, 0) => 3689348814741910323
+bit_rotl_u64(5578377670650038654, 0) => 5578377670650038654
+bit_rotr_u64(5578377670650038654, 0) => 5578377670650038654
+bit_rotl_u64(9223372036854775808, 0) => 9223372036854775808
+bit_rotr_u64(9223372036854775808, 0) => 9223372036854775808
+bit_rotl_u64(10755112315580060033, 0) => 10755112315580060033
+bit_rotr_u64(10755112315580060033, 0) => 10755112315580060033
+bit_rotl_u64(11163782031541429823, 0) => 11163782031541429823
+bit_rotr_u64(11163782031541429823, 0) => 11163782031541429823
+bit_rotl_u64(13903686156871869732, 0) => 13903686156871869732
+bit_rotr_u64(13903686156871869732, 0) => 13903686156871869732
+bit_rotl_u64(14237897302422917095, 0) => 14237897302422917095
+bit_rotr_u64(14237897302422917095, 0) => 14237897302422917095
+bit_rotl_u64(14302190498657618739, 0) => 14302190498657618739
+bit_rotr_u64(14302190498657618739, 0) => 14302190498657618739
+bit_rotl_u64(15766411510232741269, 0) => 15766411510232741269
+bit_rotr_u64(15766411510232741269, 0) => 15766411510232741269
+bit_rotl_u64(15984546468465238145, 0) => 15984546468465238145
+bit_rotr_u64(15984546468465238145, 0) => 15984546468465238145
+bit_rotl_u64(18446744073709551615, 0) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 0) => 18446744073709551615
+bit_rotl_u64(0, 1) => 0
+bit_rotr_u64(0, 1) => 0
+bit_rotl_u32(0, 1) => 0
+bit_rotr_u32(0, 1) => 0
+bit_rotl_u64(1, 1) => 2
+bit_rotr_u64(1, 1) => 9223372036854775808
+bit_rotl_u32(1, 1) => 2
+bit_rotr_u32(1, 1) => 2147483648
+bit_rotl_u64(2, 1) => 4
+bit_rotr_u64(2, 1) => 1
+bit_rotl_u32(2, 1) => 4
+bit_rotr_u32(2, 1) => 1
+bit_rotl_u64(32768, 1) => 65536
+bit_rotr_u64(32768, 1) => 16384
+bit_rotl_u32(32768, 1) => 65536
+bit_rotr_u32(32768, 1) => 16384
+bit_rotl_u64(65535, 1) => 131070
+bit_rotr_u64(65535, 1) => 9223372036854808575
+bit_rotl_u32(65535, 1) => 131070
+bit_rotr_u32(65535, 1) => 2147516415
+bit_rotl_u64(65536, 1) => 131072
+bit_rotr_u64(65536, 1) => 32768
+bit_rotl_u32(65536, 1) => 131072
+bit_rotr_u32(65536, 1) => 32768
+bit_rotl_u64(726075912, 1) => 1452151824
+bit_rotr_u64(726075912, 1) => 363037956
+bit_rotl_u32(726075912, 1) => 1452151824
+bit_rotr_u32(726075912, 1) => 363037956
+bit_rotl_u64(858993459, 1) => 1717986918
+bit_rotr_u64(858993459, 1) => 9223372037284272537
+bit_rotl_u32(858993459, 1) => 1717986918
+bit_rotr_u32(858993459, 1) => 2576980377
+bit_rotl_u64(1073741824, 1) => 2147483648
+bit_rotr_u64(1073741824, 1) => 536870912
+bit_rotl_u32(1073741824, 1) => 2147483648
+bit_rotr_u32(1073741824, 1) => 536870912
+bit_rotl_u64(1245250552, 1) => 2490501104
+bit_rotr_u64(1245250552, 1) => 622625276
+bit_rotl_u32(1245250552, 1) => 2490501104
+bit_rotr_u32(1245250552, 1) => 622625276
+bit_rotl_u64(1431655765, 1) => 2863311530
+bit_rotr_u64(1431655765, 1) => 9223372037570603690
+bit_rotl_u32(1431655765, 1) => 2863311530
+bit_rotr_u32(1431655765, 1) => 2863311530
+bit_rotl_u64(1656977767, 1) => 3313955534
+bit_rotr_u64(1656977767, 1) => 9223372037683264691
+bit_rotl_u32(1656977767, 1) => 3313955534
+bit_rotr_u32(1656977767, 1) => 2975972531
+bit_rotl_u64(2147483648, 1) => 4294967296
+bit_rotr_u64(2147483648, 1) => 1073741824
+bit_rotl_u32(2147483648, 1) => 1
+bit_rotr_u32(2147483648, 1) => 1073741824
+bit_rotl_u64(2283114629, 1) => 4566229258
+bit_rotr_u64(2283114629, 1) => 9223372037996333122
+bit_rotl_u32(2283114629, 1) => 271261963
+bit_rotr_u32(2283114629, 1) => 3289040962
+bit_rotl_u64(2502548245, 1) => 5005096490
+bit_rotr_u64(2502548245, 1) => 9223372038106049930
+bit_rotl_u32(2502548245, 1) => 710129195
+bit_rotr_u32(2502548245, 1) => 3398757770
+bit_rotl_u64(4294967295, 1) => 8589934590
+bit_rotr_u64(4294967295, 1) => 9223372039002259455
+bit_rotl_u32(4294967295, 1) => 4294967295
+bit_rotr_u32(4294967295, 1) => 4294967295
+bit_rotl_u64(708915120906848425, 1) => 1417830241813696850
+bit_rotr_u64(708915120906848425, 1) => 9577829597308200020
+bit_rotl_u64(1960191741125985428, 1) => 3920383482251970856
+bit_rotr_u64(1960191741125985428, 1) => 980095870562992714
+bit_rotl_u64(3689348814741910323, 1) => 7378697629483820646
+bit_rotr_u64(3689348814741910323, 1) => 11068046444225730969
+bit_rotl_u64(5578377670650038654, 1) => 11156755341300077308
+bit_rotr_u64(5578377670650038654, 1) => 2789188835325019327
+bit_rotl_u64(9223372036854775808, 1) => 1
+bit_rotr_u64(9223372036854775808, 1) => 4611686018427387904
+bit_rotl_u64(10755112315580060033, 1) => 3063480557450568451
+bit_rotr_u64(10755112315580060033, 1) => 14600928194644805824
+bit_rotl_u64(11163782031541429823, 1) => 3880819989373308031
+bit_rotr_u64(11163782031541429823, 1) => 14805263052625490719
+bit_rotl_u64(13903686156871869732, 1) => 9360628240034187849
+bit_rotr_u64(13903686156871869732, 1) => 6951843078435934866
+bit_rotl_u64(14237897302422917095, 1) => 10029050531136282575
+bit_rotr_u64(14237897302422917095, 1) => 16342320688066234355
+bit_rotl_u64(14302190498657618739, 1) => 10157636923605685863
+bit_rotr_u64(14302190498657618739, 1) => 16374467286183585177
+bit_rotl_u64(15766411510232741269, 1) => 13086078946755930923
+bit_rotr_u64(15766411510232741269, 1) => 17106577791971146442
+bit_rotl_u64(15984546468465238145, 1) => 13522348863220924675
+bit_rotr_u64(15984546468465238145, 1) => 17215645271087394880
+bit_rotl_u64(18446744073709551615, 1) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 1) => 18446744073709551615
+bit_rotl_u64(0, 15) => 0
+bit_rotr_u64(0, 15) => 0
+bit_rotl_u32(0, 15) => 0
+bit_rotr_u32(0, 15) => 0
+bit_rotl_u64(1, 15) => 32768
+bit_rotr_u64(1, 15) => 562949953421312
+bit_rotl_u32(1, 15) => 32768
+bit_rotr_u32(1, 15) => 131072
+bit_rotl_u64(2, 15) => 65536
+bit_rotr_u64(2, 15) => 1125899906842624
+bit_rotl_u32(2, 15) => 65536
+bit_rotr_u32(2, 15) => 262144
+bit_rotl_u64(32768, 15) => 1073741824
+bit_rotr_u64(32768, 15) => 1
+bit_rotl_u32(32768, 15) => 1073741824
+bit_rotr_u32(32768, 15) => 1
+bit_rotl_u64(65535, 15) => 2147450880
+bit_rotr_u64(65535, 15) => 18446181123756130305
+bit_rotl_u32(65535, 15) => 2147450880
+bit_rotr_u32(65535, 15) => 4294836225
+bit_rotl_u64(65536, 15) => 2147483648
+bit_rotr_u64(65536, 15) => 2
+bit_rotl_u32(65536, 15) => 2147483648
+bit_rotr_u32(65536, 15) => 2
+bit_rotl_u64(726075912, 15) => 23792055484416
+bit_rotr_u64(726075912, 15) => 1445655480385951374
+bit_rotl_u32(726075912, 15) => 2231637411
+bit_rotr_u32(726075912, 15) => 336615054
+bit_rotl_u64(858993459, 15) => 28147497664512
+bit_rotr_u64(858993459, 15) => 7378585039493162598
+bit_rotl_u32(858993459, 15) => 2576980377
+bit_rotr_u32(858993459, 15) => 1717986918
+bit_rotl_u64(1073741824, 15) => 35184372088832
+bit_rotr_u64(1073741824, 15) => 32768
+bit_rotl_u32(1073741824, 15) => 8192
+bit_rotr_u32(1073741824, 15) => 32768
+bit_rotl_u64(1245250552, 15) => 40804370087936
+bit_rotr_u64(1245250552, 15) => 571957152676090994
+bit_rotl_u32(1245250552, 15) => 2180785436
+bit_rotr_u32(1245250552, 15) => 133207154
+bit_rotl_u64(1431655765, 15) => 46912496107520
+bit_rotr_u64(1431655765, 15) => 12297641732488604330
+bit_rotl_u32(1431655765, 15) => 2863311530
+bit_rotr_u32(1431655765, 15) => 2863311530
+bit_rotl_u64(1656977767, 15) => 54295847469056
+bit_rotr_u64(1656977767, 15) => 17495921602381006214
+bit_rotl_u32(1656977767, 15) => 3165892961
+bit_rotr_u32(1656977767, 15) => 4073637254
+bit_rotl_u64(2147483648, 15) => 70368744177664
+bit_rotr_u64(2147483648, 15) => 65536
+bit_rotl_u32(2147483648, 15) => 16384
+bit_rotr_u32(2147483648, 15) => 65536
+bit_rotl_u64(2283114629, 15) => 74813100163072
+bit_rotr_u64(2283114629, 15) => 2380715353018798123
+bit_rotl_u32(2283114629, 15) => 3359818762
+bit_rotr_u32(2283114629, 15) => 554373163
+bit_rotl_u64(2502548245, 15) => 82003500892160
+bit_rotr_u64(2502548245, 15) => 13126304063924808275
+bit_rotl_u32(2502548245, 15) => 3985296020
+bit_rotr_u32(2502548245, 15) => 3056282195
+bit_rotl_u64(4294967295, 15) => 140737488322560
+bit_rotr_u64(4294967295, 15) => 18446181123756261375
+bit_rotl_u32(4294967295, 15) => 4294967295
+bit_rotr_u32(4294967295, 15) => 4294967295
+bit_rotl_u64(708915120906848425, 15) => 5279893075283707115
+bit_rotr_u64(708915120906848425, 15) => 10471453717962410780
+bit_rotl_u64(1960191741125985428, 15) => 108559631781274
+bit_rotr_u64(1960191741125985428, 15) => 659837165714377456
+bit_rotl_u64(3689348814741910323, 15) => 11068046444225730969
+bit_rotr_u64(3689348814741910323, 15) => 7378697629483820646
+bit_rotl_u64(5578377670650038654, 15) => 3492485472519661237
+bit_rotr_u64(5578377670650038654, 15) => 1368138625390162978
+bit_rotl_u64(9223372036854775808, 15) => 16384
+bit_rotr_u64(9223372036854775808, 15) => 281474976710656
+bit_rotl_u64(10755112315580060033, 15) => 16921572780133108384
+bit_rotr_u64(10755112315580060033, 15) => 2522906961261232936
+bit_rotl_u64(11163782031541429823, 15) => 15874627889163914614
+bit_rotr_u64(11163782031541429823, 15) => 14735555722393159636
+bit_rotl_u64(13903686156871869732, 15) => 16749599972631142521
+bit_rotr_u64(13903686156871869732, 15) => 5352952463958352314
+bit_rotl_u64(14237897302422917095, 15) => 10814437605877473995
+bit_rotr_u64(14237897302422917095, 15) => 2292203766521423570
+bit_rotl_u64(14302190498657618739, 15) => 14645067421692060477
+bit_rotr_u64(14302190498657618739, 15) => 10837786021529578728
+bit_rotl_u64(15766411510232741269, 15) => 14257838996763372902
+bit_rotr_u64(15766411510232741269, 15) => 16945837700629926938
+bit_rotl_u64(15984546468465238145, 15) => 4767449759914979050
+bit_rotr_u64(15984546468465238145, 15) => 13908166408919157040
+bit_rotl_u64(18446744073709551615, 15) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 15) => 18446744073709551615
+bit_rotl_u64(0, 16) => 0
+bit_rotr_u64(0, 16) => 0
+bit_rotl_u32(0, 16) => 0
+bit_rotr_u32(0, 16) => 0
+bit_rotl_u64(1, 16) => 65536
+bit_rotr_u64(1, 16) => 281474976710656
+bit_rotl_u32(1, 16) => 65536
+bit_rotr_u32(1, 16) => 65536
+bit_rotl_u64(2, 16) => 131072
+bit_rotr_u64(2, 16) => 562949953421312
+bit_rotl_u32(2, 16) => 131072
+bit_rotr_u32(2, 16) => 131072
+bit_rotl_u64(32768, 16) => 2147483648
+bit_rotr_u64(32768, 16) => 9223372036854775808
+bit_rotl_u32(32768, 16) => 2147483648
+bit_rotr_u32(32768, 16) => 2147483648
+bit_rotl_u64(65535, 16) => 4294901760
+bit_rotr_u64(65535, 16) => 18446462598732840960
+bit_rotl_u32(65535, 16) => 4294901760
+bit_rotr_u32(65535, 16) => 4294901760
+bit_rotl_u64(65536, 16) => 4294967296
+bit_rotr_u64(65536, 16) => 1
+bit_rotl_u32(65536, 16) => 1
+bit_rotr_u32(65536, 16) => 1
+bit_rotl_u64(726075912, 16) => 47584110968832
+bit_rotr_u64(726075912, 16) => 722827740192975687
+bit_rotl_u32(726075912, 16) => 168307527
+bit_rotr_u32(726075912, 16) => 168307527
+bit_rotl_u64(858993459, 16) => 56294995329024
+bit_rotr_u64(858993459, 16) => 3689292519746581299
+bit_rotl_u32(858993459, 16) => 858993459
+bit_rotr_u32(858993459, 16) => 858993459
+bit_rotl_u64(1073741824, 16) => 70368744177664
+bit_rotr_u64(1073741824, 16) => 16384
+bit_rotl_u32(1073741824, 16) => 16384
+bit_rotr_u32(1073741824, 16) => 16384
+bit_rotl_u64(1245250552, 16) => 81608740175872
+bit_rotr_u64(1245250552, 16) => 285978576338045497
+bit_rotl_u32(1245250552, 16) => 66603577
+bit_rotr_u32(1245250552, 16) => 66603577
+bit_rotl_u64(1431655765, 16) => 93824992215040
+bit_rotr_u64(1431655765, 16) => 6148820866244302165
+bit_rotl_u32(1431655765, 16) => 1431655765
+bit_rotr_u32(1431655765, 16) => 1431655765
+bit_rotl_u64(1656977767, 16) => 108591694938112
+bit_rotr_u64(1656977767, 16) => 8747960801190503107
+bit_rotl_u32(1656977767, 16) => 2036818627
+bit_rotr_u32(1656977767, 16) => 2036818627
+bit_rotl_u64(2147483648, 16) => 140737488355328
+bit_rotr_u64(2147483648, 16) => 32768
+bit_rotl_u32(2147483648, 16) => 32768
+bit_rotr_u32(2147483648, 16) => 32768
+bit_rotl_u64(2283114629, 16) => 149626200326144
+bit_rotr_u64(2283114629, 16) => 10413729713364174869
+bit_rotl_u32(2283114629, 16) => 2424670229
+bit_rotr_u32(2283114629, 16) => 2424670229
+bit_rotl_u64(2502548245, 16) => 164007001784320
+bit_rotr_u64(2502548245, 16) => 15786524068817179945
+bit_rotl_u32(2502548245, 16) => 3675624745
+bit_rotr_u32(2502548245, 16) => 3675624745
+bit_rotl_u64(4294967295, 16) => 281474976645120
+bit_rotr_u64(4294967295, 16) => 18446462598732906495
+bit_rotl_u32(4294967295, 16) => 4294967295
+bit_rotr_u32(4294967295, 16) => 4294967295
+bit_rotl_u64(708915120906848425, 16) => 10559786150567414230
+bit_rotr_u64(708915120906848425, 16) => 5235726858981205390
+bit_rotl_u64(1960191741125985428, 16) => 217119263562548
+bit_rotr_u64(1960191741125985428, 16) => 329918582857188728
+bit_rotl_u64(3689348814741910323, 16) => 3689348814741910323
+bit_rotr_u64(3689348814741910323, 16) => 3689348814741910323
+bit_rotl_u64(5578377670650038654, 16) => 6984970945039322474
+bit_rotr_u64(5578377670650038654, 16) => 684069312695081489
+bit_rotl_u64(9223372036854775808, 16) => 32768
+bit_rotr_u64(9223372036854775808, 16) => 140737488355328
+bit_rotl_u64(10755112315580060033, 16) => 15396401486556665153
+bit_rotr_u64(10755112315580060033, 16) => 1261453480630616468
+bit_rotl_u64(11163782031541429823, 16) => 13302511704618277613
+bit_rotr_u64(11163782031541429823, 16) => 7367777861196579818
+bit_rotl_u64(13903686156871869732, 16) => 15052455871552733427
+bit_rotr_u64(13903686156871869732, 16) => 2676476231979176157
+bit_rotl_u64(14237897302422917095, 16) => 3182131138045396375
+bit_rotr_u64(14237897302422917095, 16) => 1146101883260711785
+bit_rotl_u64(14302190498657618739, 16) => 10843390769674569339
+bit_rotr_u64(14302190498657618739, 16) => 5418893010764789364
+bit_rotl_u64(15766411510232741269, 16) => 10068933919817194189
+bit_rotr_u64(15766411510232741269, 16) => 8472918850314963469
+bit_rotl_u64(15984546468465238145, 16) => 9534899519829958100
+bit_rotr_u64(15984546468465238145, 16) => 6954083204459578520
+bit_rotl_u64(18446744073709551615, 16) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 16) => 18446744073709551615
+bit_rotl_u64(0, 31) => 0
+bit_rotr_u64(0, 31) => 0
+bit_rotl_u32(0, 31) => 0
+bit_rotr_u32(0, 31) => 0
+bit_rotl_u64(1, 31) => 2147483648
+bit_rotr_u64(1, 31) => 8589934592
+bit_rotl_u32(1, 31) => 2147483648
+bit_rotr_u32(1, 31) => 2
+bit_rotl_u64(2, 31) => 4294967296
+bit_rotr_u64(2, 31) => 17179869184
+bit_rotl_u32(2, 31) => 1
+bit_rotr_u32(2, 31) => 4
+bit_rotl_u64(32768, 31) => 70368744177664
+bit_rotr_u64(32768, 31) => 281474976710656
+bit_rotl_u32(32768, 31) => 16384
+bit_rotr_u32(32768, 31) => 65536
+bit_rotl_u64(65535, 31) => 140735340871680
+bit_rotr_u64(65535, 31) => 562941363486720
+bit_rotl_u32(65535, 31) => 2147516415
+bit_rotr_u32(65535, 31) => 131070
+bit_rotl_u64(65536, 31) => 140737488355328
+bit_rotr_u64(65536, 31) => 562949953421312
+bit_rotl_u32(65536, 31) => 32768
+bit_rotr_u32(65536, 31) => 131072
+bit_rotl_u64(726075912, 31) => 1559236148226686976
+bit_rotr_u64(726075912, 31) => 6236944592906747904
+bit_rotl_u32(726075912, 31) => 363037956
+bit_rotr_u32(726075912, 31) => 1452151824
+bit_rotl_u64(858993459, 31) => 1844674406941458432
+bit_rotr_u64(858993459, 31) => 7378697627765833728
+bit_rotl_u32(858993459, 31) => 2576980377
+bit_rotr_u32(858993459, 31) => 1717986918
+bit_rotl_u64(1073741824, 31) => 2305843009213693952
+bit_rotr_u64(1073741824, 31) => 9223372036854775808
+bit_rotl_u32(1073741824, 31) => 536870912
+bit_rotr_u32(1073741824, 31) => 2147483648
+bit_rotl_u64(1245250552, 31) => 2674155198082973696
+bit_rotr_u64(1245250552, 31) => 10696620792331894784
+bit_rotl_u32(1245250552, 31) => 622625276
+bit_rotr_u32(1245250552, 31) => 2490501104
+bit_rotl_u64(1431655765, 31) => 3074457344902430720
+bit_rotr_u64(1431655765, 31) => 12297829379609722880
+bit_rotl_u32(1431655765, 31) => 2863311530
+bit_rotr_u32(1431655765, 31) => 2863311530
+bit_rotl_u64(1656977767, 31) => 3558332659732054016
+bit_rotr_u64(1656977767, 31) => 14233330638928216064
+bit_rotl_u32(1656977767, 31) => 2975972531
+bit_rotr_u32(1656977767, 31) => 3313955534
+bit_rotl_u64(2147483648, 31) => 4611686018427387904
+bit_rotr_u64(2147483648, 31) => 1
+bit_rotl_u32(2147483648, 31) => 1073741824
+bit_rotr_u32(2147483648, 31) => 1
+bit_rotl_u64(2283114629, 31) => 4902951332287086592
+bit_rotr_u64(2283114629, 31) => 1165061255438794753
+bit_rotl_u32(2283114629, 31) => 3289040962
+bit_rotr_u32(2283114629, 31) => 271261963
+bit_rotl_u64(2502548245, 31) => 5374181434468597760
+bit_rotr_u64(2502548245, 31) => 3049981664164839425
+bit_rotl_u32(2502548245, 31) => 3398757770
+bit_rotr_u32(2502548245, 31) => 710129195
+bit_rotl_u64(4294967295, 31) => 9223372034707292160
+bit_rotr_u64(4294967295, 31) => 18446744065119617025
+bit_rotl_u32(4294967295, 31) => 4294967295
+bit_rotr_u32(4294967295, 31) => 4294967295
+bit_rotl_u64(708915120906848425, 31) => 17493991222969846085
+bit_rotr_u64(708915120906848425, 31) => 14635732670750729495
+bit_rotl_u64(1960191741125985428, 31) => 7114564028417572864
+bit_rotr_u64(1960191741125985428, 31) => 10011512039960739841
+bit_rotl_u64(3689348814741910323, 31) => 11068046444225730969
+bit_rotr_u64(3689348814741910323, 31) => 7378697629483820646
+bit_rotl_u64(5578377670650038654, 31) => 14774204534111940727
+bit_rotr_u64(5578377670650038654, 31) => 3756585915319108063
+bit_rotl_u64(9223372036854775808, 31) => 1073741824
+bit_rotr_u64(9223372036854775808, 31) => 4294967296
+bit_rotl_u64(10755112315580060033, 31) => 9280239606276614869
+bit_rotr_u64(10755112315580060033, 31) => 227470277687356246
+bit_rotl_u64(11163782031541429823, 31) => 141075175016160334
+bit_rotr_u64(11163782031541429823, 31) => 564300700064641336
+bit_rotl_u64(13903686156871869732, 31) => 9830956193977854066
+bit_rotr_u64(13903686156871869732, 31) => 2430336628492313034
+bit_rotl_u64(14237897302422917095, 31) => 11075626865162688020
+bit_rotr_u64(14237897302422917095, 31) => 7409019313231648850
+bit_rotl_u64(14302190498657618739, 31) => 13491136976614443837
+bit_rotr_u64(14302190498657618739, 31) => 17071059759038672118
+bit_rotl_u64(15766411510232741269, 31) => 362182200778999262
+bit_rotr_u64(15766411510232741269, 31) => 1448728803115997048
+bit_rotl_u64(15984546468465238145, 31) => 7083089369391317545
+bit_rotr_u64(15984546468465238145, 31) => 9885613403855718565
+bit_rotl_u64(18446744073709551615, 31) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 31) => 18446744073709551615
+bit_rotl_u64(0, 32) => 0
+bit_rotr_u64(0, 32) => 0
+bit_rotl_u32(0, 32) => 0
+bit_rotr_u32(0, 32) => 0
+bit_rotl_u64(1, 32) => 4294967296
+bit_rotr_u64(1, 32) => 4294967296
+bit_rotl_u32(1, 32) => 1
+bit_rotr_u32(1, 32) => 1
+bit_rotl_u64(2, 32) => 8589934592
+bit_rotr_u64(2, 32) => 8589934592
+bit_rotl_u32(2, 32) => 2
+bit_rotr_u32(2, 32) => 2
+bit_rotl_u64(32768, 32) => 140737488355328
+bit_rotr_u64(32768, 32) => 140737488355328
+bit_rotl_u32(32768, 32) => 32768
+bit_rotr_u32(32768, 32) => 32768
+bit_rotl_u64(65535, 32) => 281470681743360
+bit_rotr_u64(65535, 32) => 281470681743360
+bit_rotl_u32(65535, 32) => 65535
+bit_rotr_u32(65535, 32) => 65535
+bit_rotl_u64(65536, 32) => 281474976710656
+bit_rotr_u64(65536, 32) => 281474976710656
+bit_rotl_u32(65536, 32) => 65536
+bit_rotr_u32(65536, 32) => 65536
+bit_rotl_u64(726075912, 32) => 3118472296453373952
+bit_rotr_u64(726075912, 32) => 3118472296453373952
+bit_rotl_u32(726075912, 32) => 726075912
+bit_rotr_u32(726075912, 32) => 726075912
+bit_rotl_u64(858993459, 32) => 3689348813882916864
+bit_rotr_u64(858993459, 32) => 3689348813882916864
+bit_rotl_u32(858993459, 32) => 858993459
+bit_rotr_u32(858993459, 32) => 858993459
+bit_rotl_u64(1073741824, 32) => 4611686018427387904
+bit_rotr_u64(1073741824, 32) => 4611686018427387904
+bit_rotl_u32(1073741824, 32) => 1073741824
+bit_rotr_u32(1073741824, 32) => 1073741824
+bit_rotl_u64(1245250552, 32) => 5348310396165947392
+bit_rotr_u64(1245250552, 32) => 5348310396165947392
+bit_rotl_u32(1245250552, 32) => 1245250552
+bit_rotr_u32(1245250552, 32) => 1245250552
+bit_rotl_u64(1431655765, 32) => 6148914689804861440
+bit_rotr_u64(1431655765, 32) => 6148914689804861440
+bit_rotl_u32(1431655765, 32) => 1431655765
+bit_rotr_u32(1431655765, 32) => 1431655765
+bit_rotl_u64(1656977767, 32) => 7116665319464108032
+bit_rotr_u64(1656977767, 32) => 7116665319464108032
+bit_rotl_u32(1656977767, 32) => 1656977767
+bit_rotr_u32(1656977767, 32) => 1656977767
+bit_rotl_u64(2147483648, 32) => 9223372036854775808
+bit_rotr_u64(2147483648, 32) => 9223372036854775808
+bit_rotl_u32(2147483648, 32) => 2147483648
+bit_rotr_u32(2147483648, 32) => 2147483648
+bit_rotl_u64(2283114629, 32) => 9805902664574173184
+bit_rotr_u64(2283114629, 32) => 9805902664574173184
+bit_rotl_u32(2283114629, 32) => 2283114629
+bit_rotr_u32(2283114629, 32) => 2283114629
+bit_rotl_u64(2502548245, 32) => 10748362868937195520
+bit_rotr_u64(2502548245, 32) => 10748362868937195520
+bit_rotl_u32(2502548245, 32) => 2502548245
+bit_rotr_u32(2502548245, 32) => 2502548245
+bit_rotl_u64(4294967295, 32) => 18446744069414584320
+bit_rotr_u64(4294967295, 32) => 18446744069414584320
+bit_rotl_u32(4294967295, 32) => 4294967295
+bit_rotr_u32(4294967295, 32) => 4294967295
+bit_rotl_u64(708915120906848425, 32) => 16541238372230140555
+bit_rotr_u64(708915120906848425, 32) => 16541238372230140555
+bit_rotl_u64(1960191741125985428, 32) => 14229128056835145728
+bit_rotr_u64(1960191741125985428, 32) => 14229128056835145728
+bit_rotl_u64(3689348814741910323, 32) => 3689348814741910323
+bit_rotr_u64(3689348814741910323, 32) => 3689348814741910323
+bit_rotl_u64(5578377670650038654, 32) => 11101664994514329839
+bit_rotr_u64(5578377670650038654, 32) => 11101664994514329839
+bit_rotl_u64(9223372036854775808, 32) => 2147483648
+bit_rotr_u64(9223372036854775808, 32) => 2147483648
+bit_rotl_u64(10755112315580060033, 32) => 113735138843678123
+bit_rotr_u64(10755112315580060033, 32) => 113735138843678123
+bit_rotl_u64(11163782031541429823, 32) => 282150350032320668
+bit_rotr_u64(11163782031541429823, 32) => 282150350032320668
+bit_rotl_u64(13903686156871869732, 32) => 1215168314246156517
+bit_rotr_u64(13903686156871869732, 32) => 1215168314246156517
+bit_rotl_u64(14237897302422917095, 32) => 3704509656615824425
+bit_rotr_u64(14237897302422917095, 32) => 3704509656615824425
+bit_rotl_u64(14302190498657618739, 32) => 8535529879519336059
+bit_rotr_u64(14302190498657618739, 32) => 8535529879519336059
+bit_rotl_u64(15766411510232741269, 32) => 724364401557998524
+bit_rotr_u64(15766411510232741269, 32) => 724364401557998524
+bit_rotl_u64(15984546468465238145, 32) => 14166178738782635090
+bit_rotr_u64(15984546468465238145, 32) => 14166178738782635090
+bit_rotl_u64(18446744073709551615, 32) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 32) => 18446744073709551615
+bit_rotl_u64(0, 63) => 0
+bit_rotr_u64(0, 63) => 0
+bit_rotl_u64(1, 63) => 9223372036854775808
+bit_rotr_u64(1, 63) => 2
+bit_rotl_u64(2, 63) => 1
+bit_rotr_u64(2, 63) => 4
+bit_rotl_u64(32768, 63) => 16384
+bit_rotr_u64(32768, 63) => 65536
+bit_rotl_u64(65535, 63) => 9223372036854808575
+bit_rotr_u64(65535, 63) => 131070
+bit_rotl_u64(65536, 63) => 32768
+bit_rotr_u64(65536, 63) => 131072
+bit_rotl_u64(726075912, 63) => 363037956
+bit_rotr_u64(726075912, 63) => 1452151824
+bit_rotl_u64(858993459, 63) => 9223372037284272537
+bit_rotr_u64(858993459, 63) => 1717986918
+bit_rotl_u64(1073741824, 63) => 536870912
+bit_rotr_u64(1073741824, 63) => 2147483648
+bit_rotl_u64(1245250552, 63) => 622625276
+bit_rotr_u64(1245250552, 63) => 2490501104
+bit_rotl_u64(1431655765, 63) => 9223372037570603690
+bit_rotr_u64(1431655765, 63) => 2863311530
+bit_rotl_u64(1656977767, 63) => 9223372037683264691
+bit_rotr_u64(1656977767, 63) => 3313955534
+bit_rotl_u64(2147483648, 63) => 1073741824
+bit_rotr_u64(2147483648, 63) => 4294967296
+bit_rotl_u64(2283114629, 63) => 9223372037996333122
+bit_rotr_u64(2283114629, 63) => 4566229258
+bit_rotl_u64(2502548245, 63) => 9223372038106049930
+bit_rotr_u64(2502548245, 63) => 5005096490
+bit_rotl_u64(4294967295, 63) => 9223372039002259455
+bit_rotr_u64(4294967295, 63) => 8589934590
+bit_rotl_u64(708915120906848425, 63) => 9577829597308200020
+bit_rotr_u64(708915120906848425, 63) => 1417830241813696850
+bit_rotl_u64(1960191741125985428, 63) => 980095870562992714
+bit_rotr_u64(1960191741125985428, 63) => 3920383482251970856
+bit_rotl_u64(3689348814741910323, 63) => 11068046444225730969
+bit_rotr_u64(3689348814741910323, 63) => 7378697629483820646
+bit_rotl_u64(5578377670650038654, 63) => 2789188835325019327
+bit_rotr_u64(5578377670650038654, 63) => 11156755341300077308
+bit_rotl_u64(9223372036854775808, 63) => 4611686018427387904
+bit_rotr_u64(9223372036854775808, 63) => 1
+bit_rotl_u64(10755112315580060033, 63) => 14600928194644805824
+bit_rotr_u64(10755112315580060033, 63) => 3063480557450568451
+bit_rotl_u64(11163782031541429823, 63) => 14805263052625490719
+bit_rotr_u64(11163782031541429823, 63) => 3880819989373308031
+bit_rotl_u64(13903686156871869732, 63) => 6951843078435934866
+bit_rotr_u64(13903686156871869732, 63) => 9360628240034187849
+bit_rotl_u64(14237897302422917095, 63) => 16342320688066234355
+bit_rotr_u64(14237897302422917095, 63) => 10029050531136282575
+bit_rotl_u64(14302190498657618739, 63) => 16374467286183585177
+bit_rotr_u64(14302190498657618739, 63) => 10157636923605685863
+bit_rotl_u64(15766411510232741269, 63) => 17106577791971146442
+bit_rotr_u64(15766411510232741269, 63) => 13086078946755930923
+bit_rotl_u64(15984546468465238145, 63) => 17215645271087394880
+bit_rotr_u64(15984546468465238145, 63) => 13522348863220924675
+bit_rotl_u64(18446744073709551615, 63) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 63) => 18446744073709551615
+bit_rotl_u64(0, 64) => 0
+bit_rotr_u64(0, 64) => 0
+bit_rotl_u64(1, 64) => 1
+bit_rotr_u64(1, 64) => 1
+bit_rotl_u64(2, 64) => 2
+bit_rotr_u64(2, 64) => 2
+bit_rotl_u64(32768, 64) => 32768
+bit_rotr_u64(32768, 64) => 32768
+bit_rotl_u64(65535, 64) => 65535
+bit_rotr_u64(65535, 64) => 65535
+bit_rotl_u64(65536, 64) => 65536
+bit_rotr_u64(65536, 64) => 65536
+bit_rotl_u64(726075912, 64) => 726075912
+bit_rotr_u64(726075912, 64) => 726075912
+bit_rotl_u64(858993459, 64) => 858993459
+bit_rotr_u64(858993459, 64) => 858993459
+bit_rotl_u64(1073741824, 64) => 1073741824
+bit_rotr_u64(1073741824, 64) => 1073741824
+bit_rotl_u64(1245250552, 64) => 1245250552
+bit_rotr_u64(1245250552, 64) => 1245250552
+bit_rotl_u64(1431655765, 64) => 1431655765
+bit_rotr_u64(1431655765, 64) => 1431655765
+bit_rotl_u64(1656977767, 64) => 1656977767
+bit_rotr_u64(1656977767, 64) => 1656977767
+bit_rotl_u64(2147483648, 64) => 2147483648
+bit_rotr_u64(2147483648, 64) => 2147483648
+bit_rotl_u64(2283114629, 64) => 2283114629
+bit_rotr_u64(2283114629, 64) => 2283114629
+bit_rotl_u64(2502548245, 64) => 2502548245
+bit_rotr_u64(2502548245, 64) => 2502548245
+bit_rotl_u64(4294967295, 64) => 4294967295
+bit_rotr_u64(4294967295, 64) => 4294967295
+bit_rotl_u64(708915120906848425, 64) => 708915120906848425
+bit_rotr_u64(708915120906848425, 64) => 708915120906848425
+bit_rotl_u64(1960191741125985428, 64) => 1960191741125985428
+bit_rotr_u64(1960191741125985428, 64) => 1960191741125985428
+bit_rotl_u64(3689348814741910323, 64) => 3689348814741910323
+bit_rotr_u64(3689348814741910323, 64) => 3689348814741910323
+bit_rotl_u64(5578377670650038654, 64) => 5578377670650038654
+bit_rotr_u64(5578377670650038654, 64) => 5578377670650038654
+bit_rotl_u64(9223372036854775808, 64) => 9223372036854775808
+bit_rotr_u64(9223372036854775808, 64) => 9223372036854775808
+bit_rotl_u64(10755112315580060033, 64) => 10755112315580060033
+bit_rotr_u64(10755112315580060033, 64) => 10755112315580060033
+bit_rotl_u64(11163782031541429823, 64) => 11163782031541429823
+bit_rotr_u64(11163782031541429823, 64) => 11163782031541429823
+bit_rotl_u64(13903686156871869732, 64) => 13903686156871869732
+bit_rotr_u64(13903686156871869732, 64) => 13903686156871869732
+bit_rotl_u64(14237897302422917095, 64) => 14237897302422917095
+bit_rotr_u64(14237897302422917095, 64) => 14237897302422917095
+bit_rotl_u64(14302190498657618739, 64) => 14302190498657618739
+bit_rotr_u64(14302190498657618739, 64) => 14302190498657618739
+bit_rotl_u64(15766411510232741269, 64) => 15766411510232741269
+bit_rotr_u64(15766411510232741269, 64) => 15766411510232741269
+bit_rotl_u64(15984546468465238145, 64) => 15984546468465238145
+bit_rotr_u64(15984546468465238145, 64) => 15984546468465238145
+bit_rotl_u64(18446744073709551615, 64) => 18446744073709551615
+bit_rotr_u64(18446744073709551615, 64) => 18446744073709551615
+ *** test_rotl_rotr: done ***
+ *** test_bswap ***
+bswap_u64(0) => 0
+bswap_u32(0) => 0
+bswap_u64(1) => 72057594037927936
+bswap_u32(1) => 16777216
+bswap_u64(2) => 144115188075855872
+bswap_u32(2) => 33554432
+bswap_u64(32768) => 36028797018963968
+bswap_u32(32768) => 8388608
+bswap_u64(65535) => 18446462598732840960
+bswap_u32(65535) => 4294901760
+bswap_u64(65536) => 1099511627776
+bswap_u32(65536) => 256
+bswap_u64(726075912) => 579353752079695872
+bswap_u32(726075912) => 134891307
+bswap_u64(858993459) => 3689348813882916864
+bswap_u32(858993459) => 858993459
+bswap_u64(1073741824) => 274877906944
+bswap_u32(1073741824) => 64
+bswap_u64(1245250552) => 17871190736326623232
+bswap_u32(1245250552) => 4160960842
+bswap_u64(1431655765) => 6148914689804861440
+bswap_u32(1431655765) => 1431655765
+bswap_u64(1656977767) => 7456205483762778112
+bswap_u32(1656977767) => 1736033122
+bswap_u64(2147483648) => 549755813888
+bswap_u32(2147483648) => 128
+bswap_u64(2283114629) => 9624216077550485504
+bswap_u32(2283114629) => 2240812424
+bswap_u64(2502548245) => 1574898214622986240
+bswap_u32(2502548245) => 366684565
+bswap_u64(4294967295) => 18446744069414584320
+bswap_u32(4294967295) => 4294967295
+bswap_u64(708915120906848425) => 12198156707273299465
+bswap_u64(1960191741125985428) => 10665782605024080923
+bswap_u64(3689348814741910323) => 3689348814741910323
+bswap_u64(5578377670650038654) => 9081809480708024909
+bswap_u64(9223372036854775808) => 128
+bswap_u64(10755112315580060033) => 9300377440395542933
+bswap_u64(11163782031541429823) => 4568596173249113498
+bswap_u64(13903686156871869732) => 2604731024148591552
+bswap_u64(14237897302422917095) => 16649642015867049925
+bswap_u64(14302190498657618739) => 3696175971416046534
+bswap_u64(15766411510232741269) => 10769528423690522074
+bswap_u64(15984546468465238145) => 9322619197622375645
+bswap_u64(18446744073709551615) => 18446744073709551615
+ *** test_bswap: done ***
+ *** test_index ***
+bit_index_u64(0, *, -1) =>
+bit_index_u32(0, *, -1) =>
+bit_index_u64(1, *, -1) => 0
+bit_index_u32(1, *, -1) => 0
+bit_index_u64(2, *, -1) => 1
+bit_index_u32(2, *, -1) => 1
+bit_index_u64(32768, *, -1) => 15
+bit_index_u32(32768, *, -1) => 15
+bit_index_u64(65535, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+bit_index_u32(65535, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+bit_index_u64(65536, *, -1) => 16
+bit_index_u32(65536, *, -1) => 16
+bit_index_u64(726075912, *, -1) => 3 9 11 16 17 18 22 24 25 27 29
+bit_index_u32(726075912, *, -1) => 3 9 11 16 17 18 22 24 25 27 29
+bit_index_u64(858993459, *, -1) => 0 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29
+bit_index_u32(858993459, *, -1) => 0 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29
+bit_index_u64(1073741824, *, -1) => 30
+bit_index_u32(1073741824, *, -1) => 30
+bit_index_u64(1245250552, *, -1) => 3 4 5 6 7 8 9 16 19 20 21 25 27 30
+bit_index_u32(1245250552, *, -1) => 3 4 5 6 7 8 9 16 19 20 21 25 27 30
+bit_index_u64(1431655765, *, -1) => 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
+bit_index_u32(1431655765, *, -1) => 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
+bit_index_u64(1656977767, *, -1) => 0 1 2 5 6 8 11 12 13 14 16 17 22 23 25 29 30
+bit_index_u32(1656977767, *, -1) => 0 1 2 5 6 8 11 12 13 14 16 17 22 23 25 29 30
+bit_index_u64(2147483648, *, -1) => 31
+bit_index_u32(2147483648, *, -1) => 31
+bit_index_u64(2283114629, *, -1) => 0 2 7 12 15 16 18 20 27 31
+bit_index_u32(2283114629, *, -1) => 0 2 7 12 15 16 18 20 27 31
+bit_index_u64(2502548245, *, -1) => 0 2 4 8 9 11 12 14 15 16 19 21 24 26 28 31
+bit_index_u32(2502548245, *, -1) => 0 2 4 8 9 11 12 14 15 16 19 21 24 26 28 31
+bit_index_u64(4294967295, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+bit_index_u32(4294967295, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
+bit_index_u64(708915120906848425, *, -1) => 0 3 5 7 11 14 17 18 19 23 24 26 29 30 31 32 33 35 39 41 44 47 49 50 52 54 55 56 59
+bit_index_u64(1960191741125985428, *, -1) => 2 4 7 10 19 20 21 22 24 26 30 31 50 52 53 56 57 59 60
+bit_index_u64(3689348814741910323, *, -1) => 0 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61
+bit_index_u64(5578377670650038654, *, -1) => 1 2 3 4 5 6 8 11 16 20 25 27 28 31 32 33 34 35 37 38 39 45 46 49 51 53 54 56 58 59 62
+bit_index_u64(9223372036854775808, *, -1) => 63
+bit_index_u64(10755112315580060033, *, -1) => 0 7 8 12 18 20 23 24 32 33 35 37 39 40 42 44 46 47 48 54 56 58 60 63
+bit_index_u64(11163782031541429823, *, -1) => 0 1 2 3 4 5 9 10 13 14 17 19 21 22 23 24 25 34 35 36 39 43 44 45 47 48 50 51 53 54 55 57 59 60 63
+bit_index_u64(13903686156871869732, *, -1) => 2 5 8 10 13 16 18 19 20 22 23 28 32 34 37 38 39 44 46 47 48 49 52 53 54 55 62 63
+bit_index_u64(14237897302422917095, *, -1) => 0 1 2 5 6 7 8 9 10 11 16 19 21 22 24 25 28 29 32 35 37 42 43 45 48 49 50 52 55 56 58 62 63
+bit_index_u64(14302190498657618739, *, -1) => 0 1 4 5 8 9 11 14 18 20 21 22 25 26 28 29 30 32 33 35 36 37 38 41 42 44 47 48 49 51 52 53 54 57 58 62 63
+bit_index_u64(15766411510232741269, *, -1) => 0 2 4 7 8 10 12 13 14 16 18 19 25 27 34 35 36 37 39 40 41 43 47 48 50 51 54 55 57 59 60 62 63
+bit_index_u64(15984546468465238145, *, -1) => 0 7 13 14 19 20 23 26 30 31 33 36 38 42 47 50 52 54 55 56 58 59 60 62 63
+bit_index_u64(18446744073709551615, *, -1) => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
+ *** test_index: done ***
+
\ No newline at end of file
diff --git a/test/unit/bit.test b/test/unit/bit.test
new file mode 100644
index 0000000000000000000000000000000000000000..bd42398b072ea067924ad5ff0977c8109be9636c
--- /dev/null
+++ b/test/unit/bit.test
@@ -0,0 +1 @@
+run_test("bit_test")