Compile time/remove stdlibs from builtin

sycl/include/sycl/builtins.hpp

@@ -13,6 +13,12 @@
 #include <sycl/detail/builtins/builtins.hpp>
 
 #ifdef __SYCL_DEVICE_ONLY__
+// Pull in the minimal C runtime headers that cover the libc declarations below.
+// This keeps the device-side redeclarations aligned with the platform headers
+// without relying on heavier transitive includes such as <algorithm>.
+#include <cstdlib>
+#include <cstring>
+
 extern "C" {
 
 extern __DPCPP_SYCL_EXTERNAL_LIBC void *memcpy(void *dest, const void *src,

sycl/include/sycl/detail/builtins/builtins.hpp

@@ -71,7 +71,7 @@
 #include <sycl/half_type.hpp>
 #include <sycl/marray.hpp>
 
-#include <algorithm>
+#include <limits>
 
 namespace sycl {
 inline namespace _V1 {

sycl/include/sycl/detail/builtins/relational_functions.inc

@@ -157,6 +157,22 @@ HOST_IMPL_TEMPLATE(THREE_ARGS, bitselect, builtin_enable_bitselect_t, rel,
 #endif
 
 namespace detail {
+template <typename InputIt, typename Predicate>
+bool builtin_any_of(InputIt First, InputIt Last, Predicate Pred) {
+  for (; First != Last; ++First)
+    if (Pred(*First))
+      return true;
+  return false;
+}
+
+template <typename InputIt, typename Predicate>
+bool builtin_all_of(InputIt First, InputIt Last, Predicate Pred) {
+  for (; First != Last; ++First)
+    if (!Pred(*First))
+      return false;
+  return true;
+}
+
 template <typename T>
 struct builtin_enable_rel_all_any
     : std::enable_if<(is_marray_v<T> &&
@@ -177,7 +193,7 @@ struct builtin_enable_rel_all_any_deprecated
 template <typename T>
 typename detail::builtin_enable_rel_all_any<T>::type any(T x) {
   if constexpr (detail::is_marray_v<T>) {
-    return std::any_of(x.begin(), x.end(), [](bool x) { return x; });
+    return detail::builtin_any_of(x.begin(), x.end(), [](bool x) { return x; });
   } else {
     for (size_t i = 0; i < detail::num_elements<T>::value; ++i)
       if (detail::msbIsSet(x[i]))
@@ -190,8 +206,8 @@ template <typename T>
 __SYCL2020_DEPRECATED("This overload is deprecated in SYCL 2020.")
 typename detail::builtin_enable_rel_all_any_deprecated<T>::type any(T x) {
   if constexpr (detail::is_marray_v<T>) {
-    return std::any_of(x.begin(), x.end(),
-                       [](auto x) { return detail::msbIsSet(x); });
+    return detail::builtin_any_of(x.begin(), x.end(),
+                                  [](auto x) { return detail::msbIsSet(x); });
   } else {
     return detail::msbIsSet(x);
   }
@@ -200,7 +216,7 @@ typename detail::builtin_enable_rel_all_any_deprecated<T>::type any(T x) {
 template <typename T>
 typename detail::builtin_enable_rel_all_any<T>::type all(T x) {
   if constexpr (detail::is_marray_v<T>) {
-    return std::all_of(x.begin(), x.end(), [](bool x) { return x; });
+    return detail::builtin_all_of(x.begin(), x.end(), [](bool x) { return x; });
   } else {
     for (size_t i = 0; i < detail::num_elements<T>::value; ++i)
       if (!detail::msbIsSet(x[i]))
@@ -213,8 +229,8 @@ template <typename T>
 __SYCL2020_DEPRECATED("This overload is deprecated in SYCL 2020.")
 typename detail::builtin_enable_rel_all_any_deprecated<T>::type all(T x) {
   if constexpr (detail::is_marray_v<T>) {
-    return std::all_of(x.begin(), x.end(),
-                       [](auto x) { return detail::msbIsSet(x); });
+    return detail::builtin_all_of(x.begin(), x.end(),
+                                  [](auto x) { return detail::msbIsSet(x); });
   } else {
     return detail::msbIsSet(x);
   }

sycl/include/sycl/detail/generic_type_traits.hpp

@@ -17,7 +17,6 @@
 
 #include <cstddef>     // for byte
 #include <cstdint>     // for uint8_t
-#include <limits>      // for numeric_limits
 #include <type_traits> // for enable_if_t, condition...
 #include <utility>     // for forward
 
@@ -213,14 +212,6 @@ template <typename T> inline constexpr T msbMask(T) {
 template <typename T> inline constexpr bool msbIsSet(const T x) {
   return (x & msbMask(x));
 }
-
-template <typename T> static constexpr T max_v() {
-  return (std::numeric_limits<T>::max)();
-}
-
-template <typename T> static constexpr T min_v() {
-  return (std::numeric_limits<T>::min)();
-}
 } // namespace detail
 } // namespace _V1
 } // namespace sycl

sycl/include/sycl/detail/image_accessor_util.hpp

@@ -17,7 +17,7 @@
 #include <sycl/builtins.hpp>                   // for clamp, fmax, min
 #include <sycl/detail/array.hpp>               // for array
 #include <sycl/detail/export.hpp>              // for __SYCL_EXPORT
-#include <sycl/detail/generic_type_traits.hpp> // for max_v, min_v, TryToGe...
+#include <sycl/detail/generic_type_traits.hpp>
 #include <sycl/detail/vector_convert.hpp> // for vec, vec::convert, operator*, round...
 #include <sycl/exception.hpp>
 #include <sycl/id.hpp>      // for id
@@ -26,6 +26,7 @@
 #include <sycl/sampler.hpp> // for addressing_mode, coor...
 
 #include <cstdint>     // for int32_t, uint16_t
+#include <limits>      // for numeric_limits
 #include <stddef.h>    // for size_t
 #include <type_traits> // for enable_if_t
 
@@ -479,15 +480,15 @@ convertWriteData(const uint4 WriteData,
   switch (ImageChannelType) {
   case image_channel_type::unsigned_int8: {
     // convert_uchar_sat(Data)
-    std::uint32_t MinVal = min_v<std::uint8_t>();
-    std::uint32_t MaxVal = max_v<std::uint8_t>();
+    std::uint32_t MinVal = (std::numeric_limits<std::uint8_t>::min)();
+    std::uint32_t MaxVal = (std::numeric_limits<std::uint8_t>::max)();
     uint4 PixelData = sycl::clamp(WriteData, MinVal, MaxVal);
     return PixelData.convert<ChannelType>();
   }
   case image_channel_type::unsigned_int16: {
     // convert_ushort_sat(Data)
-    std::uint32_t MinVal = min_v<std::uint16_t>();
-    std::uint32_t MaxVal = max_v<std::uint16_t>();
+    std::uint32_t MinVal = (std::numeric_limits<std::uint16_t>::min)();
+    std::uint32_t MaxVal = (std::numeric_limits<std::uint16_t>::max)();
     uint4 PixelData = sycl::clamp(WriteData, MinVal, MaxVal);
     return PixelData.convert<ChannelType>();
   }
@@ -513,15 +514,15 @@ convertWriteData(const int4 WriteData,
   switch (ImageChannelType) {
   case image_channel_type::signed_int8: {
     // convert_char_sat(Data)
-    std::int32_t MinVal = min_v<std::int8_t>();
-    std::int32_t MaxVal = max_v<std::int8_t>();
+    std::int32_t MinVal = (std::numeric_limits<std::int8_t>::min)();
+    std::int32_t MaxVal = (std::numeric_limits<std::int8_t>::max)();
     int4 PixelData = sycl::clamp(WriteData, MinVal, MaxVal);
     return PixelData.convert<ChannelType>();
   }
   case image_channel_type::signed_int16: {
     // convert_short_sat(Data)
-    std::int32_t MinVal = min_v<std::int16_t>();
-    std::int32_t MaxVal = max_v<std::int16_t>();
+    std::int32_t MinVal = (std::numeric_limits<std::int16_t>::min)();
+    std::int32_t MaxVal = (std::numeric_limits<std::int16_t>::max)();
     int4 PixelData = sycl::clamp(WriteData, MinVal, MaxVal);
     return PixelData.convert<ChannelType>();
   }
@@ -542,7 +543,8 @@ vec<ChannelType, 4> processFloatDataToPixel(float4 WriteData, float MulFactor) {
   float4 Temp = WriteData * MulFactor;
   int4 TempInInt = Temp.convert<int, rounding_mode::rte>();
   int4 TempInIntSaturated =
-      sycl::clamp(TempInInt, min_v<ChannelType>(), max_v<ChannelType>());
+      sycl::clamp(TempInInt, (std::numeric_limits<ChannelType>::min)(),
+                  (std::numeric_limits<ChannelType>::max)());
   return TempInIntSaturated.convert<ChannelType>();
 }