Merge remote-tracking branch 'upstream/sycl' into remove_duplicate_libdevice_cflags

Author: jinge90

.github/workflows/sycl-linux-build.yml

@@ -93,11 +93,13 @@ on:
         type: choice
         options:
           - "[]"
+          - '[sycl]'
           - '[llvm, clang, sycl, llvm_spirv, xptifw, libclc]'
       build_image:
         type: choice
         options:
           - 'ghcr.io/intel/llvm/sycl_ubuntu2404_nightly:latest'
+          - 'ghcr.io/intel/llvm/ubuntu2204_build:latest'
       cc:
         type: choice
         options:

devops/dependencies-igc-dev.json

@@ -1,10 +1,10 @@
 {
   "linux": {
     "igc_dev": {
-      "github_tag": "igc-dev-6d3f69e",
-      "version": "6d3f69e",
-      "updated_at": "2025-09-20T11:44:56Z",
-      "url": "https://api.github.com/repos/intel/intel-graphics-compiler/actions/artifacts/4062749149/zip",
+      "github_tag": "igc-dev-5572ee3",
+      "version": "5572ee3",
+      "updated_at": "2025-09-28T11:41:20Z",
+      "url": "https://api.github.com/repos/intel/intel-graphics-compiler/actions/artifacts/4125423999/zip",
       "root": "{DEPS_ROOT}/opencl/runtime/linux/oclgpu"
     }
   }

devops/scripts/benchmarks/benches/compute.py

@@ -60,7 +60,8 @@ def git_url(self) -> str:
         return "https://github.com/intel/compute-benchmarks.git"
 
     def git_hash(self) -> str:
-        return "4995560017559849a519e58978a0afdd55903e15"
+        # Sep 25, 2025
+        return "7ba2e629404e34c635a46f28550a0952717d120f"
 
     def setup(self) -> None:
         if options.sycl is None:

lldb/tools/lldb-dap/package-lock.json

@@ -51,11 +51,14 @@ __SYCL_EXPORT std::error_code make_error_code(sycl::errc E) noexcept;
 __SYCL_EXPORT const std::error_category &sycl_category() noexcept;
 
 namespace detail {
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 __SYCL_EXPORT const char *stringifyErrorCode(int32_t error);
 
 inline std::string codeToString(int32_t code) {
-  return std::to_string(code) + " (" + std::string(stringifyErrorCode(code)) + ")";
+  return std::to_string(code) + " (" + std::string(stringifyErrorCode(code)) +
+         ")";
 }
+#endif
 
 class __SYCL_EXPORT SYCLCategory : public std::error_category {
 public:
@@ -78,17 +81,35 @@ class __SYCL_EXPORT exception : public virtual std::exception {
   exception() = default;
   virtual ~exception();
 
-  exception(std::error_code, const char *Msg);
+  exception(std::error_code Ec, const char *Msg)
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+      : exception(Ec, nullptr, Msg) {}
+#endif
+        ;
 
   exception(std::error_code Ec, const std::string &Msg)
       : exception(Ec, nullptr, Msg.c_str()) {}
 
-  // new SYCL 2020 constructors
-  exception(std::error_code);
+  exception(std::error_code Ec)
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+      : exception(Ec, nullptr, "") {}
+#endif
+        ;
+
   exception(int EV, const std::error_category &ECat, const std::string &WhatArg)
-      : exception(EV, ECat, WhatArg.c_str()) {}
-  exception(int, const std::error_category &, const char *);
-  exception(int, const std::error_category &);
+      : exception(std::error_code(EV, ECat), nullptr, WhatArg.c_str()) {}
+
+  exception(int EV, const std::error_category &ECat, const char *WhatArg)
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+      : exception(std::error_code(EV, ECat), nullptr, WhatArg) {}
+#endif
+        ;
+
+  exception(int EV, const std::error_category &ECat)
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+      : exception(std::error_code(EV, ECat), nullptr, "") {}
+#endif
+        ;
 
   // context.hpp depends on exception.hpp but we can't define these ctors in
   // exception.hpp while context is still an incomplete type.
@@ -119,6 +140,7 @@ class __SYCL_EXPORT exception : public virtual std::exception {
   std::error_code MErrC = make_error_code(sycl::errc::invalid);
 
 protected:
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   // base constructors used by SYCL 1.2.1 exception subclasses
   exception(std::error_code Ec, const char *Msg, const int32_t PIErr)
       : exception(Ec, std::string(Msg), PIErr) {}
@@ -127,6 +149,7 @@ class __SYCL_EXPORT exception : public virtual std::exception {
       : exception(Ec, nullptr, Msg + " " + detail::codeToString(URErr)) {
     MErr = URErr;
   }
+#endif
 
   // base constructor for all SYCL 2020 constructors
   // exception(context *, std::error_code, const std::string);

sycl/include/sycl/exception.hpp

@@ -32,6 +32,7 @@
 #include <sycl/nd_item.hpp>
 #include <sycl/nd_range.hpp>
 #include <sycl/range.hpp>
+#include <tuple>
 #include <type_traits>
 
 namespace [[deprecated("syclcompat is deprecated")]] syclcompat {

sycl/include/syclcompat/traits.hpp

@@ -580,7 +580,7 @@ class kernel_bundle_impl
           "kernel_bundle state does not match the state of the SYCLBIN file.");
 
     std::vector<const detail::RTDeviceBinaryImage *> BestImages =
-        SYCLBIN->getBestCompatibleImages(Devs);
+        SYCLBIN->getBestCompatibleImages(Devs, State);
     MDeviceImages.reserve(BestImages.size());
     for (const detail::RTDeviceBinaryImage *Image : BestImages)
       MDeviceImages.emplace_back(device_image_impl::create(

sycl/source/detail/kernel_bundle_impl.hpp

@@ -15,6 +15,7 @@
 #include <sycl/detail/common.hpp>
 #include <sycl/detail/ur.hpp>
 #include <sycl/device.hpp>
+#include <sycl/exception.hpp>
 #include <sycl/ext/oneapi/experimental/root_group.hpp>
 #include <sycl/info/info_desc.hpp>
 #include <sycl/queue.hpp>

sycl/source/detail/kernel_impl.hpp

@@ -272,21 +272,36 @@ SYCLBINBinaries::SYCLBINBinaries(const char *SYCLBINContent, size_t SYCLBINSize)
     : SYCLBINContentCopy{ContentCopy(SYCLBINContent, SYCLBINSize)},
       SYCLBINContentCopySize{SYCLBINSize},
       ParsedSYCLBIN(SYCLBIN{SYCLBINContentCopy.get(), SYCLBINSize}) {
-  size_t NumJITBinaries = 0, NumNativeBinaries = 0;
-  for (const SYCLBIN::AbstractModule &AM : ParsedSYCLBIN.AbstractModules) {
-    NumJITBinaries += AM.IRModules.size();
-    NumNativeBinaries += AM.NativeDeviceCodeImages.size();
-  }
-  DeviceBinaries.reserve(NumJITBinaries + NumNativeBinaries);
-  JITDeviceBinaryImages.reserve(NumJITBinaries);
-  NativeDeviceBinaryImages.reserve(NumNativeBinaries);
+  AbstractModuleDescriptors = std::unique_ptr<AbstractModuleDesc[]>(
+      new AbstractModuleDesc[ParsedSYCLBIN.AbstractModules.size()]);
+
+  size_t NumBinaries = 0;
+  for (const SYCLBIN::AbstractModule &AM : ParsedSYCLBIN.AbstractModules)
+    NumBinaries += AM.IRModules.size() + AM.NativeDeviceCodeImages.size();
+  DeviceBinaries.reserve(NumBinaries);
+  BinaryImages = std::unique_ptr<RTDeviceBinaryImage[]>(
+      new RTDeviceBinaryImage[NumBinaries]);
+
+  RTDeviceBinaryImage *CurrentBinaryImagesStart = BinaryImages.get();
+  for (size_t I = 0; I < getNumAbstractModules(); ++I) {
+    SYCLBIN::AbstractModule &AM = ParsedSYCLBIN.AbstractModules[I];
+    AbstractModuleDesc &AMDesc = AbstractModuleDescriptors[I];
+
+    // Set up the abstract module descriptor.
+    AMDesc.NumJITBinaries = AM.IRModules.size();
+    AMDesc.NumNativeBinaries = AM.NativeDeviceCodeImages.size();
+    AMDesc.JITBinaries = CurrentBinaryImagesStart;
+    AMDesc.NativeBinaries = CurrentBinaryImagesStart + AMDesc.NumJITBinaries;
+    CurrentBinaryImagesStart +=
+        AMDesc.NumJITBinaries + AM.NativeDeviceCodeImages.size();
 
-  for (SYCLBIN::AbstractModule &AM : ParsedSYCLBIN.AbstractModules) {
     // Construct properties from SYCLBIN metadata.
     std::vector<_sycl_device_binary_property_set_struct> &BinPropertySets =
         convertAbstractModuleProperties(AM);
 
-    for (SYCLBIN::IRModule &IRM : AM.IRModules) {
+    for (size_t J = 0; J < AM.IRModules.size(); ++J) {
+      SYCLBIN::IRModule &IRM = AM.IRModules[J];
+
       sycl_device_binary_struct &DeviceBinary = DeviceBinaries.emplace_back();
       DeviceBinary.Version = SYCL_DEVICE_BINARY_VERSION;
       DeviceBinary.Kind = 4;
@@ -309,11 +324,12 @@ SYCLBINBinaries::SYCLBINBinaries(const char *SYCLBINContent, size_t SYCLBINSize)
       DeviceBinary.PropertySetsEnd =
           BinPropertySets.data() + BinPropertySets.size();
       // Create an image from it.
-      JITDeviceBinaryImages.emplace_back(&DeviceBinary);
+      AMDesc.JITBinaries[J] = RTDeviceBinaryImage{&DeviceBinary};
     }
 
-    for (const SYCLBIN::NativeDeviceCodeImage &NDCI :
-         AM.NativeDeviceCodeImages) {
+    for (size_t J = 0; J < AM.NativeDeviceCodeImages.size(); ++J) {
+      const SYCLBIN::NativeDeviceCodeImage &NDCI = AM.NativeDeviceCodeImages[J];
+
       assert(NDCI.Metadata != nullptr);
       PropertySet &NDCIMetadataProps = (*NDCI.Metadata)
           [PropertySetRegistry::SYCLBIN_NATIVE_DEVICE_CODE_IMAGE_METADATA];
@@ -346,7 +362,7 @@ SYCLBINBinaries::SYCLBINBinaries(const char *SYCLBINContent, size_t SYCLBINSize)
       DeviceBinary.PropertySetsEnd =
           BinPropertySets.data() + BinPropertySets.size();
       // Create an image from it.
-      NativeDeviceBinaryImages.emplace_back(&DeviceBinary);
+      AMDesc.NativeBinaries[J] = RTDeviceBinaryImage{&DeviceBinary};
     }
   }
 }
@@ -394,33 +410,44 @@ SYCLBINBinaries::convertAbstractModuleProperties(SYCLBIN::AbstractModule &AM) {
 }
 
 std::vector<const RTDeviceBinaryImage *>
-SYCLBINBinaries::getBestCompatibleImages(device_impl &Dev) {
-  auto SelectCompatibleImages =
-      [&](const std::vector<RTDeviceBinaryImage> &Imgs) {
-        std::vector<const RTDeviceBinaryImage *> CompatImgs;
-        for (const RTDeviceBinaryImage &Img : Imgs)
-          if (doesDevSupportDeviceRequirements(Dev, Img) &&
-              doesImageTargetMatchDevice(Img, Dev))
-            CompatImgs.push_back(&Img);
-        return CompatImgs;
-      };
-
-  // Try with native images first.
-  std::vector<const RTDeviceBinaryImage *> NativeImgs =
-      SelectCompatibleImages(NativeDeviceBinaryImages);
-  if (!NativeImgs.empty())
-    return NativeImgs;
-
-  // If there were no native images, pick JIT images.
-  return SelectCompatibleImages(JITDeviceBinaryImages);
+SYCLBINBinaries::getBestCompatibleImages(device_impl &Dev, bundle_state State) {
+  auto GetCompatibleImage = [&](const RTDeviceBinaryImage *Imgs,
+                                size_t NumImgs) {
+    const RTDeviceBinaryImage *CompatImagePtr =
+        std::find_if(Imgs, Imgs + NumImgs, [&](const RTDeviceBinaryImage &Img) {
+          return doesDevSupportDeviceRequirements(Dev, Img) &&
+                 doesImageTargetMatchDevice(Img, Dev);
+        });
+    return (CompatImagePtr != Imgs + NumImgs) ? CompatImagePtr : nullptr;
+  };
+
+  std::vector<const RTDeviceBinaryImage *> Images;
+  for (size_t I = 0; I < getNumAbstractModules(); ++I) {
+    const AbstractModuleDesc &AMDesc = AbstractModuleDescriptors[I];
+    // If the target state is executable, try with native images first.
+    if (State == bundle_state::executable) {
+      if (const RTDeviceBinaryImage *CompatImagePtr = GetCompatibleImage(
+              AMDesc.NativeBinaries, AMDesc.NumNativeBinaries)) {
+        Images.push_back(CompatImagePtr);
+        continue;
+      }
+    }
+
+    // Otherwise, select the first compatible JIT binary.
+    if (const RTDeviceBinaryImage *CompatImagePtr =
+            GetCompatibleImage(AMDesc.JITBinaries, AMDesc.NumJITBinaries))
+      Images.push_back(CompatImagePtr);
+  }
+  return Images;
 }
 
 std::vector<const RTDeviceBinaryImage *>
-SYCLBINBinaries::getBestCompatibleImages(devices_range Devs) {
+SYCLBINBinaries::getBestCompatibleImages(devices_range Devs,
+                                         bundle_state State) {
   std::set<const RTDeviceBinaryImage *> Images;
   for (device_impl &Dev : Devs) {
     std::vector<const RTDeviceBinaryImage *> BestImagesForDev =
-        getBestCompatibleImages(Dev);
+        getBestCompatibleImages(Dev, State);
     Images.insert(BestImagesForDev.cbegin(), BestImagesForDev.cend());
   }
   return {Images.cbegin(), Images.cend()};

sycl/source/detail/syclbin.cpp

@@ -124,9 +124,9 @@ struct SYCLBINBinaries {
   ~SYCLBINBinaries() = default;
 
   std::vector<const RTDeviceBinaryImage *>
-  getBestCompatibleImages(device_impl &Dev);
+  getBestCompatibleImages(device_impl &Dev, bundle_state State);
   std::vector<const RTDeviceBinaryImage *>
-  getBestCompatibleImages(devices_range Dev);
+  getBestCompatibleImages(devices_range Dev, bundle_state State);
 
   uint8_t getState() const {
     PropertySet &GlobalMetadata =
@@ -143,6 +143,10 @@ struct SYCLBINBinaries {
   std::vector<_sycl_device_binary_property_set_struct> &
   convertAbstractModuleProperties(SYCLBIN::AbstractModule &AM);
 
+  size_t getNumAbstractModules() const {
+    return ParsedSYCLBIN.AbstractModules.size();
+  }
+
   std::unique_ptr<char[]> SYCLBINContentCopy = nullptr;
   size_t SYCLBINContentCopySize = 0;
 
@@ -156,8 +160,16 @@ struct SYCLBINBinaries {
       BinaryPropertySets;
 
   std::vector<sycl_device_binary_struct> DeviceBinaries;
-  std::vector<RTDeviceBinaryImage> JITDeviceBinaryImages;
-  std::vector<RTDeviceBinaryImage> NativeDeviceBinaryImages;
+
+  struct AbstractModuleDesc {
+    size_t NumJITBinaries;
+    size_t NumNativeBinaries;
+    RTDeviceBinaryImage *JITBinaries;
+    RTDeviceBinaryImage *NativeBinaries;
+  };
+
+  std::unique_ptr<AbstractModuleDesc[]> AbstractModuleDescriptors;
+  std::unique_ptr<RTDeviceBinaryImage[]> BinaryImages;
 };
 
 } // namespace detail