LLVM: include/llvm/ExecutionEngine/Orc/CallViaEPC.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14#ifndef LLVM_EXECUTIONENGINE_ORC_CALLVIAEPC_H
15#define LLVM_EXECUTIONENGINE_ORC_CALLVIAEPC_H
16
21
22#include <type_traits>
23
25
27
29
33
37
41
45
46
49 using ArgsTuple = typename ArgInfo::ArgsTupleType;
50 static_assert(std::tuple_size_v == 1,
51 "Handler must take exactly one argument");
52 using HandlerArgT = std::tuple_element_t<0, ArgsTuple>;
54 std::remove_cv_t<std::remove_reference_t>>::value_type;
55};
56
57}
58
59
60template <typename HandlerFn, typename Serializer, typename... ArgTs>
61std::enable_if_t<std::is_invocable_v<HandlerFn, Error>>
65
66 if (auto ArgBytes = S.serialize(std::forward(Args)...))
69 [S = std::move(S), H = std::forward(H)](
71 if (const char *ErrMsg = R.getOutOfBandError())
72 H(make_error(ErrMsg, inconvertibleErrorCode()));
73 else
74 H(S.template deserialize(std::move(R)));
75 },
76 {ArgBytes->data(), ArgBytes->size()});
77 else
78 H(ArgBytes.takeError());
79}
80
81
82
83
84
85
86
87
88template <typename PromiseT, typename Serializer, typename... ArgTs>
89std::enable_if_t<!std::is_invocable_v<PromiseT, Error>,
90 decltype(std::declval().get_future().get())>
94 using RetT = decltype(F.get());
95 callViaEPC([P = std::move(P)](RetT R) mutable { P.set_value(std::move(R)); },
96 EPC, std::move(S), std::move(Fn), std::forward(Args)...);
97 return F.get();
98}
99
100
101
103public:
106
107
108
109
110
111
112
113
114 template <typename PromiseOrHandlerT, typename... ArgTs>
116 ArgTs &&...Args) {
117 return callViaEPC(std::forward(R), EPC, S, Fn,
118 std::forward(Args)...);
119 }
120
121private:
123 Serializer S;
124};
125
126
127
129public:
132
133
134
135
136
137
138
139
140 template <typename PromiseOrHandlerT, typename... ArgTs>
141 decltype(auto) operator()(PromiseOrHandlerT &&R, ArgTs &&...Args) {
142 return Caller(std::forward(R), Fn,
143 std::forward(Args)...);
144 }
145
146private:
149};
150
151}
152
153#endif
Lightweight error class with error context and mandatory checking.
Tagged union holding either a T or a Error.
EPCCall(ExecutorProcessControl &EPC, Serializer &&S, ExecutorSymbolDef Fn)
Definition CallViaEPC.h:130
decltype(auto) operator()(PromiseOrHandlerT &&R, ArgTs &&...Args)
Definition CallViaEPC.h:141
Encapsulates calls via EPC to any function that's compatible with the given serialization scheme.
Definition CallViaEPC.h:102
decltype(auto) operator()(PromiseOrHandlerT &&R, ExecutorSymbolDef Fn, ArgTs &&...Args)
Definition CallViaEPC.h:115
EPCCaller(ExecutorProcessControl &EPC, Serializer &&S)
Definition CallViaEPC.h:104
ExecutorProcessControl supports interaction with a JIT target process.
virtual void callWrapperAsync(ExecutorAddr WrapperFnAddr, IncomingWFRHandler OnComplete, ArrayRef< char > ArgBuffer)=0
Run a wrapper function in the executor.
Represents a defining location for a JIT symbol.
const ExecutorAddr & getAddress() const
std::enable_if_t< std::is_invocable_v< HandlerFn, Error > > callViaEPC(HandlerFn &&H, ExecutorProcessControl &EPC, Serializer S, ExecutorSymbolDef Fn, ArgTs &&...Args)
Call a wrapper function via EPC asynchronously.
Definition CallViaEPC.h:62
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Implement std::hash so that hash_code can be used in STL containers.
CallableArgInfo provides typedefs for the return type and argument types (as a tuple) of the given ca...
Definition CallViaEPC.h:47
typename CallViaEPCRetValueTraits< std::remove_cv_t< std::remove_reference_t< HandlerArgT > > >::value_type RetT
Definition CallViaEPC.h:53
std::tuple_element_t< 0, ArgsTuple > HandlerArgT
Definition CallViaEPC.h:52
CallableArgInfo< HandlerT > ArgInfo
Definition CallViaEPC.h:48
typename ArgInfo::ArgsTupleType ArgsTuple
Definition CallViaEPC.h:49
void value_type
Definition CallViaEPC.h:35
RetT value_type
Definition CallViaEPC.h:31
void value_type
Definition CallViaEPC.h:43
RetT value_type
Definition CallViaEPC.h:39
Definition CallViaEPC.h:28