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

sycl/include/sycl/detail/string.hpp

@@ -0,0 +1,83 @@
+//==----------------- 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() {
+    allocate(1);
+    *str = '\0';
+  }
+
+  string(const std::string_view &strn) {
+    allocate(strn.length() + 1);
+    strcpy(str, strn.data());
+  }
+
+  string(string &&strn) {
+    str = strn.str;
+    strn.str = nullptr;
+  }
+  string(const string &strn) {
+    allocate(strlen(strn.str) + 1);
+    strcpy(str, strn.str);
+  }
+
+  string &operator=(string &&strn) {
+    delete[] str;
+    str = strn.str;
+    strn.str = nullptr;
+    return *this;
+  }
+  string &operator=(const string &strn) {
+    allocate(strlen(strn.str) + 1);
+    strcpy(str, strn.str);
+    return *this;
+  }
+
+  string &operator=(const std::string_view &strn) {
+    allocate(strn.length() + 1);
+    strcpy(str, strn.data());
+    return *this;
+  }
+
+  ~string() { delete[] str; }
+
+  const char *c_str() { return str; }
+  const char *c_str() const { return str; }
+
+  friend bool operator==(const string &lhs, const std::string_view &rhs) {
+    return rhs == lhs.c_str();
+  }
+  friend bool operator==(const std::string_view &lhs, const string &rhs) {
+    return lhs == rhs.c_str();
+  }
+
+private:
+  void allocate(int size) {
+    delete[] str;
+    str = new char[size];
+  }
+};
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/detail/string_view.hpp

@@ -0,0 +1,66 @@
+//==-------------- 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() = default;
+  string_view(const string_view &strn) = default;
+  string_view(const std::string_view &strn) : str(strn.data()) {}
+  string_view(string_view &&strn) : str(strn.data()) {}
+
+  string_view &operator=(string_view &&strn) {
+    str = strn.str;
+    return *this;
+  }
+  string_view &operator=(const string_view &strn) {
+    str = strn.str;
+    return *this;
+  }
+
+  string_view &operator=(string &&strn) {
+    str = strn.c_str();
+    return *this;
+  }
+  string_view &operator=(const string &strn) {
+    str = strn.c_str();
+    return *this;
+  }
+
+  string_view &operator=(const std::string_view &strn) {
+    str = strn.data();
+    return *this;
+  }
+
+  const char *data() { return str; }
+  const char *data() const { return str; }
+
+  friend bool operator==(const string_view &lhs, const std::string_view &rhs) {
+    return rhs == lhs.data();
+  }
+  friend bool operator==(const std::string_view &lhs, const string_view &rhs) {
+    return lhs == rhs.data();
+  }
+};
+
+} // namespace detail
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/device.hpp

@@ -8,14 +8,16 @@
 
 #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/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/detail/string.hpp>             // for c++11 abi compatibility
+#include <sycl/detail/string_view.hpp>        // for c++11 abi compatibility
+#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...
@@ -24,8 +26,9 @@
 #include <memory>      // for shar...
 #include <string>      // for string
 #include <type_traits> // for add_...
-#include <variant>     // for hash
-#include <vector>      // for vector
+#include <typeinfo>
+#include <variant> // for hash
+#include <vector>  // for vector
 
 namespace sycl {
 inline namespace _V1 {
@@ -214,8 +217,26 @@ 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 {
+    // For C++11_ABI compatibility, we handle these string Param types
+    // separately.
+    if constexpr (std::is_same_v<Param, info::device::name> ||
+                  std::is_same_v<Param, info::device::vendor> ||
+                  std::is_same_v<Param, info::device::driver_version> ||
+                  std::is_same_v<Param, info::device::version> ||
+                  std::is_same_v<Param, info::device::profile>) {
+      detail::string_view PropertyName(typeid(Param).name());
+      detail::string Info = get_device_info(PropertyName);
+      return Info.c_str();
+    }
+    return get_info_internal<Param>();
+  }
+#else
   template <typename Param>
   typename detail::is_device_info_desc<Param>::return_type get_info() const;
+#endif
 
   /// Check SYCL extension support by device
   ///
@@ -291,6 +312,14 @@ 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::is_device_info_desc<Param>::return_type
+  get_info_internal() const;
+  // proxy of get_info_internal() to handle C++11-ABI compatibility separately.
+  detail::string get_device_info(detail::string_view Type) const;
+#endif
 };
 
 } // namespace _V1

sycl/include/sycl/exception.hpp

@@ -127,8 +127,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

@@ -25,6 +25,8 @@
 #include <sycl/detail/pi.h>
 #include <sycl/detail/pi.hpp>
 #include <sycl/detail/reduction_forward.hpp>
+#include <sycl/detail/string.hpp>
+#include <sycl/detail/string_view.hpp>
 #include <sycl/device.hpp>
 #include <sycl/event.hpp>
 #include <sycl/exception.hpp>
@@ -548,7 +550,11 @@ class __SYCL_EXPORT handler {
                   bool IsKernelCreatedFromSource, bool IsESIMD);
 
   /// \return a string containing name of SYCL kernel.
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  detail::string getKernelName();
+#else
   std::string getKernelName();
+#endif
 
   template <typename LambdaNameT> bool lambdaAndKernelHaveEqualName() {
     // TODO It is unclear a kernel and a lambda/functor must to be equal or not
@@ -558,8 +564,12 @@ class __SYCL_EXPORT handler {
     // values of arguments for the kernel.
     assert(MKernel && "MKernel is not initialized");
     const std::string LambdaName = detail::KernelInfo<LambdaNameT>::getName();
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+    detail::string KernelName = getKernelName();
+#else
     const std::string KernelName = getKernelName();
-    return LambdaName == KernelName;
+#endif
+    return KernelName == LambdaName;
   }
 
   /// Saves the location of user's code passed in \p CodeLoc for future usage in
@@ -842,7 +852,15 @@ 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) {
+    detail::string_view Name(KernelName);
+    verifyUsedKernelBundleInternal(Name);
+  }
+  void verifyUsedKernelBundleInternal(detail::string_view KernelName);
+#else
   void verifyUsedKernelBundle(const std::string &KernelName);
+#endif
 
   /// Stores lambda to the template-free object
   ///
@@ -894,7 +912,11 @@ class __SYCL_EXPORT handler {
       extractArgsAndReqsFromLambda(reinterpret_cast<char *>(KernelPtr),
                                    KI::getNumParams(), &KI::getParamDesc(0),
                                    KI::isESIMD());
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+      MKernelName = detail::string(KI::getName());
+#else
       MKernelName = KI::getName();
+#endif
     } else {
       // In case w/o the integration header it is necessary to process
       // accessors from the list(which are associated with this handler) as
@@ -3294,7 +3316,11 @@ class __SYCL_EXPORT handler {
   std::vector<detail::ArgDesc> MAssociatedAccesors;
   /// Struct that encodes global size, local size, ...
   detail::NDRDescT MNDRDesc;
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  detail::string MKernelName;
+#else
   std::string MKernelName;
+#endif
   /// 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.
@@ -3396,17 +3422,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();

sycl/include/sycl/kernel_bundle.hpp

@@ -46,7 +46,7 @@ auto get_native(const kernel_bundle<State> &Obj)
 namespace detail {
 class kernel_id_impl;
 class kernel_impl;
-}
+} // namespace detail
 
 template <typename KernelName> kernel_id get_kernel_id();
 
@@ -446,15 +446,23 @@ kernel_bundle(kernel_bundle<State> &&) -> kernel_bundle<State>;
 namespace detail {
 // Internal non-template versions of get_kernel_id API which is used by public
 // onces
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+__SYCL_EXPORT kernel_id get_kernel_id_impl(string_view KernelName);
+#else
 __SYCL_EXPORT kernel_id get_kernel_id_impl(std::string KernelName);
+#endif
 } // namespace detail
 
 /// \returns the kernel_id associated with the KernelName
 template <typename KernelName> kernel_id get_kernel_id() {
   // FIXME: This must fail at link-time if KernelName not in any available
   // translation units.
   using KI = sycl::detail::KernelInfo<KernelName>;
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+  return detail::get_kernel_id_impl(detail::string_view(KI::getName()));
+#else
   return detail::get_kernel_id_impl(KI::getName());
+#endif
 }
 
 /// \returns a vector with all kernel_id's defined in the application