[SYCL] Implement sycl::opencl::cl_* aliases (#7931)

This resolves #7242

Author: AlexeySachkov

sycl/include/sycl/aliases.hpp

@@ -106,6 +106,23 @@ using cl_half = half;
 using cl_float = float;
 using cl_double = double;
 
+namespace opencl {
+// Strictly speaking, cl_* aliases should not be defined in opencl namespace in
+// SYCL 1.2.1 mode, but we do so to simplify our implementation
+using cl_bool = bool;
+using cl_char = std::int8_t;
+using cl_uchar = std::uint8_t;
+using cl_short = std::int16_t;
+using cl_ushort = std::uint16_t;
+using cl_int = std::int32_t;
+using cl_uint = std::uint32_t;
+using cl_long = std::int64_t;
+using cl_ulong = std::uint64_t;
+using cl_half = half;
+using cl_float = float;
+using cl_double = double;
+} // namespace opencl
+
 // Vector aliases are different between SYCL 1.2.1 and SYCL 2020
 #if SYCL_LANGUAGE_VERSION >= 202001
 __SYCL_2020_MAKE_VECTOR_ALIASES_FOR_VECTOR_LENGTH(2)

sycl/test/aliases-opencl.cpp

@@ -0,0 +1,95 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+//
+// This test aims to check that the implementation provides aliases for
+// interoperability with OpenCL in accordance with section C.7.1 Data types of
+// SYCL 2020 specification, revision 6
+
+#include <sycl/sycl.hpp>
+
+#include <type_traits>
+
+int main() {
+  // cl_bool
+  // Alias to a conditional data type which can be either true or false.
+  // The value true expands to the integer constant 1 and the value false
+  // expands to the integer constant 0.
+  constexpr sycl::opencl::cl_bool True = true;
+  constexpr sycl::opencl::cl_bool False = false;
+  static_assert((int)True == 1);
+  static_assert((int)False == 0);
+
+  // cl_char
+  // Alias to a signed 1-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_char) == 1);
+  static_assert(std::is_signed_v<sycl::opencl::cl_char>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_char>);
+
+  // cl_uchar
+  // Alias to an unsigned 1-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_uchar) == 1);
+  static_assert(std::is_unsigned_v<sycl::opencl::cl_uchar>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_uchar>);
+
+  // cl_short
+  // Alias to a signed 2-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_short) == 2);
+  static_assert(std::is_signed_v<sycl::opencl::cl_short>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_short>);
+
+  // cl_ushort
+  // Alias to an unsigned 2-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_ushort) == 2);
+  static_assert(std::is_unsigned_v<sycl::opencl::cl_ushort>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_ushort>);
+
+  // cl_int
+  // Alias to a signed 4-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_int) == 4);
+  static_assert(std::is_signed_v<sycl::opencl::cl_int>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_int>);
+
+  // cl_uint
+  // Alias to an unsigned 4-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_uint) == 4);
+  static_assert(std::is_unsigned_v<sycl::opencl::cl_uint>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_uint>);
+
+  // cl_long
+  // Alias to a signed 8-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_long) == 8);
+  static_assert(std::is_signed_v<sycl::opencl::cl_long>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_long>);
+
+  // cl_ulong
+  // Alias to an unsigned 8-bit integer, as defined by the C++ core language.
+  static_assert(sizeof(sycl::opencl::cl_ulong) == 8);
+  static_assert(std::is_unsigned_v<sycl::opencl::cl_ulong>);
+  static_assert(std::is_integral_v<sycl::opencl::cl_ulong>);
+
+  // TODO: how can we check that the type conforms to IEEE 754?
+  // There is std::numeric_limits<T>::is_iec559 - is it enough?
+
+  // cl_float
+  // Alias to a 4-bit floating-point. The float data type must conform to the
+  // IEEE 754 single precision storage format.
+  static_assert(sizeof(sycl::opencl::cl_float) == 4);
+  static_assert(std::is_floating_point_v<sycl::opencl::cl_float>);
+
+  // cl_double
+  // Alias to a 8-bit floating-point. The double data type must conform to the
+  // IEEE 754 double precision storage format.
+  static_assert(sizeof(sycl::opencl::cl_double) == 8);
+  static_assert(std::is_floating_point_v<sycl::opencl::cl_double>);
+
+  // cl_half
+  // Alias to a 2-bit floating-point. The half data type must conform to the
+  // IEEE 754-2001 half precision storage format.
+  static_assert(sizeof(sycl::opencl::cl_half) == 2);
+  // TODO: do we need std::is_floating_point to return true for
+  // sycl::opencl::cl_half?
+  // We alias it to our custom class sycl::half and C++ spec says it is UB
+  // to provide specializations for std::is_floating_point type trait
+  // static_assert(std::is_floating_point_v<sycl::opencl::cl_half>);
+
+  return 0;
+}