LLVM 19.0.0git
ExecutorProcessControl.cpp
Go to the documentation of this file.
1//===---- ExecutorProcessControl.cpp -- Executor process control APIs -----===//
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
10
18
19#define DEBUG_TYPE "orc"
20
21namespace llvm {
22namespace orc {
23
25
27
29 std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D,
30 Triple TargetTriple, unsigned PageSize,
31 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr)
33 InProcessMemoryAccess(TargetTriple.isArch64Bit()) {
34
35 OwnedMemMgr = std::move(MemMgr);
36 if (!OwnedMemMgr)
37 OwnedMemMgr = std::make_unique<jitlink::InProcessMemoryManager>(
39
40 this->TargetTriple = std::move(TargetTriple);
41 this->PageSize = PageSize;
42 this->MemMgr = OwnedMemMgr.get();
43 this->MemAccess = this;
44 this->JDI = {ExecutorAddr::fromPtr(jitDispatchViaWrapperFunctionManager),
46 if (this->TargetTriple.isOSBinFormatMachO())
47 GlobalManglingPrefix = '_';
48
53}
54
57 std::shared_ptr<SymbolStringPool> SSP,
58 std::unique_ptr<TaskDispatcher> D,
59 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) {
60
61 if (!SSP)
62 SSP = std::make_shared<SymbolStringPool>();
63
64 if (!D)
65 D = std::make_unique<InPlaceTaskDispatcher>();
66
68 if (!PageSize)
69 return PageSize.takeError();
70
72
73 return std::make_unique<SelfExecutorProcessControl>(
74 std::move(SSP), std::move(D), std::move(TT), *PageSize,
75 std::move(MemMgr));
76}
77
80 std::string ErrMsg;
81 auto Dylib = sys::DynamicLibrary::getPermanentLibrary(DylibPath, &ErrMsg);
82 if (!Dylib.isValid())
83 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
84 return ExecutorAddr::fromPtr(Dylib.getOSSpecificHandle());
85}
86
90 std::vector<tpctypes::LookupResult> R;
91
92 for (auto &Elem : Request) {
93 sys::DynamicLibrary Dylib(Elem.Handle.toPtr<void *>());
94 R.push_back(std::vector<ExecutorSymbolDef>());
95 for (auto &KV : Elem.Symbols) {
96 auto &Sym = KV.first;
97 std::string Tmp((*Sym).data() + !!GlobalManglingPrefix,
98 (*Sym).size() - !!GlobalManglingPrefix);
99 void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str());
100 if (!Addr && KV.second == SymbolLookupFlags::RequiredSymbol) {
101 // FIXME: Collect all failing symbols before erroring out.
102 SymbolNameVector MissingSymbols;
103 MissingSymbols.push_back(Sym);
104 return Complete(
105 make_error<SymbolsNotFound>(SSP, std::move(MissingSymbols)));
106 }
107 // FIXME: determine accurate JITSymbolFlags.
108 R.back().push_back(
110 }
111 }
112
113 Complete(std::move(R));
114}
115
119 using MainTy = int (*)(int, char *[]);
120 return orc::runAsMain(MainFnAddr.toPtr<MainTy>(), Args);
121}
122
125 using VoidTy = int (*)();
126 return orc::runAsVoidFunction(VoidFnAddr.toPtr<VoidTy>());
127}
128
131 using IntTy = int (*)(int);
132 return orc::runAsIntFunction(IntFnAddr.toPtr<IntTy>(), Arg);
133}
134
136 IncomingWFRHandler SendResult,
137 ArrayRef<char> ArgBuffer) {
138 using WrapperFnTy =
139 shared::CWrapperFunctionResult (*)(const char *Data, size_t Size);
140 auto *WrapperFn = WrapperFnAddr.toPtr<WrapperFnTy>();
141 SendResult(WrapperFn(ArgBuffer.data(), ArgBuffer.size()));
142}
143
145 D->shutdown();
146 return Error::success();
147}
148
150 WriteResultFn OnWriteComplete) {
151 for (auto &W : Ws)
152 *W.Addr.toPtr<uint8_t *>() = W.Value;
153 OnWriteComplete(Error::success());
154}
155
158 for (auto &W : Ws)
159 *W.Addr.toPtr<uint16_t *>() = W.Value;
160 OnWriteComplete(Error::success());
161}
162
165 for (auto &W : Ws)
166 *W.Addr.toPtr<uint32_t *>() = W.Value;
167 OnWriteComplete(Error::success());
168}
169
172 for (auto &W : Ws)
173 *W.Addr.toPtr<uint64_t *>() = W.Value;
174 OnWriteComplete(Error::success());
175}
176
179 for (auto &W : Ws)
180 memcpy(W.Addr.toPtr<char *>(), W.Buffer.data(), W.Buffer.size());
181 OnWriteComplete(Error::success());
182}
183
186 if (IsArch64Bit) {
187 for (auto &W : Ws)
188 *W.Addr.toPtr<uint64_t *>() = W.Value.getValue();
189 } else {
190 for (auto &W : Ws)
191 *W.Addr.toPtr<uint32_t *>() = static_cast<uint32_t>(W.Value.getValue());
192 }
193
194 OnWriteComplete(Error::success());
195}
196
198SelfExecutorProcessControl::jitDispatchViaWrapperFunctionManager(
199 void *Ctx, const void *FnTag, const char *Data, size_t Size) {
200
201 LLVM_DEBUG({
202 dbgs() << "jit-dispatch call with tag " << FnTag << " and " << Size
203 << " byte payload.\n";
204 });
205
206 std::promise<shared::WrapperFunctionResult> ResultP;
207 auto ResultF = ResultP.get_future();
208 static_cast<SelfExecutorProcessControl *>(Ctx)
211 [ResultP = std::move(ResultP)](
212 shared::WrapperFunctionResult Result) mutable {
213 ResultP.set_value(std::move(Result));
214 },
215 ExecutorAddr::fromPtr(FnTag), {Data, Size});
216
217 return ResultF.get().release();
218}
219
220} // end namespace orc
221} // end namespace llvm
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define LLVM_DEBUG(X)
Definition: Debug.h:101
uint64_t Addr
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)
Provides a library for accessing information about this process and other processes on the operating ...
llvm::orc::shared::CWrapperFunctionResult llvm_orc_deregisterEHFrameSectionWrapper(const char *Data, uint64_t Size)
llvm::orc::shared::CWrapperFunctionResult llvm_orc_registerEHFrameSectionWrapper(const char *Data, uint64_t Size)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
const T * data() const
Definition: ArrayRef.h:162
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:732
void runJITDispatchHandler(SendResultFunction SendResult, ExecutorAddr HandlerFnTagAddr, ArrayRef< char > ArgBuffer)
Run a registered jit-side wrapper function.
Definition: Core.cpp:1945
Represents an address in the executor process.
static ExecutorAddr fromPtr(T *Ptr, UnwrapFn &&Unwrap=UnwrapFn())
Create an ExecutorAddr from the given pointer.
std::enable_if_t< std::is_pointer< T >::value, T > toPtr(WrapFn &&Wrap=WrapFn()) const
Cast this ExecutorAddr to a pointer of the given type.
A handler or incoming WrapperFunctionResults – either return values from callWrapper* calls,...
ExecutorProcessControl supports interaction with a JIT target process.
std::unique_ptr< TaskDispatcher > D
std::shared_ptr< SymbolStringPool > SSP
StringMap< ExecutorAddr > BootstrapSymbols
jitlink::JITLinkMemoryManager * MemMgr
ExecutionSession & getExecutionSession()
Return the ExecutionSession associated with this instance.
void writePointersAsync(ArrayRef< tpctypes::PointerWrite > Ws, WriteResultFn OnWriteComplete) override
void writeUInt32sAsync(ArrayRef< tpctypes::UInt32Write > Ws, WriteResultFn OnWriteComplete) override
void writeUInt8sAsync(ArrayRef< tpctypes::UInt8Write > Ws, WriteResultFn OnWriteComplete) override
void writeUInt16sAsync(ArrayRef< tpctypes::UInt16Write > Ws, WriteResultFn OnWriteComplete) override
void writeBuffersAsync(ArrayRef< tpctypes::BufferWrite > Ws, WriteResultFn OnWriteComplete) override
void writeUInt64sAsync(ArrayRef< tpctypes::UInt64Write > Ws, WriteResultFn OnWriteComplete) override
SelfExecutorProcessControl(std::shared_ptr< SymbolStringPool > SSP, std::unique_ptr< TaskDispatcher > D, Triple TargetTriple, unsigned PageSize, std::unique_ptr< jitlink::JITLinkMemoryManager > MemMgr)
Expected< tpctypes::DylibHandle > loadDylib(const char *DylibPath) override
Load the dynamic library at the given path and return a handle to it.
void lookupSymbolsAsync(ArrayRef< LookupRequest > Request, SymbolLookupCompleteFn F) override
Search for symbols in the target process.
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.
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.
This class provides a portable interface to dynamic libraries which also might be known as shared lib...
static DynamicLibrary getPermanentLibrary(const char *filename, std::string *errMsg=nullptr)
This function permanently loads the dynamic library at the given path using the library load operatio...
void * getAddressOfSymbol(const char *symbolName)
Searches through the library for the symbol symbolName.
static Expected< unsigned > getPageSize()
Get the process's page size.
static unsigned getPageSizeEstimate()
Get the process's estimated page size.
Definition: Process.h:61
unique_function is a type-erasing functor similar to std::function.
const char * DeregisterEHFrameSectionWrapperName
Definition: OrcRTBridge.cpp:55
const char * RegisterEHFrameSectionWrapperName
Definition: OrcRTBridge.cpp:53
int runAsVoidFunction(int(*Func)(void))
int runAsIntFunction(int(*Func)(int), int Arg)
std::vector< SymbolStringPtr > SymbolNameVector
A vector of symbol names.
Definition: Core.h:117
int runAsMain(int(*Main)(int, char *[]), ArrayRef< std::string > Args, std::optional< StringRef > ProgramName=std::nullopt)
Run a main function, returning the result.
std::string getProcessTriple()
getProcessTriple() - Return an appropriate target triple for generating code to be loaded into the cu...
Definition: Host.cpp:2040
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:98
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
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:1849
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858