[ORC] Add read operations to orc::MemoryAccess. (#145834)

This commit adds operations to orc::MemoryAccess for reading basic types
(uint8_t, uint16_t, uint32_t, uint64_t, pointers, buffers, and strings)
from executor memory.

The InProcessMemoryAccess and EPCGenericMemoryAccess implementations are
updated to support the new operations.

Author: lhames

llvm/include/llvm/ExecutionEngine/Orc/EPCGenericMemoryAccess.h

@@ -31,8 +31,15 @@ class EPCGenericMemoryAccess : public MemoryAccess {
     ExecutorAddr WriteUInt16s;
     ExecutorAddr WriteUInt32s;
     ExecutorAddr WriteUInt64s;
-    ExecutorAddr WriteBuffers;
     ExecutorAddr WritePointers;
+    ExecutorAddr WriteBuffers;
+    ExecutorAddr ReadUInt8s;
+    ExecutorAddr ReadUInt16s;
+    ExecutorAddr ReadUInt32s;
+    ExecutorAddr ReadUInt64s;
+    ExecutorAddr ReadPointers;
+    ExecutorAddr ReadBuffers;
+    ExecutorAddr ReadStrings;
   };
 
   /// Create an EPCGenericMemoryAccess instance from a given set of
@@ -68,18 +75,130 @@ class EPCGenericMemoryAccess : public MemoryAccess {
         FAs.WriteUInt64s, std::move(OnWriteComplete), Ws);
   }
 
+  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                          WriteResultFn OnWriteComplete) override {
+    using namespace shared;
+    EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessPointerWrite>)>(
+        FAs.WritePointers, std::move(OnWriteComplete), Ws);
+  }
+
   void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
                          WriteResultFn OnWriteComplete) override {
     using namespace shared;
     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessBufferWrite>)>(
         FAs.WriteBuffers, std::move(OnWriteComplete), Ws);
   }
 
-  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
-                          WriteResultFn OnWriteComplete) override {
+  void readUInt8sAsync(ArrayRef<ExecutorAddr> Rs,
+                       OnReadUIntsCompleteFn<uint8_t> OnComplete) override {
     using namespace shared;
-    EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessPointerWrite>)>(
-        FAs.WritePointers, std::move(OnWriteComplete), Ws);
+    EPC.callSPSWrapperAsync<SPSSequence<uint8_t>(SPSSequence<SPSExecutorAddr>)>(
+        FAs.ReadUInt8s,
+        [OnComplete = std::move(OnComplete)](
+            Error Err, ReadUIntsResult<uint8_t> Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
+  }
+
+  void readUInt16sAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadUIntsCompleteFn<uint16_t> OnComplete) override {
+    using namespace shared;
+    EPC.callSPSWrapperAsync<SPSSequence<uint16_t>(
+        SPSSequence<SPSExecutorAddr>)>(
+        FAs.ReadUInt16s,
+        [OnComplete = std::move(OnComplete)](
+            Error Err, ReadUIntsResult<uint16_t> Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
+  }
+
+  void readUInt32sAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadUIntsCompleteFn<uint32_t> OnComplete) override {
+    using namespace shared;
+    EPC.callSPSWrapperAsync<SPSSequence<uint32_t>(
+        SPSSequence<SPSExecutorAddr>)>(
+        FAs.ReadUInt32s,
+        [OnComplete = std::move(OnComplete)](
+            Error Err, ReadUIntsResult<uint32_t> Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
+  }
+
+  void readUInt64sAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadUIntsCompleteFn<uint64_t> OnComplete) override {
+    using namespace shared;
+    EPC.callSPSWrapperAsync<SPSSequence<uint64_t>(
+        SPSSequence<SPSExecutorAddr>)>(
+        FAs.ReadUInt64s,
+        [OnComplete = std::move(OnComplete)](
+            Error Err, ReadUIntsResult<uint64_t> Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
+  }
+
+  void readPointersAsync(ArrayRef<ExecutorAddr> Rs,
+                         OnReadPointersCompleteFn OnComplete) override {
+    using namespace shared;
+    using SPSSig = SPSSequence<SPSExecutorAddr>(SPSSequence<SPSExecutorAddr>);
+    EPC.callSPSWrapperAsync<SPSSig>(
+        FAs.ReadPointers,
+        [OnComplete = std::move(OnComplete)](
+            Error Err, ReadPointersResult Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
+  }
+
+  void readBuffersAsync(ArrayRef<ExecutorAddrRange> Rs,
+                        OnReadBuffersCompleteFn OnComplete) override {
+    using namespace shared;
+    using SPSSig =
+        SPSSequence<SPSSequence<uint8_t>>(SPSSequence<SPSExecutorAddrRange>);
+    EPC.callSPSWrapperAsync<SPSSig>(
+        FAs.ReadBuffers,
+        [OnComplete = std::move(OnComplete)](Error Err,
+                                             ReadBuffersResult Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
+  }
+
+  void readStringsAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadStringsCompleteFn OnComplete) override {
+    using namespace shared;
+    using SPSSig = SPSSequence<SPSString>(SPSSequence<SPSExecutorAddr>);
+    EPC.callSPSWrapperAsync<SPSSig>(
+        FAs.ReadStrings,
+        [OnComplete = std::move(OnComplete)](Error Err,
+                                             ReadStringsResult Result) mutable {
+          if (Err)
+            OnComplete(std::move(Err));
+          else
+            OnComplete(std::move(Result));
+        },
+        Rs);
   }
 
 private:

llvm/include/llvm/ExecutionEngine/Orc/InProcessMemoryAccess.h

@@ -32,11 +32,32 @@ class LLVM_ABI InProcessMemoryAccess : public MemoryAccess {
   void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
                          WriteResultFn OnWriteComplete) override;
 
+  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                          WriteResultFn OnWriteComplete) override;
+
   void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
                          WriteResultFn OnWriteComplete) override;
 
-  void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
-                          WriteResultFn OnWriteComplete) override;
+  void readUInt8sAsync(ArrayRef<ExecutorAddr> Rs,
+                       OnReadUIntsCompleteFn<uint8_t> OnComplete) override;
+
+  void readUInt16sAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadUIntsCompleteFn<uint16_t> OnComplete) override;
+
+  void readUInt32sAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadUIntsCompleteFn<uint32_t> OnComplete) override;
+
+  void readUInt64sAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadUIntsCompleteFn<uint64_t> OnComplete) override;
+
+  void readPointersAsync(ArrayRef<ExecutorAddr> Rs,
+                         OnReadPointersCompleteFn OnComplete) override;
+
+  void readBuffersAsync(ArrayRef<ExecutorAddrRange> Rs,
+                        OnReadBuffersCompleteFn OnComplete) override;
+
+  void readStringsAsync(ArrayRef<ExecutorAddr> Rs,
+                        OnReadStringsCompleteFn OnComplete) override;
 
 private:
   bool IsArch64Bit;

llvm/include/llvm/ExecutionEngine/Orc/MemoryAccess.h

@@ -28,6 +28,23 @@ class LLVM_ABI MemoryAccess {
   /// Callback function for asynchronous writes.
   using WriteResultFn = unique_function<void(Error)>;
 
+  template <typename T> using ReadUIntsResult = std::vector<T>;
+  template <typename T>
+  using OnReadUIntsCompleteFn =
+      unique_function<void(Expected<ReadUIntsResult<T>>)>;
+
+  using ReadPointersResult = std::vector<ExecutorAddr>;
+  using OnReadPointersCompleteFn =
+      unique_function<void(Expected<ReadPointersResult>)>;
+
+  using ReadBuffersResult = std::vector<std::vector<uint8_t>>;
+  using OnReadBuffersCompleteFn =
+      unique_function<void(Expected<ReadBuffersResult>)>;
+
+  using ReadStringsResult = std::vector<std::string>;
+  using OnReadStringsCompleteFn =
+      unique_function<void(Expected<ReadStringsResult>)>;
+
   virtual ~MemoryAccess();
 
   virtual void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
@@ -42,11 +59,32 @@ class LLVM_ABI MemoryAccess {
   virtual void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
                                  WriteResultFn OnWriteComplete) = 0;
 
+  virtual void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
+                                  WriteResultFn OnWriteComplete) = 0;
+
   virtual void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
                                  WriteResultFn OnWriteComplete) = 0;
 
-  virtual void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,
-                                  WriteResultFn OnWriteComplete) = 0;
+  virtual void readUInt8sAsync(ArrayRef<ExecutorAddr> Rs,
+                               OnReadUIntsCompleteFn<uint8_t> OnComplete) = 0;
+
+  virtual void readUInt16sAsync(ArrayRef<ExecutorAddr> Rs,
+                                OnReadUIntsCompleteFn<uint16_t> OnComplete) = 0;
+
+  virtual void readUInt32sAsync(ArrayRef<ExecutorAddr> Rs,
+                                OnReadUIntsCompleteFn<uint32_t> OnComplete) = 0;
+
+  virtual void readUInt64sAsync(ArrayRef<ExecutorAddr> Rs,
+                                OnReadUIntsCompleteFn<uint64_t> OnComplete) = 0;
+
+  virtual void readPointersAsync(ArrayRef<ExecutorAddr> Rs,
+                                 OnReadPointersCompleteFn OnComplete) = 0;
+
+  virtual void readBuffersAsync(ArrayRef<ExecutorAddrRange> Rs,
+                                OnReadBuffersCompleteFn OnComplete) = 0;
+
+  virtual void readStringsAsync(ArrayRef<ExecutorAddr> Rs,
+                                OnReadStringsCompleteFn OnComplete) = 0;
 
   Error writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws) {
     std::promise<MSVCPError> ResultP;
@@ -79,21 +117,77 @@ class LLVM_ABI MemoryAccess {
     return ResultF.get();
   }
 
-  Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
+  Error writePointers(ArrayRef<tpctypes::PointerWrite> Ws) {
     std::promise<MSVCPError> ResultP;
     auto ResultF = ResultP.get_future();
-    writeBuffersAsync(Ws,
-                      [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    writePointersAsync(Ws,
+                       [&](Error Err) { ResultP.set_value(std::move(Err)); });
     return ResultF.get();
   }
 
-  Error writePointers(ArrayRef<tpctypes::PointerWrite> Ws) {
+  Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
     std::promise<MSVCPError> ResultP;
     auto ResultF = ResultP.get_future();
-    writePointersAsync(Ws,
-                       [&](Error Err) { ResultP.set_value(std::move(Err)); });
+    writeBuffersAsync(Ws,
+                      [&](Error Err) { ResultP.set_value(std::move(Err)); });
     return ResultF.get();
   }
+
+  Expected<ReadUIntsResult<uint8_t>> readUInt8s(ArrayRef<ExecutorAddr> Rs) {
+    std::promise<MSVCPExpected<ReadUIntsResult<uint8_t>>> P;
+    readUInt8sAsync(Rs, [&](Expected<ReadUIntsResult<uint8_t>> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
+
+  Expected<ReadUIntsResult<uint16_t>> readUInt16s(ArrayRef<ExecutorAddr> Rs) {
+    std::promise<MSVCPExpected<ReadUIntsResult<uint16_t>>> P;
+    readUInt16sAsync(Rs, [&](Expected<ReadUIntsResult<uint16_t>> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
+
+  Expected<ReadUIntsResult<uint32_t>> readUInt32s(ArrayRef<ExecutorAddr> Rs) {
+    std::promise<MSVCPExpected<ReadUIntsResult<uint32_t>>> P;
+    readUInt32sAsync(Rs, [&](Expected<ReadUIntsResult<uint32_t>> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
+
+  Expected<ReadUIntsResult<uint64_t>> readUInt64s(ArrayRef<ExecutorAddr> Rs) {
+    std::promise<MSVCPExpected<ReadUIntsResult<uint64_t>>> P;
+    readUInt64sAsync(Rs, [&](Expected<ReadUIntsResult<uint64_t>> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
+
+  Expected<ReadPointersResult> readPointers(ArrayRef<ExecutorAddr> Rs) {
+    std::promise<MSVCPExpected<ReadPointersResult>> P;
+    readPointersAsync(Rs, [&](Expected<ReadPointersResult> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
+
+  Expected<ReadBuffersResult> readBuffers(ArrayRef<ExecutorAddrRange> Rs) {
+    std::promise<MSVCPExpected<ReadBuffersResult>> P;
+    readBuffersAsync(Rs, [&](Expected<ReadBuffersResult> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
+
+  Expected<ReadStringsResult> readStrings(ArrayRef<ExecutorAddr> Rs) {
+    std::promise<MSVCPExpected<ReadStringsResult>> P;
+    readStringsAsync(Rs, [&](Expected<ReadStringsResult> Result) {
+      P.set_value(std::move(Result));
+    });
+    return P.get_future().get();
+  }
 };
 
 } // namespace llvm::orc

llvm/include/llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h

@@ -44,8 +44,16 @@ LLVM_ABI extern const char *MemoryWriteUInt8sWrapperName;
 LLVM_ABI extern const char *MemoryWriteUInt16sWrapperName;
 LLVM_ABI extern const char *MemoryWriteUInt32sWrapperName;
 LLVM_ABI extern const char *MemoryWriteUInt64sWrapperName;
-LLVM_ABI extern const char *MemoryWriteBuffersWrapperName;
 LLVM_ABI extern const char *MemoryWritePointersWrapperName;
+LLVM_ABI extern const char *MemoryWriteBuffersWrapperName;
+
+LLVM_ABI extern const char *MemoryReadUInt8sWrapperName;
+LLVM_ABI extern const char *MemoryReadUInt16sWrapperName;
+LLVM_ABI extern const char *MemoryReadUInt32sWrapperName;
+LLVM_ABI extern const char *MemoryReadUInt64sWrapperName;
+LLVM_ABI extern const char *MemoryReadPointersWrapperName;
+LLVM_ABI extern const char *MemoryReadBuffersWrapperName;
+LLVM_ABI extern const char *MemoryReadStringsWrapperName;
 
 LLVM_ABI extern const char *RegisterEHFrameSectionAllocActionName;
 LLVM_ABI extern const char *DeregisterEHFrameSectionAllocActionName;

llvm/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h

@@ -93,11 +93,11 @@ using UInt64Write = UIntWrite<uint64_t>;
 /// For use with TargetProcessControl::MemoryAccess objects.
 struct BufferWrite {
   BufferWrite() = default;
-  BufferWrite(ExecutorAddr Addr, StringRef Buffer)
+  BufferWrite(ExecutorAddr Addr, ArrayRef<char> Buffer)
       : Addr(Addr), Buffer(Buffer) {}
 
   ExecutorAddr Addr;
-  StringRef Buffer;
+  ArrayRef<char> Buffer;
 };
 
 /// Describes a write to a pointer.