intel · bader · Apr 7, 2020 · Apr 2, 2020 · Apr 5, 2020 · Apr 6, 2020
@@ -5,7 +5,6 @@ project(sycl-solution)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 option(SYCL_ENABLE_WERROR "Treat all warnings as errors in SYCL project" OFF)
 
 # enable all warnings by default

@@ -9,6 +9,7 @@
 #pragma once
 #include <CL/__spirv/spirv_types.hpp>
 #include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
@@ -256,16 +257,17 @@ OpGroupAsyncCopyLocalToGlobal(__spv::Scope::Flag Execution, dataT *Dest,
   return nullptr;
 }
 
-extern void __spirv_ocl_prefetch(const char *Ptr, size_t NumBytes) noexcept;
+extern __SYCL_EXPORT void __spirv_ocl_prefetch(const char *Ptr,
+                                               size_t NumBytes) noexcept;
 
-__SYCL_CONVERGENT__ extern SYCL_EXTERNAL void
+__SYCL_CONVERGENT__ extern SYCL_EXTERNAL __SYCL_EXPORT void
 __spirv_ControlBarrier(__spv::Scope Execution, __spv::Scope Memory,
                        uint32_t Semantics) noexcept;
 
-__SYCL_CONVERGENT__ extern SYCL_EXTERNAL void
+__SYCL_CONVERGENT__ extern SYCL_EXTERNAL __SYCL_EXPORT void
 __spirv_MemoryBarrier(__spv::Scope Memory, uint32_t Semantics) noexcept;
 
-__SYCL_CONVERGENT__ extern SYCL_EXTERNAL void
+__SYCL_CONVERGENT__ extern SYCL_EXTERNAL __SYCL_EXPORT void
 __spirv_GroupWaitEvents(__spv::Scope Execution, uint32_t NumEvents,
                         __ocl_event_t *WaitEvents) noexcept;
 

@@ -8,9 +8,11 @@
 
 #pragma once
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/exception_list.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/stl.hpp>
+
 #include <type_traits>
 // 4.6.2 Context class
 
@@ -23,7 +25,7 @@ namespace detail {
 class context_impl;
 }
 
-class context {
+class __SYCL_EXPORT context {
 public:
   /// Constructs a SYCL context instance using an instance of default_selector.
   ///

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <CL/sycl/access/access.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/sycl_mem_obj_i.hpp>
 #include <CL/sycl/id.hpp>
 #include <CL/sycl/range.hpp>
@@ -37,8 +38,7 @@ template <int Dims> class AccessorImplDevice {
   range<Dims> MemRange;
 
   bool operator==(const AccessorImplDevice &Rhs) const {
-    return (Offset == Rhs.Offset &&
-            AccessRange == Rhs.AccessRange &&
+    return (Offset == Rhs.Offset && AccessRange == Rhs.AccessRange &&
             MemRange == Rhs.MemRange);
   }
 };
@@ -59,7 +59,7 @@ template <int Dims> class LocalAccessorBaseDevice {
   }
 };
 
-class AccessorImplHost {
+class __SYCL_EXPORT AccessorImplHost {
 public:
   AccessorImplHost(id<3> Offset, range<3> AccessRange, range<3> MemoryRange,
                    access::mode AccessMode, detail::SYCLMemObjI *SYCLMemObject,
@@ -129,7 +129,7 @@ class AccessorBaseHost {
   AccessorImplPtr impl;
 };
 
-class LocalAccessorImplHost {
+class __SYCL_EXPORT LocalAccessorImplHost {
 public:
   LocalAccessorImplHost(sycl::range<3> Size, int Dims, int ElemSize)
       : MSize(Size), MDims(Dims), MElemSize(ElemSize),
@@ -185,7 +185,7 @@ class LocalAccessorBaseHost {
 
 using Requirement = AccessorImplHost;
 
-void addHostAccessorAndWait(Requirement *Req);
+void __SYCL_EXPORT addHostAccessorAndWait(Requirement *Req);
 
 } // namespace detail
 } // namespace sycl

@@ -12,6 +12,7 @@
 #include <CL/sycl/access/access.hpp>
 #include <CL/sycl/context.hpp>
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/helpers.hpp>
 #include <CL/sycl/detail/sycl_mem_obj_t.hpp>
 #include <CL/sycl/handler.hpp>
@@ -38,7 +39,7 @@ using buffer_allocator = detail::sycl_memory_object_allocator;
 
 namespace detail {
 
-class buffer_impl final : public SYCLMemObjT {
+class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
   using BaseT = SYCLMemObjT;
   using typename BaseT::MemObjType;
 
@@ -104,7 +105,7 @@ class buffer_impl final : public SYCLMemObjT {
               std::move(Allocator)) {}
 
   void *allocateMem(ContextImplPtr Context, bool InitFromUserData,
-                   void *HostPtr, RT::PiEvent &OutEventToWait) override;
+                    void *HostPtr, RT::PiEvent &OutEventToWait) override;
 
   MemObjType getType() const override { return MemObjType::BUFFER; }
 

@@ -10,6 +10,7 @@
 
 #include <CL/sycl/detail/accessor_impl.hpp>
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/helpers.hpp>
 #include <CL/sycl/detail/host_profiling_info.hpp>
 #include <CL/sycl/detail/kernel_desc.hpp>
@@ -55,7 +56,7 @@ class interop_handler {
 private:
   cl_command_queue MQueue;
   std::vector<ReqToMem> MMemObjs;
-  cl_mem getMemImpl(detail::Requirement* Req) const;
+  __SYCL_EXPORT cl_mem getMemImpl(detail::Requirement *Req) const;
 };
 
 namespace detail {

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/detail/export.hpp>
 
 // Suppress a compiler warning about undefined CL_TARGET_OPENCL_VERSION
 // Khronos ICD supports only latest OpenCL version
@@ -84,7 +85,7 @@ __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
-const char *stringifyErrorCode(cl_int error);
+__SYCL_EXPORT const char *stringifyErrorCode(cl_int error);
 
 static inline std::string codeToString(cl_int code) {
   return std::string(std::to_string(code) + " (" + stringifyErrorCode(code) +

@@ -7,14 +7,15 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/stl.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
-vector_class<string_class> split_string(const string_class &str,
-                                        char delimeter);
+vector_class<string_class> __SYCL_EXPORT split_string(const string_class &str,
+                                                      char delimeter);
 
 } // namespace detail
 } // namespace sycl

@@ -31,11 +31,3 @@
 #ifndef SYCL_EXTERNAL
 #define SYCL_EXTERNAL
 #endif
-
-#if __cplusplus >= 201402
-#define __SYCL_DEPRECATED__(message) [[deprecated(message)]]
-#elif !defined _MSC_VER
-#define __SYCL_DEPRECATED__(message) __attribute__((deprecated(message)))
-#else
-#define __SYCL_DEPRECATED__(message)
-#endif
@@ -0,0 +1,38 @@
+//==---------------- export.hpp - SYCL standard header file ----------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#ifndef SYCL_DEVICE_ONLY
+#ifndef __SYCL_EXPORT
+#ifdef _WIN32
+
+// MSVC discourages export of classes, that use STL class in API. This
+// results in a warning, treated as compile error. Silence C4251 to workaround.
+#pragma warning(disable : 4251)
+#pragma warning(disable : 4275)
+
+#define DLL_LOCAL
+
+#if __SYCL_BUILD_SYCL_DLL
+#define __SYCL_EXPORT __declspec(dllexport)
+#define __SYCL_EXPORT_DEPRECATED(x) __declspec(dllexport, deprecated)
+#else
+#define __SYCL_EXPORT __declspec(dllimport)
+#define __SYCL_EXPORT_DEPRECATED(x) __declspec(dllimport, deprecated)
+#endif
+#else
+
+#define DLL_LOCAL __attribute__((visibility("hidden")))
+
+#define __SYCL_EXPORT __attribute__((visibility("default")))
+#define __SYCL_EXPORT_DEPRECATED(x)                                            \
+  __attribute__((visibility("default"), deprecated(x)))
+#endif
+#endif
+#endif
@@ -9,13 +9,15 @@
 #pragma once
 
 #include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
-bool match_types(const info::device_type &l, const info::device_type &r);
+__SYCL_EXPORT bool match_types(const info::device_type &l,
+                               const info::device_type &r);
 
 info::device_type get_forced_type();
 

@@ -582,11 +582,11 @@ struct RelConverter<
 };
 
 template <typename T> static constexpr T max_v() {
-  return std::numeric_limits<T>::max();
+  return (std::numeric_limits<T>::max)();
 }
 
 template <typename T> static constexpr T min_v() {
-  return std::numeric_limits<T>::min();
+  return (std::numeric_limits<T>::min)();
 }
 
 template <typename T> static constexpr T quiet_NaN() {
@@ -604,8 +604,7 @@ class is_same_vector_size_impl<FirstSize, T, Args...> {
 
 public:
   static constexpr bool value =
-      IsSizeEqual ? is_same_vector_size_impl<FirstSize, Args...>::value
-                   : false;
+      IsSizeEqual ? is_same_vector_size_impl<FirstSize, Args...>::value : false;
 };
 
 template <int FirstSize>

@@ -12,6 +12,7 @@
 #include <CL/__spirv/spirv_vars.hpp>
 #include <CL/sycl/access/access.hpp>
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <CL/sycl/detail/type_traits.hpp>
 
@@ -44,11 +45,11 @@ inline void memcpy(void *Dst, const void *Src, size_t Size) {
 class context_impl;
 // The function returns list of events that can be passed to OpenCL API as
 // dependency list and waits for others.
-std::vector<RT::PiEvent>
+__SYCL_EXPORT std::vector<RT::PiEvent>
 getOrWaitEvents(std::vector<cl::sycl::event> DepEvents,
                 std::shared_ptr<cl::sycl::detail::context_impl> Context);
 
-void waitEvents(std::vector<cl::sycl::event> DepEvents);
+__SYCL_EXPORT void waitEvents(std::vector<cl::sycl::event> DepEvents);
 
 class Builder {
 public:

@@ -9,13 +9,14 @@
 #pragma once
 
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/export.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
 /// Profiling info for the host execution.
-class HostProfilingInfo {
+class __SYCL_EXPORT HostProfilingInfo {
   cl_ulong StartTime = 0;
   cl_ulong EndTime = 0;
 

@@ -13,6 +13,7 @@
 
 #ifndef __SYCL_DEVICE_ONLY__
 #include <CL/sycl/builtins.hpp>
+#include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/detail/generic_type_traits.hpp>
 #include <CL/sycl/image.hpp>
 #include <CL/sycl/sampler.hpp>
@@ -99,21 +100,25 @@ getImageOffset(const vec<T, 4> &Coords, const id<3> ImgPitch,
 
 // Process cl_float4 Coordinates and return the appropriate Pixel Coordinates to
 // read from based on Addressing Mode for Nearest filter mode.
-cl_int4 getPixelCoordNearestFiltMode(cl_float4, const addressing_mode,
-                                     const range<3>);
+__SYCL_EXPORT cl_int4 getPixelCoordNearestFiltMode(cl_float4,
+                                                   const addressing_mode,
+                                                   const range<3>);
 
 // Process cl_float4 Coordinates and return the appropriate Pixel Coordinates to
 // read from based on Addressing Mode for Linear filter mode.
-cl_int8 getPixelCoordLinearFiltMode(cl_float4, const addressing_mode,
-                                    const range<3>, cl_float4 &);
+__SYCL_EXPORT cl_int8 getPixelCoordLinearFiltMode(cl_float4,
+                                                  const addressing_mode,
+                                                  const range<3>, cl_float4 &);
 
 // Check if PixelCoord are out of range for Sampler with clamp adressing mode.
-bool isOutOfRange(const cl_int4 PixelCoord, const addressing_mode SmplAddrMode,
-                  const range<3> ImgRange);
+__SYCL_EXPORT bool isOutOfRange(const cl_int4 PixelCoord,
+                                const addressing_mode SmplAddrMode,
+                                const range<3> ImgRange);
 
 // Get Border Color for the image_channel_order, the border color values are
 // only used when the sampler has clamp addressing mode.
-cl_float4 getBorderColor(const image_channel_order ImgChannelOrder);
+__SYCL_EXPORT cl_float4
+getBorderColor(const image_channel_order ImgChannelOrder);
 
 // Reads data from a pixel at Ptr location, based on the number of Channels in
 // Order and returns the data.