[SYCL] Initial changes for C++11 ABI=0 support

sycl/include/sycl/detail/string.hpp

@@ -0,0 +1,72 @@
+//==----------------- string.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstring>
+#include <string>
+
+#pragma once
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+
+// This class and detail::string_view class are intended to support
+// different ABIs between libsycl and the user program.
+// This class is not inteded to replace std::string for general purpose usage.
+class string {
+  char *str = nullptr;
+
+public:
+  string() noexcept = default;
+  ~string() { delete[] str; }
+
+  string(std::string_view strn) {
+    size_t len = strn.length();
+    str = new char[len + 1];
+    strn.copy(str, len);
+    str[len] = 0;
+  }
+
+  friend void swap(string &lhs, string &rhs) noexcept {
+    std::swap(lhs.str, rhs.str);
+  }
+
+  string(string &&other) noexcept { swap(*this, other); }
+  string(const string &other) {
+    if (other.str == nullptr)
+      return;
+    *this = string{other.str};
+  }
+
+  string &operator=(string &&other) noexcept {
+    swap(*this, other);
+    return *this;
+  }
+  string &operator=(const string &other) {
+    *this = string{other};
+    return *this;
+  }
+
+  string &operator=(std::string_view strn) {
+    *this = string{strn};
+    return *this;
+  }
+
+  const char *c_str() const noexcept { return str ? str : ""; }
+
+  friend bool operator==(const string &lhs, std::string_view rhs) noexcept {
+    return rhs == lhs.c_str();
+  }
+  friend bool operator==(std::string_view lhs, const string &rhs) noexcept {
+    return lhs == rhs.c_str();
+  }
+};
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/detail/string_view.hpp

@@ -0,0 +1,52 @@
+//==-------------- string_view.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <string>
+
+#pragma once
+
+namespace sycl {
+inline namespace _V1 {
+namespace detail {
+
+// This class and detail::string class are intended to support
+// different ABIs between libsycl and the user program.
+// This class is not inteded to replace std::string_view for general purpose
+// usage.
+class string_view {
+  const char *str = nullptr;
+
+public:
+  string_view() noexcept = default;
+  string_view(const string_view &strn) noexcept = default;
+  string_view(string_view &&strn) noexcept = default;
+  string_view(std::string_view strn) noexcept : str(strn.data()) {}
+
+  string_view &operator=(string_view &&strn) noexcept = default;
+  string_view &operator=(const string_view &strn) noexcept = default;
+
+  string_view &operator=(std::string_view strn) noexcept {
+    str = strn.data();
+    return *this;
+  }
+
+  const char *data() const noexcept { return str; }
+
+  friend bool operator==(const string_view &lhs,
+                         std::string_view rhs) noexcept {
+    return rhs == lhs.data();
+  }
+  friend bool operator==(std::string_view lhs,
+                         const string_view &rhs) noexcept {
+    return lhs == rhs.data();
+  }
+};
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/detail/util.hpp

@@ -11,7 +11,9 @@
 #ifndef __SYCL_DEVICE_ONLY
 
 #include <sycl/detail/defines.hpp>
-
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+#include <sycl/detail/string.hpp>
+#endif
 #include <cstring>
 #include <mutex>
 #include <vector>
@@ -67,6 +69,26 @@ struct CmpCStr {
 
 using SerializedObj = std::vector<unsigned char>;
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+template <typename T> struct ABINeutralT { using type = T; };
+// We need special handling of std::string to handle ABI incompatibility
+// for get_info<>() when it returns std::string and vector<std::string>.
+// For this purpose, get_info_impl<>() is created to handle special
+// cases, and it is only called internally and not exposed to the user.
+// The following ReturnType structure is intended for general return type,
+// and special return types (std::string and vector of it).
+
+template <> struct ABINeutralT<std::string> { using type = detail::string; };
+
+template <> struct ABINeutralT<std::vector<std::string>> {
+  using type = std::vector<detail::string>;
+};
+
+template <typename T> using ABINeutralT_t = typename ABINeutralT<T>::type;
+#else
+template <typename T> using ABINeutralT_t = T;
+#endif
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl

sycl/include/sycl/device.hpp

@@ -8,24 +8,30 @@
 
 #pragma once
 
-#include <sycl/aspects.hpp>                                     // for aspect
-#include <sycl/backend_types.hpp>                               // for backend
-#include <sycl/detail/defines_elementary.hpp>                   // for __SY...
-#include <sycl/detail/export.hpp>                               // for __SY...
-#include <sycl/detail/info_desc_helpers.hpp>                    // for is_d...
-#include <sycl/detail/owner_less_base.hpp>                      // for Owne...
-#include <sycl/detail/pi.h>                                     // for pi_n...
-#include <sycl/device_selector.hpp>                             // for Enab...
-#include <sycl/ext/oneapi/experimental/device_architecture.hpp> // for arch...
-#include <sycl/info/info_desc.hpp>                              // for part...
-#include <sycl/platform.hpp>                                    // for plat...
-
-#include <cstddef>     // for size_t
-#include <memory>      // for shar...
-#include <string>      // for string
-#include <type_traits> // for add_...
-#include <variant>     // for hash
-#include <vector>      // for vector
+#include <sycl/aspects.hpp>
+#include <sycl/backend_types.hpp>
+#include <sycl/detail/defines_elementary.hpp>
+#include <sycl/detail/export.hpp>
+#include <sycl/detail/info_desc_helpers.hpp>
+#include <sycl/detail/owner_less_base.hpp>
+#include <sycl/detail/pi.h>
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+#include <sycl/detail/string.hpp>
+#include <sycl/detail/string_view.hpp>
+#endif
+#include <sycl/detail/util.hpp>
+#include <sycl/device_selector.hpp>
+#include <sycl/ext/oneapi/experimental/device_architecture.hpp>
+#include <sycl/info/info_desc.hpp>
+#include <sycl/platform.hpp>
+
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <variant>
+#include <vector>
 
 namespace sycl {
 inline namespace _V1 {
@@ -214,8 +220,18 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   /// type associated with the param parameter.
   ///
   /// \return device info of type described in Table 4.20.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  template <typename Param>
+  typename detail::is_device_info_desc<Param>::return_type get_info() const {
+    auto Info = get_info_impl<Param>();
+    return detail::convert_from_abi_neutral(Info);
+  }
+#else
   template <typename Param>
-  typename detail::is_device_info_desc<Param>::return_type get_info() const;
+  detail::ABINeutralT_t<
+      typename detail::is_device_info_desc<Param>::return_type>
+  get_info() const;
+#endif
 
   /// Check SYCL extension support by device
   ///
@@ -291,6 +307,13 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   template <backend BackendName, class SyclObjectT>
   friend auto get_native(const SyclObjectT &Obj)
       -> backend_return_t<BackendName, SyclObjectT>;
+
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  template <typename Param>
+  typename detail::ABINeutralT_t<
+      typename detail::is_device_info_desc<Param>::return_type>
+  get_info_impl() const;
+#endif
 };
 
 } // namespace _V1
@@ -303,4 +326,5 @@ template <> struct hash<sycl::device> {
         sycl::detail::getSyclObjImpl(Device));
   }
 };
+
 } // namespace std

sycl/include/sycl/exception.hpp

@@ -74,11 +74,21 @@ class __SYCL_EXPORT exception : public virtual std::exception {
 
   exception(std::error_code, const char *Msg);
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  exception(std::error_code ec, const std::string &Msg)
+      : exception(ec, nullptr, Msg.c_str()) {}
+#else
   exception(std::error_code, const std::string &Msg);
+#endif
 
   // new SYCL 2020 constructors
   exception(std::error_code);
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  exception(int EV, const std::error_category &ECat, const std::string &WhatArg)
+      : exception(EV, ECat, WhatArg.c_str()) {}
+#else
   exception(int, const std::error_category &, const std::string &);
+#endif
   exception(int, const std::error_category &, const char *);
   exception(int, const std::error_category &);
 
@@ -127,8 +137,16 @@ class __SYCL_EXPORT exception : public virtual std::exception {
   // base constructor for all SYCL 2020 constructors
   // exception(context *ctxPtr, std::error_code ec, const std::string
   // &what_arg);
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  exception(std::error_code ec, std::shared_ptr<context> SharedPtrCtx,
+            const std::string &what_arg)
+      : exception(ec, SharedPtrCtx, what_arg.c_str()) {}
+  exception(std::error_code EC, std::shared_ptr<context> SharedPtrCtx,
+            const char *WhatArg);
+#else
   exception(std::error_code ec, std::shared_ptr<context> SharedPtrCtx,
             const std::string &what_arg);
+#endif
 };
 
 class __SYCL2020_DEPRECATED(

sycl/include/sycl/handler.hpp

@@ -21,6 +21,10 @@
 #include <sycl/detail/pi.h>
 #include <sycl/detail/pi.hpp>
 #include <sycl/detail/reduction_forward.hpp>
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+#include <sycl/detail/string.hpp>
+#include <sycl/detail/string_view.hpp>
+#endif
 #include <sycl/device.hpp>
 #include <sycl/event.hpp>
 #include <sycl/exception.hpp>
@@ -415,6 +419,10 @@ template <int Dims> bool range_size_fits_in_size_t(const range<Dims> &r) {
   }
   return true;
 }
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+using string = std::string;
+using string_view = std::string;
+#endif
 
 } // namespace detail
 
@@ -543,7 +551,7 @@ class __SYCL_EXPORT handler {
                   bool IsKernelCreatedFromSource, bool IsESIMD);
 
   /// \return a string containing name of SYCL kernel.
-  std::string getKernelName();
+  detail::string getKernelName();
 
   template <typename LambdaNameT> bool lambdaAndKernelHaveEqualName() {
     // TODO It is unclear a kernel and a lambda/functor must to be equal or not
@@ -553,8 +561,8 @@ class __SYCL_EXPORT handler {
     // values of arguments for the kernel.
     assert(MKernel && "MKernel is not initialized");
     const std::string LambdaName = detail::KernelInfo<LambdaNameT>::getName();
-    const std::string KernelName = getKernelName();
-    return LambdaName == KernelName;
+    detail::string KernelName = getKernelName();
+    return KernelName == LambdaName;
   }
 
   /// Saves the location of user's code passed in \p CodeLoc for future usage in
@@ -837,7 +845,14 @@ class __SYCL_EXPORT handler {
   ///
   /// \param KernelName is the name of the SYCL kernel to check that the used
   ///                   kernel bundle contains.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  void verifyUsedKernelBundle(const std::string &KernelName) {
+    verifyUsedKernelBundleInternal(detail::string_view{KernelName});
+  }
+  void verifyUsedKernelBundleInternal(detail::string_view KernelName);
+#else
   void verifyUsedKernelBundle(const std::string &KernelName);
+#endif
 
   /// Stores lambda to the template-free object
   ///
@@ -3307,7 +3322,7 @@ class __SYCL_EXPORT handler {
   std::vector<detail::ArgDesc> MAssociatedAccesors;
   /// Struct that encodes global size, local size, ...
   detail::NDRDescT MNDRDesc;
-  std::string MKernelName;
+  detail::string MKernelName;
   /// Storage for a sycl::kernel object.
   std::shared_ptr<detail::kernel_impl> MKernel;
   /// Type of the command group, e.g. kernel, fill. Can also encode version.
@@ -3409,17 +3424,35 @@ class __SYCL_EXPORT handler {
   ///        expr m_Storage member
   /// \param Size the size of data getting read back / to.
   /// \param Block if read operation is blocking, default to false.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  void ext_intel_read_host_pipe(const std::string &Name, void *Ptr, size_t Size,
+                                bool Block = false) {
+    ext_intel_read_host_pipe(detail::string_view(Name), Ptr, Size, Block);
+  }
+  void ext_intel_read_host_pipe(detail::string_view Name, void *Ptr,
+                                size_t Size, bool Block = false);
+#else
   void ext_intel_read_host_pipe(const std::string &Name, void *Ptr, size_t Size,
                                 bool Block = false);
+#endif
 
   /// Write to host pipes given a host address and
   /// \param Name name of the host pipe to be passed into lower level runtime
   /// \param Ptr host pointer of host pipe as identified by address of its const
   /// expr m_Storage member
   /// \param Size the size of data getting read back / to.
   /// \param Block if write opeartion is blocking, default to false.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   void ext_intel_write_host_pipe(const std::string &Name, void *Ptr,
+                                 size_t Size, bool Block = false) {
+    ext_intel_write_host_pipe(detail::string_view(Name), Ptr, Size, Block);
+  }
+  void ext_intel_write_host_pipe(detail::string_view Name, void *Ptr,
                                  size_t Size, bool Block = false);
+#else
+  void ext_intel_write_host_pipe(const std::string &Name, void *Ptr,
+                                 size_t Size, bool Block = false);
+#endif
   friend class ext::oneapi::experimental::detail::graph_impl;
 
   bool DisableRangeRounding();