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/TargetProcess/TargetExecutionUtils.h" 13 #include "llvm/Support/Host.h" 14 #include "llvm/Support/Process.h" 15 16 #include <mutex> 17 18 namespace llvm { 19 namespace orc { 20 21 ExecutorProcessControl::MemoryAccess::~MemoryAccess() {} 22 23 ExecutorProcessControl::~ExecutorProcessControl() {} 24 25 SelfExecutorProcessControl::SelfExecutorProcessControl( 26 std::shared_ptr<SymbolStringPool> SSP, Triple TargetTriple, 27 unsigned PageSize, std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) 28 : ExecutorProcessControl(std::move(SSP)) { 29 30 OwnedMemMgr = std::move(MemMgr); 31 if (!OwnedMemMgr) 32 OwnedMemMgr = std::make_unique<jitlink::InProcessMemoryManager>(); 33 34 this->TargetTriple = std::move(TargetTriple); 35 this->PageSize = PageSize; 36 this->MemMgr = OwnedMemMgr.get(); 37 this->MemAccess = this; 38 if (this->TargetTriple.isOSBinFormatMachO()) 39 GlobalManglingPrefix = '_'; 40 } 41 42 Expected<std::unique_ptr<SelfExecutorProcessControl>> 43 SelfExecutorProcessControl::Create( 44 std::shared_ptr<SymbolStringPool> SSP, 45 std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) { 46 auto PageSize = sys::Process::getPageSize(); 47 if (!PageSize) 48 return PageSize.takeError(); 49 50 Triple TT(sys::getProcessTriple()); 51 52 return std::make_unique<SelfExecutorProcessControl>( 53 std::move(SSP), std::move(TT), *PageSize, std::move(MemMgr)); 54 } 55 56 Expected<tpctypes::DylibHandle> 57 SelfExecutorProcessControl::loadDylib(const char *DylibPath) { 58 std::string ErrMsg; 59 auto Dylib = std::make_unique<sys::DynamicLibrary>( 60 sys::DynamicLibrary::getPermanentLibrary(DylibPath, &ErrMsg)); 61 if (!Dylib->isValid()) 62 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()); 63 DynamicLibraries.push_back(std::move(Dylib)); 64 return pointerToJITTargetAddress(DynamicLibraries.back().get()); 65 } 66 67 Expected<std::vector<tpctypes::LookupResult>> 68 SelfExecutorProcessControl::lookupSymbols(ArrayRef<LookupRequest> Request) { 69 std::vector<tpctypes::LookupResult> R; 70 71 for (auto &Elem : Request) { 72 auto *Dylib = jitTargetAddressToPointer<sys::DynamicLibrary *>(Elem.Handle); 73 assert(llvm::any_of(DynamicLibraries, 74 [=](const std::unique_ptr<sys::DynamicLibrary> &DL) { 75 return DL.get() == Dylib; 76 }) && 77 "Invalid handle"); 78 79 R.push_back(std::vector<JITTargetAddress>()); 80 for (auto &KV : Elem.Symbols) { 81 auto &Sym = KV.first; 82 std::string Tmp((*Sym).data() + !!GlobalManglingPrefix, 83 (*Sym).size() - !!GlobalManglingPrefix); 84 void *Addr = Dylib->getAddressOfSymbol(Tmp.c_str()); 85 if (!Addr && KV.second == SymbolLookupFlags::RequiredSymbol) { 86 // FIXME: Collect all failing symbols before erroring out. 87 SymbolNameVector MissingSymbols; 88 MissingSymbols.push_back(Sym); 89 return make_error<SymbolsNotFound>(std::move(MissingSymbols)); 90 } 91 R.back().push_back(pointerToJITTargetAddress(Addr)); 92 } 93 } 94 95 return R; 96 } 97 98 Expected<int32_t> 99 SelfExecutorProcessControl::runAsMain(JITTargetAddress MainFnAddr, 100 ArrayRef<std::string> Args) { 101 using MainTy = int (*)(int, char *[]); 102 return orc::runAsMain(jitTargetAddressToFunction<MainTy>(MainFnAddr), Args); 103 } 104 105 Expected<shared::WrapperFunctionResult> 106 SelfExecutorProcessControl::runWrapper(JITTargetAddress WrapperFnAddr, 107 ArrayRef<char> ArgBuffer) { 108 using WrapperFnTy = shared::detail::CWrapperFunctionResult (*)( 109 const char *Data, uint64_t Size); 110 auto *WrapperFn = jitTargetAddressToFunction<WrapperFnTy>(WrapperFnAddr); 111 return WrapperFn(ArgBuffer.data(), ArgBuffer.size()); 112 } 113 114 Error SelfExecutorProcessControl::disconnect() { return Error::success(); } 115 116 void SelfExecutorProcessControl::writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws, 117 WriteResultFn OnWriteComplete) { 118 for (auto &W : Ws) 119 *jitTargetAddressToPointer<uint8_t *>(W.Address) = W.Value; 120 OnWriteComplete(Error::success()); 121 } 122 123 void SelfExecutorProcessControl::writeUInt16s( 124 ArrayRef<tpctypes::UInt16Write> Ws, WriteResultFn OnWriteComplete) { 125 for (auto &W : Ws) 126 *jitTargetAddressToPointer<uint16_t *>(W.Address) = W.Value; 127 OnWriteComplete(Error::success()); 128 } 129 130 void SelfExecutorProcessControl::writeUInt32s( 131 ArrayRef<tpctypes::UInt32Write> Ws, WriteResultFn OnWriteComplete) { 132 for (auto &W : Ws) 133 *jitTargetAddressToPointer<uint32_t *>(W.Address) = W.Value; 134 OnWriteComplete(Error::success()); 135 } 136 137 void SelfExecutorProcessControl::writeUInt64s( 138 ArrayRef<tpctypes::UInt64Write> Ws, WriteResultFn OnWriteComplete) { 139 for (auto &W : Ws) 140 *jitTargetAddressToPointer<uint64_t *>(W.Address) = W.Value; 141 OnWriteComplete(Error::success()); 142 } 143 144 void SelfExecutorProcessControl::writeBuffers( 145 ArrayRef<tpctypes::BufferWrite> Ws, WriteResultFn OnWriteComplete) { 146 for (auto &W : Ws) 147 memcpy(jitTargetAddressToPointer<char *>(W.Address), W.Buffer.data(), 148 W.Buffer.size()); 149 OnWriteComplete(Error::success()); 150 } 151 152 } // end namespace orc 153 } // end namespace llvm 154