[ORC] Rename WrapperFunctionResult to WrapperFunctionBuffer. NFCI. (llvm#172633)

Also renames CWrapperFunctionResult to CWrapperFunctionBuffer.

These types are used as argument buffers, as well as result buffers. The
new name better reflects their purpose, and is consistent with naming in
the new ORC runtime (llvm-project/orc-rt).

Author: lhames

llvm/include/llvm/ExecutionEngine/Orc/CallSPSViaEPC.h

@@ -26,8 +26,8 @@ struct SPSCallSerializationImpl {
   using ArgSerialization = shared::SPSArgList<SPSArgTs...>;
 
   template <typename... ArgTs>
-  Expected<shared::WrapperFunctionResult> serialize(ArgTs &&...Args) {
-    auto Buffer = shared::WrapperFunctionResult::allocate(
+  Expected<shared::WrapperFunctionBuffer> serialize(ArgTs &&...Args) {
+    auto Buffer = shared::WrapperFunctionBuffer::allocate(
         ArgSerialization::size(Args...));
     shared::SPSOutputBuffer OB(Buffer.data(), Buffer.size());
     if (!ArgSerialization::serialize(OB, Args...))
@@ -48,7 +48,7 @@ template <typename SPSSig>
 struct SPSCallSerializer : public detail::SPSCallSerialization<SPSSig> {
 
   template <typename RetT>
-  Expected<RetT> deserialize(shared::WrapperFunctionResult ResultBytes) {
+  Expected<RetT> deserialize(shared::WrapperFunctionBuffer ResultBytes) {
     using RetDeserialization =
         typename detail::SPSCallSerialization<SPSSig>::RetSerialization;
     shared::SPSInputBuffer IB(ResultBytes.data(), ResultBytes.size());
@@ -66,7 +66,7 @@ struct SPSCallSerializer<void(SPSArgTs...)>
     : public detail::SPSCallSerialization<void(SPSArgTs...)> {
   template <typename RetT>
   std::enable_if_t<std::is_void_v<RetT>, Error>
-  deserialize(shared::WrapperFunctionResult ResultBytes) {
+  deserialize(shared::WrapperFunctionBuffer ResultBytes) {
     if (!ResultBytes.empty())
       return make_error<StringError>("Could not deserialize return value",
                                      inconvertibleErrorCode());

llvm/include/llvm/ExecutionEngine/Orc/CallViaEPC.h

@@ -67,7 +67,7 @@ callViaEPC(HandlerFn &&H, ExecutorProcessControl &EPC, Serializer S,
     EPC.callWrapperAsync(
         Fn.getAddress(),
         [S = std::move(S), H = std::forward<HandlerFn>(H)](
-            shared::WrapperFunctionResult R) mutable {
+            shared::WrapperFunctionBuffer R) mutable {
           if (const char *ErrMsg = R.getOutOfBandError())
             H(make_error<StringError>(ErrMsg, inconvertibleErrorCode()));
           else

llvm/include/llvm/ExecutionEngine/Orc/Core.h

@@ -1352,7 +1352,7 @@ class ExecutionSession {
   using ErrorReporter = unique_function<void(Error)>;
 
   /// Send a result to the remote.
-  using SendResultFunction = unique_function<void(shared::WrapperFunctionResult)>;
+  using SendResultFunction = unique_function<void(shared::WrapperFunctionBuffer)>;
 
   /// An asynchronous wrapper-function callable from the executor via
   /// jit-dispatch.
@@ -1584,7 +1584,7 @@ class ExecutionSession {
   /// The wrapper function should be callable as:
   ///
   /// \code{.cpp}
-  ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
+  ///   CWrapperFunctionBuffer fn(uint8_t *Data, uint64_t Size);
   /// \endcode{.cpp}
   void callWrapperAsync(ExecutorAddr WrapperFnAddr,
                         ExecutorProcessControl::IncomingWFRHandler OnComplete,
@@ -1614,9 +1614,9 @@ class ExecutionSession {
   /// callable as:
   ///
   /// \code{.cpp}
-  ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
+  ///   CWrapperFunctionBuffer fn(uint8_t *Data, uint64_t Size);
   /// \endcode{.cpp}
-  shared::WrapperFunctionResult callWrapper(ExecutorAddr WrapperFnAddr,
+  shared::WrapperFunctionBuffer callWrapper(ExecutorAddr WrapperFnAddr,
                                             ArrayRef<char> ArgBuffer) {
     return EPC->callWrapper(WrapperFnAddr, ArgBuffer);
   }

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

@@ -39,27 +39,27 @@ class LLVM_ABI ExecutorProcessControl {
   friend class ExecutionSession;
 public:
 
-  /// A handler or incoming WrapperFunctionResults -- either return values from
+  /// A handler or incoming WrapperFunctionBuffers -- either return values from
   /// callWrapper* calls, or incoming JIT-dispatch requests.
   ///
   /// IncomingWFRHandlers are constructible from
-  /// unique_function<void(shared::WrapperFunctionResult)>s using the
+  /// unique_function<void(shared::WrapperFunctionBuffer)>s using the
   /// runInPlace function or a RunWithDispatch object.
   class IncomingWFRHandler {
     friend class ExecutorProcessControl;
   public:
     IncomingWFRHandler() = default;
     explicit operator bool() const { return !!H; }
-    void operator()(shared::WrapperFunctionResult WFR) { H(std::move(WFR)); }
+    void operator()(shared::WrapperFunctionBuffer WFR) { H(std::move(WFR)); }
   private:
     template <typename FnT> IncomingWFRHandler(FnT &&Fn)
       : H(std::forward<FnT>(Fn)) {}
 
-    unique_function<void(shared::WrapperFunctionResult)> H;
+    unique_function<void(shared::WrapperFunctionBuffer)> H;
   };
 
   /// Constructs an IncomingWFRHandler from a function object that is callable
-  /// as void(shared::WrapperFunctionResult). The function object will be called
+  /// as void(shared::WrapperFunctionBuffer). The function object will be called
   /// directly. This should be used with care as it may block listener threads
   /// in remote EPCs. It is only suitable for simple tasks (e.g. setting a
   /// future), or for performing some quick analysis before dispatching "real"
@@ -85,7 +85,7 @@ class LLVM_ABI ExecutorProcessControl {
     IncomingWFRHandler operator()(FnT &&Fn) {
       return IncomingWFRHandler(
           [&D = this->D, Fn = std::move(Fn)]
-          (shared::WrapperFunctionResult WFR) mutable {
+          (shared::WrapperFunctionBuffer WFR) mutable {
               D.dispatch(
                 makeGenericNamedTask(
                     [Fn = std::move(Fn), WFR = std::move(WFR)]() mutable {
@@ -219,7 +219,7 @@ class LLVM_ABI ExecutorProcessControl {
   /// The wrapper function should be callable as:
   ///
   /// \code{.cpp}
-  ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
+  ///   CWrapperFunctionBuffer fn(uint8_t *Data, uint64_t Size);
   /// \endcode{.cpp}
   virtual void callWrapperAsync(ExecutorAddr WrapperFnAddr,
                                 IncomingWFRHandler OnComplete,
@@ -247,15 +247,15 @@ class LLVM_ABI ExecutorProcessControl {
   /// callable as:
   ///
   /// \code{.cpp}
-  ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
+  ///   CWrapperFunctionBuffer fn(uint8_t *Data, uint64_t Size);
   /// \endcode{.cpp}
-  shared::WrapperFunctionResult callWrapper(ExecutorAddr WrapperFnAddr,
+  shared::WrapperFunctionBuffer callWrapper(ExecutorAddr WrapperFnAddr,
                                             ArrayRef<char> ArgBuffer) {
-    std::promise<shared::WrapperFunctionResult> RP;
+    std::promise<shared::WrapperFunctionBuffer> RP;
     auto RF = RP.get_future();
     callWrapperAsync(
         RunInPlace(), WrapperFnAddr,
-        [&](shared::WrapperFunctionResult R) {
+        [&](shared::WrapperFunctionBuffer R) {
           RP.set_value(std::move(R));
         }, ArgBuffer);
     return RF.get();

llvm/include/llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h

@@ -54,7 +54,7 @@ class LLVM_ABI SelfExecutorProcessControl : public ExecutorProcessControl,
   Error disconnect() override;
 
 private:
-  static shared::CWrapperFunctionResult
+  static shared::CWrapperFunctionBuffer
   jitDispatchViaWrapperFunctionManager(void *Ctx, const void *FnTag,
                                        const char *Data, size_t Size);