LLVM 17.0.0git
ExecutorProcessControl.h
Go to the documentation of this file.
1//===- ExecutorProcessControl.h - Executor process control APIs -*- 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// Utilities for interacting with the executor processes.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_ORC_EXECUTORPROCESSCONTROL_H
14#define LLVM_EXECUTIONENGINE_ORC_EXECUTORPROCESSCONTROL_H
15
16#include "llvm/ADT/StringRef.h"
26
27#include <future>
28#include <mutex>
29#include <vector>
30
31namespace llvm {
32namespace orc {
33
34class ExecutionSession;
35class SymbolLookupSet;
36
37/// ExecutorProcessControl supports interaction with a JIT target process.
39 friend class ExecutionSession;
40public:
41
42 /// A handler or incoming WrapperFunctionResults -- either return values from
43 /// callWrapper* calls, or incoming JIT-dispatch requests.
44 ///
45 /// IncomingWFRHandlers are constructible from
46 /// unique_function<void(shared::WrapperFunctionResult)>s using the
47 /// runInPlace function or a RunWithDispatch object.
50 public:
51 IncomingWFRHandler() = default;
52 explicit operator bool() const { return !!H; }
53 void operator()(shared::WrapperFunctionResult WFR) { H(std::move(WFR)); }
54 private:
55 template <typename FnT> IncomingWFRHandler(FnT &&Fn)
56 : H(std::forward<FnT>(Fn)) {}
57
59 };
60
61 /// Constructs an IncomingWFRHandler from a function object that is callable
62 /// as void(shared::WrapperFunctionResult). The function object will be called
63 /// directly. This should be used with care as it may block listener threads
64 /// in remote EPCs. It is only suitable for simple tasks (e.g. setting a
65 /// future), or for performing some quick analysis before dispatching "real"
66 /// work as a Task.
67 class RunInPlace {
68 public:
69 template <typename FnT>
71 return IncomingWFRHandler(std::forward<FnT>(Fn));
72 }
73 };
74
75 /// Constructs an IncomingWFRHandler from a function object by creating a new
76 /// function object that dispatches the original using a TaskDispatcher,
77 /// wrapping the original as a GenericNamedTask.
78 ///
79 /// This is the default approach for running WFR handlers.
80 class RunAsTask {
81 public:
83
84 template <typename FnT>
86 return IncomingWFRHandler(
87 [&D = this->D, Fn = std::move(Fn)]
88 (shared::WrapperFunctionResult WFR) mutable {
89 D.dispatch(
91 [Fn = std::move(Fn), WFR = std::move(WFR)]() mutable {
92 Fn(std::move(WFR));
93 }, "WFR handler task"));
94 });
95 }
96 private:
98 };
99
100 /// APIs for manipulating memory in the target process.
102 public:
103 /// Callback function for asynchronous writes.
105
106 virtual ~MemoryAccess();
107
109 WriteResultFn OnWriteComplete) = 0;
110
112 WriteResultFn OnWriteComplete) = 0;
113
115 WriteResultFn OnWriteComplete) = 0;
116
118 WriteResultFn OnWriteComplete) = 0;
119
121 WriteResultFn OnWriteComplete) = 0;
122
124 std::promise<MSVCPError> ResultP;
125 auto ResultF = ResultP.get_future();
127 [&](Error Err) { ResultP.set_value(std::move(Err)); });
128 return ResultF.get();
129 }
130
132 std::promise<MSVCPError> ResultP;
133 auto ResultF = ResultP.get_future();
135 [&](Error Err) { ResultP.set_value(std::move(Err)); });
136 return ResultF.get();
137 }
138
140 std::promise<MSVCPError> ResultP;
141 auto ResultF = ResultP.get_future();
143 [&](Error Err) { ResultP.set_value(std::move(Err)); });
144 return ResultF.get();
145 }
146
148 std::promise<MSVCPError> ResultP;
149 auto ResultF = ResultP.get_future();
151 [&](Error Err) { ResultP.set_value(std::move(Err)); });
152 return ResultF.get();
153 }
154
156 std::promise<MSVCPError> ResultP;
157 auto ResultF = ResultP.get_future();
159 [&](Error Err) { ResultP.set_value(std::move(Err)); });
160 return ResultF.get();
161 }
162 };
163
164 /// A pair of a dylib and a set of symbols to be looked up.
170 };
171
172 /// Contains the address of the dispatch function and context that the ORC
173 /// runtime can use to call functions in the JIT.
177 };
178
179 ExecutorProcessControl(std::shared_ptr<SymbolStringPool> SSP,
180 std::unique_ptr<TaskDispatcher> D)
181 : SSP(std::move(SSP)), D(std::move(D)) {}
182
184
185 /// Return the ExecutionSession associated with this instance.
186 /// Not callable until the ExecutionSession has been associated.
188 assert(ES && "No ExecutionSession associated yet");
189 return *ES;
190 }
191
192 /// Intern a symbol name in the SymbolStringPool.
193 SymbolStringPtr intern(StringRef SymName) { return SSP->intern(SymName); }
194
195 /// Return a shared pointer to the SymbolStringPool for this instance.
196 std::shared_ptr<SymbolStringPool> getSymbolStringPool() const { return SSP; }
197
199
200 /// Return the Triple for the target process.
201 const Triple &getTargetTriple() const { return TargetTriple; }
202
203 /// Get the page size for the target process.
204 unsigned getPageSize() const { return PageSize; }
205
206 /// Get the JIT dispatch function and context address for the executor.
207 const JITDispatchInfo &getJITDispatchInfo() const { return JDI; }
208
209 /// Return a MemoryAccess object for the target process.
211 assert(MemAccess && "No MemAccess object set.");
212 return *MemAccess;
213 }
214
215 /// Return a JITLinkMemoryManager for the target process.
217 assert(MemMgr && "No MemMgr object set");
218 return *MemMgr;
219 }
220
221 /// Returns the bootstrap map.
223 return BootstrapMap;
224 }
225
226 /// Look up and SPS-deserialize a bootstrap map value.
227 ///
228 ///
229 template <typename T, typename SPSTagT>
230 Error getBootstrapMapValue(StringRef Key, std::optional<T> &Val) const {
231 Val = std::nullopt;
232
233 auto I = BootstrapMap.find(Key);
234 if (I == BootstrapMap.end())
235 return Error::success();
236
237 T Tmp;
238 shared::SPSInputBuffer IB(I->second.data(), I->second.size());
240 return make_error<StringError>("Could not deserialize value for key " +
241 Key,
243
244 Val = std::move(Tmp);
245 return Error::success();
246 }
247
248 /// Returns the bootstrap symbol map.
250 return BootstrapSymbols;
251 }
252
253 /// For each (ExecutorAddr&, StringRef) pair, looks up the string in the
254 /// bootstrap symbols map and writes its address to the ExecutorAddr if
255 /// found. If any symbol is not found then the function returns an error.
257 ArrayRef<std::pair<ExecutorAddr &, StringRef>> Pairs) const {
258 for (const auto &KV : Pairs) {
259 auto I = BootstrapSymbols.find(KV.second);
260 if (I == BootstrapSymbols.end())
261 return make_error<StringError>("Symbol \"" + KV.second +
262 "\" not found "
263 "in bootstrap symbols map",
265
266 KV.first = I->second;
267 }
268 return Error::success();
269 }
270
271 /// Load the dynamic library at the given path and return a handle to it.
272 /// If LibraryPath is null this function will return the global handle for
273 /// the target process.
274 virtual Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) = 0;
275
276 /// Search for symbols in the target process.
277 ///
278 /// The result of the lookup is a 2-dimentional array of target addresses
279 /// that correspond to the lookup order. If a required symbol is not
280 /// found then this method will return an error. If a weakly referenced
281 /// symbol is not found then it be assigned a '0' value.
284
285 /// Run function with a main-like signature.
287 ArrayRef<std::string> Args) = 0;
288
289 // TODO: move this to ORC runtime.
290 /// Run function with a int (*)(void) signature.
292
293 // TODO: move this to ORC runtime.
294 /// Run function with a int (*)(int) signature.
296 int Arg) = 0;
297
298 /// Run a wrapper function in the executor. The given WFRHandler will be
299 /// called on the result when it is returned.
300 ///
301 /// The wrapper function should be callable as:
302 ///
303 /// \code{.cpp}
304 /// CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
305 /// \endcode{.cpp}
306 virtual void callWrapperAsync(ExecutorAddr WrapperFnAddr,
307 IncomingWFRHandler OnComplete,
308 ArrayRef<char> ArgBuffer) = 0;
309
310 /// Run a wrapper function in the executor using the given Runner to dispatch
311 /// OnComplete when the result is ready.
312 template <typename RunPolicyT, typename FnT>
313 void callWrapperAsync(RunPolicyT &&Runner, ExecutorAddr WrapperFnAddr,
314 FnT &&OnComplete, ArrayRef<char> ArgBuffer) {
316 WrapperFnAddr, Runner(std::forward<FnT>(OnComplete)), ArgBuffer);
317 }
318
319 /// Run a wrapper function in the executor. OnComplete will be dispatched
320 /// as a GenericNamedTask using this instance's TaskDispatch object.
321 template <typename FnT>
322 void callWrapperAsync(ExecutorAddr WrapperFnAddr, FnT &&OnComplete,
323 ArrayRef<char> ArgBuffer) {
324 callWrapperAsync(RunAsTask(*D), WrapperFnAddr,
325 std::forward<FnT>(OnComplete), ArgBuffer);
326 }
327
328 /// Run a wrapper function in the executor. The wrapper function should be
329 /// callable as:
330 ///
331 /// \code{.cpp}
332 /// CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
333 /// \endcode{.cpp}
335 ArrayRef<char> ArgBuffer) {
336 std::promise<shared::WrapperFunctionResult> RP;
337 auto RF = RP.get_future();
339 RunInPlace(), WrapperFnAddr,
341 RP.set_value(std::move(R));
342 }, ArgBuffer);
343 return RF.get();
344 }
345
346 /// Run a wrapper function using SPS to serialize the arguments and
347 /// deserialize the results.
348 template <typename SPSSignature, typename RunPolicyT, typename SendResultT,
349 typename... ArgTs>
350 void callSPSWrapperAsync(RunPolicyT &&Runner, ExecutorAddr WrapperFnAddr,
351 SendResultT &&SendResult, const ArgTs &...Args) {
353 [this, WrapperFnAddr, Runner = std::move(Runner)]
354 (auto &&SendResult, const char *ArgData, size_t ArgSize) mutable {
355 this->callWrapperAsync(std::move(Runner), WrapperFnAddr,
356 std::move(SendResult),
357 ArrayRef<char>(ArgData, ArgSize));
358 },
359 std::forward<SendResultT>(SendResult), Args...);
360 }
361
362 /// Run a wrapper function using SPS to serialize the arguments and
363 /// deserialize the results.
364 template <typename SPSSignature, typename SendResultT, typename... ArgTs>
365 void callSPSWrapperAsync(ExecutorAddr WrapperFnAddr, SendResultT &&SendResult,
366 const ArgTs &...Args) {
367 callSPSWrapperAsync<SPSSignature>(RunAsTask(*D), WrapperFnAddr,
368 std::forward<SendResultT>(SendResult),
369 Args...);
370 }
371
372 /// Run a wrapper function using SPS to serialize the arguments and
373 /// deserialize the results.
374 ///
375 /// If SPSSignature is a non-void function signature then the second argument
376 /// (the first in the Args list) should be a reference to a return value.
377 template <typename SPSSignature, typename... WrapperCallArgTs>
379 WrapperCallArgTs &&...WrapperCallArgs) {
381 [this, WrapperFnAddr](const char *ArgData, size_t ArgSize) {
382 return callWrapper(WrapperFnAddr, ArrayRef<char>(ArgData, ArgSize));
383 },
384 std::forward<WrapperCallArgTs>(WrapperCallArgs)...);
385 }
386
387 /// Disconnect from the target process.
388 ///
389 /// This should be called after the JIT session is shut down.
390 virtual Error disconnect() = 0;
391
392protected:
393
394 std::shared_ptr<SymbolStringPool> SSP;
395 std::unique_ptr<TaskDispatcher> D;
398 unsigned PageSize = 0;
404};
405
406/// A ExecutorProcessControl instance that asserts if any of its methods are
407/// used. Suitable for use is unit tests, and by ORC clients who haven't moved
408/// to ExecutorProcessControl-based APIs yet.
410public:
412 std::shared_ptr<SymbolStringPool> SSP = nullptr,
413 std::unique_ptr<TaskDispatcher> D = nullptr,
414 const std::string &TT = "", unsigned PageSize = 0)
416 : std::make_shared<SymbolStringPool>(),
417 D ? std::move(D)
418 : std::make_unique<InPlaceTaskDispatcher>()) {
419 this->TargetTriple = Triple(TT);
420 this->PageSize = PageSize;
421 }
422
423 Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override {
424 llvm_unreachable("Unsupported");
425 }
426
429 llvm_unreachable("Unsupported");
430 }
431
433 ArrayRef<std::string> Args) override {
434 llvm_unreachable("Unsupported");
435 }
436
438 llvm_unreachable("Unsupported");
439 }
440
442 llvm_unreachable("Unsupported");
443 }
444
445 void callWrapperAsync(ExecutorAddr WrapperFnAddr,
446 IncomingWFRHandler OnComplete,
447 ArrayRef<char> ArgBuffer) override {
448 llvm_unreachable("Unsupported");
449 }
450
451 Error disconnect() override { return Error::success(); }
452};
453
454/// A ExecutorProcessControl implementation targeting the current process.
456 : public ExecutorProcessControl,
458public:
460 std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D,
461 Triple TargetTriple, unsigned PageSize,
462 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
463
464 /// Create a SelfExecutorProcessControl with the given symbol string pool and
465 /// memory manager.
466 /// If no symbol string pool is given then one will be created.
467 /// If no memory manager is given a jitlink::InProcessMemoryManager will
468 /// be created and used by default.
470 Create(std::shared_ptr<SymbolStringPool> SSP = nullptr,
471 std::unique_ptr<TaskDispatcher> D = nullptr,
472 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
473
474 Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
475
477 lookupSymbols(ArrayRef<LookupRequest> Request) override;
478
480 ArrayRef<std::string> Args) override;
481
483
484 Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override;
485
486 void callWrapperAsync(ExecutorAddr WrapperFnAddr,
487 IncomingWFRHandler OnComplete,
488 ArrayRef<char> ArgBuffer) override;
489
490 Error disconnect() override;
491
492private:
493 void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,
494 WriteResultFn OnWriteComplete) override;
495
496 void writeUInt16sAsync(ArrayRef<tpctypes::UInt16Write> Ws,
497 WriteResultFn OnWriteComplete) override;
498
499 void writeUInt32sAsync(ArrayRef<tpctypes::UInt32Write> Ws,
500 WriteResultFn OnWriteComplete) override;
501
502 void writeUInt64sAsync(ArrayRef<tpctypes::UInt64Write> Ws,
503 WriteResultFn OnWriteComplete) override;
504
505 void writeBuffersAsync(ArrayRef<tpctypes::BufferWrite> Ws,
506 WriteResultFn OnWriteComplete) override;
507
509 jitDispatchViaWrapperFunctionManager(void *Ctx, const void *FnTag,
510 const char *Data, size_t Size);
511
512 std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
513 char GlobalManglingPrefix = 0;
514};
515
516} // end namespace orc
517} // end namespace llvm
518
519#endif // LLVM_EXECUTIONENGINE_ORC_EXECUTORPROCESSCONTROL_H
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
uint64_t Size
#define I(x, y, z)
Definition: MD5.cpp:58
#define H(x, y, z)
Definition: MD5.cpp:57
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:111
iterator end()
Definition: StringMap.h:204
iterator find(StringRef Key)
Definition: StringMap.h:217
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
An ExecutionSession represents a running JIT program.
Definition: Core.h:1378
Represents an address in the executor process.
A handler or incoming WrapperFunctionResults – either return values from callWrapper* calls,...
void operator()(shared::WrapperFunctionResult WFR)
APIs for manipulating memory in the target process.
Error writeUInt64s(ArrayRef< tpctypes::UInt64Write > Ws)
Error writeBuffers(ArrayRef< tpctypes::BufferWrite > Ws)
Error writeUInt32s(ArrayRef< tpctypes::UInt32Write > Ws)
Error writeUInt8s(ArrayRef< tpctypes::UInt8Write > Ws)
virtual void writeUInt8sAsync(ArrayRef< tpctypes::UInt8Write > Ws, WriteResultFn OnWriteComplete)=0
Error writeUInt16s(ArrayRef< tpctypes::UInt16Write > Ws)
virtual void writeUInt32sAsync(ArrayRef< tpctypes::UInt32Write > Ws, WriteResultFn OnWriteComplete)=0
virtual void writeBuffersAsync(ArrayRef< tpctypes::BufferWrite > Ws, WriteResultFn OnWriteComplete)=0
virtual void writeUInt16sAsync(ArrayRef< tpctypes::UInt16Write > Ws, WriteResultFn OnWriteComplete)=0
virtual void writeUInt64sAsync(ArrayRef< tpctypes::UInt64Write > Ws, WriteResultFn OnWriteComplete)=0
Constructs an IncomingWFRHandler from a function object by creating a new function object that dispat...
Constructs an IncomingWFRHandler from a function object that is callable as void(shared::WrapperFunct...
ExecutorProcessControl supports interaction with a JIT target process.
jitlink::JITLinkMemoryManager & getMemMgr() const
Return a JITLinkMemoryManager for the target process.
shared::WrapperFunctionResult callWrapper(ExecutorAddr WrapperFnAddr, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor.
virtual Expected< std::vector< tpctypes::LookupResult > > lookupSymbols(ArrayRef< LookupRequest > Request)=0
Search for symbols in the target process.
void callWrapperAsync(ExecutorAddr WrapperFnAddr, FnT &&OnComplete, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor.
virtual Expected< int32_t > runAsIntFunction(ExecutorAddr IntFnAddr, int Arg)=0
Run function with a int (*)(int) signature.
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.
virtual Expected< int32_t > runAsMain(ExecutorAddr MainFnAddr, ArrayRef< std::string > Args)=0
Run function with a main-like signature.
Error getBootstrapMapValue(StringRef Key, std::optional< T > &Val) const
Look up and SPS-deserialize a bootstrap map value.
std::unique_ptr< TaskDispatcher > D
void callSPSWrapperAsync(ExecutorAddr WrapperFnAddr, SendResultT &&SendResult, const ArgTs &...Args)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
virtual void callWrapperAsync(ExecutorAddr WrapperFnAddr, IncomingWFRHandler OnComplete, ArrayRef< char > ArgBuffer)=0
Run a wrapper function in the executor.
virtual Expected< tpctypes::DylibHandle > loadDylib(const char *DylibPath)=0
Load the dynamic library at the given path and return a handle to it.
const StringMap< std::vector< char > > & getBootstrapMap() const
Returns the bootstrap map.
std::shared_ptr< SymbolStringPool > SSP
const Triple & getTargetTriple() const
Return the Triple for the target process.
StringMap< ExecutorAddr > BootstrapSymbols
SymbolStringPtr intern(StringRef SymName)
Intern a symbol name in the SymbolStringPool.
virtual Error disconnect()=0
Disconnect from the target process.
StringMap< std::vector< char > > BootstrapMap
std::shared_ptr< SymbolStringPool > getSymbolStringPool() const
Return a shared pointer to the SymbolStringPool for this instance.
const StringMap< ExecutorAddr > & getBootstrapSymbolsMap() const
Returns the bootstrap symbol map.
virtual Expected< int32_t > runAsVoidFunction(ExecutorAddr VoidFnAddr)=0
Run function with a int (*)(void) signature.
jitlink::JITLinkMemoryManager * MemMgr
unsigned getPageSize() const
Get the page size for the target process.
const JITDispatchInfo & getJITDispatchInfo() const
Get the JIT dispatch function and context address for the executor.
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
void callWrapperAsync(RunPolicyT &&Runner, ExecutorAddr WrapperFnAddr, FnT &&OnComplete, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor using the given Runner to dispatch OnComplete when the result ...
Error getBootstrapSymbols(ArrayRef< std::pair< ExecutorAddr &, StringRef > > Pairs) const
For each (ExecutorAddr&, StringRef) pair, looks up the string in the bootstrap symbols map and writes...
ExecutionSession & getExecutionSession()
Return the ExecutionSession associated with this instance.
ExecutorProcessControl(std::shared_ptr< SymbolStringPool > SSP, std::unique_ptr< TaskDispatcher > D)
MemoryAccess & getMemoryAccess() const
Return a MemoryAccess object for the target process.
Runs all tasks on the current thread.
Definition: TaskDispatch.h:107
A ExecutorProcessControl implementation targeting the current process.
Expected< tpctypes::DylibHandle > loadDylib(const char *DylibPath) override
Load the dynamic library at the given path and return a handle to it.
Error disconnect() override
Disconnect from the target process.
Expected< int32_t > runAsVoidFunction(ExecutorAddr VoidFnAddr) override
Run function with a int (*)(void) signature.
Expected< int32_t > runAsMain(ExecutorAddr MainFnAddr, ArrayRef< std::string > Args) override
Run function with a main-like signature.
void callWrapperAsync(ExecutorAddr WrapperFnAddr, IncomingWFRHandler OnComplete, ArrayRef< char > ArgBuffer) override
Run a wrapper function in the executor.
Expected< std::vector< tpctypes::LookupResult > > lookupSymbols(ArrayRef< LookupRequest > Request) override
Search for symbols in the target process.
static Expected< std::unique_ptr< SelfExecutorProcessControl > > Create(std::shared_ptr< SymbolStringPool > SSP=nullptr, std::unique_ptr< TaskDispatcher > D=nullptr, std::unique_ptr< jitlink::JITLinkMemoryManager > MemMgr=nullptr)
Create a SelfExecutorProcessControl with the given symbol string pool and memory manager.
Expected< int32_t > runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override
Run function with a int (*)(int) signature.
A set of symbols to look up, each associated with a SymbolLookupFlags value.
Definition: Core.h:182
String pool for symbol names used by the JIT.
Pointer to a pooled string representing a symbol name.
Abstract base for classes that dispatch ORC Tasks.
Definition: TaskDispatch.h:95
virtual void dispatch(std::unique_ptr< Task > T)=0
Run the given task.
A ExecutorProcessControl instance that asserts if any of its methods are used.
Expected< tpctypes::DylibHandle > loadDylib(const char *DylibPath) override
Load the dynamic library at the given path and return a handle to it.
Expected< int32_t > runAsMain(ExecutorAddr MainFnAddr, ArrayRef< std::string > Args) override
Run function with a main-like signature.
Expected< std::vector< tpctypes::LookupResult > > lookupSymbols(ArrayRef< LookupRequest > Request) override
Search for symbols in the target process.
UnsupportedExecutorProcessControl(std::shared_ptr< SymbolStringPool > SSP=nullptr, std::unique_ptr< TaskDispatcher > D=nullptr, const std::string &TT="", unsigned PageSize=0)
void callWrapperAsync(ExecutorAddr WrapperFnAddr, IncomingWFRHandler OnComplete, ArrayRef< char > ArgBuffer) override
Run a wrapper function in the executor.
Error disconnect() override
Disconnect from the target process.
Expected< int32_t > runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override
Run function with a int (*)(int) signature.
Expected< int32_t > runAsVoidFunction(ExecutorAddr VoidFnAddr) override
Run function with a int (*)(void) signature.
A utility class for serializing to a blob from a variadic list.
Input char buffer with underflow check.
C++ wrapper function result: Same as CWrapperFunctionResult but auto-releases memory.
unique_function is a type-erasing functor similar to std::function.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::unique_ptr< GenericNamedTask > makeGenericNamedTask(FnT &&Fn, std::string Desc)
Create a generic named task from a std::string description.
Definition: TaskDispatch.h:78
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:79
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1946
Definition: BitVector.h:858
Contains the address of the dispatch function and context that the ORC runtime can use to call functi...
A pair of a dylib and a set of symbols to be looked up.
LookupRequest(tpctypes::DylibHandle Handle, const SymbolLookupSet &Symbols)