[SYCL][COMPAT] Replace T{-1} with static_cast<T>(-1) for mask creation (#16527)

Also include `<limits>` header for `std::numeric_limits<unsigned
char>::digits` (equal to `CHAR_BIT`), and tests for char types.

Author: joeatodd

sycl/include/syclcompat/math.hpp

@@ -31,6 +31,7 @@
 
 #pragma once
 
+#include <limits>
 #include <sycl/feature_test.hpp>
 #include <type_traits>
 
@@ -308,7 +309,9 @@ inline T bfe(const T source, const uint32_t bit_start,
   // FIXME(syclcompat-lib-reviewers): This ternary was added to catch a case
   // which may be undefined anyway. Consider that we are losing perf here.
   const T mask =
-      num_bits >= CHAR_BIT * sizeof(T) ? T{-1} : ((T{1} << num_bits) - 1);
+      num_bits >= std::numeric_limits<unsigned char>::digits * sizeof(T)
+          ? static_cast<T>(-1)
+          : ((static_cast<T>(1) << num_bits) - 1);
   return (source >> bit_start) & mask;
 }
 
@@ -321,7 +324,7 @@ inline T bfe(const T source, const uint32_t bit_start,
 /// and source \param num_bits gives the bit field length in bits.
 ///
 /// The result is padded with the sign bit of the extracted field. If `num_bits`
-/// is zero, the  result is zero. If the start position is beyond the msb of the
+/// is zero, the result is zero. If the start position is beyond the msb of the
 /// input, the result is filled with the replicated sign bit of the extracted
 /// field.
 ///
@@ -363,7 +366,8 @@ inline T bfe_safe(const T source, const uint32_t bit_start,
     return res;
   }
 #endif
-  const uint32_t bit_width = CHAR_BIT * sizeof(T);
+  const uint32_t bit_width =
+      std::numeric_limits<unsigned char>::digits * sizeof(T);
   const uint32_t pos = std::min(bit_start, bit_width);
   const uint32_t len = std::min(pos + num_bits, bit_width) - pos;
   if constexpr (std::is_signed_v<T>) {
@@ -397,7 +401,8 @@ template <typename T>
 inline T bfi(const T x, const T y, const uint32_t bit_start,
              const uint32_t num_bits) {
   static_assert(std::is_unsigned_v<T>);
-  constexpr unsigned bit_width = CHAR_BIT * sizeof(T);
+  constexpr unsigned bit_width =
+      std::numeric_limits<unsigned char>::digits * sizeof(T);
 
   // if bit_start > bit_width || len == 0, should return y.
   const T ignore_bfi = static_cast<T>(bit_start > bit_width || num_bits == 0);
@@ -441,7 +446,8 @@ inline T bfi_safe(const T x, const T y, const uint32_t bit_start,
     return res;
   }
 #endif
-  constexpr unsigned bit_width = CHAR_BIT * sizeof(T);
+  constexpr unsigned bit_width =
+      std::numeric_limits<unsigned char>::digits * sizeof(T);
   const uint32_t pos = std::min(bit_start, bit_width);
   const uint32_t len = std::min(pos + num_bits, bit_width) - pos;
   return syclcompat::detail::bfi(x, y, pos, len);

sycl/test-e2e/syclcompat/math/math_bfe.cpp

@@ -46,7 +46,8 @@
 template <typename T>
 inline std::enable_if_t<std::is_integral_v<T>, T>
 bfe_slow(const T source, const uint32_t bit_start, const uint32_t num_bits) {
-  const uint32_t msb = CHAR_BIT * sizeof(T) - 1;
+  const uint32_t msb =
+      std::numeric_limits<unsigned char>::digits * sizeof(T) - 1;
   const uint32_t pos = bit_start;
   const uint32_t len = num_bits;
 
@@ -55,7 +56,8 @@ bfe_slow(const T source, const uint32_t bit_start, const uint32_t num_bits) {
     return 0ULL;
 
   T sbit;
-  std::bitset<CHAR_BIT * sizeof(T)> source_bitset(source);
+  std::bitset<std::numeric_limits<unsigned char>::digits * sizeof(T)>
+      source_bitset(source);
   if (std::is_unsigned_v<T> || len == 0)
     sbit = 0;
   else
@@ -67,16 +69,17 @@ bfe_slow(const T source, const uint32_t bit_start, const uint32_t num_bits) {
   if (bit_start > msb)
     return -sbit;
 
-  std::bitset<CHAR_BIT * sizeof(T)> result_bitset;
+  std::bitset<std::numeric_limits<unsigned char>::digits * sizeof(T)>
+      result_bitset;
   for (uint8_t i = 0; i <= msb; ++i)
     result_bitset[i] =
         (i < len && pos + i <= msb) ? source_bitset[pos + i] : sbit;
   return result_bitset.to_ullong();
 }
 
 template <typename T> bool test(const char *Msg, int N) {
-  uint32_t bit_width = CHAR_BIT * sizeof(T);
-  T min_value = std::numeric_limits<T>::min();
+  uint32_t bit_width = std::numeric_limits<unsigned char>::digits * sizeof(T);
+  T min_value = std::numeric_limits<T>::lowest();
   T max_value = std::numeric_limits<T>::max();
   std::random_device rd;
   std::mt19937::result_type seed =
@@ -91,7 +94,9 @@ template <typename T> bool test(const char *Msg, int N) {
                .count());
 
   std::mt19937 gen(seed);
-  std::uniform_int_distribution<T> rd_source(min_value, max_value);
+  // Support for char type with uniform_int_distribution isn't universal
+  using RandomDataT = std::conditional_t<sizeof(T) == 1, int, T>;
+  std::uniform_int_distribution<RandomDataT> rd_source(min_value, max_value);
 
   // Define a small overshoot so that we adequately test out-of-range cases
   // without sacrificing depth of testing of valid start+length combinations
@@ -105,7 +110,7 @@ template <typename T> bool test(const char *Msg, int N) {
   std::vector<uint32_t> starts(N, 0);
   std::vector<uint32_t> lengths(N, 0);
   for (int i = 0; i < N; ++i) {
-    sources[i] = rd_source(gen);
+    sources[i] = static_cast<T>(rd_source(gen));
     starts[i] = rd_start(gen);
     lengths[i] = rd_length(gen);
   }
@@ -172,6 +177,8 @@ template <typename T> bool test(const char *Msg, int N) {
 
 int main() {
   const int N = 1000;
+  assert(test<int8_t>("int8", N));
+  assert(test<uint8_t>("uint8", N));
   assert(test<int16_t>("int16", N));
   assert(test<uint16_t>("uint16", N));
   assert(test<int32_t>("int32", N));