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

This reverts commit 49bbcbf.

Author: steffenlarsen

sycl/include/sycl/builtins.hpp

@@ -60,10 +60,6 @@ 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)
@@ -259,8 +255,6 @@ 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                                                 \
@@ -275,8 +269,6 @@ 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                                                \
@@ -291,7 +283,6 @@ 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                                                  \
@@ -323,17 +314,8 @@ namespace __sycl_std = __host_std;
   __SYCL_DEF_BUILTIN_GENGEOFLOATD                                              \
   __SYCL_DEF_BUILTIN_GENGEOFLOATH
 
-#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)
@@ -1960,106 +1942,141 @@ __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)
-#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
+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);
+}
 
 // float dot (float p0, float p1)
 // double dot (double p0, double p1)
 // half dot (half p0, half 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
+template <typename T>
+std::enable_if_t<detail::is_sgenfloat<T>::value, T> dot(T p0, T p1) __NOEXC {
+  return p0 * p1;
+}
+
 // 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)
-#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
+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);
+}
 
 // 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)
-#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
+template <typename T>
+std::enable_if_t<detail::is_gengeohalf<T>::value, T> normalize(T p) __NOEXC {
+  return __sycl_std::__invoke_normalize<T>(p);
+}
 
 // float fast_distance (gengeofloat p0, gengeofloat 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
+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);
+}
 
 // float fast_length (gengeofloat 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
+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);
+}
 
 // gengeofloat fast_normalize (gengeofloat 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
+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);
+}
 
 // marray geometric functions