[SYCL] Resolve min/max conflict (#1339)

Adding #undef macros to resolve conflict between definitions of the min
and max function in the CL/sycl.h and windows.h or another min and max
define.

Use adding brackets around min & max function declarations

Signed-off-by: Mochalova <anastasiya.mochalova@intel.com>
Co-Authored-By: Alexey Bader <alexey.bader@intel.com>

Author: MochalovaAn

sycl/include/CL/sycl/builtins.hpp

@@ -530,31 +530,31 @@ detail::enable_if_t<detail::is_genfloat<T>::value, T> abs(T x) __NOEXC {
 
 // genfloat max (genfloat x, genfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_genfloat<T>::value, T> max(T x, T y) __NOEXC {
+detail::enable_if_t<detail::is_genfloat<T>::value, T>(max)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmax_common<T>(x, y);
 }
 
 // genfloatf max (genfloatf x, float y)
 // genfloatd max (genfloatd x, double y)
 // genfloath max (genfloath x, half y)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
-max(T x, typename T::element_type y) __NOEXC {
+detail::enable_if_t<detail::is_vgenfloat<T>::value, T>(max)(
+    T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_fmax_common<T>(x, T(y));
 }
 
 // genfloat min (genfloat x, genfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_genfloat<T>::value, T> min(T x, T y) __NOEXC {
+detail::enable_if_t<detail::is_genfloat<T>::value, T>(min)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmin_common<T>(x, y);
 }
 
 // genfloatf min (genfloatf x, float y)
 // genfloatd min (genfloatd x, double y)
 // genfloath min (genfloath x, half y)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
-min(T x, typename T::element_type y) __NOEXC {
+detail::enable_if_t<detail::is_vgenfloat<T>::value, T>(min)(
+    T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_fmin_common<T>(x, T(y));
 }
 
@@ -766,53 +766,57 @@ detail::enable_if_t<detail::is_ugeninteger<T>::value, T> mad_sat(T a, T b,
 
 // igeninteger max (igeninteger x, igeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> max(T x, T y) __NOEXC {
+detail::enable_if_t<detail::is_igeninteger<T>::value, T>(max)(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_s_max<T>(x, y);
 }
 
 // ugeninteger max (ugeninteger x, ugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> max(T x, T y) __NOEXC {
+detail::enable_if_t<detail::is_ugeninteger<T>::value, T>(max)(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_u_max<T>(x, y);
 }
 
 // igeninteger max (vigeninteger x, sigeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, T>
-max(T x, typename T::element_type y) __NOEXC {
+detail::enable_if_t<detail::is_vigeninteger<T>::value, T>(max)(
+    T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_s_max<T>(x, T(y));
 }
 
 // vugeninteger max (vugeninteger x, sugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vugeninteger<T>::value, T>
-max(T x, typename T::element_type y) __NOEXC {
+detail::enable_if_t<detail::is_vugeninteger<T>::value, T>(max)(
+    T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_u_max<T>(x, T(y));
 }
 
 // igeninteger min (igeninteger x, igeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> min(T x, T y) __NOEXC {
+detail::enable_if_t<detail::is_igeninteger<T>::value, T>(min)(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_s_min<T>(x, y);
 }
 
 // ugeninteger min (ugeninteger x, ugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> min(T x, T y) __NOEXC {
+detail::enable_if_t<detail::is_ugeninteger<T>::value, T>(min)(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_u_min<T>(x, y);
 }
 
 // vigeninteger min (vigeninteger x, sigeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, T>
-min(T x, typename T::element_type y) __NOEXC {
+detail::enable_if_t<detail::is_vigeninteger<T>::value, T>(min)(
+    T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_s_min<T>(x, T(y));
 }
 
 // vugeninteger min (vugeninteger x, sugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vugeninteger<T>::value, T>
-min(T x, typename T::element_type y) __NOEXC {
+detail::enable_if_t<detail::is_vugeninteger<T>::value, T>(min)(
+    T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_u_min<T>(x, T(y));
 }
 

sycl/include/CL/sycl/detail/generic_type_traits.hpp

@@ -582,11 +582,11 @@ struct RelConverter<
 };
 
 template <typename T> static constexpr T max_v() {
-  return std::numeric_limits<T>::max();
+  return (std::numeric_limits<T>::max)();
 }
 
 template <typename T> static constexpr T min_v() {
-  return std::numeric_limits<T>::min();
+  return (std::numeric_limits<T>::min)();
 }
 
 template <typename T> static constexpr T quiet_NaN() {

sycl/include/CL/sycl/half_type.hpp

@@ -306,11 +306,11 @@ template <> struct numeric_limits<half> {
 
   static constexpr const float_round_style round_style = round_to_nearest;
 
-  static __SYCL_CONSTEXPR_ON_DEVICE const half min() noexcept {
+  static __SYCL_CONSTEXPR_ON_DEVICE const half(min)() noexcept {
     return SYCL_HLF_MIN;
   }
 
-  static __SYCL_CONSTEXPR_ON_DEVICE const half max() noexcept {
+  static __SYCL_CONSTEXPR_ON_DEVICE const half(max)() noexcept {
     return SYCL_HLF_MAX;
   }
 

sycl/include/CL/sycl/intel/group_algorithm.hpp

@@ -98,7 +98,7 @@ template <typename T, typename V> struct identity<T, intel::plus<V>> {
 };
 
 template <typename T, typename V> struct identity<T, intel::minimum<V>> {
-  static constexpr T value = std::numeric_limits<T>::max();
+  static constexpr T value = (std::numeric_limits<T>::max)();
 };
 
 template <typename T, typename V> struct identity<T, intel::maximum<V>> {

sycl/test/basic_tests/min_max_test.cpp

@@ -0,0 +1,12 @@
+// REQUIRES: windows
+// RUN: %clangxx -fsycl -fsycl-device-only -fsyntax-only -Xclang -verify %s -I %sycl_include
+// expected-no-diagnostics
+
+#include "windows.h"
+
+#include "CL/sycl.hpp"
+
+int main() {
+  int tmp = min(1, 4);
+  return 0;
+}