1 //===- EPCGenericMemoryAccess.h - Generic EPC MemoryAccess impl -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Implements ExecutorProcessControl::MemoryAccess by making calls to
10 // ExecutorProcessControl::callWrapperAsync.
11 //
12 // This simplifies the implementaton of new ExecutorProcessControl instances,
13 // as this implementation will always work (at the cost of some performance
14 // overhead for the calls).
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
19 #define LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
20 
21 #include "llvm/ExecutionEngine/Orc/Core.h"
22 
23 namespace llvm {
24 namespace orc {
25 
26 class EPCGenericMemoryAccess : public ExecutorProcessControl::MemoryAccess {
27 public:
28   /// Function addresses for memory access.
29   struct FuncAddrs {
30     ExecutorAddr WriteUInt8s;
31     ExecutorAddr WriteUInt16s;
32     ExecutorAddr WriteUInt32s;
33     ExecutorAddr WriteUInt64s;
34     ExecutorAddr WriteBuffers;
35   };
36 
37   /// Create an EPCGenericMemoryAccess instance from a given set of
38   /// function addrs.
39   EPCGenericMemoryAccess(ExecutorProcessControl &EPC, FuncAddrs FAs)
40       : EPC(EPC), FAs(FAs) {}
41 
42   void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
43                         WriteResultFn OnWriteComplete) override {
44     using namespace shared;
45     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt8Write>)>(
46         FAs.WriteUInt8s, std::move(OnWriteComplete), Ws);
47   }
48 
49   void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
50                          WriteResultFn OnWriteComplete) override {
51     using namespace shared;
52     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt16Write>)>(
53         FAs.WriteUInt16s, std::move(OnWriteComplete), Ws);
54   }
55 
56   void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
57                          WriteResultFn OnWriteComplete) override {
58     using namespace shared;
59     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt32Write>)>(
60         FAs.WriteUInt32s, std::move(OnWriteComplete), Ws);
61   }
62 
63   void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
64                          WriteResultFn OnWriteComplete) override {
65     using namespace shared;
66     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt64Write>)>(
67         FAs.WriteUInt64s, std::move(OnWriteComplete), Ws);
68   }
69 
70   void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
71                          WriteResultFn OnWriteComplete) override {
72     using namespace shared;
73     EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessBufferWrite>)>(
74         FAs.WriteBuffers, std::move(OnWriteComplete), Ws);
75   }
76 
77 private:
78   ExecutorProcessControl &EPC;
79   FuncAddrs FAs;
80 };
81 
82 } // end namespace orc
83 } // end namespace llvm
84 
85 #endif // LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
86