[SYCL] Add platform enumeration and info query using liboffload

libsycl/CMakeLists.txt

@@ -37,8 +37,6 @@ option(LIBSYCL_ENABLE_PEDANTIC "Compile with pedantic enabled." OFF)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-set(LIBSYCL_SHARED_OUTPUT_NAME "sycl" CACHE STRING "Output name for the shared libsycl runtime library.")
-
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(LIBSYCL_TARGET_SUBDIR ${LLVM_DEFAULT_TARGET_TRIPLE})
   if(LIBSYCL_LIBDIR_SUBDIR)
@@ -65,7 +63,7 @@ set(LIBSYCL_SOURCE_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBSYCL_LIBRARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBSYCL_LIBRARY_DIR})
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBSYCL_LIBRARY_DIR})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LLVM_TOOLS_BINARY_DIR})
 
 set(LIBSYCL_MAJOR_VERSION 0)
 set(LIBSYCL_MINOR_VERSION 1)
@@ -117,10 +115,23 @@ add_custom_command(
 install(DIRECTORY "${LIBSYCL_SOURCE_INCLUDE_DIR}/sycl" DESTINATION ${LIBSYCL_INCLUDE_DIR} COMPONENT sycl-headers)
 install(DIRECTORY "${LIBSYCL_SOURCE_INCLUDE_DIR}/CL" DESTINATION ${LIBSYCL_INCLUDE_DIR} COMPONENT sycl-headers)
 
-set(LIBSYCL_RT_LIBS ${LIBSYCL_SHARED_OUTPUT_NAME})
-
-add_subdirectory(src)
+set(LIBSYCL_LIB_NAME "sycl")
+set(LIBSYCL_SHARED_OUTPUT_NAME "${LIBSYCL_LIB_NAME}")
+if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+  if (CMAKE_MSVC_RUNTIME_LIBRARY AND (NOT CMAKE_MSVC_RUNTIME_LIBRARY MATCHES "DLL$"))
+      message(FATAL_ERROR "libsycl requires a DLL version of the MSVC CRT.")
+  endif()
+  if ((NOT CMAKE_MSVC_RUNTIME_LIBRARY AND uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+      OR (CMAKE_MSVC_RUNTIME_LIBRARY STREQUAL "MultiThreadedDebugDLL"))
+    set(LIBSYCL_SHARED_OUTPUT_NAME "${LIBSYCL_SHARED_OUTPUT_NAME}d")
+  endif()
+endif()
 
+set(LIBSYCL_RT_LIBS ${LIBSYCL_SHARED_OUTPUT_NAME})
 add_custom_target(libsycl-runtime-libraries
   DEPENDS ${LIBSYCL_RT_LIBS}
 )
+
+add_subdirectory(src)
+
+add_subdirectory(tools)

libsycl/docs/index.rst

@@ -69,11 +69,17 @@ To build LLVM with libsycl runtime enabled the following script can be used.
   mkdir -p $installprefix
 
   cmake -G Ninja -S $llvm/llvm -B $build_llvm \
-        -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra" \
+        -DLLVM_ENABLE_PROJECTS="clang" \
         -DLLVM_INSTALL_UTILS=ON \
         -DCMAKE_INSTALL_PREFIX=$installprefix \
-        -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libsycl;libunwind" \
+        -DLLVM_ENABLE_RUNTIMES="offload;openmp;libsycl" \
         -DCMAKE_BUILD_TYPE=Release
 
   ninja -C $build_llvm install
-
+
+
+Limitations
+========
+
+SYCL runtime is not tested and is not guaranteed to work on Windows because offloading runtime (liboffload) used by SYCL runtime doesn't currently support Windows.
+The limitation to be revised once liboffload will add support for Windows.

libsycl/include/sycl/__impl/backend.hpp

@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the declaration of the SYCL enum class backend that is
+/// implementation-defined and is populated with a unique identifier for each
+/// SYCL backend that the SYCL implementation can support.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBSYCL___IMPL_BACKEND_HPP
+#define _LIBSYCL___IMPL_BACKEND_HPP
+
+#include <sycl/__impl/detail/config.hpp>
+
+#include <string_view>
+#include <type_traits>
+
+_LIBSYCL_BEGIN_NAMESPACE_SYCL
+
+// 4.1. Backends
+enum class backend : char {
+  opencl = 1,
+  level_zero = 2,
+  cuda = 3,
+  hip = 4,
+  all = 5,
+};
+
+namespace detail {
+template <typename T> struct is_backend_info_desc : std::false_type {};
+} // namespace detail
+
+// 4.5.1.1. Type traits backend_traits
+template <backend Backend> class backend_traits;
+
+template <backend Backend, typename SYCLObjectT>
+using backend_input_t =
+    typename backend_traits<Backend>::template input_type<SYCLObjectT>;
+template <backend Backend, typename SYCLObjectT>
+using backend_return_t =
+    typename backend_traits<Backend>::template return_type<SYCLObjectT>;
+
+namespace detail {
+// Used by SYCL tools
+inline std::string_view get_backend_name(const backend &Backend) {
+  switch (Backend) {
+  case backend::opencl:
+    return "opencl";
+  case backend::level_zero:
+    return "level_zero";
+  case backend::cuda:
+    return "cuda";
+  case backend::hip:
+    return "hip";
+  case backend::all:
+    return "all";
+  }
+
+  return "";
+}
+} // namespace detail
+
+_LIBSYCL_END_NAMESPACE_SYCL
+
+#endif // _LIBSYCL___IMPL_BACKEND_HPP

libsycl/include/sycl/__impl/detail/config.hpp

@@ -41,8 +41,8 @@
 
 #    else // _WIN32
 
-#      define _LIBSYCL_DLL_LOCAL [[__gnu__::__visibility__("hidden")]]
-#      define _LIBSYCL_EXPORT [[__gnu__::__visibility__("default")]]
+#      define _LIBSYCL_DLL_LOCAL __attribute__((visibility("hidden")))
+#      define _LIBSYCL_EXPORT __attribute__((visibility("default")))
 
 #    endif // _WIN32
 #  endif   // _LIBSYCL_EXPORT

libsycl/include/sycl/__impl/detail/macro_definitions.hpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains macro definitions used in SYCL implementation.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBSYCL___IMPL_DETAIL_MACRO_DEFINITIONS_HPP
+#define _LIBSYCL___IMPL_DETAIL_MACRO_DEFINITIONS_HPP
+
+#ifndef __SYCL2020_DEPRECATED
+#  if SYCL_LANGUAGE_VERSION == 202012L &&                                      \
+      !defined(SYCL2020_DISABLE_DEPRECATION_WARNINGS)
+#    define __SYCL2020_DEPRECATED(message) [[deprecated(message)]]
+#  else
+#    define __SYCL2020_DEPRECATED(message)
+#  endif
+#endif // __SYCL2020_DEPRECATED
+
+static_assert(__cplusplus >= 201703L,
+              "SYCL RT does not support C++ version earlier than C++17.");
+
+#if defined(_WIN32) && !defined(_DLL) && !defined(__SYCL_DEVICE_ONLY__)
+// SYCL library is designed such a way that STL objects cross DLL boundary,
+// which is guaranteed to work properly only when the application uses the same
+// C++ runtime that SYCL library uses.
+// The appplications using sycl.dll must be linked with dynamic/release C++ MSVC
+// runtime, i.e. be compiled with /MD switch. Similarly, the applications using
+// sycld.dll must be linked with dynamic/debug C++ runtime and be compiled with
+// /MDd switch.
+// Compiler automatically adds /MD or /MDd when -fsycl switch is used.
+// The options /MD and /MDd that make the code to use dynamic runtime also
+// define the _DLL macro.
+#  define ERROR_MESSAGE                                                        \
+    "SYCL library is designed to work safely with dynamic C++ runtime."        \
+    "Please use /MD switch with sycl.dll, /MDd switch with sycld.dll, "        \
+    "or -fsycl switch to set C++ runtime automatically."
+#  if defined(_MSC_VER)
+#    pragma message(ERROR_MESSAGE)
+#  else
+#    warning ERROR_MESSAGE
+#  endif
+#  undef ERROR_MESSAGE
+#endif // defined(_WIN32) && !defined(_DLL) && !defined(__SYCL_DEVICE_ONLY__)
+
+#endif //_LIBSYCL___IMPL_DETAIL_MACRO_DEFINITIONS_HPP

libsycl/include/sycl/__impl/detail/obj_utils.hpp

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains helper functions for tranformation between implementation
+/// and SYCL's interface objects.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBSYCL___IMPL_DETAIL_OBJ_UTILS_HPP
+#define _LIBSYCL___IMPL_DETAIL_OBJ_UTILS_HPP
+
+#include <sycl/__impl/detail/config.hpp>
+
+#include <cassert>
+#include <memory>
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+_LIBSYCL_BEGIN_NAMESPACE_SYCL
+
+namespace detail {
+
+// Note! This class relies on the fact that all SYCL interface
+// classes contain "impl" field that points to implementation object. "impl"
+// field should be accessible from this class.
+struct ImplUtils {
+  // Helper function for extracting implementation from SYCL's interface
+  // objects.
+  template <class Obj>
+  static const decltype(Obj::impl) &getSyclObjImpl(const Obj &SyclObj) {
+    assert(SyclObj.impl && "every constructor should create an impl");
+    return SyclObj.impl;
+  }
+
+  // Helper function for creation SYCL interface objects from implementations.
+  template <typename SyclObject, typename From>
+  static SyclObject createSyclObjFromImpl(From &&from) {
+    if constexpr (std::is_same_v<decltype(SyclObject::impl),
+                                 std::shared_ptr<std::decay_t<From>>>)
+      return SyclObject{from.shared_from_this()};
+    else
+      return SyclObject{std::forward<From>(from)};
+  }
+};
+
+template <class Obj>
+auto getSyclObjImpl(const Obj &SyclObj)
+    -> decltype(ImplUtils::getSyclObjImpl(SyclObj)) {
+  return ImplUtils::getSyclObjImpl(SyclObj);
+}
+
+template <typename SyclObject, typename From>
+SyclObject createSyclObjFromImpl(From &&from) {
+  return ImplUtils::createSyclObjFromImpl<SyclObject>(std::forward<From>(from));
+}
+
+// std::hash support (4.5.2. Common reference semantics)
+template <typename T> struct HashBase {
+  size_t operator()(const T &Obj) const {
+#ifdef __SYCL_DEVICE_ONLY__
+    (void)Obj;
+    return 0;
+#else
+    auto &Impl = sycl::detail::getSyclObjImpl(Obj);
+    return std::hash<std::decay_t<decltype(Impl)>>{}(Impl);
+#endif
+  }
+};
+
+} // namespace detail
+
+_LIBSYCL_END_NAMESPACE_SYCL
+
+#endif // _LIBSYCL___IMPL_DETAIL_OBJ_UTILS_HPP