[llvm] [OFFLOAD] Generalize support for OffloadBinary images (PR #186088)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 12 06:10:00 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-amdgpu
Author: Alex Duran (adurang)
<details>
<summary>Changes</summary>
This generalizes the OffloadBinary support introduced for L0 in #<!-- -->185404 to all plugins. It reuses all existing validation and loading images code, while adds support to use the metadata stored in the OffloadBinary.
For now only the first compatible image in the binary is loaded. While it might be desirable to add support for loading multiple images, our current interface is limiting (i.e., it returns a single Image) and it's unclear if in all cases this behavior is desirable so we would need to add more options to control it. So, should we want it, it's better in a follow-up PR IMO.
---
Patch is 24.02 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/186088.diff
11 Files Affected:
- (modified) offload/plugins-nextgen/amdgpu/src/rtl.cpp (+2-2)
- (modified) offload/plugins-nextgen/common/include/PluginInterface.h (+23-1)
- (modified) offload/plugins-nextgen/common/src/PluginInterface.cpp (+171-11)
- (modified) offload/plugins-nextgen/cuda/src/rtl.cpp (+2-2)
- (modified) offload/plugins-nextgen/host/src/rtl.cpp (+2-2)
- (modified) offload/plugins-nextgen/level_zero/include/L0Device.h (+2-2)
- (modified) offload/plugins-nextgen/level_zero/include/L0Plugin.h (+3)
- (modified) offload/plugins-nextgen/level_zero/include/L0Program.h (+8-2)
- (modified) offload/plugins-nextgen/level_zero/src/L0Device.cpp (+4-2)
- (modified) offload/plugins-nextgen/level_zero/src/L0Plugin.cpp (+18-29)
- (modified) offload/plugins-nextgen/level_zero/src/L0Program.cpp (+15-44)
``````````diff
diff --git a/offload/plugins-nextgen/amdgpu/src/rtl.cpp b/offload/plugins-nextgen/amdgpu/src/rtl.cpp
index 37d7c6345f02e..332d356348acc 100644
--- a/offload/plugins-nextgen/amdgpu/src/rtl.cpp
+++ b/offload/plugins-nextgen/amdgpu/src/rtl.cpp
@@ -2383,8 +2383,8 @@ struct AMDGPUDeviceTy : public GenericDeviceTy, AMDGenericDeviceTy {
/// Load the binary image into the device and allocate an image object.
Expected<DeviceImageTy *>
- loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
- int32_t ImageId) override {
+ loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage, int32_t ImageId,
+ const OffloadBinMetadataTy *Metadata) override {
// Allocate and initialize the image object.
AMDGPUDeviceImageTy *AMDImage = Plugin.allocate<AMDGPUDeviceImageTy>();
new (AMDImage) AMDGPUDeviceImageTy(ImageId, *this, std::move(TgtImage));
diff --git a/offload/plugins-nextgen/common/include/PluginInterface.h b/offload/plugins-nextgen/common/include/PluginInterface.h
index 5ed3b57704da6..46fbe1df97121 100644
--- a/offload/plugins-nextgen/common/include/PluginInterface.h
+++ b/offload/plugins-nextgen/common/include/PluginInterface.h
@@ -41,8 +41,10 @@
#endif
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
#include "llvm/Frontend/OpenMP/OMPConstants.h"
#include "llvm/Frontend/OpenMP/OMPGridValues.h"
+#include "llvm/Object/OffloadBinary.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
@@ -313,10 +315,20 @@ struct DynBlockMemConfTy {
void *FallbackPtr = nullptr;
};
+/// Metadata extracted from OffloadBinary format
+struct OffloadBinMetadataTy {
+ llvm::object::ImageKind ImageKind;
+ llvm::object::OffloadKind OffloadKind;
+ std::string Triple;
+ std::string Arch;
+ llvm::StringMap<std::string> StringData;
+};
+
/// Class wrapping a __tgt_device_image and its offload entry table on a
/// specific device. This class is responsible for storing and managing
/// the offload entries for an image on a device.
class DeviceImageTy {
+private:
/// Image identifier within the corresponding device. Notice that this id is
/// not unique between different device; they may overlap.
int32_t ImageId;
@@ -807,7 +819,8 @@ struct GenericDeviceTy : public DeviceAllocatorTy {
Expected<DeviceImageTy *> loadBinary(GenericPluginTy &Plugin,
StringRef TgtImage);
virtual Expected<DeviceImageTy *>
- loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage, int32_t ImageId) = 0;
+ loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage, int32_t ImageId,
+ const OffloadBinMetadataTy *Metadata) = 0;
/// Unload a previously loaded Image from the device
Error unloadBinary(DeviceImageTy *Image);
@@ -1411,6 +1424,15 @@ struct GenericPluginTy {
return isImageCompatible(Image);
}
+ /// Validate OffloadBinary metadata for compatibility with the plugin.
+ /// This is called when unwrapping OffloadBinary to check if the metadata
+ /// (triple, arch, ImageKind, etc.) is compatible before checking the inner
+ /// image. Returns true if metadata is compatible, false otherwise.
+ virtual Expected<bool>
+ isMetadataCompatible(const OffloadBinMetadataTy &Metadata) const {
+ return true;
+ }
+
virtual Error flushQueueImpl(omp_interop_val_t *Interop) {
return Plugin::success();
}
diff --git a/offload/plugins-nextgen/common/src/PluginInterface.cpp b/offload/plugins-nextgen/common/src/PluginInterface.cpp
index a9af92826e633..7393170afb2d0 100644
--- a/offload/plugins-nextgen/common/src/PluginInterface.cpp
+++ b/offload/plugins-nextgen/common/src/PluginInterface.cpp
@@ -47,6 +47,39 @@ using namespace llvm::offload::debug;
// TODO: Fix any thread safety issues for multi-threaded kernel recording.
namespace llvm::omp::target::plugin {
+
+// Parse OffloadBinary and extract all inner images with metadata
+static Expected<SmallVector<std::pair<OffloadBinMetadataTy, StringRef>>>
+parseOffloadBinary(MemoryBufferRef Buffer) {
+ auto BinariesOrErr = llvm::object::OffloadBinary::create(Buffer);
+ if (!BinariesOrErr)
+ return BinariesOrErr.takeError();
+
+ auto &Binaries = *BinariesOrErr;
+
+ SmallVector<std::pair<OffloadBinMetadataTy, StringRef>> Results;
+ Results.reserve(Binaries.size());
+
+ for (const auto &BinaryPtr : Binaries) {
+ const llvm::object::OffloadBinary *Binary = BinaryPtr.get();
+
+ // Extract metadata for this entry
+ OffloadBinMetadataTy Metadata;
+ Metadata.ImageKind = Binary->getImageKind();
+ Metadata.OffloadKind = Binary->getOffloadKind();
+ Metadata.Triple = Binary->getTriple().str();
+ Metadata.Arch = Binary->getArch().str();
+ for (auto [Key, Value] : Binary->strings())
+ Metadata.StringData[Key] = Value.str();
+
+ StringRef InnerImage = Binary->getImage();
+
+ Results.emplace_back(std::move(Metadata), InnerImage);
+ }
+
+ return Results;
+}
+
struct RecordReplayTy {
// Describes the state of the record replay mechanism.
@@ -938,12 +971,28 @@ Error GenericDeviceTy::deinit(GenericPluginTy &Plugin) {
return deinitImpl();
}
+
+// Helper function to finalize image loading after loadBinaryImpl succeeds
+static Error finalizeImageLoad(GenericDeviceTy &Device, GenericPluginTy &Plugin,
+ DeviceImageTy *Image) {
+ Device.LoadedImages.push_back(Image);
+
+ if (auto Err = Device.setupRPCServer(Plugin, *Image))
+ return Err;
+
+ if (auto Err = Device.callGlobalConstructors(Plugin, *Image))
+ return Err;
+
+ return Error::success();
+}
+
Expected<DeviceImageTy *> GenericDeviceTy::loadBinary(GenericPluginTy &Plugin,
StringRef InputTgtImage) {
ODBG(OLDT_Init) << "Load data from image "
<< static_cast<const void *>(InputTgtImage.bytes_begin());
std::unique_ptr<MemoryBuffer> Buffer;
+
if (identify_magic(InputTgtImage) == file_magic::bitcode) {
auto CompiledImageOrErr = Plugin.getJIT().process(InputTgtImage, *this);
if (!CompiledImageOrErr) {
@@ -952,21 +1001,90 @@ Expected<DeviceImageTy *> GenericDeviceTy::loadBinary(GenericPluginTy &Plugin,
"failure to jit IR image");
}
Buffer = std::move(*CompiledImageOrErr);
+ } else if (identify_magic(InputTgtImage) == file_magic::offload_binary) {
+ MemoryBufferRef InputBuffer(InputTgtImage, "offload_binary");
+
+ auto ParsedOrErr = parseOffloadBinary(InputBuffer);
+ if (!ParsedOrErr)
+ return ParsedOrErr.takeError();
+
+ auto &InnerImages = *ParsedOrErr;
+
+ DeviceImageTy *FirstLoadedImage = nullptr;
+ Error LoadErrors = Error::success();
+
+ for (auto &[ExtractedMetadata, InnerImage] : InnerImages) {
+ if (identify_magic(InnerImage) == file_magic::offload_binary) {
+ auto ImageOrErr = loadBinary(Plugin, InnerImage);
+ if (ImageOrErr) {
+ if (!FirstLoadedImage)
+ FirstLoadedImage = *ImageOrErr;
+ } else {
+ LoadErrors =
+ joinErrors(std::move(LoadErrors), ImageOrErr.takeError());
+ }
+ continue;
+ }
+
+ int32_t Compatible = Plugin.isDeviceCompatible(DeviceId, InnerImage);
+ if (!Compatible)
+ continue; // Not compatible, skip
+
+ auto InnerBuffer = MemoryBuffer::getMemBufferCopy(InnerImage);
+ const OffloadBinMetadataTy *MetadataPtr = &ExtractedMetadata;
+
+ auto ImageOrErr = loadBinaryImpl(std::move(InnerBuffer),
+ LoadedImages.size(), MetadataPtr);
+ if (ImageOrErr) {
+ DeviceImageTy *LoadedImage = *ImageOrErr;
+
+ if (auto Err = finalizeImageLoad(*this, Plugin, LoadedImage)) {
+ LoadErrors = joinErrors(std::move(LoadErrors), std::move(Err));
+ continue;
+ }
+
+#ifdef OMPT_SUPPORT
+ if (ompt::Initialized) {
+ size_t Bytes = InnerImage.size();
+ performOmptCallback(
+ device_load, Plugin.getUserId(DeviceId),
+ /*FileName=*/nullptr, /*FileOffset=*/0, /*VmaInFile=*/nullptr,
+ /*ImgSize=*/Bytes,
+ /*HostAddr=*/
+ const_cast<unsigned char *>(InnerImage.bytes_begin()),
+ /*DeviceAddr=*/nullptr, /* FIXME: ModuleId */ 0);
+ }
+#endif
+
+ ODBG(OLDT_Init) << "Found compatible image from OffloadBinary: "
+ << static_cast<const void *>(InnerImage.bytes_begin());
+ FirstLoadedImage = LoadedImage;
+ break;
+ } else {
+ LoadErrors = joinErrors(std::move(LoadErrors), ImageOrErr.takeError());
+ }
+ }
+
+ if (!FirstLoadedImage) {
+ if (LoadErrors)
+ return std::move(LoadErrors);
+ return Plugin::error(ErrorCode::UNKNOWN,
+ "No compatible image found in OffloadBinary");
+ }
+
+ return FirstLoadedImage;
} else {
Buffer = MemoryBuffer::getMemBufferCopy(InputTgtImage);
}
- // Load the binary and allocate the image object. Use the next available id
- // for the image id, which is the number of previously loaded images.
- auto ImageOrErr = loadBinaryImpl(std::move(Buffer), LoadedImages.size());
+ auto ImageOrErr =
+ loadBinaryImpl(std::move(Buffer), LoadedImages.size(), nullptr);
if (!ImageOrErr)
return ImageOrErr.takeError();
DeviceImageTy *Image = *ImageOrErr;
- // Add the image to list.
- LoadedImages.push_back(Image);
-
- if (auto Err = setupRPCServer(Plugin, *Image))
+ // Finalize image load (track, setup RPC, call constructors)
+ if (auto Err = finalizeImageLoad(*this, Plugin, Image))
return std::move(Err);
#ifdef OMPT_SUPPORT
@@ -981,10 +1099,6 @@ Expected<DeviceImageTy *> GenericDeviceTy::loadBinary(GenericPluginTy &Plugin,
}
#endif
- // Call any global constructors present on the device.
- if (auto Err = callGlobalConstructors(Plugin, *Image))
- return std::move(Err);
-
// Return the pointer to the table of entries.
return Image;
}
@@ -1716,6 +1830,29 @@ int32_t GenericPluginTy::isPluginCompatible(StringRef Image) {
return HandleError(std::move(Err));
return *MatchOrErr;
}
+ case file_magic::offload_binary: {
+ // Unwrap OffloadBinary and check if ANY inner image is compatible
+ auto ParsedOrErr =
+ parseOffloadBinary(MemoryBufferRef(Image, "offload_binary"));
+ if (Error Err = ParsedOrErr.takeError())
+ return HandleError(std::move(Err));
+
+ auto &InnerImages = *ParsedOrErr;
+
+ for (auto &[Metadata, InnerImage] : InnerImages) {
+ // First check if metadata is compatible
+ auto MetadataMatchOrErr = isMetadataCompatible(Metadata);
+ if (Error Err = MetadataMatchOrErr.takeError())
+ return HandleError(std::move(Err));
+ if (!*MetadataMatchOrErr)
+ continue;
+
+ if (isPluginCompatible(InnerImage))
+ return true;
+ }
+
+ return false;
+ }
default:
auto MatchOrErr = isImageCompatible(Image);
if (Error Err = MatchOrErr.takeError())
@@ -1756,6 +1893,29 @@ int32_t GenericPluginTy::isDeviceCompatible(int32_t DeviceId, StringRef Image) {
return HandleError(std::move(Err));
return *MatchOrErr;
}
+ case file_magic::offload_binary: {
+ auto ParsedOrErr =
+ parseOffloadBinary(MemoryBufferRef(Image, "offload_binary"));
+ if (Error Err = ParsedOrErr.takeError())
+ return HandleError(std::move(Err));
+
+ auto &InnerImages = *ParsedOrErr;
+
+ for (auto &[Metadata, InnerImage] : InnerImages) {
+ // First check if metadata is compatible
+ auto MetadataMatchOrErr = isMetadataCompatible(Metadata);
+ if (Error Err = MetadataMatchOrErr.takeError())
+ return HandleError(std::move(Err));
+ if (!*MetadataMatchOrErr)
+ continue; // Metadata not compatible, skip this image
+
+ // Metadata compatible, check inner image recursively
+ if (isDeviceCompatible(DeviceId, InnerImage))
+ return true;
+ }
+
+ return false;
+ }
default:
auto MatchOrErr = isImageCompatible(DeviceId, Image);
if (Error Err = MatchOrErr.takeError())
diff --git a/offload/plugins-nextgen/cuda/src/rtl.cpp b/offload/plugins-nextgen/cuda/src/rtl.cpp
index c96cf3d89d3d4..771bca3df6c91 100644
--- a/offload/plugins-nextgen/cuda/src/rtl.cpp
+++ b/offload/plugins-nextgen/cuda/src/rtl.cpp
@@ -589,8 +589,8 @@ struct CUDADeviceTy : public GenericDeviceTy {
/// Load the binary image into the device and allocate an image object.
Expected<DeviceImageTy *>
- loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
- int32_t ImageId) override {
+ loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage, int32_t ImageId,
+ const OffloadBinMetadataTy *Metadata) override {
if (auto Err = setContext())
return std::move(Err);
diff --git a/offload/plugins-nextgen/host/src/rtl.cpp b/offload/plugins-nextgen/host/src/rtl.cpp
index d1c9af92a9fb0..a444aac904a57 100644
--- a/offload/plugins-nextgen/host/src/rtl.cpp
+++ b/offload/plugins-nextgen/host/src/rtl.cpp
@@ -200,8 +200,8 @@ struct GenELF64DeviceTy : public GenericDeviceTy {
/// Load the binary image into the device and allocate an image object.
Expected<DeviceImageTy *>
- loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
- int32_t ImageId) override {
+ loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage, int32_t ImageId,
+ const OffloadBinMetadataTy *Metadata) override {
// Allocate and initialize the image object.
GenELF64DeviceImageTy *Image = Plugin.allocate<GenELF64DeviceImageTy>();
new (Image) GenELF64DeviceImageTy(ImageId, *this, std::move(TgtImage));
diff --git a/offload/plugins-nextgen/level_zero/include/L0Device.h b/offload/plugins-nextgen/level_zero/include/L0Device.h
index 001a41ba77d7b..f37ca1b41371a 100644
--- a/offload/plugins-nextgen/level_zero/include/L0Device.h
+++ b/offload/plugins-nextgen/level_zero/include/L0Device.h
@@ -549,8 +549,8 @@ class L0DeviceTy final : public GenericDeviceTy {
// Generic device interface implementation.
Expected<DeviceImageTy *>
- loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
- int32_t ImageId) override;
+ loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage, int32_t ImageId,
+ const OffloadBinMetadataTy *Metadata) override;
Error unloadBinaryImpl(DeviceImageTy *Image) override;
Expected<void *> allocate(size_t Size, void *HstPtr,
TargetAllocTy Kind) override;
diff --git a/offload/plugins-nextgen/level_zero/include/L0Plugin.h b/offload/plugins-nextgen/level_zero/include/L0Plugin.h
index 7ab3696a49af6..434e3d6f5e08b 100644
--- a/offload/plugins-nextgen/level_zero/include/L0Plugin.h
+++ b/offload/plugins-nextgen/level_zero/include/L0Plugin.h
@@ -109,6 +109,9 @@ class LevelZeroPluginTy final : public GenericPluginTy {
Error asyncBarrierImpl(omp_interop_val_t *Interop) override;
Expected<bool> isImageCompatible(StringRef Image) const override;
+
+ Expected<bool>
+ isMetadataCompatible(const OffloadBinMetadataTy &Metadata) const override;
};
} // namespace llvm::omp::target::plugin
diff --git a/offload/plugins-nextgen/level_zero/include/L0Program.h b/offload/plugins-nextgen/level_zero/include/L0Program.h
index 2658ab10ca5c1..948f1f7bf9568 100644
--- a/offload/plugins-nextgen/level_zero/include/L0Program.h
+++ b/offload/plugins-nextgen/level_zero/include/L0Program.h
@@ -22,6 +22,8 @@ class L0DeviceTy;
class L0ProgramBuilderTy {
L0DeviceTy &Device;
std::unique_ptr<MemoryBuffer> Image;
+ const OffloadBinMetadataTy *Metadata;
+
/// Handle multiple modules within a single target image.
llvm::SmallVector<ze_module_handle_t> Modules;
@@ -39,8 +41,11 @@ class L0ProgramBuilderTy {
Error linkModules();
public:
- L0ProgramBuilderTy(L0DeviceTy &Device, std::unique_ptr<MemoryBuffer> &&Image)
- : Device(Device), Image(std::move(Image)) {}
+ L0ProgramBuilderTy(L0DeviceTy &Device, std::unique_ptr<MemoryBuffer> &&Image,
+ int32_t ImageId, const OffloadBinMetadataTy *Metadata)
+ : Device(Device), Image(std::move(Image)), Metadata(Metadata) {
+ (void)ImageId; // Unused parameter
+ }
~L0ProgramBuilderTy() = default;
L0DeviceTy &getL0Device() const { return Device; }
@@ -48,6 +53,7 @@ class L0ProgramBuilderTy {
llvm::SmallVector<ze_module_handle_t> &getModules() { return Modules; }
MemoryBufferRef getMemoryBuffer() const { return MemoryBufferRef(*Image); }
+ const OffloadBinMetadataTy *getMetadata() const { return Metadata; }
Error buildModules(const std::string_view BuildOptions);
/// Retrieve the ELF binary for the program.
diff --git a/offload/plugins-nextgen/level_zero/src/L0Device.cpp b/offload/plugins-nextgen/level_zero/src/L0Device.cpp
index 4db3c4e47f544..5f7c8cba47ec1 100644
--- a/offload/plugins-nextgen/level_zero/src/L0Device.cpp
+++ b/offload/plugins-nextgen/level_zero/src/L0Device.cpp
@@ -234,7 +234,8 @@ Error L0DeviceTy::deinitImpl() {
Expected<DeviceImageTy *>
L0DeviceTy::loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
- int32_t ImageId) {
+ int32_t ImageId,
+ const OffloadBinMetadataTy *Metadata) {
auto *PGM = getProgramFromImage(TgtImage->getMemBufferRef());
if (PGM) {
// Program already exists.
@@ -255,7 +256,8 @@ L0DeviceTy::loadBinaryImpl(std::unique_ptr<MemoryBuffer> &&TgtImage,
CompilationOptions += " ";
CompilationOptions += Options.InternalCompilationOptions;
- L0ProgramBuilderTy Builder(*this, std::move(TgtImage));
+ // Pass metadata to builder
+ L0ProgramBuilderTy Builder(*this, std::move(TgtImage), ImageId, Metadata);
if (auto Err = Builder.buildModules(CompilationOptions))
return std::move(Err);
diff --git a/offload/plugins-nextgen/level_zero/src/L0Plugin.cpp b/offload/plugins-nextgen/level_zero/src/L0Plugin.cpp
index 7dc0b919ca5a5..3cae0ec0bfead 100644
--- a/offload/plugins-nextgen/level_zero/src/L0Plugin.cpp
+++ b/offload/plugins-nextgen/level_zero/src/L0Plugin.cpp
@@ -165,38 +165,27 @@ Expected<bool> LevelZeroPluginTy::isELFCompatible(uint32_t DeviceId,
// We only need to check for formats other than ELF here.
Expected<bool> LevelZeroPluginTy::isImageCompatible(StringRef Image) const {
- switch (identify_magic(Image)) {
- case file_magic::spirv_object:
- // Handle SPIRV objects directly
- return true;
- case file_magic::offload_binary: {
- // Handle OffloadBinary format
- MemoryBufferRef Buffer(Image, "offload_binary");
- auto BinariesOrErr = OffloadBinary::create(Buffer);
- if (!BinariesOrErr)
- return BinariesOrErr.takeError();
-
- auto &Binaries = *BinariesOrErr;
- if (Binaries.size() != 1)
- return false;
-
- const OffloadBinary *InnerBinary = Binaries[0].get();
- ImageKind ImageKind = InnerBinary->getImageKind();
- llvm::Triple Triple(InnerBinary->getTriple());
-
- if (Triple.getArch() != getTripleArch())
- return false;
-
- if (ImageKind != llvm::object::IMG_SPIRV &&
- ImageKind != llvm::object::IMG_Object)
- return false;
-
- return true;
+ return identify_magic(Image) == file_magic::spirv_object;
+}
+
+Expected<bool> LevelZeroPluginTy::isMetadataCompatible(
+ const OffloadBinMetadataTy &Metadata) const {
+
+ llvm::Triple Triple(Metadata.Triple);
+ if (!Triple.isSPIRV() || Triple.getVendor() != llvm::Triple::Intel) {
+ ODBG(OLDT_Init) << "Rejecting image: incompatible triple '"
+ << Metadata.Triple << "' (expected spirv64-intel)";
+ return false;
}
- default:
- // Unknown format
+
+ llvm::object::ImageKind Kind = Metadata.ImageKind;
+ if (Kind != llvm::object::IMG_SPIRV && Kind != llvm::object::IMG_Object) {
+ ODBG(OLDT_Init) << "Rejecting image: incompatible ImageKind " << Kind
+ << " (expected IMG_SPIRV=" << llvm::object::IMG_SPIRV
+ << " or IMG_Object=" << llvm::object::IMG_Object << ")";
return false;
}
+ return true;
}
Error LevelZeroPluginTy::syncBarrierImpl(omp_interop_val_t *Interop) {
diff --git a/offload/plugins-nextgen/level_zero/src/L0Program.cpp b/offload/plugins-nextgen/level_zero/src/L0Program.cpp
index 60a71c9ad65a2..1c5fd3c214f78 100644
--- a/offload/plugins-nextgen/lev...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/186088
More information about the llvm-commits
mailing list