Merge commit '558760009cf4' from llvm.org/main into next

Author: git apple-llvm automerger

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);