[SYCL] Don't include <complex> from <sycl/sycl.hpp>

This addresses a part of a bigger issue of polluting the global
namespace with math functions by implicitly including <cmath> from sycl
headers. Internally, <complex> includes <cmath> so we shouldn't be
including it as well, which this patch implements.

I'm doing it by providing our own version of <complex> that does
`#include_next <complex>` and also provides needed functions/template
specializations to support `std::complex`-related functionality whenever
user program includes <complex> on its own. System include path for this
is only provided in SYCL mode so non-SYCL compilation flow is unaffected.

Author: aelovikov-intel

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -1128,9 +1128,16 @@ void SYCLToolChain::AddSYCLIncludeArgs(const clang::driver::Driver &Driver,
   llvm::sys::path::append(P, "include");
   SmallString<128> SYCLP(P);
   llvm::sys::path::append(SYCLP, "sycl");
+  // This is used to provide our wrappers around STL headers that provide
+  // additional functions/template specializations when the user includes those
+  // STL headers in their programs (e.g., <complex>).
+  SmallString<128> STL_WRAPPERS_PATH(SYCLP);
+  llvm::sys::path::append(STL_WRAPPERS_PATH, "stl_wrappers");
   CC1Args.push_back("-internal-isystem");
   CC1Args.push_back(DriverArgs.MakeArgString(SYCLP));
   CC1Args.push_back("-internal-isystem");
+  CC1Args.push_back(DriverArgs.MakeArgString(STL_WRAPPERS_PATH));
+  CC1Args.push_back("-internal-isystem");
   CC1Args.push_back(DriverArgs.MakeArgString(P));
 }
 

sycl/include/CL/__spirv/spirv_ops.hpp

@@ -1212,19 +1212,6 @@ __CLC_BF16_SCAL_VEC(uint32_t)
 #undef __CLC_BF16_SCAL_VEC
 #undef __CLC_BF16
 
-__SYCL_CONVERGENT__ extern __DPCPP_SYCL_EXTERNAL
-    __SYCL_EXPORT __spv::complex_half
-    __spirv_GroupCMulINTEL(unsigned int, unsigned int,
-                           __spv::complex_half) noexcept;
-__SYCL_CONVERGENT__ extern __DPCPP_SYCL_EXTERNAL
-    __SYCL_EXPORT __spv::complex_float
-    __spirv_GroupCMulINTEL(unsigned int, unsigned int,
-                           __spv::complex_float) noexcept;
-__SYCL_CONVERGENT__ extern __DPCPP_SYCL_EXTERNAL
-    __SYCL_EXPORT __spv::complex_double
-    __spirv_GroupCMulINTEL(unsigned int, unsigned int,
-                           __spv::complex_double) noexcept;
-
 extern __DPCPP_SYCL_EXTERNAL int32_t __spirv_BuiltInGlobalHWThreadIDINTEL();
 extern __DPCPP_SYCL_EXTERNAL int32_t __spirv_BuiltInSubDeviceIDINTEL();
 

sycl/include/CL/__spirv/spirv_types.hpp

@@ -11,7 +11,6 @@
 #include <sycl/detail/defines.hpp> // for SYCL_EXT_ONEAPI_MATRIX_VERSION
 #include <sycl/half_type.hpp>      // for half
 
-#include <complex> // for complex
 #include <cstddef> // for size_t
 #include <cstdint> // for uint32_t
 
@@ -130,27 +129,6 @@ enum class MatrixLayout : uint32_t {
 
 enum class MatrixUse : uint32_t { MatrixA = 0, MatrixB = 1, Accumulator = 2 };
 
-struct complex_float {
-  complex_float() = default;
-  complex_float(std::complex<float> x) : real(x.real()), imag(x.imag()) {}
-  operator std::complex<float>() { return {real, imag}; }
-  float real, imag;
-};
-
-struct complex_double {
-  complex_double() = default;
-  complex_double(std::complex<double> x) : real(x.real()), imag(x.imag()) {}
-  operator std::complex<double>() { return {real, imag}; }
-  double real, imag;
-};
-
-struct complex_half {
-  complex_half() = default;
-  complex_half(std::complex<sycl::half> x) : real(x.real()), imag(x.imag()) {}
-  operator std::complex<sycl::half>() { return {real, imag}; }
-  sycl::half real, imag;
-};
-
 #if (SYCL_EXT_ONEAPI_MATRIX_VERSION > 1)
 template <typename T, std::size_t R, std::size_t C, MatrixLayout L,
           Scope::Flag S = Scope::Flag::Subgroup,

sycl/include/sycl/builtins.hpp

@@ -15,6 +15,11 @@
 #include <sycl/builtins_scalar_gen.hpp>
 #include <sycl/builtins_vector_gen.hpp>
 
+// We don't use the same exception specifier as <cmath> so we get warnings if
+// our code is processed before STL's <cmath>.
+// TODO: We should remove this dependency alltogether in a subsequent patch.
+#include <cmath>
+
 #ifdef __SYCL_DEVICE_ONLY__
 extern "C" {
 extern __DPCPP_SYCL_EXTERNAL int abs(int x);

sycl/include/sycl/detail/generic_type_traits.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include <CL/__spirv/spirv_types.hpp>         // for complex_double, comple...
 #include <sycl/access/access.hpp>             // for decorated, address_space
 #include <sycl/aliases.hpp>                   // for half, cl_char, cl_double
 #include <sycl/detail/generic_type_lists.hpp> // for nonconst_address_space...
@@ -18,7 +17,6 @@
 #include <sycl/half_type.hpp>                 // for BIsRepresentationT
 #include <sycl/multi_ptr.hpp>                 // for multi_ptr, address_spa...
 
-#include <complex>     // for complex
 #include <cstddef>     // for byte
 #include <cstdint>     // for uint8_t
 #include <limits>      // for numeric_limits
@@ -485,13 +483,17 @@ using select_cl_scalar_float_t =
     select_apply_cl_scalar_t<T, std::false_type, sycl::opencl::cl_half,
                              sycl::opencl::cl_float, sycl::opencl::cl_double>;
 
+// Use SFINAE so that std::complex specialization could be implemented in
+// include/sycl/stl_wrappers/complex that would only be available if STL's
+// <complex> is included by users.
+template <typename T, typename = void>
+struct select_cl_scalar_complex_or_T {
+  using type = T;
+};
+
 template <typename T>
-using select_cl_scalar_complex_or_T_t = std::conditional_t<
-    std::is_same_v<T, std::complex<float>>, __spv::complex_float,
-    std::conditional_t<std::is_same_v<T, std::complex<double>>,
-                       __spv::complex_double,
-                       std::conditional_t<std::is_same_v<T, std::complex<half>>,
-                                          __spv::complex_half, T>>>;
+using select_cl_scalar_complex_or_T_t =
+    typename select_cl_scalar_complex_or_T<T>::type;
 
 template <typename T>
 using select_cl_scalar_integral_t =

sycl/include/sycl/ext/oneapi/functional.hpp

@@ -53,19 +53,13 @@ struct GroupOpTag<T, std::enable_if_t<detail::is_sgenfloat<T>::value>> {
   using type = GroupOpFP;
 };
 
-template <typename T>
-struct GroupOpTag<
-    T, std::enable_if_t<std::is_same<T, std::complex<half>>::value ||
-                        std::is_same<T, std::complex<float>>::value ||
-                        std::is_same<T, std::complex<double>>::value>> {
-  using type = GroupOpC;
-};
-
 template <typename T>
 struct GroupOpTag<T, std::enable_if_t<detail::is_genbool<T>::value>> {
   using type = GroupOpBool;
 };
 
+// GroupOpC (std::complex) is handled in sycl/stl_wrappers/complex.
+
 #define __SYCL_CALC_OVERLOAD(GroupTag, SPIRVOperation, BinaryOperation)        \
   template <__spv::GroupOperation O, typename Group, typename T>               \
   static T calc(Group g, GroupTag, T x, BinaryOperation) {                     \

sycl/include/sycl/group_algorithm.hpp

@@ -31,7 +31,6 @@
 #endif
 #endif
 
-#include <complex>     // for complex
 #include <stddef.h>    // for size_t
 #include <type_traits> // for enable_if_t, decay_t, integra...
 
@@ -127,13 +126,11 @@ using is_multiplies = std::integral_constant<
               std::is_same_v<BinaryOperation, sycl::multiplies<void>>>;
 
 // ---- is_complex
-// NOTE: std::complex<long double> not yet supported by group algorithms.
-template <typename T>
-struct is_complex
-    : std::integral_constant<bool,
-                             std::is_same_v<T, std::complex<half>> ||
-                                 std::is_same_v<T, std::complex<float>> ||
-                                 std::is_same_v<T, std::complex<double>>> {};
+// Use SFINAE so that the "true" branch could be implemented in
+// include/sycl/stl_wrappers/complex that would only be available if STL's
+// <complex> is included by users.
+template <typename T, typename = void>
+struct is_complex : public std::false_type {};
 
 // ---- is_arithmetic_or_complex
 template <typename T>

sycl/include/sycl/known_identity.hpp

@@ -15,7 +15,6 @@
 #include <sycl/marray.hpp>                     // for marray
 #include <sycl/types.hpp>                      // for vec
 
-#include <complex>     // for complex
 #include <cstddef>     // for byte, size_t
 #include <functional>  // for logical_and, logical_or
 #include <limits>      // for numeric_limits
@@ -75,9 +74,11 @@ using IsLogicalOR =
                        std::is_same_v<BinaryOperation, sycl::logical_or<T>> ||
                        std::is_same_v<BinaryOperation, sycl::logical_or<void>>>;
 
-template <typename T>
-using isComplex = std::bool_constant<std::is_same_v<T, std::complex<float>> ||
-                                     std::is_same_v<T, std::complex<double>>>;
+// Use SFINAE so that the "true" branch could be implemented in
+// include/sycl/stl_wrappers/complex that would only be available if STL's
+// <complex> is included by users.
+template <typename T, typename = void>
+struct isComplex : public std::false_type {};
 
 // Identity = 0
 template <typename T, class BinaryOperation>

sycl/include/sycl/stl_wrappers/complex

@@ -0,0 +1,91 @@
+#pragma once
+
+#include_next <complex>
+
+#include <type_traits>
+
+#include <CL/__spirv/spirv_ops.hpp> // for __SYCL_CONVERGENT__
+#include <sycl/half_type.hpp>       // for half
+
+// We provide std::complex specializations here for the following:
+// select_cl_scalar_complex_or_T:
+#include <sycl/detail/generic_type_traits.hpp>
+// sycl::detail::GroupOpTag:
+#include <sycl/ext/oneapi/functional.hpp>
+// sycl::detail::is_complex:
+#include <sycl/group_algorithm.hpp>
+// sycl::detail::isComplex
+#include <sycl/known_identity.hpp>
+
+namespace __spv {
+struct complex_float {
+  complex_float() = default;
+  complex_float(std::complex<float> x) : real(x.real()), imag(x.imag()) {}
+  operator std::complex<float>() { return {real, imag}; }
+  float real, imag;
+};
+
+struct complex_double {
+  complex_double() = default;
+  complex_double(std::complex<double> x) : real(x.real()), imag(x.imag()) {}
+  operator std::complex<double>() { return {real, imag}; }
+  double real, imag;
+};
+
+struct complex_half {
+  complex_half() = default;
+  complex_half(std::complex<sycl::half> x) : real(x.real()), imag(x.imag()) {}
+  operator std::complex<sycl::half>() { return {real, imag}; }
+  sycl::half real, imag;
+};
+} // namespace __spv
+
+__SYCL_CONVERGENT__ extern __DPCPP_SYCL_EXTERNAL
+    __SYCL_EXPORT __spv::complex_half
+    __spirv_GroupCMulINTEL(unsigned int, unsigned int,
+                           __spv::complex_half) noexcept;
+__SYCL_CONVERGENT__ extern __DPCPP_SYCL_EXTERNAL
+    __SYCL_EXPORT __spv::complex_float
+    __spirv_GroupCMulINTEL(unsigned int, unsigned int,
+                           __spv::complex_float) noexcept;
+__SYCL_CONVERGENT__ extern __DPCPP_SYCL_EXTERNAL
+    __SYCL_EXPORT __spv::complex_double
+    __spirv_GroupCMulINTEL(unsigned int, unsigned int,
+                           __spv::complex_double) noexcept;
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+template <typename T>
+struct isComplex<T, std::enable_if_t<std::is_same_v<T, std::complex<float>> ||
+                                     std::is_same_v<T, std::complex<double>>>>
+    : public std::true_type {};
+
+// NOTE: std::complex<long double> not yet supported by group algorithms.
+template <typename T>
+struct is_complex<T, std::enable_if_t<std::is_same_v<T, std::complex<half>> ||
+                                      std::is_same_v<T, std::complex<float>> ||
+                                      std::is_same_v<T, std::complex<double>>>>
+    : public std::true_type {};
+
+#ifdef __SYCL_DEVICE_ONLY__
+template <typename T>
+struct GroupOpTag<
+    T, std::enable_if_t<std::is_same<T, std::complex<half>>::value ||
+                        std::is_same<T, std::complex<float>>::value ||
+                        std::is_same<T, std::complex<double>>::value>> {
+  using type = GroupOpC;
+};
+#endif
+
+template <typename T>
+struct select_cl_scalar_complex_or_T<T,
+                                     std::enable_if_t<is_complex<T>::value>> {
+  using type = std::conditional_t<
+      std::is_same_v<T, std::complex<float>>, __spv::complex_float,
+      std::conditional_t<std::is_same_v<T, std::complex<double>>,
+                         __spv::complex_double, __spv::complex_half>>;
+};
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

sycl/test-e2e/GroupAlgorithm/different_types.cpp

@@ -1,6 +1,7 @@
 // RUN: %{build} -fsycl-device-code-split=per_kernel -I . -o %t.out
 // RUN: %{run} %t.out
 
+#include <complex>
 #include <cstdint>
 #include <limits>
 #include <numeric>

sycl/test-e2e/GroupAlgorithm/exclusive_scan_sycl2020.cpp

@@ -5,6 +5,7 @@
 #include "support.h"
 #include <algorithm>
 #include <cassert>
+#include <complex>
 #include <iostream>
 #include <limits>
 #include <numeric>

sycl/test-e2e/GroupAlgorithm/inclusive_scan_sycl2020.cpp

@@ -5,6 +5,7 @@
 #include "support.h"
 #include <algorithm>
 #include <cassert>
+#include <complex>
 #include <iostream>
 #include <limits>
 #include <numeric>

sycl/test-e2e/UserDefinedReductions/user_defined_reductions.cpp

@@ -3,6 +3,7 @@
 //
 // UNSUPPORTED: cuda || hip
 
+#include <complex>
 #include <numeric>
 
 #include <sycl/ext/oneapi/experimental/user_defined_reductions.hpp>