[SYCL] Make SYCL geometrical functions overloads instead of templates (#10014)

It was decided to change all built-in functions from templates to
overloads. This patch changes non-marray part of "4.17.8. Geometric
functions".

Marray part: #10048

Spec: KhronosGroup/SYCL-Docs#428

---------

Co-authored-by: Steffen Larsen <[email protected]>

Author: KornevNikita

sycl/include/sycl/builtins.hpp

@@ -60,6 +60,10 @@ namespace __sycl_std = __host_std;
   __SYCL_BUILTIN_DEF(TYPE##3)                                                  \
   __SYCL_BUILTIN_DEF(TYPE##4)
 
+#define __SYCL_DEF_BUILTIN_GEOCROSSVEC(TYPE)                                   \
+  __SYCL_BUILTIN_DEF(TYPE##3)                                                  \
+  __SYCL_BUILTIN_DEF(TYPE##4)
+
 #define __SYCL_DEF_BUILTIN_MARRAY(TYPE)
 
 #define __SYCL_DEF_BUILTIN_CHAR_SCALAR __SYCL_BUILTIN_DEF(char)
@@ -255,6 +259,8 @@ namespace __sycl_std = __host_std;
 #define __SYCL_DEF_BUILTIN_FLOAT_SCALAR __SYCL_BUILTIN_DEF(float)
 #define __SYCL_DEF_BUILTIN_FLOAT_VEC __SYCL_DEF_BUILTIN_VEC(float)
 #define __SYCL_DEF_BUILTIN_FLOAT_GEOVEC __SYCL_DEF_BUILTIN_GEOVEC(float)
+#define __SYCL_DEF_BUILTIN_FLOAT_GEOCROSSVEC                                   \
+  __SYCL_DEF_BUILTIN_GEOCROSSVEC(float)
 #define __SYCL_DEF_BUILTIN_FLOAT_MARRAY __SYCL_DEF_BUILTIN_MARRAY(float)
 #define __SYCL_DEF_BUILTIN_FLOATN                                              \
   __SYCL_DEF_BUILTIN_FLOAT_VEC                                                 \
@@ -269,6 +275,8 @@ namespace __sycl_std = __host_std;
 #define __SYCL_DEF_BUILTIN_DOUBLE_SCALAR __SYCL_BUILTIN_DEF(double)
 #define __SYCL_DEF_BUILTIN_DOUBLE_VEC __SYCL_DEF_BUILTIN_VEC(double)
 #define __SYCL_DEF_BUILTIN_DOUBLE_GEOVEC __SYCL_DEF_BUILTIN_GEOVEC(double)
+#define __SYCL_DEF_BUILTIN_DOUBLE_GEOCROSSVEC                                  \
+  __SYCL_DEF_BUILTIN_GEOCROSSVEC(double)
 #define __SYCL_DEF_BUILTIN_DOUBLE_MARRAY __SYCL_DEF_BUILTIN_MARRAY(double)
 #define __SYCL_DEF_BUILTIN_DOUBLEN                                             \
   __SYCL_DEF_BUILTIN_DOUBLE_VEC                                                \
@@ -283,6 +291,7 @@ namespace __sycl_std = __host_std;
 #define __SYCL_DEF_BUILTIN_HALF_SCALAR __SYCL_BUILTIN_DEF(half)
 #define __SYCL_DEF_BUILTIN_HALF_VEC __SYCL_DEF_BUILTIN_VEC(half)
 #define __SYCL_DEF_BUILTIN_HALF_GEOVEC __SYCL_DEF_BUILTIN_GEOVEC(half)
+#define __SYCL_DEF_BUILTIN_HALF_GEOCROSSVEC __SYCL_DEF_BUILTIN_GEOCROSSVEC(half)
 #define __SYCL_DEF_BUILTIN_HALF_MARRAY __SYCL_DEF_BUILTIN_MARRAY(half)
 #define __SYCL_DEF_BUILTIN_HALFN                                               \
   __SYCL_DEF_BUILTIN_HALF_VEC                                                  \
@@ -314,8 +323,17 @@ namespace __sycl_std = __host_std;
   __SYCL_DEF_BUILTIN_GENGEOFLOATD                                              \
   __SYCL_DEF_BUILTIN_GENGEOFLOATH
 
-// TODO: Replace with overloads.
+#define __SYCL_DEF_BUILTIN_VGENGEOCROSSFLOAT                                   \
+  __SYCL_DEF_BUILTIN_FLOAT_GEOCROSSVEC                                         \
+  __SYCL_DEF_BUILTIN_DOUBLE_GEOCROSSVEC                                        \
+  __SYCL_DEF_BUILTIN_HALF_GEOCROSSVEC
+
+#define __SYCL_DEF_BUILTIN_VGENGEOFLOAT                                        \
+  __SYCL_DEF_BUILTIN_FLOAT_GEOVEC                                              \
+  __SYCL_DEF_BUILTIN_DOUBLE_GEOVEC                                             \
+  __SYCL_DEF_BUILTIN_HALF_GEOVEC
 
+// TODO: Replace with overloads.
 #ifdef __FAST_MATH__
 #define __FAST_MATH_GENFLOAT(T)                                                \
   (detail::is_svgenfloatd<T>::value || detail::is_svgenfloath<T>::value)
@@ -1942,141 +1960,106 @@ __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_IU_OVERLOAD(upsample, 32bit)
 // double4 cross (double4 p0, double4 p1)
 // half3 cross (half3 p0, half3 p1)
 // half4 cross (half4 p0, half4 p1)
-template <typename T>
-std::enable_if_t<detail::is_gencross<T>::value, T> cross(T p0, T p1) __NOEXC {
-  return __sycl_std::__invoke_cross<T>(p0, p1);
-}
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE cross(TYPE p0, TYPE p1) __NOEXC {                                \
+    return __sycl_std::__invoke_cross<TYPE>(p0, p1);                           \
+  }
+__SYCL_DEF_BUILTIN_VGENGEOCROSSFLOAT
+#undef __SYCL_BUILTIN_DEF
+#undef __SYCL_DEF_BUILTIN_VGENGEOCROSSFLOAT
+#undef __SYCL_DEF_BUILTIN_HALF_GEOCROSSVEC
+#undef __SYCL_DEF_BUILTIN_DOUBLE_GEOCROSSVEC
+#undef __SYCL_DEF_BUILTIN_FLOAT_GEOCROSSVEC
+#undef __SYCL_DEF_BUILTIN_GEOCROSSVEC
 
 // float dot (float p0, float p1)
 // double dot (double p0, double p1)
 // half dot (half p0, half p1)
-template <typename T>
-std::enable_if_t<detail::is_sgenfloat<T>::value, T> dot(T p0, T p1) __NOEXC {
-  return p0 * p1;
-}
-
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE dot(TYPE p0, TYPE p1) __NOEXC { return p0 * p1; }
+__SYCL_DEF_BUILTIN_SGENFLOAT
+#undef __SYCL_BUILTIN_DEF
 // float dot (vgengeofloat p0, vgengeofloat p1)
-template <typename T>
-std::enable_if_t<detail::is_vgengeofloat<T>::value, float> dot(T p0,
-                                                               T p1) __NOEXC {
-  return __sycl_std::__invoke_Dot<float>(p0, p1);
-}
-
 // double dot (vgengeodouble p0, vgengeodouble p1)
-template <typename T>
-std::enable_if_t<detail::is_vgengeodouble<T>::value, double> dot(T p0,
-                                                                 T p1) __NOEXC {
-  return __sycl_std::__invoke_Dot<double>(p0, p1);
-}
-
 // half dot (vgengeohalf p0, vgengeohalf p1)
-template <typename T>
-std::enable_if_t<detail::is_vgengeohalf<T>::value, half> dot(T p0,
-                                                             T p1) __NOEXC {
-  return __sycl_std::__invoke_Dot<half>(p0, p1);
-}
-
-// float distance (gengeofloat p0, gengeofloat p1)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
-float distance(T p0, T p1) __NOEXC {
-  return __sycl_std::__invoke_distance<float>(p0, p1);
-}
-
-// double distance (gengeodouble p0, gengeodouble p1)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
-double distance(T p0, T p1) __NOEXC {
-  return __sycl_std::__invoke_distance<double>(p0, p1);
-}
-
-// half distance (gengeohalf p0, gengeohalf p1)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeohalf<T>::value, T>>
-half distance(T p0, T p1) __NOEXC {
-  return __sycl_std::__invoke_distance<half>(p0, p1);
-}
-
-// float length (gengeofloat p)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
-float length(T p) __NOEXC {
-  return __sycl_std::__invoke_length<float>(p);
-}
-
-// double length (gengeodouble p)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
-double length(T p) __NOEXC {
-  return __sycl_std::__invoke_length<double>(p);
-}
-
-// half length (gengeohalf p)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeohalf<T>::value, T>>
-half length(T p) __NOEXC {
-  return __sycl_std::__invoke_length<half>(p);
-}
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE::element_type dot(TYPE p0, TYPE p1) __NOEXC {                    \
+    return __sycl_std::__invoke_Dot<TYPE::element_type>(p0, p1);               \
+  }
+__SYCL_DEF_BUILTIN_VGENGEOFLOAT
+#undef __SYCL_BUILTIN_DEF
+
+// float distance (float p0, float p1)
+// double distance (double p0, double p1)
+// half distance (half p0, half p1)
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE distance(TYPE p0, TYPE p1) __NOEXC {                             \
+    return __sycl_std::__invoke_distance<TYPE>(p0, p1);                        \
+  }
+__SYCL_DEF_BUILTIN_SGENFLOAT
+#undef __SYCL_BUILTIN_DEF
+// float distance (vgengeofloat p0, vgengeofloat p1)
+// double distance (vgengeodouble p0, vgengeodouble p1)
+// half distance (vgengeohalf p0, vgengeohalf p1)
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE::element_type distance(TYPE p0, TYPE p1) __NOEXC {               \
+    return __sycl_std::__invoke_distance<TYPE::element_type>(p0, p1);          \
+  }
+__SYCL_DEF_BUILTIN_VGENGEOFLOAT
+#undef __SYCL_BUILTIN_DEF
+
+// float length (float p0, float p1)
+// double length (double p0, double p1)
+// half length (half p0, half p1)
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE length(TYPE p) __NOEXC {                                         \
+    return __sycl_std::__invoke_length<TYPE>(p);                               \
+  }
+__SYCL_DEF_BUILTIN_SGENFLOAT
+#undef __SYCL_BUILTIN_DEF
+// float length (vgengeofloat p0, vgengeofloat p1)
+// double length (vgengeodouble p0, vgengeodouble p1)
+// half length (vgengeohalf p0, vgengeohalf p1)
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE::element_type length(TYPE p) __NOEXC {                           \
+    return __sycl_std::__invoke_length<TYPE::element_type>(p);                 \
+  }
+__SYCL_DEF_BUILTIN_VGENGEOFLOAT
+#undef __SYCL_BUILTIN_DEF
 
 // gengeofloat normalize (gengeofloat p)
-template <typename T>
-std::enable_if_t<detail::is_gengeofloat<T>::value, T> normalize(T p) __NOEXC {
-  return __sycl_std::__invoke_normalize<T>(p);
-}
-
 // gengeodouble normalize (gengeodouble p)
-template <typename T>
-std::enable_if_t<detail::is_gengeodouble<T>::value, T> normalize(T p) __NOEXC {
-  return __sycl_std::__invoke_normalize<T>(p);
-}
-
 // gengeohalf normalize (gengeohalf p)
-template <typename T>
-std::enable_if_t<detail::is_gengeohalf<T>::value, T> normalize(T p) __NOEXC {
-  return __sycl_std::__invoke_normalize<T>(p);
-}
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE normalize(TYPE p) __NOEXC {                                      \
+    return __sycl_std::__invoke_normalize<TYPE>(p);                            \
+  }
+__SYCL_DEF_BUILTIN_GENGEOFLOAT
+#undef __SYCL_BUILTIN_DEF
 
 // float fast_distance (gengeofloat p0, gengeofloat p1)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
-float fast_distance(T p0, T p1) __NOEXC {
-  return __sycl_std::__invoke_fast_distance<float>(p0, p1);
-}
-
-// double fast_distance (gengeodouble p0, gengeodouble p1)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
-double fast_distance(T p0, T p1) __NOEXC {
-  return __sycl_std::__invoke_fast_distance<double>(p0, p1);
-}
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline float fast_distance(TYPE p0, TYPE p1) __NOEXC {                       \
+    return __sycl_std::__invoke_fast_distance<float>(p0, p1);                  \
+  }
+__SYCL_DEF_BUILTIN_GENGEOFLOATF
+#undef __SYCL_BUILTIN_DEF
 
 // float fast_length (gengeofloat p)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
-float fast_length(T p) __NOEXC {
-  return __sycl_std::__invoke_fast_length<float>(p);
-}
-
-// double fast_length (gengeodouble p)
-template <typename T,
-          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
-double fast_length(T p) __NOEXC {
-  return __sycl_std::__invoke_fast_length<double>(p);
-}
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline float fast_length(TYPE p) __NOEXC {                                   \
+    return __sycl_std::__invoke_fast_length<float>(p);                         \
+  }
+__SYCL_DEF_BUILTIN_GENGEOFLOATF
+#undef __SYCL_BUILTIN_DEF
 
 // gengeofloat fast_normalize (gengeofloat p)
-template <typename T>
-std::enable_if_t<detail::is_gengeofloat<T>::value, T>
-fast_normalize(T p) __NOEXC {
-  return __sycl_std::__invoke_fast_normalize<T>(p);
-}
-
-// gengeodouble fast_normalize (gengeodouble p)
-template <typename T>
-std::enable_if_t<detail::is_gengeodouble<T>::value, T>
-fast_normalize(T p) __NOEXC {
-  return __sycl_std::__invoke_fast_normalize<T>(p);
-}
+#define __SYCL_BUILTIN_DEF(TYPE)                                               \
+  inline TYPE fast_normalize(TYPE p) __NOEXC {                                 \
+    return __sycl_std::__invoke_fast_normalize<TYPE>(p);                       \
+  }
+__SYCL_DEF_BUILTIN_GENGEOFLOATF
+#undef __SYCL_BUILTIN_DEF
 
 // marray geometric functions