[Offload] Follow other LLVM error code handling

Author: RossBrunton

offload/plugins-nextgen/common/CMakeLists.txt

@@ -5,6 +5,7 @@ add_library(PluginCommon OBJECT
   src/GlobalHandler.cpp
   src/JIT.cpp
   src/RPC.cpp
+  src/OffloadError.cpp
   src/Utils/ELF.cpp
 )
 add_dependencies(PluginCommon intrinsics_gen)

offload/plugins-nextgen/common/include/OffloadError.h

@@ -0,0 +1,76 @@
+//===- OffloadError.h - Definition of error class -------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_COMMON_OFFLOAD_ERROR_H
+#define OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_COMMON_OFFLOAD_ERROR_H
+
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace llvm {
+namespace omp {
+namespace target {
+namespace plugin {
+
+enum class ErrorCode {
+#define OFFLOAD_ERRC(Name, _, Value) Name = Value,
+#include "OffloadErrcodes.inc"
+#undef OFFLOAD_ERRC
+};
+
+class OffloadErrorCategory : public std::error_category {
+  const char *name() const noexcept override { return "Offload Error"; }
+  std::string message(int ev) const override {
+    switch (static_cast<ErrorCode>(ev)) {
+#define OFFLOAD_ERRC(Name, Desc, Value)                                        \
+  case ErrorCode::Name:                                                        \
+    return #Desc;
+#include "OffloadErrcodes.inc"
+#undef OFFLOAD_ERRC
+    }
+  }
+};
+} // namespace plugin
+} // namespace target
+} // namespace omp
+} // namespace llvm
+
+namespace std {
+template <>
+struct is_error_code_enum<llvm::omp::target::plugin::ErrorCode>
+    : std::true_type {};
+} // namespace std
+
+namespace llvm {
+namespace omp {
+namespace target {
+namespace plugin {
+
+const std::error_category &OffloadErrCategory();
+
+inline std::error_code make_error_code(ErrorCode E) {
+  return std::error_code(static_cast<int>(E), OffloadErrCategory());
+}
+
+/// Base class for errors originating in DIA SDK, e.g. COM calls
+class OffloadError : public ErrorInfo<OffloadError, StringError> {
+public:
+  using ErrorInfo<OffloadError, StringError>::ErrorInfo;
+
+  OffloadError(const Twine &S) : ErrorInfo(S, ErrorCode::UNKNOWN) {}
+
+  static char ID;
+};
+} // namespace plugin
+} // namespace target
+} // namespace omp
+} // namespace llvm
+
+#endif

offload/plugins-nextgen/common/include/PluginInterface.h

@@ -30,6 +30,7 @@
 #include "GlobalHandler.h"
 #include "JIT.h"
 #include "MemoryManager.h"
+#include "OffloadError.h"
 #include "RPC.h"
 #include "omptarget.h"
 
@@ -58,30 +59,6 @@ struct GenericKernelTy;
 struct GenericDeviceTy;
 struct RecordReplayTy;
 
-enum class ErrorCode {
-#define OFFLOAD_ERRC(Name, _, Value) Name = Value,
-#include "OffloadErrcodes.inc"
-#undef OFFLOAD_ERRC
-};
-
-class OffloadErrorCategory : public std::error_category {
-  const char *name() const noexcept override { return "Offload Error"; }
-  std::string message(int ev) const override {
-    switch (static_cast<ErrorCode>(ev)) {
-#define OFFLOAD_ERRC(Name, Desc, Value)                                        \
-  case ErrorCode::Name:                                                        \
-    return #Desc;
-#include "OffloadErrcodes.inc"
-#undef OFFLOAD_ERRC
-    }
-  }
-};
-
-inline std::error_code make_error_code(ErrorCode EC) {
-  static OffloadErrorCategory Cat{};
-  return {static_cast<int>(EC), Cat};
-}
-
 /// Class that wraps the __tgt_async_info to simply its usage. In case the
 /// object is constructed without a valid __tgt_async_info, the object will use
 /// an internal one and will synchronize the current thread with the pending
@@ -1406,16 +1383,25 @@ namespace Plugin {
 /// Plugin::check().
 static inline Error success() { return Error::success(); }
 
-/// Create a string error.
+/// Create an Offload error.
 template <typename... ArgsTy>
-static Error error(const char *ErrFmt, ArgsTy... Args) {
-  return createStringError(ErrorCode::UNKNOWN, ErrFmt, Args...);
+static Error error(ErrorCode Code, const char *ErrFmt, ArgsTy... Args) {
+  std::string Buffer;
+  raw_string_ostream(Buffer) << format(ErrFmt, Args...);
+  return make_error<OffloadError>(Code, Buffer);
 }
 
-/// Create a string error.
 template <typename... ArgsTy>
-static Error error(ErrorCode Code, const char *ErrFmt, ArgsTy... Args) {
-  return createStringError(Code, ErrFmt, Args...);
+static Error error(const char *ErrFmt, ArgsTy... Args) {
+  return error(ErrorCode::UNKNOWN, ErrFmt, Args...);
+}
+
+inline Error error(ErrorCode Code, const char *S) {
+  return make_error<OffloadError>(Code, S);
+}
+
+inline Error error(const char *S) {
+  return make_error<OffloadError>(ErrorCode::UNKNOWN, S);
 }
 
 /// Check the plugin-specific error code and return an error or success
@@ -1626,10 +1612,4 @@ template <typename ResourceRef> class GenericDeviceResourceManagerTy {
 } // namespace omp
 } // namespace llvm
 
-namespace std {
-template <>
-struct is_error_code_enum<llvm::omp::target::plugin::ErrorCode>
-    : std::true_type {};
-} // namespace std
-
 #endif // OPENMP_LIBOMPTARGET_PLUGINS_COMMON_PLUGININTERFACE_H

offload/plugins-nextgen/common/src/OffloadError.cpp

@@ -0,0 +1,40 @@
+//===- OffloadError.cpp - Error extensions for offload --------------------===//
+//
+// 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 "OffloadError.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace llvm;
+using namespace llvm::omp::target::plugin;
+
+namespace {
+// FIXME: This class is only here to support the transition to llvm::Error. It
+// will be removed once this transition is complete. Clients should prefer to
+// deal with the Error value directly, rather than converting to error_code.
+class OffloadErrorCategory : public std::error_category {
+public:
+  const char *name() const noexcept override { return "llvm.offload"; }
+  std::string message(int Condition) const override {
+    switch (static_cast<ErrorCode>(Condition)) {
+#define OFFLOAD_ERRC(Name, Desc, Value)                                        \
+  case ErrorCode::Name:                                                        \
+    return #Desc;
+#include "OffloadErrcodes.inc"
+#undef OFFLOAD_ERRC
+    }
+    llvm_unreachable("Unrecognized offload ErrorCode");
+  }
+};
+} // namespace
+
+const std::error_category &llvm::omp::target::plugin::OffloadErrCategory() {
+  static OffloadErrorCategory MSFCategory;
+  return MSFCategory;
+}
+
+char OffloadError::ID;