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

sycl/include/sycl/device.hpp

@@ -19,13 +19,15 @@
 #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 <sycl/string.hpp> // for c++11 abi compatibility
 
 #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 <typeinfo>
+#include <variant> // for hash
+#include <vector>  // for vector
 
 namespace sycl {
 inline namespace _V1 {
@@ -215,7 +217,24 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   ///
   /// \return device info of type described in Table 4.20.
   template <typename Param>
-  typename detail::is_device_info_desc<Param>::return_type get_info() const;
+  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>) {
+
+      string Info = typeid(Param).name();
+      Info.allocate(100);
+      get_device_info(Info);
+      std::string DeviceInfo = Info.marshall();
+      Info.deallocate();
+      return DeviceInfo;
+    }
+    return get_info_internal<Param>();
+  }
 
   /// Check SYCL extension support by device
   ///
@@ -291,6 +310,12 @@ 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>;
+
+  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.
+  void get_device_info(string &Type) const;
 };
 
 } // namespace _V1

sycl/include/sycl/exception.hpp

@@ -128,7 +128,10 @@ class __SYCL_EXPORT exception : public virtual std::exception {
   // exception(context *ctxPtr, std::error_code ec, const std::string
   // &what_arg);
   exception(std::error_code ec, std::shared_ptr<context> SharedPtrCtx,
-            const std::string &what_arg);
+            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);
 };
 
 class __SYCL2020_DEPRECATED(

sycl/include/sycl/handler.hpp

@@ -52,6 +52,7 @@
 #include <sycl/property_list.hpp>
 #include <sycl/range.hpp>
 #include <sycl/sampler.hpp>
+#include <sycl/string.hpp>
 #include <sycl/types.hpp>
 #include <sycl/usm/usm_enums.hpp>
 #include <sycl/usm/usm_pointer_info.hpp>
@@ -548,7 +549,7 @@ class __SYCL_EXPORT handler {
                   bool IsKernelCreatedFromSource, bool IsESIMD);
 
   /// \return a string containing name of SYCL kernel.
-  std::string getKernelName();
+  string getKernelName();
 
   template <typename LambdaNameT> bool lambdaAndKernelHaveEqualName() {
     // TODO It is unclear a kernel and a lambda/functor must to be equal or not
@@ -558,8 +559,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;
+    string KernelName = getKernelName();
+    return LambdaName == KernelName.marshall();
   }
 
   /// Saves the location of user's code passed in \p CodeLoc for future usage in
@@ -842,7 +843,11 @@ class __SYCL_EXPORT handler {
   ///
   /// \param KernelName is the name of the SYCL kernel to check that the used
   ///                   kernel bundle contains.
-  void verifyUsedKernelBundle(const std::string &KernelName);
+  void verifyUsedKernelBundle(const std::string &KernelName) {
+    string Name = string(KernelName);
+    verifyUsedKernelBundleInternal(Name);
+  }
+  void verifyUsedKernelBundleInternal(string &KernelName);
 
   /// Stores lambda to the template-free object
   ///
@@ -3294,7 +3299,7 @@ class __SYCL_EXPORT handler {
   std::vector<detail::ArgDesc> MAssociatedAccesors;
   /// Struct that encodes global size, local size, ...
   detail::NDRDescT MNDRDesc;
-  std::string MKernelName;
+  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.
@@ -3397,6 +3402,10 @@ class __SYCL_EXPORT handler {
   /// \param Size the size of data getting read back / to.
   /// \param Block if read operation is blocking, default to false.
   void ext_intel_read_host_pipe(const std::string &Name, void *Ptr, size_t Size,
+                                bool Block = false) {
+    ext_intel_read_host_pipe(string(Name), Ptr, Size, Block);
+  }
+  void ext_intel_read_host_pipe(string Name, void *Ptr, size_t Size,
                                 bool Block = false);
 
   /// Write to host pipes given a host address and
@@ -3406,7 +3415,11 @@ class __SYCL_EXPORT handler {
   /// \param Size the size of data getting read back / to.
   /// \param Block if write opeartion is blocking, default to false.
   void ext_intel_write_host_pipe(const std::string &Name, void *Ptr,
-                                 size_t Size, bool Block = false);
+                                 size_t Size, bool Block = false) {
+    ext_intel_write_host_pipe(string(Name), Ptr, Size, Block);
+  }
+  void ext_intel_write_host_pipe(string Name, void *Ptr, size_t Size,
+                                 bool Block = false);
   friend class ext::oneapi::experimental::detail::graph_impl;
 
   bool DisableRangeRounding();

sycl/include/sycl/platform.hpp

@@ -18,6 +18,7 @@
 #include <sycl/detail/pi.h>                   // for pi_native_handle
 #include <sycl/device_selector.hpp>           // for EnableIfSYCL2020DeviceS...
 #include <sycl/info/info_desc.hpp>            // for device_type
+#include <sycl/string.hpp>
 
 #ifdef __SYCL_INTERNAL_API
 #include <sycl/detail/cl.h>
@@ -145,7 +146,23 @@ class __SYCL_EXPORT platform : public detail::OwnerLessBase<platform> {
   ///
   /// The return type depends on information being queried.
   template <typename Param>
-  typename detail::is_platform_info_desc<Param>::return_type get_info() const;
+  typename detail::is_platform_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::platform::name> ||
+                  std::is_same_v<Param, info::platform::vendor> ||
+                  std::is_same_v<Param, info::platform::version> ||
+                  std::is_same_v<Param, info::platform::profile>) {
+
+      string Info = typeid(Param).name();
+      Info.allocate(100);
+      get_platform_info(Info);
+      std::string PlatformInfo = Info.marshall();
+      Info.deallocate();
+      return PlatformInfo;
+    }
+    return get_info_internal<Param>();
+  }
 
   /// Returns all available SYCL platforms in the system.
   ///
@@ -204,6 +221,12 @@ class __SYCL_EXPORT platform : public detail::OwnerLessBase<platform> {
   template <backend BackendName, class SyclObjectT>
   friend auto get_native(const SyclObjectT &Obj)
       -> backend_return_t<BackendName, SyclObjectT>;
+
+  template <typename Param>
+  typename detail::is_platform_info_desc<Param>::return_type
+  get_info_internal() const;
+  // proxy of get_info_internal() to handle C++11-ABI compatibility separately.
+  void get_platform_info(string &Type) const;
 }; // class platform
 } // namespace _V1
 } // namespace sycl

sycl/include/sycl/string.hpp

@@ -0,0 +1,42 @@
+//==----------------- 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 <iostream>
+
+#pragma once
+
+namespace sycl {
+inline namespace _V1 {
+
+class string {
+  const char *str; // used to send existing std::string to libsycl
+  char *ret_str;   // set from libsycl
+
+public:
+  string() : str(nullptr), ret_str(nullptr) {}
+  string(const char *ptr) : str(ptr) {}
+  string(std::string strn) : str(strn.c_str()) {}
+
+  bool operator==(const char *st) { return strcmp(str, st) == 0; }
+
+  std::string marshall() { return std::string(ret_str); }
+
+  std::string marshall() const { return std::string(ret_str); }
+
+  void unmarshall(std::string &strn) { strcpy(ret_str, strn.c_str()); }
+
+  void allocate(int size) { ret_str = new char[size]; }
+
+  void deallocate() { delete[] ret_str; }
+
+  const char *getPtr() { return str; }
+
+  char *getRetPtr() { return ret_str; }
+};
+
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/sycl.hpp

@@ -53,6 +53,7 @@
 #include <sycl/sampler.hpp>
 #include <sycl/specialization_id.hpp>
 #include <sycl/stream.hpp>
+#include <sycl/string.hpp>
 #include <sycl/sub_group.hpp>
 #include <sycl/types.hpp>
 #include <sycl/usm.hpp>

sycl/source/detail/queue_impl.hpp

@@ -803,9 +803,9 @@ class queue_impl {
 
       if (IsKernel)
         // Kernel only uses assert if it's non interop one
-        KernelUsesAssert =
-            !(Handler.MKernel && Handler.MKernel->isInterop()) &&
-            ProgramManager::getInstance().kernelUsesAssert(Handler.MKernelName);
+        KernelUsesAssert = !(Handler.MKernel && Handler.MKernel->isInterop()) &&
+                           ProgramManager::getInstance().kernelUsesAssert(
+                               Handler.MKernelName.marshall());
 
       finalizeHandler(Handler, Type, Event);
 

sycl/source/device.cpp

@@ -16,6 +16,7 @@
 #include <sycl/info/info_desc.hpp>
 
 #include <algorithm>
+#include <typeinfo>
 
 namespace sycl {
 inline namespace _V1 {
@@ -133,13 +134,33 @@ bool device::has_extension(const std::string &extension_name) const {
 
 template <typename Param>
 typename detail::is_device_info_desc<Param>::return_type
-device::get_info() const {
+device::get_info_internal() const {
   return impl->template get_info<Param>();
 }
 
+void device::get_device_info(string &Type) const {
+  std::string Info;
+  if (Type == typeid(info::device::name).name()) {
+    Info = impl->template get_info<info::device::name>();
+  } else if (Type == typeid(info::device::vendor).name()) {
+    Info = impl->template get_info<info::device::vendor>();
+  } else if (Type == typeid(info::device::driver_version).name()) {
+    Info = impl->template get_info<info::device::driver_version>();
+  } else if (Type == typeid(info::device::version).name()) {
+    Info = impl->template get_info<info::device::version>();
+  } else if (Type == typeid(info::device::profile).name()) {
+    Info = impl->template get_info<info::device::profile>();
+  } else {
+    throw sycl::invalid_parameter_error("unsupported device info requested",
+                                        PI_ERROR_INVALID_OPERATION);
+  }
+  Type.unmarshall(Info);
+}
+
 // Explicit override. Not fulfilled by #include device_traits.def below.
 template <>
-__SYCL_EXPORT device device::get_info<info::device::parent_device>() const {
+__SYCL_EXPORT device
+device::get_info_internal<info::device::parent_device>() const {
   // With ONEAPI_DEVICE_SELECTOR the impl.MRootDevice is preset and may be
   // overridden (ie it may be nullptr on a sub-device) The PI of the sub-devices
   // have parents, but we don't want to return them. They must pretend to be
@@ -154,7 +175,7 @@ __SYCL_EXPORT device device::get_info<info::device::parent_device>() const {
 
 template <>
 __SYCL_EXPORT std::vector<sycl::aspect>
-device::get_info<info::device::aspects>() const {
+device::get_info_internal<info::device::aspects>() const {
   std::vector<sycl::aspect> DeviceAspects{
 #define __SYCL_ASPECT(ASPECT, ID) aspect::ASPECT,
 #include <sycl/info/aspects.def>
@@ -178,14 +199,16 @@ device::get_info<info::device::aspects>() const {
 }
 
 template <>
-__SYCL_EXPORT bool device::get_info<info::device::image_support>() const {
+__SYCL_EXPORT bool
+device::get_info_internal<info::device::image_support>() const {
   // Explicit specialization is needed due to the class of info handle. The
   // implementation is done in get_device_info_impl.
   return impl->template get_info<info::device::image_support>();
 }
 
 #define __SYCL_PARAM_TRAITS_SPEC(DescType, Desc, ReturnT, PiCode)              \
-  template __SYCL_EXPORT ReturnT device::get_info<info::device::Desc>() const;
+  template __SYCL_EXPORT ReturnT                                               \
+  device::get_info_internal<info::device::Desc>() const;
 
 #define __SYCL_PARAM_TRAITS_SPEC_SPECIALIZED(DescType, Desc, ReturnT, PiCode)
 
@@ -195,7 +218,7 @@ __SYCL_EXPORT bool device::get_info<info::device::image_support>() const {
 
 #define __SYCL_PARAM_TRAITS_SPEC(Namespace, DescType, Desc, ReturnT, PiCode)   \
   template __SYCL_EXPORT ReturnT                                               \
-  device::get_info<Namespace::info::DescType::Desc>() const;
+  device::get_info_internal<Namespace::info::DescType::Desc>() const;
 
 #include <sycl/info/ext_codeplay_device_traits.def>
 #include <sycl/info/ext_intel_device_traits.def>

sycl/source/exception.cpp

@@ -59,7 +59,7 @@ exception::exception(context Ctx, int EV, const std::error_category &ECat)
 
 // protected base constructor for all SYCL 2020 constructors
 exception::exception(std::error_code EC, std::shared_ptr<context> SharedPtrCtx,
-                     const std::string &WhatArg)
+                     const char *WhatArg)
     : MMsg(std::make_shared<std::string>(WhatArg)),
       MPIErr(PI_ERROR_INVALID_VALUE), MContext(SharedPtrCtx), MErrC(EC) {
   detail::GlobalHandler::instance().TraceEventXPTI(MMsg->c_str());