1//===------ SelfExecutorProcessControl.cpp -- EPC for in-process JITs -----===//
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#include "llvm/ExecutionEngine/Orc/SelfExecutorProcessControl.h"
10#include "llvm/ExecutionEngine/Orc/Shared/Mangler.h"
11
12#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
13#include "llvm/ExecutionEngine/Orc/Core.h"
14#include "llvm/ExecutionEngine/Orc/DylibManager.h"
15#include "llvm/ExecutionEngine/Orc/InProcessMemoryAccess.h"
16#include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
17#include "llvm/ExecutionEngine/Orc/TargetProcess/DefaultHostBootstrapValues.h"
18#include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRTBootstrap.h"
19#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
20#include "llvm/Support/DynamicLibrary.h"
21#include "llvm/Support/Process.h"
22#include "llvm/TargetParser/Host.h"
23
24#define DEBUG_TYPE "orc"
25
26namespace llvm::orc {
27
28class SelfExecutorProcessControl::InProcessDylibManager : public DylibManager {
29public:
30 InProcessDylibManager(char GlobalManglingPrefix);
31 Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
32 void
33 lookupSymbolsAsync(tpctypes::DylibHandle H, const SymbolLookupSet &Symbols,
34 DylibManager::SymbolLookupCompleteFn Complete) override;
35
36private:
37 char GlobalManglingPrefix;
38};
39
40SelfExecutorProcessControl::SelfExecutorProcessControl(
41 std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D,
42 Triple TargetTriple, unsigned PageSize)
43 : ExecutorProcessControl(std::move(SSP), std::move(D)) {
44
45 this->TargetTriple = std::move(TargetTriple);
46 this->PageSize = PageSize;
47
48 addDefaultBootstrapValuesForHostProcess(BootstrapMap, BootstrapSymbols);
49 rt_bootstrap::addRunAsFunctionWrappersTo(M&: BootstrapSymbols);
50
51 Mangler Mangle(getTargetTriple());
52 BootstrapSymbols[Mangle.mangledCopy(Name: rt::DispatchName)] =
53 ExecutorAddr::fromPtr(Ptr: jitDispatchViaWrapperFunctionManager);
54 BootstrapSymbols[Mangle.mangledCopy(Name: rt::DispatchCtxName)] =
55 ExecutorAddr::fromPtr(Ptr: this);
56
57#ifdef __APPLE__
58 // FIXME: Don't add an UnwindInfoManager by default -- it's redundant when
59 // the ORC runtime is loaded. We'll need a way to document this and
60 // allow clients to choose.
61 if (UnwindInfoManager::TryEnable())
62 UnwindInfoManager::addBootstrapSymbols(this->BootstrapSymbols);
63#endif // __APPLE__
64}
65
66Expected<std::unique_ptr<SelfExecutorProcessControl>>
67SelfExecutorProcessControl::Create(std::shared_ptr<SymbolStringPool> SSP,
68 std::unique_ptr<TaskDispatcher> D) {
69
70 if (!SSP)
71 SSP = std::make_shared<SymbolStringPool>();
72
73 if (!D)
74 D = std::make_unique<InPlaceTaskDispatcher>();
75
76 auto PageSize = sys::Process::getPageSize();
77 if (!PageSize)
78 return PageSize.takeError();
79
80 Triple TT(sys::getProcessTriple());
81
82 return std::make_unique<SelfExecutorProcessControl>(
83 args: std::move(SSP), args: std::move(D), args: std::move(TT), args&: *PageSize);
84}
85
86Expected<int32_t>
87SelfExecutorProcessControl::runAsMain(ExecutorAddr MainFnAddr,
88 ArrayRef<std::string> Args) {
89 using MainTy = int (*)(int, char *[]);
90 return orc::runAsMain(Main: MainFnAddr.toPtr<MainTy>(), Args);
91}
92
93void SelfExecutorProcessControl::callWrapperAsync(ExecutorAddr WrapperFnAddr,
94 IncomingWFRHandler SendResult,
95 ArrayRef<char> ArgBuffer) {
96 using WrapperFnTy =
97 shared::CWrapperFunctionBuffer (*)(const char *Data, size_t Size);
98 auto *WrapperFn = WrapperFnAddr.toPtr<WrapperFnTy>();
99 SendResult(shared::WrapperFunctionBuffer(
100 WrapperFn(ArgBuffer.data(), ArgBuffer.size())));
101}
102
103Error SelfExecutorProcessControl::disconnect() {
104 D->shutdown();
105 return Error::success();
106}
107
108Expected<std::unique_ptr<jitlink::JITLinkMemoryManager>>
109SelfExecutorProcessControl::createDefaultMemoryManager() {
110 return std::make_unique<jitlink::InProcessMemoryManager>(
111 args: sys::Process::getPageSizeEstimate());
112}
113
114Expected<std::unique_ptr<DylibManager>>
115SelfExecutorProcessControl::createDefaultDylibMgr() {
116 char Prefix = TargetTriple.isOSBinFormatMachO() ? '_' : '\0';
117 return std::make_unique<InProcessDylibManager>(args&: Prefix);
118}
119
120Expected<std::unique_ptr<MemoryAccess>>
121SelfExecutorProcessControl::createDefaultMemoryAccess() {
122 return std::make_unique<InProcessMemoryAccess>(args: TargetTriple.isArch64Bit());
123}
124
125shared::CWrapperFunctionBuffer
126SelfExecutorProcessControl::jitDispatchViaWrapperFunctionManager(
127 void *Ctx, const void *FnTag, const char *Data, size_t Size) {
128
129 LLVM_DEBUG({
130 dbgs() << "jit-dispatch call with tag " << FnTag << " and " << Size
131 << " byte payload.\n";
132 });
133
134 std::promise<shared::WrapperFunctionBuffer> ResultP;
135 auto ResultF = ResultP.get_future();
136 static_cast<SelfExecutorProcessControl *>(Ctx)
137 ->getExecutionSession()
138 .runJITDispatchHandler(
139 SendResult: [ResultP = std::move(ResultP)](
140 shared::WrapperFunctionBuffer Result) mutable {
141 ResultP.set_value(std::move(Result));
142 },
143 HandlerFnTagAddr: ExecutorAddr::fromPtr(Ptr: FnTag),
144 ArgBytes: shared::WrapperFunctionBuffer::copyFrom(Source: Data, Size));
145
146 return ResultF.get().release();
147}
148
149SelfExecutorProcessControl::InProcessDylibManager::InProcessDylibManager(
150 char GlobalManglingPrefix)
151 : GlobalManglingPrefix(GlobalManglingPrefix) {}
152
153Expected<tpctypes::DylibHandle>
154SelfExecutorProcessControl::InProcessDylibManager::loadDylib(
155 const char *DylibPath) {
156 std::string ErrMsg;
157 auto Dylib = sys::DynamicLibrary::getPermanentLibrary(filename: DylibPath, errMsg: &ErrMsg);
158 if (!Dylib.isValid())
159 return make_error<StringError>(Args: std::move(ErrMsg), Args: inconvertibleErrorCode());
160 return ExecutorAddr::fromPtr(Ptr: Dylib.getOSSpecificHandle());
161}
162
163void SelfExecutorProcessControl::InProcessDylibManager::lookupSymbolsAsync(
164 tpctypes::DylibHandle H, const SymbolLookupSet &Symbols,
165 DylibManager::SymbolLookupCompleteFn Complete) {
166 tpctypes::LookupResult R;
167
168 sys::DynamicLibrary Dylib(H.toPtr<void *>());
169 for (auto &KV : Symbols) {
170 auto &Sym = KV.first;
171 std::string Tmp((*Sym).data() + !!GlobalManglingPrefix,
172 (*Sym).size() - !!GlobalManglingPrefix);
173 void *Addr = Dylib.getAddressOfSymbol(symbolName: Tmp.c_str());
174 if (!Addr && KV.second == SymbolLookupFlags::RequiredSymbol)
175 R.emplace_back();
176 else
177 R.emplace_back(args: ExecutorAddr::fromPtr(Ptr: Addr));
178 }
179 Complete(std::move(R));
180}
181
182} // namespace llvm::orc
183