Revert "[ORC-RT] Update WrapperFunctionCall for 089acf25223."

[fhahn]

Summary

This reverts commit 0ede1b906d4dc949b297d4f5d94ae9f4fc84a2b3.

[tianshilei1992]

openmp/libomptarget/test/offloading/bug50022.cpp

36

This must be a typo.

[fhahn]

This was just an attempt to see if this patch has been causing the large number ob libomp test failures in the precommit checks. It didn't/t

[MaskRay]

You can use arc diff --draft 'HEAD^' to not make it a review.

compiler-rt/lib/orc/macho_platform.cpp

 }
 
 void destroyMachOTLVMgr(void *MachOTLVMgr) {
   delete static_cast<MachOPlatformRuntimeTLVManager *>(MachOTLVMgr);
 }
 
 Error runWrapperFunctionCalls(std::vector<WrapperFunctionCall> WFCs) {
   for (auto &WFC : WFCs)
-    if (auto Err = WFC.runWithSPSRet<void>())
+    if (auto Err = WFC.runWithSPSRet())
       return Err;
   return Error::success();
 }
 
 } // end anonymous namespace
 
 //------------------------------------------------------------------------------
 //                             JIT entry points

compiler-rt/lib/orc/unittests/wrapper_function_utils_test.cpp

 TEST(WrapperFunctionUtilsTest, WrapperFunctionMethodCallAndHandleRet) {
   int32_t Result;
   AddClass AddObj(1);
   EXPECT_FALSE(!!WrapperFunction<int32_t(SPSExecutorAddr, int32_t)>::call(
       (void *)&addMethodWrapper, Result, ExecutorAddr::fromPtr(&AddObj), 2));
   EXPECT_EQ(Result, (int32_t)3);
 }
 
-static __orc_rt_CWrapperFunctionResult sumArrayWrapper(const char *ArgData,
+// A non-SPS wrapper function that calculates the sum of a byte array.
+static __orc_rt_CWrapperFunctionResult sumArrayRawWrapper(const char *ArgData,
                                                           size_t ArgSize) {
-  return WrapperFunction<int8_t(SPSExecutorAddrRange)>::handle(
-             ArgData, ArgSize,
-             [](ExecutorAddrRange R) {
-               int8_t Sum = 0;
-               for (char C : R.toSpan<char>())
-                 Sum += C;
-               return Sum;
-             })
-      .release();
+  auto WFR = WrapperFunctionResult::allocate(1);
+  *WFR.data() = 0;
+  for (unsigned I = 0; I != ArgSize; ++I)
+    *WFR.data() += ArgData[I];
+  return WFR.release();
 }
 
 TEST(WrapperFunctionUtilsTest, SerializedWrapperFunctionCallTest) {
   {
-    // Check wrapper function calls.
+    // Check raw wrapper function calls.
     char A[] = {1, 2, 3, 4};
 
-    auto WFC =
-        cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddrRange>>(
-            ExecutorAddr::fromPtr(sumArrayWrapper),
+    WrapperFunctionCall WFC{ExecutorAddr::fromPtr(sumArrayRawWrapper),
                             ExecutorAddrRange(ExecutorAddr::fromPtr(A),
-                              ExecutorAddrDiff(sizeof(A)))));
+                                              ExecutorAddrDiff(sizeof(A)))};
 
     WrapperFunctionResult WFR(WFC.run());
     EXPECT_EQ(WFR.size(), 1U);
     EXPECT_EQ(WFR.data()[0], 10);
   }
 
   {
     // Check calls to void functions.
-    auto WFC =
-        cantFail(WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddrRange>>(
-            ExecutorAddr::fromPtr(voidNoopWrapper), ExecutorAddrRange()));
-    auto Err = WFC.runWithSPSRet<void>();
+    WrapperFunctionCall WFC{ExecutorAddr::fromPtr(voidNoopWrapper),
+                            ExecutorAddrRange()};
+    auto Err = WFC.runWithSPSRet();
     EXPECT_FALSE(!!Err);
   }
 
   {
     // Check calls with arguments and return values.
-    auto WFC =
-        cantFail(WrapperFunctionCall::Create<SPSArgList<int32_t, int32_t>>(
-            ExecutorAddr::fromPtr(addWrapper), 2, 4));
+    auto ArgWFR =
+        WrapperFunctionResult::fromSPSArgs<SPSArgList<int32_t, int32_t>>(2, 4);
+    WrapperFunctionCall WFC{
+        ExecutorAddr::fromPtr(addWrapper),
+        ExecutorAddrRange(ExecutorAddr::fromPtr(ArgWFR.data()),
+                          ExecutorAddrDiff(ArgWFR.size()))};
 
     int32_t Result = 0;
     auto Err = WFC.runWithSPSRet<int32_t>(Result);
     EXPECT_FALSE(!!Err);
     EXPECT_EQ(Result, 6);
   }
 }

compiler-rt/lib/orc/wrapper_function_utils.h

 /// Create a MethodWrapperHandler object from the given method pointer.
 template <typename RetT, typename ClassT, typename... ArgTs>
 MethodWrapperHandler<RetT, ClassT, ArgTs...>
 makeMethodWrapperHandler(RetT (ClassT::*Method)(ArgTs...)) {
   return MethodWrapperHandler<RetT, ClassT, ArgTs...>(Method);
 }
 
 /// Represents a call to a wrapper function.
-class WrapperFunctionCall {
-public:
-  // FIXME: Switch to a SmallVector<char, 24> once ORC runtime has a
-  // smallvector.
-  using ArgDataBufferType = std::vector<char>;
-
-  /// Create a WrapperFunctionCall using the given SPS serializer to serialize
-  /// the arguments.
-  template <typename SPSSerializer, typename... ArgTs>
-  static Expected<WrapperFunctionCall> Create(ExecutorAddr FnAddr,
-                                              const ArgTs &...Args) {
-    ArgDataBufferType ArgData;
-    ArgData.resize(SPSSerializer::size(Args...));
-    SPSOutputBuffer OB(&ArgData[0], ArgData.size());
-    if (SPSSerializer::serialize(OB, Args...))
-      return WrapperFunctionCall(FnAddr, std::move(ArgData));
-    return make_error<StringError>("Cannot serialize arguments for "
-                                   "AllocActionCall");
-  }
+struct WrapperFunctionCall {
+  ExecutorAddr Func;
+  ExecutorAddrRange ArgData;
 
   WrapperFunctionCall() = default;
+  WrapperFunctionCall(ExecutorAddr Func, ExecutorAddrRange ArgData)
+      : Func(Func), ArgData(ArgData) {}
 
-  /// Create a WrapperFunctionCall from a target function and arg buffer.
-  WrapperFunctionCall(ExecutorAddr FnAddr, ArgDataBufferType ArgData)
-      : FnAddr(FnAddr), ArgData(std::move(ArgData)) {}
-
-  /// Returns the address to be called.
-  const ExecutorAddr &getCallee() const { return FnAddr; }
-
-  /// Returns the argument data.
-  const ArgDataBufferType &getArgData() const { return ArgData; }
-
-  /// WrapperFunctionCalls convert to true if the callee is non-null.
-  explicit operator bool() const { return !!FnAddr; }
-
-  /// Run call returning raw WrapperFunctionResult.
-  WrapperFunctionResult run() const {
-    using FnTy =
-        __orc_rt_CWrapperFunctionResult(const char *ArgData, size_t ArgSize);
-    return WrapperFunctionResult(
-        FnAddr.toPtr<FnTy *>()(ArgData.data(), ArgData.size()));
+  /// Run and return result as WrapperFunctionResult.
+  WrapperFunctionResult run() {
+    WrapperFunctionResult WFR(
+        Func.toPtr<__orc_rt_CWrapperFunctionResult (*)(const char *, size_t)>()(
+            ArgData.Start.toPtr<const char *>(),
+            static_cast<size_t>(ArgData.size().getValue())));
+    return WFR;
   }
 
   /// Run call and deserialize result using SPS.
-  template <typename SPSRetT, typename RetT>
-  std::enable_if_t<!std::is_same<SPSRetT, void>::value, Error>
-  runWithSPSRet(RetT &RetVal) const {
+  template <typename SPSRetT, typename RetT> Error runWithSPSRet(RetT &RetVal) {
     auto WFR = run();
     if (const char *ErrMsg = WFR.getOutOfBandError())
       return make_error<StringError>(ErrMsg);
     SPSInputBuffer IB(WFR.data(), WFR.size());
     if (!SPSSerializationTraits<SPSRetT, RetT>::deserialize(IB, RetVal))
       return make_error<StringError>("Could not deserialize result from "
                                      "serialized wrapper function call");
     return Error::success();
   }
 
   /// Overload for SPS functions returning void.
-  template <typename SPSRetT>
-  std::enable_if_t<std::is_same<SPSRetT, void>::value, Error>
-  runWithSPSRet() const {
+  Error runWithSPSRet() {
     SPSEmpty E;
     return runWithSPSRet<SPSEmpty>(E);
   }
-
-  /// Run call and deserialize an SPSError result. SPSError returns and
-  /// deserialization failures are merged into the returned error.
-  Error runWithSPSRetErrorMerged() const {
-    detail::SPSSerializableError RetErr;
-    if (auto Err = runWithSPSRet<SPSError>(RetErr))
-      return Err;
-    return detail::fromSPSSerializable(std::move(RetErr));
-  }
-
-private:
-  ExecutorAddr FnAddr;
-  std::vector<char> ArgData;
 };
 
-using SPSWrapperFunctionCall = SPSTuple<SPSExecutorAddr, SPSSequence<char>>;
+class SPSWrapperFunctionCall {};
 
 template <>
 class SPSSerializationTraits<SPSWrapperFunctionCall, WrapperFunctionCall> {
 public:
   static size_t size(const WrapperFunctionCall &WFC) {
-    return SPSArgList<SPSExecutorAddr, SPSSequence<char>>::size(
-        WFC.getCallee(), WFC.getArgData());
+    return SPSArgList<SPSExecutorAddr, SPSExecutorAddrRange>::size(WFC.Func,
+                                                                   WFC.ArgData);
   }
 
   static bool serialize(SPSOutputBuffer &OB, const WrapperFunctionCall &WFC) {
-    return SPSArgList<SPSExecutorAddr, SPSSequence<char>>::serialize(
-        OB, WFC.getCallee(), WFC.getArgData());
+    return SPSArgList<SPSExecutorAddr, SPSExecutorAddrRange>::serialize(
+        OB, WFC.Func, WFC.ArgData);
   }
 
   static bool deserialize(SPSInputBuffer &IB, WrapperFunctionCall &WFC) {
-    ExecutorAddr FnAddr;
-    WrapperFunctionCall::ArgDataBufferType ArgData;
-    if (!SPSWrapperFunctionCall::AsArgList::deserialize(IB, FnAddr, ArgData))
-      return false;
-    WFC = WrapperFunctionCall(FnAddr, std::move(ArgData));
-    return true;
+    return SPSArgList<SPSExecutorAddr, SPSExecutorAddrRange>::deserialize(
+        IB, WFC.Func, WFC.ArgData);
   }
 };
 
 } // end namespace __orc_rt
 
 #endif // ORC_RT_WRAPPER_FUNCTION_UTILS_H

openmp/libomptarget/test/offloading/bug50022.cpp

#pragma omp task depend(inout : a) shared(a)
     std::cout << "a = " << a << " addr " << &a << std::endl;
     if (a != 2)
       throw std::runtime_error("wrong result!");
     a = 3;
   }
 
 #pragma omp taskwait
 
-  assert(a == 3 && "wrong result!");
+  assert(a == 3 && "wrong result2!");
 
   return 0;
 }