Fix unsupported SPIR-V was generated from OpenCL C

Henry Linjamäki · Henry Linjamäki · commit 8ae849291f5a · 2024-12-19T14:15:25.000+02:00
Fix PoCL/level0 generated SPIR-V from OpenCL C with a version not
supported by the driver and crashed in the presence of an instruction
the version enabled (OpPtrEqual).
diff --git a/include/pocl.h b/include/pocl.h
@@ -565,4 +565,18 @@ typedef enum
   POCL_AUTOLOCALS_TO_ARGS_ONLY_IF_DYNAMIC_LOCALS_PRESENT = 2,
 } pocl_autolocals_to_args_strategy;
 
+typedef struct pocl_version_t
+{
+  unsigned major;
+  unsigned minor;
+
+#ifdef __cplusplus
+  pocl_version_t () : major (0), minor (0) {}
+  pocl_version_t (unsigned the_major, unsigned the_minor)
+    : major (the_major), minor (the_minor)
+  {
+  }
+#endif
+} pocl_version_t;
+
 #endif /* POCL_H */
diff --git a/lib/CL/devices/level0/level0-compilation.cc b/lib/CL/devices/level0/level0-compilation.cc
@@ -167,6 +167,23 @@ Level0Program::~Level0Program() {
   }
 }
 
+static ze_result_t getTargetSpvVersion(ze_device_handle_t Dev,
+                                       pocl_version_t &VersionOut) {
+
+  ze_device_module_properties_t ModuleProperties{};
+  ModuleProperties.stype = ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES;
+  ModuleProperties.pNext = nullptr;
+  ze_result_t Result = zeDeviceGetModuleProperties(Dev, &ModuleProperties);
+  if (Result != ZE_RESULT_SUCCESS)
+    return Result;
+
+  VersionOut =
+      pocl_version_t(ZE_MAJOR_VERSION(ModuleProperties.spirvVersionSupported),
+                     ZE_MINOR_VERSION(ModuleProperties.spirvVersionSupported));
+  assert(VersionOut.major && "Unexpected SPIR-V version!");
+  return Result;
+}
+
 Level0Program::Level0Program(ze_context_handle_t Ctx, ze_device_handle_t Dev,
                              bool EnableJIT, bool Optimize, uint32_t NumSpecs,
                              uint32_t *SpecIDs, const void **SpecValues,
@@ -191,12 +208,18 @@ bool Level0Program::init() {
   if (JITCompilation) {
     if (ProgramBC.size() <= 20)
       return false;
+
+    auto TargetVersion = pocl_version_t();
+    if (getTargetSpvVersion(DeviceH, TargetVersion) != ZE_RESULT_SUCCESS) {
+      POCL_MSG_ERR("Could not infer target SPIR-V version\n");
+      return false;
+    }
+
     char *LinkinSpirvContent = nullptr;
     uint64_t LinkinSpirvSize = 0;
-    ProgramLLVMCtx = pocl_llvm_create_context_for_program(ProgramBC.data(),
-                                                          ProgramBC.size(),
-                                                          &LinkinSpirvContent,
-                                                          &LinkinSpirvSize);
+    ProgramLLVMCtx = pocl_llvm_create_context_for_program(
+        ProgramBC.data(), ProgramBC.size(), &LinkinSpirvContent,
+        &LinkinSpirvSize, TargetVersion);
 
     if (ProgramLLVMCtx == nullptr) {
       POCL_MSG_ERR("Null ProgramLLVMCtx\n");
@@ -410,13 +433,23 @@ bool Level0Program::extractKernelSPIRV(std::string &KernelName,
     }
   }
 
+  ze_device_module_properties_t ModuleProperties{};
+  ModuleProperties.stype = ZE_STRUCTURE_TYPE_DEVICE_MODULE_PROPERTIES;
+  ModuleProperties.pNext = nullptr;
+
+  auto TargetVersion = pocl_version_t();
+  if (getTargetSpvVersion(DeviceH, TargetVersion) != ZE_RESULT_SUCCESS) {
+    POCL_MSG_ERR("Could not infer target SPIR-V version\n");
+    return false;
+  }
+
   char *SpirvContent = nullptr;
   uint64_t SpirvSize = 0;
   // to avoid having to hold a lock on the Program, use separate BuildLog
   std::string ExtractBuildLog;
   int Res = pocl_llvm_extract_kernel_spirv(ProgramLLVMCtx, KernelName.c_str(),
                                            &ExtractBuildLog, &SpirvContent,
-                                           &SpirvSize);
+                                           &SpirvSize, TargetVersion);
 
   {
     std::lock_guard<std::mutex> LockGuard(Mutex);
diff --git a/lib/CL/devices/level0/level0-driver.cc b/lib/CL/devices/level0/level0-driver.cc
@@ -2401,6 +2401,11 @@ bool Level0Device::setupModuleProperties(bool &SupportsInt64Atomics,
   if (ModuleProperties.maxArgumentsSize > 256)
     ClDev->max_parameter_size = ModuleProperties.maxArgumentsSize - 64;
 #endif
+
+  uint32_t SpvVer = ModuleProperties.spirvVersionSupported;
+  SupportedSpvVersion =
+      pocl_version_t(ZE_MAJOR_VERSION(SpvVer), ZE_MINOR_VERSION(SpvVer));
+
   return true;
 }
 
diff --git a/lib/CL/devices/level0/level0-driver.hh b/lib/CL/devices/level0/level0-driver.hh
@@ -447,6 +447,12 @@ public:
   // the batch needs to be split at points where memcpy is required.
   bool prefersHostQueues() { return ClDev->type == CL_DEVICE_TYPE_CUSTOM; }
 
+  /// Return a SPIR-V version the device supports.
+  pocl_version_t getSupportedSpvVersion() const {
+    assert(SupportedSpvVersion.major && "SPIR-V is not supported?");
+    return SupportedSpvVersion;
+  }
+
 private:
   Level0AllocatorSPtr Alloc;
   std::deque<Level0EventPool> EventPools;
@@ -496,6 +502,7 @@ private:
   uint32_t MaxMemoryFillPatternSize = 0;
   uint32_t GlobalMemOrd = UINT32_MAX;
   std::vector<size_t> SupportedSubgroupSizes;
+  pocl_version_t SupportedSpvVersion = pocl_version_t();
 
   /// initializes kernels used internally by the driver
   /// to implement functionality missing in the Level Zero API,
diff --git a/lib/CL/devices/level0/pocl-level0.cc b/lib/CL/devices/level0/pocl-level0.cc
@@ -584,12 +584,12 @@ static int linkWithLLVMLink(cl_program Program, cl_uint DeviceI,
   if (Err != CL_SUCCESS)
     return Err;
 
-  Err = pocl_convert_bitcode_to_spirv(ProgramBcPathTemp,
-                                      nullptr, 0,
-                                      Program, DeviceI,
-                                      1, // useIntelExt
-                                      ProgramSpvPathTemp,
-                                      nullptr, nullptr);
+  cl_device_id Dev = Program->devices[DeviceI];
+  Level0Device *Device = static_cast<Level0Device *>(Dev->data);
+  Err = pocl_convert_bitcode_to_spirv(
+      ProgramBcPathTemp, nullptr, 0, Program, DeviceI,
+      1, // useIntelExt
+      ProgramSpvPathTemp, nullptr, nullptr, Device->getSupportedSpvVersion());
 
   POCL_RETURN_ERROR_ON((Err != 0), CL_BUILD_PROGRAM_FAILURE,
                        "llvm-spirv exited with nonzero code\n");
@@ -643,14 +643,12 @@ int pocl_level0_build_source(cl_program Program, cl_uint DeviceI,
     if (Err != CL_SUCCESS)
       return Err;
 
-    Err = pocl_convert_bitcode_to_spirv(nullptr,
-                                        (char*)Program->binaries[DeviceI],
-                                        Program->binary_sizes[DeviceI],
-                                        Program, DeviceI,
-                                        1, // useIntelExt
-                                        ProgramSpvPathTemp,
-                                        &OutputBinary,
-                                        &OutputBinarySize);
+    Err = pocl_convert_bitcode_to_spirv(
+        nullptr, (char *)Program->binaries[DeviceI],
+        Program->binary_sizes[DeviceI], Program, DeviceI,
+        1, // useIntelExt
+        ProgramSpvPathTemp, &OutputBinary, &OutputBinarySize,
+        Device->getSupportedSpvVersion());
     POCL_RETURN_ERROR_ON((Err != 0), CL_BUILD_PROGRAM_FAILURE,
                          "llvm-spirv exited with nonzero code\n");
 
@@ -773,13 +771,14 @@ int pocl_level0_build_binary(cl_program Program, cl_uint DeviceI,
                            "the binary supplied to level0 driver is "
                            "not a recognized binary type\n");
 
-      Err = pocl_convert_bitcode_to_spirv(ProgramBcPathTemp,
-                                          (char *)Program->binaries[DeviceI],
-                                          Program->binary_sizes[DeviceI],
-                                          Program, DeviceI,
-                                          1, // useIntelExt
-                                          ProgramSpvPathTemp,
-                                          &OutputBinary, &OutputBinarySize);
+      cl_device_id Dev = Program->devices[DeviceI];
+      Level0Device *Device = static_cast<Level0Device *>(Dev->data);
+      Err = pocl_convert_bitcode_to_spirv(
+          ProgramBcPathTemp, (char *)Program->binaries[DeviceI],
+          Program->binary_sizes[DeviceI], Program, DeviceI,
+          1, // useIntelExt
+          ProgramSpvPathTemp, &OutputBinary, &OutputBinarySize,
+          Device->getSupportedSpvVersion());
       POCL_RETURN_ERROR_ON((Err != 0), CL_BUILD_PROGRAM_FAILURE,
                            "failed to compile BC -> SPV\n");
       Program->program_il = OutputBinary;
diff --git a/lib/CL/pocl_llvm.h b/lib/CL/pocl_llvm.h
@@ -144,7 +144,8 @@ extern "C" {
   void *pocl_llvm_create_context_for_program (char *ProgramBcContent,
                                               size_t ProgramBcSize,
                                               char **LinkinSpirvContent,
-                                              uint64_t *LinkinSpirvSize);
+                                              uint64_t *LinkinSpirvSize,
+                                              pocl_version_t TargetVersion);
 
   /**
   * \brief extracts SPIR-V of a single Kernel (plus all functions it uses)
@@ -159,11 +160,12 @@ extern "C" {
   *
   */
   POCL_EXPORT
-  int pocl_llvm_extract_kernel_spirv(void* ProgCtx,
-                                     const char* KernelName,
-                                     void* BuildLogStr,
-                                     char **SpirvContent,
-                                     uint64_t *SpirvSize);
+  int pocl_llvm_extract_kernel_spirv (void *ProgCtx,
+                                      const char *KernelName,
+                                      void *BuildLogStr,
+                                      char **SpirvContent,
+                                      uint64_t *SpirvSize,
+                                      pocl_version_t TargetVersion);
 
   /**
   * \brief destroys the instance of hidden class used to extract kernel SPIR-V
@@ -214,6 +216,7 @@ extern "C" {
    * nullptr \param [out] SpirvContent pointer where to store the raw output.
    *              can be nullptr
    * \param [out] SpirvSize size of data stored at SpirvContent
+   * \param [in] TargetVersion The SPIR-V version to emit.
    * \returns 0 on success
    *
    */
@@ -225,22 +228,25 @@ extern "C" {
                                                  int UseIntelExts,
                                                  char *TempSpirvPathOut,
                                                  char **SpirvContent,
-                                                 uint64_t *SpirvSize);
+                                                 uint64_t *SpirvSize,
+                                                 pocl_version_t TargetVersion);
 
   /**
    * \brief converts LLVM IR with "spir64-unknown-unknown" triple to SPIR-V
    *
    * The same as pocl_convert_bitcode_to_spirv, but takes a std::string*
    * cast to void* as buildLog argument
    */
-  POCL_EXPORT int pocl_convert_bitcode_to_spirv2 (char *TempBitcodePath,
-                                                  const char *Bitcode,
-                                                  uint64_t BitcodeSize,
-                                                  void *BuildLog,
-                                                  int UseIntelExts,
-                                                  char *TempSpirvPathOut,
-                                                  char **SpirvContent,
-                                                  uint64_t *SpirvSize);
+  POCL_EXPORT int
+  pocl_convert_bitcode_to_spirv2 (char *TempBitcodePath,
+                                  const char *Bitcode,
+                                  uint64_t BitcodeSize,
+                                  void *BuildLog,
+                                  int UseIntelExts,
+                                  char *TempSpirvPathOut,
+                                  char **SpirvContent,
+                                  uint64_t *SpirvSize,
+                                  pocl_version_t TargetVersion);
 
   /**
    * \brief converts SPIR-V to LLVM IR with "spir64-unknown-unknown" triple
diff --git a/lib/CL/pocl_llvm_wg.cc b/lib/CL/pocl_llvm_wg.cc
diff --git a/tests/kernel/CMakeLists.txt b/tests/kernel/CMakeLists.txt
diff --git a/tests/kernel/test_ptr_compare.cl b/tests/kernel/test_ptr_compare.cl
