LLVM 20.0.0git
EPCGenericMemoryAccess.h
Go to the documentation of this file.
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
22
23namespace llvm {
24namespace orc {
25
27public:
28 /// Function addresses for memory access.
29 struct FuncAddrs {
36 };
37
38 /// Create an EPCGenericMemoryAccess instance from a given set of
39 /// function addrs.
41 : EPC(EPC), FAs(FAs) {}
42
44 WriteResultFn OnWriteComplete) override {
45 using namespace shared;
46 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt8Write>)>(
47 FAs.WriteUInt8s, std::move(OnWriteComplete), Ws);
48 }
49
51 WriteResultFn OnWriteComplete) override {
52 using namespace shared;
53 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt16Write>)>(
54 FAs.WriteUInt16s, std::move(OnWriteComplete), Ws);
55 }
56
58 WriteResultFn OnWriteComplete) override {
59 using namespace shared;
60 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt32Write>)>(
61 FAs.WriteUInt32s, std::move(OnWriteComplete), Ws);
62 }
63
65 WriteResultFn OnWriteComplete) override {
66 using namespace shared;
67 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessUInt64Write>)>(
68 FAs.WriteUInt64s, std::move(OnWriteComplete), Ws);
69 }
70
72 WriteResultFn OnWriteComplete) override {
73 using namespace shared;
74 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessBufferWrite>)>(
75 FAs.WriteBuffers, std::move(OnWriteComplete), Ws);
76 }
77
79 WriteResultFn OnWriteComplete) override {
80 using namespace shared;
81 EPC.callSPSWrapperAsync<void(SPSSequence<SPSMemoryAccessPointerWrite>)>(
82 FAs.WritePointers, std::move(OnWriteComplete), Ws);
83 }
84
85private:
87 FuncAddrs FAs;
88};
89
90} // end namespace orc
91} // end namespace llvm
92
93#endif // LLVM_EXECUTIONENGINE_ORC_EPCGENERICMEMORYACCESS_H
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
void writeUInt16sAsync(ArrayRef< tpctypes::UInt16Write > Ws, WriteResultFn OnWriteComplete) override
void writeUInt32sAsync(ArrayRef< tpctypes::UInt32Write > Ws, WriteResultFn OnWriteComplete) override
void writeUInt64sAsync(ArrayRef< tpctypes::UInt64Write > Ws, WriteResultFn OnWriteComplete) override
void writePointersAsync(ArrayRef< tpctypes::PointerWrite > Ws, WriteResultFn OnWriteComplete) override
EPCGenericMemoryAccess(ExecutorProcessControl &EPC, FuncAddrs FAs)
Create an EPCGenericMemoryAccess instance from a given set of function addrs.
void writeUInt8sAsync(ArrayRef< tpctypes::UInt8Write > Ws, WriteResultFn OnWriteComplete) override
void writeBuffersAsync(ArrayRef< tpctypes::BufferWrite > Ws, WriteResultFn OnWriteComplete) override
Represents an address in the executor process.
APIs for manipulating memory in the target process.
ExecutorProcessControl supports interaction with a JIT target process.
void callSPSWrapperAsync(RunPolicyT &&Runner, ExecutorAddr WrapperFnAddr, SendResultT &&SendResult, const ArgTs &...Args)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Function addresses for memory access.