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 9 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h" 10 11 #include "llvm/ExecutionEngine/Orc/Core.h" 12 #include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h" 13 #include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h" 14 #include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h" 15 #include "llvm/Support/Process.h" 16 #include "llvm/TargetParser/Host.h" 17 18 #define DEBUG_TYPE "orc" 19 20 namespace llvm { 21 namespace orc { 22 23 DylibManager::~DylibManager() = default; 24 25 ExecutorProcessControl::MemoryAccess::~MemoryAccess() = default; 26 27 ExecutorProcessControl::~ExecutorProcessControl() = default; 28 29 SelfExecutorProcessControl::SelfExecutorProcessControl( 30 std::shared_ptr<SymbolStringPool> SSP, std::unique_ptr<TaskDispatcher> D, 31 Triple TargetTriple, unsigned PageSize, 32 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) 33 : ExecutorProcessControl(std::move(SSP), std::move(D)), 34 InProcessMemoryAccess(TargetTriple.isArch64Bit()) { 35 36 OwnedMemMgr = std::move(MemMgr); 37 if (!OwnedMemMgr) 38 OwnedMemMgr = std::make_unique<jitlink::InProcessMemoryManager>( 39 sys::Process::getPageSizeEstimate()); 40 41 this->TargetTriple = std::move(TargetTriple); 42 this->PageSize = PageSize; 43 this->MemMgr = OwnedMemMgr.get(); 44 this->MemAccess = this; 45 this->DylibMgr = this; 46 this->JDI = {ExecutorAddr::fromPtr(jitDispatchViaWrapperFunctionManager), 47 ExecutorAddr::fromPtr(this)}; 48 this->UnwindInfoMgr = UnwindInfoManager::TryCreate(); 49 if (this->TargetTriple.isOSBinFormatMachO()) 50 GlobalManglingPrefix = '_'; 51 52 this->BootstrapSymbols[rt::RegisterEHFrameSectionWrapperName] = 53 ExecutorAddr::fromPtr(&llvm_orc_registerEHFrameSectionWrapper); 54 this->BootstrapSymbols[rt::DeregisterEHFrameSectionWrapperName] = 55 ExecutorAddr::fromPtr(&llvm_orc_deregisterEHFrameSectionWrapper); 56 if (this->UnwindInfoMgr) 57 this->UnwindInfoMgr->addBootstrapSymbols(this->BootstrapSymbols); 58 } 59 60 Expected<std::unique_ptr<SelfExecutorProcessControl>> 61 SelfExecutorProcessControl::Create( 62 std::shared_ptr<SymbolStringPool> SSP, 63 std::unique_ptr<TaskDispatcher> D, 64 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) { 65 66 if (!SSP) 67 SSP = std::make_shared<SymbolStringPool>(); 68 69 if (!D) 70 D = std::make_unique<InPlaceTaskDispatcher>(); 71 72 auto PageSize = sys::Process::getPageSize(); 73 if (!PageSize) 74 return PageSize.takeError(); 75 76 Triple TT(sys::getProcessTriple()); 77 78 return std::make_unique<SelfExecutorProcessControl>( 79 std::move(SSP), std::move(D), std::move(TT), *PageSize, 80 std::move(MemMgr)); 81 } 82 83 Expected<tpctypes::DylibHandle> 84 SelfExecutorProcessControl::loadDylib(const char *DylibPath) { 85 std::string ErrMsg; 86 auto Dylib = sys::DynamicLibrary::getPermanentLibrary(DylibPath, &ErrMsg); 87 if (!Dylib.isValid()) 88 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()); 89 return ExecutorAddr::fromPtr(Dylib.getOSSpecificHandle()); 90 } 91 92 void SelfExecutorProcessControl::lookupSymbolsAsync( 93 ArrayRef<LookupRequest> Request, 94 DylibManager::SymbolLookupCompleteFn Complete) { 95 std::vector<tpctypes::LookupResult> R; 96 97 for (auto &Elem : Request) { 98 sys::DynamicLibrary Dylib(Elem.Handle.toPtr<void *>()); 99 R.push_back(std::vector<ExecutorSymbolDef>()); 100 for (auto &KV : Elem.Symbols) { 101 auto &Sym = KV.first; 102 std::string Tmp((*Sym).data() + !!GlobalManglingPrefix, 103 (*Sym).size() - !!GlobalManglingPrefix); 104 void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str()); 105 if (!Addr && KV.second == SymbolLookupFlags::RequiredSymbol) { 106 // FIXME: Collect all failing symbols before erroring out. 107 SymbolNameVector MissingSymbols; 108 MissingSymbols.push_back(Sym); 109 return Complete( 110 make_error<SymbolsNotFound>(SSP, std::move(MissingSymbols))); 111 } 112 // FIXME: determine accurate JITSymbolFlags. 113 R.back().push_back( 114 {ExecutorAddr::fromPtr(Addr), JITSymbolFlags::Exported}); 115 } 116 } 117 118 Complete(std::move(R)); 119 } 120 121 Expected<int32_t> 122 SelfExecutorProcessControl::runAsMain(ExecutorAddr MainFnAddr, 123 ArrayRef<std::string> Args) { 124 using MainTy = int (*)(int, char *[]); 125 return orc::runAsMain(MainFnAddr.toPtr<MainTy>(), Args); 126 } 127 128 Expected<int32_t> 129 SelfExecutorProcessControl::runAsVoidFunction(ExecutorAddr VoidFnAddr) { 130 using VoidTy = int (*)(); 131 return orc::runAsVoidFunction(VoidFnAddr.toPtr<VoidTy>()); 132 } 133 134 Expected<int32_t> 135 SelfExecutorProcessControl::runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) { 136 using IntTy = int (*)(int); 137 return orc::runAsIntFunction(IntFnAddr.toPtr<IntTy>(), Arg); 138 } 139 140 void SelfExecutorProcessControl::callWrapperAsync(ExecutorAddr WrapperFnAddr, 141 IncomingWFRHandler SendResult, 142 ArrayRef<char> ArgBuffer) { 143 using WrapperFnTy = 144 shared::CWrapperFunctionResult (*)(const char *Data, size_t Size); 145 auto *WrapperFn = WrapperFnAddr.toPtr<WrapperFnTy>(); 146 SendResult(WrapperFn(ArgBuffer.data(), ArgBuffer.size())); 147 } 148 149 Error SelfExecutorProcessControl::disconnect() { 150 D->shutdown(); 151 return Error::success(); 152 } 153 154 void InProcessMemoryAccess::writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws, 155 WriteResultFn OnWriteComplete) { 156 for (auto &W : Ws) 157 *W.Addr.toPtr<uint8_t *>() = W.Value; 158 OnWriteComplete(Error::success()); 159 } 160 161 void InProcessMemoryAccess::writeUInt16sAsync( 162 ArrayRef<tpctypes::UInt16Write> Ws, WriteResultFn OnWriteComplete) { 163 for (auto &W : Ws) 164 *W.Addr.toPtr<uint16_t *>() = W.Value; 165 OnWriteComplete(Error::success()); 166 } 167 168 void InProcessMemoryAccess::writeUInt32sAsync( 169 ArrayRef<tpctypes::UInt32Write> Ws, WriteResultFn OnWriteComplete) { 170 for (auto &W : Ws) 171 *W.Addr.toPtr<uint32_t *>() = W.Value; 172 OnWriteComplete(Error::success()); 173 } 174 175 void InProcessMemoryAccess::writeUInt64sAsync( 176 ArrayRef<tpctypes::UInt64Write> Ws, WriteResultFn OnWriteComplete) { 177 for (auto &W : Ws) 178 *W.Addr.toPtr<uint64_t *>() = W.Value; 179 OnWriteComplete(Error::success()); 180 } 181 182 void InProcessMemoryAccess::writeBuffersAsync( 183 ArrayRef<tpctypes::BufferWrite> Ws, WriteResultFn OnWriteComplete) { 184 for (auto &W : Ws) 185 memcpy(W.Addr.toPtr<char *>(), W.Buffer.data(), W.Buffer.size()); 186 OnWriteComplete(Error::success()); 187 } 188 189 void InProcessMemoryAccess::writePointersAsync( 190 ArrayRef<tpctypes::PointerWrite> Ws, WriteResultFn OnWriteComplete) { 191 if (IsArch64Bit) { 192 for (auto &W : Ws) 193 *W.Addr.toPtr<uint64_t *>() = W.Value.getValue(); 194 } else { 195 for (auto &W : Ws) 196 *W.Addr.toPtr<uint32_t *>() = static_cast<uint32_t>(W.Value.getValue()); 197 } 198 199 OnWriteComplete(Error::success()); 200 } 201 202 shared::CWrapperFunctionResult 203 SelfExecutorProcessControl::jitDispatchViaWrapperFunctionManager( 204 void *Ctx, const void *FnTag, const char *Data, size_t Size) { 205 206 LLVM_DEBUG({ 207 dbgs() << "jit-dispatch call with tag " << FnTag << " and " << Size 208 << " byte payload.\n"; 209 }); 210 211 std::promise<shared::WrapperFunctionResult> ResultP; 212 auto ResultF = ResultP.get_future(); 213 static_cast<SelfExecutorProcessControl *>(Ctx) 214 ->getExecutionSession() 215 .runJITDispatchHandler( 216 [ResultP = std::move(ResultP)]( 217 shared::WrapperFunctionResult Result) mutable { 218 ResultP.set_value(std::move(Result)); 219 }, 220 ExecutorAddr::fromPtr(FnTag), {Data, Size}); 221 222 return ResultF.get().release(); 223 } 224 225 } // end namespace orc 226 } // end namespace llvm 227