Throw exception with errc::invalid when unsupported build option is detected

Signed-off-by: Julian Oppermann <[email protected]>

Author: jopperm

sycl-jit/jit-compiler/include/KernelFusion.h

@@ -86,32 +86,37 @@ class RTCHashResult {
   sycl::detail::string HashOrLog;
 };
 
+enum class RTCErrorCode { SUCCESS, BUILD, INVALID };
+
 class RTCResult {
 public:
-  explicit RTCResult(const char *BuildLog)
-      : Failed{true}, BundleInfo{}, BuildLog{BuildLog} {}
+  explicit RTCResult(const char *BuildLog,
+                     RTCErrorCode ErrorCode = RTCErrorCode::BUILD)
+      : ErrorCode{ErrorCode}, BundleInfo{}, BuildLog{BuildLog} {
+    assert(ErrorCode != RTCErrorCode::SUCCESS);
+  }
 
   RTCResult(RTCBundleInfo &&BundleInfo, RTCDeviceCodeIR &&DeviceCodeIR,
             const char *BuildLog)
-      : Failed{false}, BundleInfo{std::move(BundleInfo)},
+      : ErrorCode{RTCErrorCode::SUCCESS}, BundleInfo{std::move(BundleInfo)},
         DeviceCodeIR(std::move(DeviceCodeIR)), BuildLog{BuildLog} {}
 
-  bool failed() const { return Failed; }
+  RTCErrorCode getErrorCode() const { return ErrorCode; }
 
   const char *getBuildLog() const { return BuildLog.c_str(); }
 
   const RTCBundleInfo &getBundleInfo() const {
-    assert(!failed() && "No bundle info");
+    assert(ErrorCode == RTCErrorCode::SUCCESS && "No bundle info");
     return BundleInfo;
   }
 
   const RTCDeviceCodeIR &getDeviceCodeIR() const {
-    assert(!failed() && "No device code IR");
+    assert(ErrorCode == RTCErrorCode::SUCCESS && "No device code IR");
     return DeviceCodeIR;
   }
 
 private:
-  bool Failed;
+  RTCErrorCode ErrorCode;
   RTCBundleInfo BundleInfo;
   RTCDeviceCodeIR DeviceCodeIR;
   sycl::detail::string BuildLog;

sycl-jit/jit-compiler/lib/KernelFusion.cpp

@@ -45,11 +45,12 @@ static std::string formatError(llvm::Error &&Err, const std::string &Msg) {
   return ErrMsg.str();
 }
 
-template <typename ResultType>
-static ResultType errorTo(llvm::Error &&Err, const std::string &Msg) {
+template <typename ResultType, typename... ExtraArgTypes>
+static ResultType errorTo(llvm::Error &&Err, const std::string &Msg,
+                          ExtraArgTypes... ExtraArgs) {
   // Cannot throw an exception here if LLVM itself is compiled without exception
   // support.
-  return ResultType{formatError(std::move(Err), Msg).c_str()};
+  return ResultType{formatError(std::move(Err), Msg).c_str(), ExtraArgs...};
 }
 
 static std::vector<jit_compiler::NDRange>
@@ -288,7 +289,8 @@ compileSYCL(InMemoryFile SourceFile, View<InMemoryFile> IncludeFiles,
   auto UserArgListOrErr = parseUserArgs(UserArgs);
   if (!UserArgListOrErr) {
     return errorTo<RTCResult>(UserArgListOrErr.takeError(),
-                              "Parsing of user arguments failed");
+                              "Parsing of user arguments failed",
+                              RTCErrorCode::INVALID);
   }
   llvm::opt::InputArgList UserArgList = std::move(*UserArgListOrErr);
 

sycl/source/detail/jit_compiler.cpp

@@ -1302,9 +1302,16 @@ std::pair<sycl_device_binaries, std::string> jit_compiler::compileSYCL(
   auto Result = CompileSYCLHandle(SourceFile, IncludeFilesView, UserArgsView,
                                   CachedIR, /*SaveIR=*/!CacheKey.empty());
 
-  appendToLog(Result.getBuildLog());
-  if (Result.failed()) {
-    throw sycl::exception(sycl::errc::build, Result.getBuildLog());
+  const char *BuildLog = Result.getBuildLog();
+  appendToLog(BuildLog);
+  switch (Result.getErrorCode()) {
+    using RTCErrC = ::jit_compiler::RTCErrorCode;
+  case RTCErrC::BUILD:
+    throw sycl::exception(sycl::errc::build, BuildLog);
+  case RTCErrC::INVALID:
+    throw sycl::exception(sycl::errc::invalid, BuildLog);
+  default: // RTCErrC::SUCCESS
+    break;
   }
 
   const auto &IR = Result.getDeviceCodeIR();

sycl/test-e2e/KernelCompiler/sycl.cpp

@@ -558,7 +558,7 @@ int test_unsupported_options() {
                       syclex::build_options{"-fsycl-targets=intel_gpu_pvc"}});
     assert(false && "unsupported option not detected");
   } catch (sycl::exception &e) {
-    assert(e.code() == sycl::errc::build);
+    assert(e.code() == sycl::errc::invalid);
     assert(std::string(e.what()).find("Parsing of user arguments failed") !=
            std::string::npos);
   }