Merge remote-tracking branch 'origin/sycl' into HEAD

Author: aelovikov-intel

clang/lib/Driver/SanitizerArgs.cpp

@@ -1297,6 +1297,8 @@ void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
       CmdArgs.push_back("-asan-stack-dynamic-alloca=0");
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-asan-use-after-return=never");
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back("-asan-instrument-dynamic-allocas=0");
 
       if (!RecoverableSanitizers.empty())
         CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" +

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -147,7 +147,7 @@ SYCLInstallationDetector::SYCLInstallationDetector(const Driver &D)
 SYCLInstallationDetector::SYCLInstallationDetector(
     const Driver &D, const llvm::Triple &HostTriple,
     const llvm::opt::ArgList &Args)
-    : D(D) {}
+    : SYCLInstallationDetector(D) {}
 
 static llvm::SmallString<64>
 getLibSpirvBasename(const llvm::Triple &DeviceTriple,

clang/test/Driver/sycl-device-sanitizer.cpp

@@ -18,6 +18,7 @@
 // SYCL-ASAN-SAME: "-mllvm" "-asan-globals=0"
 // SYCL-ASAN-SAME: "-mllvm" "-asan-stack-dynamic-alloca=0"
 // SYCL-ASAN-SAME: "-mllvm" "-asan-use-after-return=never"
+// SYCL-ASAN-SAME: "-mllvm" "-asan-instrument-dynamic-allocas=0"
 // SYCL-ASAN-SAME: "-mllvm" "-asan-mapping-scale=4"
 
 // RUN: %clangxx -fsycl -Xarch_device -fsanitize=address -c %s -### 2>&1 \

libclc/clc/include/clc/math/unary_builtin_scalarize.inc

@@ -17,24 +17,26 @@
 #define __CLC_BUILTIN_H __CLC_BUILTIN_F
 #endif
 
+#if (!defined(__HALF_ONLY) && !defined(__DOUBLE_ONLY))
 _CLC_DEFINE_UNARY_BUILTIN_SCALARIZE(float, __CLC_FUNCTION, __CLC_BUILTIN_F, float)
+#endif
 
-#ifndef __FLOAT_ONLY
-
+#if (!defined(__HALF_ONLY) && !defined(__FLOAT_ONLY))
 #ifdef cl_khr_fp64
 
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
 
 _CLC_DEFINE_UNARY_BUILTIN_SCALARIZE(double, __CLC_FUNCTION, __CLC_BUILTIN_D, double)
 
 #endif
+#endif // (!defined(__HALF_ONLY) && !defined(__FLOAT_ONLY))
 
+#if (!defined(__FLOAT_ONLY) && !defined(__DOUBLE_ONLY))
 #ifdef cl_khr_fp16
 
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
 
 _CLC_DEFINE_UNARY_BUILTIN_SCALARIZE(half, __CLC_FUNCTION, __CLC_BUILTIN_H, half)
 
 #endif
-
-#endif // !__FLOAT_ONLY
+#endif // (!defined(__FLOAT_ONLY) && !defined(__DOUBLE_ONLY))

libclc/clc/lib/amdgcn/SOURCES

@@ -1,3 +1,9 @@
+math/clc_exp.cl
 math/clc_fmax.cl
 math/clc_fmin.cl
 math/clc_ldexp_override.cl
+math/clc_lgamma.cl
+math/clc_log.cl
+math/clc_sinpi.cl
+math/clc_sqrt.cl
+math/clc_sqrt_fp64.cl

libclc/libspirv/lib/amdgcn-amdhsa/math/exp.cl renamed to libclc/clc/lib/amdgcn/math/clc_exp.cl

@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <clc/clcmacro.h>
-#include <libspirv/spirv.h>
+#include <clc/internal/clc.h>
+#include <clc/math/clc_exp.h>
 
-#define __CLC_FUNCTION __spirv_ocl_exp
+#define __CLC_FUNCTION __clc_exp
 #define __CLC_BUILTIN __ocml_exp
 
 float __ocml_exp_f32(float);

libclc/clc/lib/amdgcn/math/clc_fmax.cl

@@ -6,44 +6,25 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <clc/clcmacro.h>
 #include <clc/internal/clc.h>
-#include <clc/relational/clc_isnan.h>
+#include <clc/math/clc_fmax.h>
 
-_CLC_DEF _CLC_OVERLOAD float __clc_fmax(float x, float y) {
-  // fcanonicalize removes sNaNs and flushes denormals if not enabled. Otherwise
-  // fmax instruction flushes the values for comparison, but outputs original
-  // denormal
-  x = __builtin_canonicalizef(x);
-  y = __builtin_canonicalizef(y);
-  return __builtin_fmaxf(x, y);
-}
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, float, __clc_fmax, float, float)
+#define __CLC_FUNCTION __clc_fmax
+#define __CLC_BUILTIN __ocml_fmax
 
-#ifdef cl_khr_fp64
+float __ocml_fmax_f32(float, float);
+#define __CLC_BUILTIN_F __CLC_XCONCAT(__CLC_BUILTIN, _f32)
 
+#ifdef cl_khr_fp64
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
+double __ocml_fmax_f64(double, double);
+#define __CLC_BUILTIN_D __CLC_XCONCAT(__CLC_BUILTIN, _f64)
+#endif // cl_khr_fp64
 
-_CLC_DEF _CLC_OVERLOAD double __clc_fmax(double x, double y) {
-  x = __builtin_canonicalize(x);
-  y = __builtin_canonicalize(y);
-  return __builtin_fmax(x, y);
-}
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, double, __clc_fmax, double,
-                      double)
-
-#endif
 #ifdef cl_khr_fp16
-
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
+half __ocml_fmax_f16(half, half);
+#define __CLC_BUILTIN_H __CLC_XCONCAT(__CLC_BUILTIN, _f16)
+#endif // cl_khr_fp16
 
-_CLC_DEF _CLC_OVERLOAD half __clc_fmax(half x, half y) {
-  if (__clc_isnan(x))
-    return y;
-  if (__clc_isnan(y))
-    return x;
-  return (y < x) ? x : y;
-}
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, half, __clc_fmax, half, half)
-
-#endif
+#include <clc/math/binary_builtin.inc>

libclc/clc/lib/amdgcn/math/clc_fmin.cl

@@ -6,45 +6,25 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <clc/clcmacro.h>
 #include <clc/internal/clc.h>
-#include <clc/relational/clc_isnan.h>
+#include <clc/math/clc_fmin.h>
 
-_CLC_DEF _CLC_OVERLOAD float __clc_fmin(float x, float y) {
-  // fcanonicalize removes sNaNs and flushes denormals if not enabled. Otherwise
-  // fmin instruction flushes the values for comparison, but outputs original
-  // denormal
-  x = __builtin_canonicalizef(x);
-  y = __builtin_canonicalizef(y);
-  return __builtin_fminf(x, y);
-}
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, float, __clc_fmin, float, float)
+#define __CLC_FUNCTION __clc_fmin
+#define __CLC_BUILTIN __ocml_fmin
 
-#ifdef cl_khr_fp64
+float __ocml_fmin_f32(float, float);
+#define __CLC_BUILTIN_F __CLC_XCONCAT(__CLC_BUILTIN, _f32)
 
+#ifdef cl_khr_fp64
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-_CLC_DEF _CLC_OVERLOAD double __clc_fmin(double x, double y) {
-  x = __builtin_canonicalize(x);
-  y = __builtin_canonicalize(y);
-  return __builtin_fmin(x, y);
-}
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, double, __clc_fmin, double,
-                      double)
-
-#endif
+double __ocml_fmin_f64(double, double);
+#define __CLC_BUILTIN_D __CLC_XCONCAT(__CLC_BUILTIN, _f64)
+#endif // cl_khr_fp64
 
 #ifdef cl_khr_fp16
-
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
+half __ocml_fmin_f16(half, half);
+#define __CLC_BUILTIN_H __CLC_XCONCAT(__CLC_BUILTIN, _f16)
+#endif // cl_khr_fp16
 
-_CLC_DEF _CLC_OVERLOAD half __clc_fmin(half x, half y) {
-  if (__clc_isnan(x))
-    return y;
-  if (__clc_isnan(y))
-    return x;
-  return (y < x) ? y : x;
-}
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, half, __clc_fmin, half, half)
-
-#endif
+#include <clc/math/binary_builtin.inc>

libclc/libspirv/lib/amdgcn-amdhsa/math/lgamma.cl renamed to libclc/clc/lib/amdgcn/math/clc_lgamma.cl

@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <clc/clcmacro.h>
-#include <libspirv/spirv.h>
+#include <clc/internal/clc.h>
+#include <clc/math/clc_lgamma.h>
 
-#define __CLC_FUNCTION __spirv_ocl_lgamma
+#define __CLC_FUNCTION __clc_lgamma
 #define __CLC_BUILTIN __ocml_lgamma
 
 float __ocml_lgamma_f32(float);

libclc/libspirv/lib/amdgcn-amdhsa/math/log.cl renamed to libclc/clc/lib/amdgcn/math/clc_log.cl

@@ -6,10 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <clc/clcmacro.h>
-#include <libspirv/spirv.h>
+#include <clc/internal/clc.h>
+#include <clc/math/clc_log.h>
 
-#define __CLC_FUNCTION __spirv_ocl_log
+#define __CLC_FUNCTION __clc_log
 #define __CLC_BUILTIN __ocml_log
 
 float __ocml_log_f32(float);