Move OffloadError to shared

Author: RossBrunton

offload/plugins-nextgen/common/include/OffloadError.h renamed to offload/include/Shared/OffloadError.h

@@ -14,32 +14,21 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 
-namespace llvm {
-namespace omp {
-namespace target {
-namespace plugin {
+namespace error {
 
 enum class ErrorCode {
 #define OFFLOAD_ERRC(Name, _, Value) Name = Value,
 #include "Shared/OffloadErrcodes.inc"
 #undef OFFLOAD_ERRC
 };
 
-} // namespace plugin
-} // namespace target
-} // namespace omp
-} // namespace llvm
+} // namespace error
 
 namespace std {
-template <>
-struct is_error_code_enum<llvm::omp::target::plugin::ErrorCode>
-    : std::true_type {};
+template <> struct is_error_code_enum<error::ErrorCode> : std::true_type {};
 } // namespace std
 
-namespace llvm {
-namespace omp {
-namespace target {
-namespace plugin {
+namespace error {
 
 const std::error_category &OffloadErrCategory();
 
@@ -48,17 +37,15 @@ inline std::error_code make_error_code(ErrorCode E) {
 }
 
 /// Base class for errors originating in DIA SDK, e.g. COM calls
-class OffloadError : public ErrorInfo<OffloadError, StringError> {
+class OffloadError : public llvm::ErrorInfo<OffloadError, llvm::StringError> {
 public:
   using ErrorInfo<OffloadError, StringError>::ErrorInfo;
 
-  OffloadError(const Twine &S) : ErrorInfo(S, ErrorCode::UNKNOWN) {}
+  OffloadError(const llvm::Twine &S) : ErrorInfo(S, ErrorCode::UNKNOWN) {}
 
+  // The definition for this resides in the plugin static library
   static char ID;
 };
-} // namespace plugin
-} // namespace target
-} // namespace omp
-} // namespace llvm
+} // namespace error
 
 #endif

offload/liboffload/include/OffloadImpl.hpp

@@ -105,9 +105,8 @@ struct ol_impl_result_t {
 
 private:
   static ol_errc_t GetErrorCode(std::error_code Code) {
-    if (Code.category() == llvm::omp::target::plugin::make_error_code(
-                               llvm::omp::target::plugin::ErrorCode::SUCCESS)
-                               .category()) {
+    if (Code.category() ==
+        error::make_error_code(error::ErrorCode::SUCCESS).category()) {
       return static_cast<ol_errc_t>(Code.value());
     }
     return OL_ERRC_UNKNOWN;

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

@@ -24,13 +24,13 @@
 #include "Shared/Debug.h"
 #include "Shared/Environment.h"
 #include "Shared/EnvironmentVar.h"
+#include "Shared/OffloadError.h"
 #include "Shared/Requirements.h"
 #include "Shared/Utils.h"
 
 #include "GlobalHandler.h"
 #include "JIT.h"
 #include "MemoryManager.h"
-#include "OffloadError.h"
 #include "RPC.h"
 #include "omptarget.h"
 
@@ -1382,23 +1382,23 @@ static inline Error success() { return Error::success(); }
 
 /// Create an Offload error.
 template <typename... ArgsTy>
-static Error error(ErrorCode Code, const char *ErrFmt, ArgsTy... Args) {
+static Error 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);
+  return make_error<error::OffloadError>(Code, Buffer);
 }
 
 template <typename... ArgsTy>
 static Error error(const char *ErrFmt, ArgsTy... Args) {
-  return error(ErrorCode::UNKNOWN, ErrFmt, Args...);
+  return error(error::ErrorCode::UNKNOWN, ErrFmt, Args...);
 }
 
-inline Error error(ErrorCode Code, const char *S) {
-  return make_error<OffloadError>(Code, S);
+inline Error error(error::ErrorCode Code, const char *S) {
+  return make_error<error::OffloadError>(Code, S);
 }
 
 inline Error error(const char *S) {
-  return make_error<OffloadError>(ErrorCode::UNKNOWN, S);
+  return make_error<error::OffloadError>(error::ErrorCode::UNKNOWN, S);
 }
 
 /// Check the plugin-specific error code and return an error or success

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

@@ -6,11 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "OffloadError.h"
+#include "Shared/OffloadError.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
-using namespace llvm::omp::target::plugin;
+using namespace error;
 
 namespace {
 // OffloadError inherits from llvm::StringError which requires a
@@ -32,7 +32,7 @@ class OffloadErrorCategory : public std::error_category {
 };
 } // namespace
 
-const std::error_category &llvm::omp::target::plugin::OffloadErrCategory() {
+const std::error_category &error::OffloadErrCategory() {
   static OffloadErrorCategory MSFCategory;
   return MSFCategory;
 }