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