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