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 ExecutorAddr WritePointers; 36 }; 37 38 /// Create an EPCGenericMemoryAccess instance from a given set of 39 /// function addrs. EPCGenericMemoryAccess(ExecutorProcessControl & EPC,FuncAddrs FAs)40 EPCGenericMemoryAccess(ExecutorProcessControl &EPC, FuncAddrs FAs) 41 : EPC(EPC), FAs(FAs) {} 42 writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,WriteResultFn OnWriteComplete)43 void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws, 44 WriteResultFn OnWriteComplete) override { 45 using namespace shared; 46 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt8Write>)>( 47 FAs.WriteUInt8s, std::move(OnWriteComplete), Ws); 48 } 49 writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,WriteResultFn OnWriteComplete)50 void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws, 51 WriteResultFn OnWriteComplete) override { 52 using namespace shared; 53 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt16Write>)>( 54 FAs.WriteUInt16s, std::move(OnWriteComplete), Ws); 55 } 56 writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,WriteResultFn OnWriteComplete)57 void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws, 58 WriteResultFn OnWriteComplete) override { 59 using namespace shared; 60 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt32Write>)>( 61 FAs.WriteUInt32s, std::move(OnWriteComplete), Ws); 62 } 63 writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,WriteResultFn OnWriteComplete)64 void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws, 65 WriteResultFn OnWriteComplete) override { 66 using namespace shared; 67 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt64Write>)>( 68 FAs.WriteUInt64s, std::move(OnWriteComplete), Ws); 69 } 70 writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,WriteResultFn OnWriteComplete)71 void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws, 72 WriteResultFn OnWriteComplete) override { 73 using namespace shared; 74 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessBufferWrite>)>( 75 FAs.WriteBuffers, std::move(OnWriteComplete), Ws); 76 } 77 writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws,WriteResultFn OnWriteComplete)78 void writePointersAsync(ArrayRef<tpctypes::PointerWrite> Ws, 79 WriteResultFn OnWriteComplete) override { 80 using namespace shared; 81 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessPointerWrite>)>( 82 FAs.WritePointers, std::move(OnWriteComplete), Ws); 83 } 84 85 private: 86 ExecutorProcessControl &EPC; 87 FuncAddrs FAs; 88 }; 89 90 } // end namespace orc 91 } // end namespace llvm 92 93 #endif // LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H 94