LLVM 22.0.0git
ExecutorResolutionGenerator.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
13#include "llvm/Support/Error.h"
14
15#define DEBUG_TYPE "orc"
16
17namespace llvm {
18namespace orc {
19
20Expected<std::unique_ptr<ExecutorResolutionGenerator>>
22 SymbolPredicate Allow,
23 AbsoluteSymbolsFn AbsoluteSymbols) {
24 auto H = ES.getExecutorProcessControl().getDylibMgr().loadDylib(LibraryPath);
25 if (H)
26 return H.takeError();
27 return std::make_unique<ExecutorResolutionGenerator>(
28 ES, *H, std::move(Allow), std::move(AbsoluteSymbols));
29}
30
33 JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &LookupSet) {
34
35 if (LookupSet.empty())
36 return Error::success();
37
39 dbgs() << "ExecutorResolutionGenerator trying to generate " << LookupSet
40 << "\n";
41 });
42
43 SymbolLookupSet LookupSymbols;
44 for (auto &[Name, LookupFlag] : LookupSet) {
45 if (Allow && !Allow(Name))
46 continue;
47 LookupSymbols.add(Name, LookupFlag);
48 }
49
50 DylibManager::LookupRequest LR(H, LookupSymbols);
51 EPC.getDylibMgr().lookupSymbolsAsync(
52 LR, [this, LS = std::move(LS), JD = JITDylibSP(&JD),
53 LookupSymbols](auto Result) mutable {
54 if (Result) {
56 dbgs() << "ExecutorResolutionGenerator lookup failed due to error";
57 });
58 return LS.continueLookup(Result.takeError());
59 }
60 assert(Result->size() == 1 &&
61 "Results for more than one library returned");
62 assert(Result->front().size() == LookupSymbols.size() &&
63 "Result has incorrect number of elements");
64
65 // const tpctypes::LookupResult &Syms = Result->front();
66 // size_t SymIdx = 0;
67 auto Syms = Result->front().begin();
68 SymbolNameSet MissingSymbols;
69 SymbolMap NewSyms;
70 for (auto &[Name, Flags] : LookupSymbols) {
71 const auto &Sym = *Syms++;
72 if (Sym && Sym->getAddress())
73 NewSyms[Name] = *Sym;
74 else if (LLVM_UNLIKELY(!Sym &&
76 MissingSymbols.insert(Name);
77 }
78
80 dbgs() << "ExecutorResolutionGenerator lookup returned " << NewSyms
81 << "\n";
82 });
83
84 if (NewSyms.empty())
85 return LS.continueLookup(Error::success());
86
87 if (LLVM_UNLIKELY(!MissingSymbols.empty()))
88 return LS.continueLookup(make_error<SymbolsNotFound>(
89 this->EPC.getSymbolStringPool(), std::move(MissingSymbols)));
90
91 LS.continueLookup(JD->define(AbsoluteSymbols(std::move(NewSyms))));
92 });
93
94 return Error::success();
95}
96
97} // end namespace orc
98} // end namespace llvm
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
#define LLVM_UNLIKELY(EXPR)
Definition Compiler.h:336
#define LLVM_DEBUG(...)
Definition Debug.h:114
bool empty() const
Definition DenseMap.h:109
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
std::pair< iterator, bool > insert(const ValueT &V)
Definition DenseSet.h:202
friend class ExecutionSession
Definition Core.h:860
virtual Expected< tpctypes::DylibHandle > loadDylib(const char *DylibPath)=0
Load the dynamic library at the given path and return a handle to it.
ExecutorProcessControl & getExecutorProcessControl()
Get the ExecutorProcessControl object associated with this ExecutionSession.
Definition Core.h:1395
DylibManager & getDylibMgr() const
Return the DylibManager for the target process.
static Expected< std::unique_ptr< ExecutorResolutionGenerator > > Load(ExecutionSession &ES, const char *LibraryPath, SymbolPredicate Allow=SymbolPredicate(), AbsoluteSymbolsFn AbsoluteSymbols=absoluteSymbols)
Permanently loads the library at the given path and, on success, returns an ExecutorResolutionGenerat...
unique_function< std::unique_ptr< MaterializationUnit >(SymbolMap)> AbsoluteSymbolsFn
Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &LookupSet) override
DefinitionGenerators should override this method to insert new definitions into the parent JITDylib.
unique_function< bool(const SymbolStringPtr &)> SymbolPredicate
Represents a JIT'd dynamic library.
Definition Core.h:902
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
Definition Core.h:1882
Wraps state for a lookup-in-progress.
Definition Core.h:834
A set of symbols to look up, each associated with a SymbolLookupFlags value.
Definition Core.h:195
bool empty() const
Definition Core.h:275
IntrusiveRefCntPtr< JITDylib > JITDylibSP
Definition Core.h:53
JITDylibLookupFlags
Lookup flags that apply to each dylib in the search order for a lookup.
Definition Core.h:147
DenseMap< SymbolStringPtr, ExecutorSymbolDef > SymbolMap
A map from symbol names (as SymbolStringPtrs) to JITSymbols (address/flags pairs).
LookupKind
Describes the kind of lookup being performed.
Definition Core.h:169
DenseSet< SymbolStringPtr > SymbolNameSet
A set of symbol names (represented by SymbolStringPtrs for.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition Debug.cpp:207
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
Definition Error.h:340
A pair of a dylib and a set of symbols to be looked up.