Restrict bit manip to unsigned types

Author: AntoinePrv

include/xsimd/utils/bits.hpp

@@ -13,14 +13,16 @@
 #define XSIMD_CPUID_UTILS_HPP
 
 #include <cassert>
+#include <type_traits>
+
 namespace xsimd
 {
     namespace utils
     {
         template <typename I>
         constexpr I make_bit_mask(I bit)
         {
-            assert(bit >= 0);
+            static_assert(std::is_unsigned<I>::value);
             assert(bit < static_cast<I>(8 * sizeof(I)));
             return static_cast<I>(I { 1 } << bit);
         }
@@ -29,19 +31,22 @@ namespace xsimd
         constexpr I make_bit_mask(I bit, Args... bits)
         {
             // TODO(C++17): Use fold expression
+            static_assert(std::is_unsigned<I>::value);
             return make_bit_mask<I>(bit) | make_bit_mask<I>(static_cast<I>(bits)...);
         }
 
         template <int... Bits, typename I>
         constexpr bool all_bits_set(I value)
         {
+            static_assert(std::is_unsigned<I>::value);
             constexpr I mask = make_bit_mask<I>(static_cast<I>(Bits)...);
             return (value & mask) == mask;
         }
 
         template <int Bit, typename I>
         constexpr I set_bit(I value)
         {
+            static_assert(std::is_unsigned<I>::value);
             constexpr I mask = make_bit_mask<I>(static_cast<I>(Bit));
             return value | mask;
         }
@@ -52,7 +57,7 @@ namespace xsimd
         template <typename I>
         constexpr I make_low_mask(I width) noexcept
         {
-            assert(width >= 0);
+            static_assert(std::is_unsigned<I>::value);
             assert(width <= static_cast<I>(8 * sizeof(I)));
             if (width == static_cast<I>(8 * sizeof(I)))
             {

test/test_utils_bits.cpp

@@ -21,39 +21,37 @@ TEST_CASE("[utils::make_bit_mask] single bit")
     CHECK_EQ(xsimd::utils::make_bit_mask<std::uint8_t>(7), 0x80);
     CHECK_EQ(xsimd::utils::make_bit_mask<std::uint32_t>(0), 0x01u);
     CHECK_EQ(xsimd::utils::make_bit_mask<std::uint32_t>(31), 0x80000000u);
-    CHECK_EQ(xsimd::utils::make_bit_mask<std::int32_t>(0), 0x01);
-    CHECK_EQ(xsimd::utils::make_bit_mask<std::int32_t>(16), 0x00010000);
 }
 
 TEST_CASE("[utils::make_bit_mask] multiple bits")
 {
-    CHECK_EQ(xsimd::utils::make_bit_mask(0, 1), 0b11);
+    CHECK_EQ(xsimd::utils::make_bit_mask(0u, 1u), 0b11);
     CHECK_EQ(xsimd::utils::make_bit_mask<std::uint8_t>(0, 2, 4), 0b00010101);
 }
 
 TEST_CASE("[utils::all_bits_set] basic")
 {
-    CHECK(xsimd::utils::all_bits_set<0>(0x01));
-    CHECK(xsimd::utils::all_bits_set<7>(0x80));
-    CHECK_FALSE(xsimd::utils::all_bits_set<0>(0x00));
-    CHECK_FALSE(xsimd::utils::all_bits_set<1>(0x01));
+    CHECK(xsimd::utils::all_bits_set<0>(0x01u));
+    CHECK(xsimd::utils::all_bits_set<7>(0x80u));
+    CHECK_FALSE(xsimd::utils::all_bits_set<0>(0x00u));
+    CHECK_FALSE(xsimd::utils::all_bits_set<1>(0x01u));
 }
 
 TEST_CASE("[utils::all_bits_set] multiple bits")
 {
-    CHECK((xsimd::utils::all_bits_set<0, 1>(0x03)));
-    CHECK((xsimd::utils::all_bits_set<0, 1>(0xFF)));
-    CHECK_FALSE((xsimd::utils::all_bits_set<0, 1>(0x01)));
+    CHECK((xsimd::utils::all_bits_set<0, 1>(0x03u)));
+    CHECK((xsimd::utils::all_bits_set<0, 1>(0xFFu)));
+    CHECK_FALSE((xsimd::utils::all_bits_set<0, 1>(0x01u)));
 }
 
 TEST_CASE("[utils::set_bit]")
 {
-    CHECK_EQ(xsimd::utils::set_bit<0>(0), 0x01);
-    CHECK_EQ(xsimd::utils::set_bit<3>(0), 0x08);
+    CHECK_EQ(xsimd::utils::set_bit<0>(0u), 0x01u);
+    CHECK_EQ(xsimd::utils::set_bit<3>(0u), 0x08u);
     // Idempotent: setting an already-set bit
-    CHECK_EQ(xsimd::utils::set_bit<0>(0x01), 0x01);
+    CHECK_EQ(xsimd::utils::set_bit<0>(0x01u), 0x01u);
     // Does not clear other bits
-    CHECK_EQ(xsimd::utils::set_bit<1>(0b1101), 0b1111);
+    CHECK_EQ(xsimd::utils::set_bit<1>(0b1101u), 0b1111u);
 }
 
 TEST_CASE("[utils::make_low_mask]")
@@ -85,7 +83,7 @@ TEST_CASE("[utils::uint_bitset] default construction")
 
 TEST_CASE("[utils::uint_bitset] construction from raw value")
 {
-    xsimd::utils::uint_bitset<flag, std::uint32_t> bs(0b11);
+    xsimd::utils::uint_bitset<flag, std::uint32_t> bs(0b11u);
     CHECK(bs.bit_is_set<flag::A>());
     CHECK(bs.bit_is_set<flag::B>());
     CHECK_FALSE(bs.bit_is_set<flag::C>());
@@ -103,7 +101,7 @@ TEST_CASE("[utils::uint_bitset] set_bit")
 
 TEST_CASE("[utils::uint_bitset] all_bits_set")
 {
-    xsimd::utils::uint_bitset<flag, std::uint32_t> bs(0b11);
+    xsimd::utils::uint_bitset<flag, std::uint32_t> bs(0b11u);
     CHECK((bs.all_bits_set<flag::A, flag::B>()));
     CHECK_FALSE((bs.all_bits_set<flag::A, flag::C>()));
 }
@@ -116,7 +114,7 @@ TEST_CASE("[utils::uint_bitset] get_range")
         mid = 4,
         hi = 8
     };
-    xsimd::utils::uint_bitset<rk, std::uint32_t> bs(0b10101011);
-    CHECK_EQ((bs.get_range<rk::lo, rk::mid>()), 0b1011);
-    CHECK_EQ((bs.get_range<rk::mid, rk::hi>()), 0b1010);
+    xsimd::utils::uint_bitset<rk, std::uint32_t> bs(0b10101011u);
+    CHECK_EQ((bs.get_range<rk::lo, rk::mid>()), 0b1011u);
+    CHECK_EQ((bs.get_range<rk::mid, rk::hi>()), 0b1010u);
 }