[llvm] 2f08f84 - Revert "[ORC] Add "wrap" and "unwrap" steps to ExecutorAddr toPtr/fromPtr."

[Lang Hames via llvm-commits]

Author: Lang Hames
Date: 2022-08-26T13:54:30-07:00
New Revision: 2f08f8426c5e240c673755a14dded8efaa7d49e4

URL: https://github.com/llvm/llvm-project/commit/2f08f8426c5e240c673755a14dded8efaa7d49e4
DIFF: https://github.com/llvm/llvm-project/commit/2f08f8426c5e240c673755a14dded8efaa7d49e4.diff

LOG: Revert "[ORC] Add "wrap" and "unwrap" steps to ExecutorAddr toPtr/fromPtr."

This reverts commit f14cb494a34db6df9853d713c6027a476f030dbf.

Reverting while I investigate bot failures, e.g.
https://lab.llvm.org/buildbot#builders/117/builds/8701

Added: 
    

Modified: 
    llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h
    llvm/unittests/ExecutionEngine/Orc/ExecutorAddressTest.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h b/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h
index 1264531e8f0df..5d545f8abdb99 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h
@@ -14,7 +14,6 @@
 #define LLVM_EXECUTIONENGINE_ORC_SHARED_EXECUTORADDRESS_H
 
 #include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/ADT/identity.h"
 #include "llvm/ExecutionEngine/Orc/Shared/SimplePackedSerialization.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
@@ -30,45 +29,6 @@ using ExecutorAddrDiff = uint64_t;
 /// Represents an address in the executor process.
 class ExecutorAddr {
 public:
-  /// A wrap/unwrap function that leaves pointers unmodified.
-  template <typename T> using rawPtr = llvm::identity<T>;
-
-  /// Default wrap function to use on this host.
-  template <typename T> using defaultWrap = rawPtr<T>;
-
-  /// Default unwrap function to use on this host.
-  template <typename T> using defaultUnwrap = rawPtr<T>;
-
-  /// Merges a tag into the raw address value:
-  ///   P' = P | (TagValue << TagOffset).
-  class Tag {
-  public:
-    constexpr Tag(uintptr_t TagValue, uintptr_t TagOffset)
-        : TagMask(TagValue << TagOffset) {}
-
-    template <typename T> constexpr T *operator()(T *P) {
-      return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(P) | TagMask);
-    }
-
-  private:
-    uintptr_t TagMask;
-  };
-
-  /// Strips a tag of the given length from the given offset within the pointer:
-  /// P' = P & ~(((1 << TagLen) -1) << TagOffset)
-  class Untag {
-  public:
-    constexpr Untag(uintptr_t TagLen, uintptr_t TagOffset)
-        : UntagMask(~(((1 << TagLen) - 1) << TagOffset)) {}
-
-    template <typename T> constexpr T *operator()(T *P) {
-      return reinterpret_cast<T *>(reinterpret_cast<uintptr_t>(P) & UntagMask);
-    }
-
-  private:
-    uintptr_t UntagMask;
-  };
-
   ExecutorAddr() = default;
 
   /// Create an ExecutorAddr from the given value.
@@ -76,30 +36,27 @@ class ExecutorAddr {
 
   /// Create an ExecutorAddr from the given pointer.
   /// Warning: This should only be used when JITing in-process.
-  template <typename T, typename UnwrapFn = defaultUnwrap<T *>>
-  static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap = UnwrapFn()) {
+  template <typename T> static ExecutorAddr fromPtr(T *Value) {
     return ExecutorAddr(
-        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(Unwrap(Ptr))));
+        static_cast<uint64_t>(reinterpret_cast<uintptr_t>(Value)));
   }
 
   /// Cast this ExecutorAddr to a pointer of the given type.
   /// Warning: This should only be used when JITing in-process.
-  template <typename T, typename WrapFn = defaultWrap<T>>
-  std::enable_if_t<std::is_pointer<T>::value, T>
-  toPtr(WrapFn &&Wrap = WrapFn()) const {
+  template <typename T>
+  std::enable_if_t<std::is_pointer<T>::value, T> toPtr() const {
     uintptr_t IntPtr = static_cast<uintptr_t>(Addr);
     assert(IntPtr == Addr && "ExecutorAddr value out of range for uintptr_t");
-    return Wrap(reinterpret_cast<T>(IntPtr));
+    return reinterpret_cast<T>(IntPtr);
   }
 
   /// Cast this ExecutorAddr to a pointer of the given function type.
   /// Warning: This should only be used when JITing in-process.
-  template <typename T, typename WrapFn = defaultWrap<T *>>
-  std::enable_if_t<std::is_function<T>::value, T *>
-  toPtr(WrapFn &&Wrap = WrapFn()) const {
+  template <typename T>
+  std::enable_if_t<std::is_function<T>::value, T *> toPtr() const {
     uintptr_t IntPtr = static_cast<uintptr_t>(Addr);
     assert(IntPtr == Addr && "ExecutorAddr value out of range for uintptr_t");
-    return Wrap(reinterpret_cast<T *>(IntPtr));
+    return reinterpret_cast<T *>(IntPtr);
   }
 
   uint64_t getValue() const { return Addr; }

diff  --git a/llvm/unittests/ExecutionEngine/Orc/ExecutorAddressTest.cpp b/llvm/unittests/ExecutionEngine/Orc/ExecutorAddressTest.cpp
index f829de6d6cb3c..7cbfdffd49bcf 100644
--- a/llvm/unittests/ExecutionEngine/Orc/ExecutorAddressTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/ExecutorAddressTest.cpp
@@ -58,26 +58,6 @@ TEST(ExecutorAddrTest, PtrConversionWithFunctionType) {
   EXPECT_EQ(FPtr, &F);
 }
 
-TEST(ExecutorAddrTest, WrappingAndUnwrapping) {
-  constexpr uintptr_t RawAddr = 0x123456;
-  int *RawPtr = (int *)RawAddr;
-
-  constexpr uintptr_t TagOffset = 8 * (sizeof(uintptr_t) - 1);
-  uintptr_t TagVal = 0xA5;
-  uintptr_t TagBits = TagVal << TagOffset;
-  void *TaggedPtr = (void *)((uintptr_t)RawPtr | TagBits);
-
-  ExecutorAddr EA =
-      ExecutorAddr::fromPtr(TaggedPtr, ExecutorAddr::Untag(8, TagOffset));
-
-  EXPECT_EQ(EA.getValue(), RawAddr);
-
-  void *ReconstitutedTaggedPtr =
-      EA.toPtr<void *>(ExecutorAddr::Tag(TagVal, TagOffset));
-
-  EXPECT_EQ(TaggedPtr, ReconstitutedTaggedPtr);
-}
-
 TEST(ExecutorAddrTest, AddrRanges) {
   ExecutorAddr A0(0), A1(1), A2(2), A3(3);
   ExecutorAddrRange R0(A0, A1), R1(A1, A2), R2(A2, A3), R3(A0, A2), R4(A1, A3);