[Orc][RPC] Add an RPCFunctionNotSupported error type and return it from

negotiateFunction where appropriate.

Replacing the old ECError with a custom type allows us to attach the name of
the function that could not be negotiated, enabling better diagnostics for
negotiation failures.

llvm-svn: 292055

include/llvm/ExecutionEngine/Orc/OrcError.h

@@ -35,6 +35,18 @@ enum class OrcErrorCode : int {
 
 Error orcError(OrcErrorCode ErrCode);
 
+class RPCFunctionNotSupported : public ErrorInfo<RPCFunctionNotSupported> {
+public:
+  static char ID;
+
+  RPCFunctionNotSupported(std::string RPCFunctionSignature);
+  std::error_code convertToErrorCode() const override;
+  void log(raw_ostream &OS) const override;
+  const std::string &getFunctionSignature() const;
+private:
+  std::string RPCFunctionSignature;
+};
+
 } // End namespace orc.
 } // End namespace llvm.
 

include/llvm/ExecutionEngine/Orc/RPCUtils.h

@@ -1116,7 +1116,7 @@ public:
         return Error::success();
       // If it's invalid and we can't re-attempt negotiation, throw an error.
       if (!Retry)
-        return orcError(OrcErrorCode::UnknownRPCFunction);
+        return make_error<RPCFunctionNotSupported>(Func::getPrototype());
     }
 
     // We don't have a function id for Func yet, call the remote to try to
@@ -1254,7 +1254,7 @@ public:
         return Error::success();
       // If it's invalid and we can't re-attempt negotiation, throw an error.
       if (!Retry)
-        return orcError(OrcErrorCode::UnknownRPCFunction);
+        return make_error<RPCFunctionNotSupported>(Func::getPrototype());
     }
 
     // We don't have a function id for Func yet, call the remote to try to

lib/ExecutionEngine/Orc/OrcError.cpp

@@ -58,10 +58,30 @@ static ManagedStatic<OrcErrorCategory> OrcErrCat;
 namespace llvm {
 namespace orc {
 
+char RPCFunctionNotSupported::ID = 0;
+
 Error orcError(OrcErrorCode ErrCode) {
   typedef std::underlying_type<OrcErrorCode>::type UT;
   return errorCodeToError(
       std::error_code(static_cast<UT>(ErrCode), *OrcErrCat));
 }
+
+RPCFunctionNotSupported::RPCFunctionNotSupported(std::string RPCFunctionSignature)
+  : RPCFunctionSignature(std::move(RPCFunctionSignature)) {}
+
+std::error_code RPCFunctionNotSupported::convertToErrorCode() const {
+  typedef std::underlying_type<OrcErrorCode>::type UT;
+  return std::error_code(static_cast<UT>(OrcErrorCode::UnknownRPCFunction),
+                         *OrcErrCat);
+}
+
+void RPCFunctionNotSupported::log(raw_ostream &OS) const {
+  OS << "Could not negotiate RPC function '" << RPCFunctionSignature << "'";
+}
+
+const std::string &RPCFunctionNotSupported::getFunctionSignature() const {
+  return RPCFunctionSignature;
+}
+
 }
 }