13#ifndef LLVM_EXECUTIONENGINE_ORC_CORE_H
14#define LLVM_EXECUTIONENGINE_ORC_CORE_H
40class AsynchronousSymbolQuery;
41class ExecutionSession;
42class MaterializationUnit;
43class MaterializationResponsibility;
46class InProgressLookupState;
72 return *
reinterpret_cast<JITDylib *
>(JDAndFlag.load() &
73 ~static_cast<uintptr_t>(1));
88 bool isDefunct()
const {
return JDAndFlag.load() & 0x1; }
100 std::atomic_uintptr_t JDAndFlag;
162 std::vector<std::pair<JITDylib *, JITDylibLookupFlags>>;
170 O.reserve(JDs.
size());
172 O.push_back(std::make_pair(JD, Flags));
185 using value_type = std::pair<SymbolStringPtr, SymbolLookupFlags>;
200 std::initializer_list<SymbolStringPtr> Names,
202 Symbols.reserve(Names.size());
203 for (
const auto &
Name : Names)
212 Symbols.reserve(Names.
size());
213 for (
const auto &
Name : Names)
224 Symbols.reserve(Names.
size());
225 for (
const auto &
Name : Names)
230 template <
typename KeyT>
235 Result.Symbols.reserve(M.size());
236 for (
const auto &KV : M)
237 Result.add(KV.first, Flags);
246 Symbols.push_back(std::make_pair(std::move(
Name), Flags));
252 Symbols.reserve(Symbols.size() +
Other.size());
253 for (
auto &KV :
Other)
254 Symbols.push_back(std::move(KV));
258 bool empty()
const {
return Symbols.empty(); }
259 UnderlyingVector::size_type
size()
const {
return Symbols.size(); }
277 template <
typename PredFn>
void remove_if(PredFn &&Pred) {
278 UnderlyingVector::size_type
I = 0;
279 while (
I != Symbols.size()) {
280 const auto &
Name = Symbols[
I].first;
281 auto Flags = Symbols[
I].second;
282 if (Pred(
Name, Flags))
294 template <
typename BodyFn>
296 std::is_same<decltype(Body(std::declval<const SymbolStringPtr &>(),
297 std::declval<SymbolLookupFlags>())),
299 UnderlyingVector::size_type
I = 0;
300 while (
I != Symbols.size()) {
301 const auto &
Name = Symbols[
I].first;
302 auto Flags = Symbols[
I].second;
303 if (Body(
Name, Flags))
316 template <
typename BodyFn>
318 std::is_same<decltype(Body(std::declval<const SymbolStringPtr &>(),
319 std::declval<SymbolLookupFlags>())),
322 UnderlyingVector::size_type
I = 0;
323 while (
I != Symbols.size()) {
324 const auto &
Name = Symbols[
I].first;
325 auto Flags = Symbols[
I].second;
326 auto Remove = Body(
Name, Flags);
328 return Remove.takeError();
341 Names.reserve(Symbols.size());
342 for (
const auto &KV : Symbols)
343 Names.push_back(KV.first);
356 return *
LHS.first < *
RHS.first;
364 auto LastI = std::unique(Symbols.begin(), Symbols.end());
365 Symbols.erase(LastI, Symbols.end());
372 if (Symbols.size() < 2)
375 for (UnderlyingVector::size_type
I = 1;
I != Symbols.size(); ++
I)
376 if (Symbols[
I].first == Symbols[
I - 1].first)
428 std::shared_ptr<SymbolDependenceMap> Symbols);
435 std::shared_ptr<SymbolStringPool> SSP;
436 std::shared_ptr<SymbolDependenceMap> Symbols;
453 std::shared_ptr<SymbolStringPool> SSP;
470 std::shared_ptr<SymbolStringPool> SSP;
492 std::shared_ptr<SymbolStringPool> SSP;
515 std::shared_ptr<SymbolStringPool> SSP;
544 return RT->withResourceKeyDo(std::forward<Func>(
F));
643 : JD(RT->getJITDylib()), RT(
std::
move(RT)),
644 SymbolFlags(
std::
move(SymbolFlags)), InitSymbol(
std::
move(InitSymbol)) {
645 assert(!this->SymbolFlags.
empty() &&
"Materializing nothing?");
651 SymbolStringPtr InitSymbol;
675 "If set, InitSymbol should appear in InitialSymbolFlags map");
701 materialize(std::unique_ptr<MaterializationResponsibility> R) = 0;
709 dbgs() <<
"In " <<
getName() <<
": discarding init symbol \""
714 discard(JD, std::move(
Name));
722 virtual void anchor();
742 void materialize(std::unique_ptr<MaterializationResponsibility> R)
override;
759inline std::unique_ptr<AbsoluteSymbolsMaterializationUnit>
761 return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
784 void materialize(std::unique_ptr<MaterializationResponsibility> R)
override;
805inline std::unique_ptr<ReExportsMaterializationUnit>
807 return std::make_unique<ReExportsMaterializationUnit>(
814inline std::unique_ptr<ReExportsMaterializationUnit>
818 return std::make_unique<ReExportsMaterializationUnit>(
819 &SourceJD, SourceJDLookupFlags, std::move(Aliases));
862 bool isComplete()
const {
return OutstandingSymbolsCount == 0; }
868 SymbolState getRequiredState() {
return RequiredState; }
870 void addQueryDependence(
JITDylib &JD, SymbolStringPtr
Name);
872 void removeQueryDependence(
JITDylib &JD,
const SymbolStringPtr &
Name);
874 void dropSymbol(
const SymbolStringPtr &
Name);
876 void handleFailed(
Error Err);
883 size_t OutstandingSymbolsCount;
905 LookupState(std::unique_ptr<InProgressLookupState> IPLS);
910 std::unique_ptr<InProgressLookupState> IPLS;
934 std::deque<LookupState> PendingLookups;
1017 template <
typename GeneratorT>
1018 GeneratorT &
addGenerator(std::unique_ptr<GeneratorT> DefGenerator);
1051 bool LinkAgainstThisJITDylibFirst =
true);
1087 template <
typename Func>
1089 ->
decltype(
F(std::declval<const JITDylibSearchOrder &>()));
1101 template <
typename MaterializationUnitType>
1102 Error define(std::unique_ptr<MaterializationUnitType> &&MU,
1115 template <
typename MaterializationUnitType>
1116 Error define(std::unique_ptr<MaterializationUnitType> &MU,
1167 using AsynchronousSymbolQuerySet =
1168 std::set<std::shared_ptr<AsynchronousSymbolQuery>>;
1170 using AsynchronousSymbolQueryList =
1171 std::vector<std::shared_ptr<AsynchronousSymbolQuery>>;
1173 struct UnmaterializedInfo {
1174 UnmaterializedInfo(std::unique_ptr<MaterializationUnit> MU,
1176 : MU(
std::
move(MU)), RT(RT) {}
1178 std::unique_ptr<MaterializationUnit> MU;
1179 ResourceTracker *RT;
1182 using UnmaterializedInfosMap =
1183 DenseMap<SymbolStringPtr, std::shared_ptr<UnmaterializedInfo>>;
1185 using UnmaterializedInfosList =
1186 std::vector<std::shared_ptr<UnmaterializedInfo>>;
1188 struct MaterializingInfo {
1192 void addQuery(std::shared_ptr<AsynchronousSymbolQuery> Q);
1194 AsynchronousSymbolQueryList takeQueriesMeeting(
SymbolState RequiredState);
1195 AsynchronousSymbolQueryList takeAllPendingQueries() {
1196 return std::move(PendingQueries);
1198 bool hasQueriesPending()
const {
return !PendingQueries.empty(); }
1199 const AsynchronousSymbolQueryList &pendingQueries()
const {
1200 return PendingQueries;
1203 AsynchronousSymbolQueryList PendingQueries;
1206 using MaterializingInfosMap = DenseMap<SymbolStringPtr, MaterializingInfo>;
1208 class SymbolTableEntry {
1210 SymbolTableEntry() =
default;
1211 SymbolTableEntry(JITSymbolFlags Flags)
1213 MaterializerAttached(
false), PendingRemoval(
false) {}
1215 ExecutorAddr getAddress()
const {
return Addr; }
1216 JITSymbolFlags getFlags()
const {
return Flags; }
1219 bool hasMaterializerAttached()
const {
return MaterializerAttached; }
1220 bool isPendingRemoval()
const {
return PendingRemoval; }
1222 void setAddress(ExecutorAddr Addr) { this->Addr =
Addr; }
1223 void setFlags(JITSymbolFlags Flags) { this->Flags =
Flags; }
1225 assert(
static_cast<uint8_t
>(State) < (1 << 6) &&
1226 "State does not fit in bitfield");
1227 this->State =
static_cast<uint8_t
>(State);
1230 void setMaterializerAttached(
bool MaterializerAttached) {
1231 this->MaterializerAttached = MaterializerAttached;
1234 void setPendingRemoval(
bool PendingRemoval) {
1235 this->PendingRemoval = PendingRemoval;
1238 ExecutorSymbolDef getSymbol()
const {
return {
Addr,
Flags}; }
1242 JITSymbolFlags
Flags;
1244 uint8_t MaterializerAttached : 1;
1245 uint8_t PendingRemoval : 1;
1248 using SymbolTable = DenseMap<SymbolStringPtr, SymbolTableEntry>;
1252 std::pair<AsynchronousSymbolQuerySet, std::shared_ptr<SymbolDependenceMap>>
1253 removeTracker(ResourceTracker &RT);
1255 void transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
1257 Error defineImpl(MaterializationUnit &MU);
1259 void installMaterializationUnit(std::unique_ptr<MaterializationUnit> MU,
1260 ResourceTracker &RT);
1265 void transferEmittedNodeDependencies(MaterializingInfo &DependantMI,
1266 const SymbolStringPtr &DependantName,
1267 MaterializingInfo &EmittedMI);
1269 Expected<SymbolFlagsMap>
1274 std::unique_ptr<MaterializationUnit> MU);
1276 Expected<std::unique_ptr<MaterializationResponsibility>>
1278 SymbolStringPtr InitSymbol);
1282 void addDependencies(
const SymbolStringPtr &Name,
1291 using FailedSymbolsWorklist =
1292 std::vector<std::pair<JITDylib *, SymbolStringPtr>>;
1294 static std::pair<AsynchronousSymbolQuerySet,
1295 std::shared_ptr<SymbolDependenceMap>>
1296 failSymbols(FailedSymbolsWorklist);
1299 enum { Open, Closing, Closed } State = Open;
1300 std::mutex GeneratorsMutex;
1301 SymbolTable Symbols;
1302 UnmaterializedInfosMap UnmaterializedInfos;
1303 MaterializingInfosMap MaterializingInfos;
1304 std::vector<std::shared_ptr<DefinitionGenerator>> DefGenerators;
1309 DenseMap<ResourceTracker *, SymbolNameVector> TrackerSymbols;
1310 DenseMap<ResourceTracker *, DenseSet<MaterializationResponsibility *>>
1363 std::unique_ptr<MaterializationResponsibility> MR)
1366 void run()
override;
1369 std::unique_ptr<MaterializationUnit> MU;
1370 std::unique_ptr<MaterializationResponsibility> MR;
1382 void run()
override;
1411 const char *ArgData,
size_t ArgSize)>;
1442 return EPC->getSymbolStringPool();
1457 std::lock_guard<std::recursive_mutex> Lock(SessionMutex);
1520 this->ReportError = std::move(ReportError);
1531 this->DispatchTask = std::move(DispatchTask);
1607 assert(
T &&
"T must be non-null");
1609 DispatchTask(std::move(
T));
1621 template <
typename... ArgTs>
1623 EPC->callWrapperAsync(std::forward<ArgTs>(Args)...);
1634 return EPC->callWrapper(WrapperFnAddr, ArgBuffer);
1639 template <
typename SPSSignature,
typename SendResultT,
typename... ArgTs>
1641 const ArgTs &...Args) {
1642 EPC->callSPSWrapperAsync<SPSSignature, SendResultT, ArgTs...>(
1643 WrapperFnAddr, std::forward<SendResultT>(SendResult), Args...);
1651 template <
typename SPSSignature,
typename... WrapperCallArgTs>
1653 WrapperCallArgTs &&...WrapperCallArgs) {
1654 return EPC->callSPSWrapper<SPSSignature, WrapperCallArgTs...>(
1655 WrapperFnAddr, std::forward<WrapperCallArgTs>(WrapperCallArgs)...);
1665 template <
typename SPSSignature,
typename HandlerT>
1667 return [
H = std::forward<HandlerT>(
H)](
1669 const char *ArgData,
size_t ArgSize)
mutable {
1671 std::move(SendResult));
1682 template <
typename SPSSignature,
typename ClassT,
typename... MethodArgTs>
1685 return wrapAsyncWithSPS<SPSSignature>(
1686 [Instance, Method](MethodArgTs &&...MethodArgs) {
1687 (Instance->*Method)(std::forward<MethodArgTs>(MethodArgs)...);
1714 static void logErrorsToStdErr(
Error Err) {
1718 static void runOnCurrentThread(std::unique_ptr<Task>
T) {
T->run(); }
1720 void dispatchOutstandingMUs();
1722 static std::unique_ptr<MaterializationResponsibility>
1725 SymbolStringPtr InitSymbol) {
1726 auto &JD = RT.getJITDylib();
1727 std::unique_ptr<MaterializationResponsibility> MR(
1729 std::move(InitSymbol)));
1730 JD.TrackerMRs[&RT].insert(MR.get());
1744 SymbolLookupSet &Candidates,
1745 SymbolLookupSet *NonCandidates);
1748 void OL_resumeLookupAfterGeneration(InProgressLookupState &IPLS);
1753 void OL_applyQueryPhase1(std::unique_ptr<InProgressLookupState> IPLS,
1760 void OL_completeLookup(std::unique_ptr<InProgressLookupState> IPLS,
1761 std::shared_ptr<AsynchronousSymbolQuery> Q,
1766 void OL_completeLookupFlags(
1767 std::unique_ptr<InProgressLookupState> IPLS,
1768 unique_function<
void(Expected<SymbolFlagsMap>)> OnComplete);
1771 void OL_destroyMaterializationResponsibility(
1781 std::unique_ptr<MaterializationUnit> MU);
1782 Expected<std::unique_ptr<MaterializationResponsibility>>
1785 const SymbolStringPtr &
Name,
1791 void dumpDispatchInfo(Task &
T);
1794 mutable std::recursive_mutex SessionMutex;
1795 bool SessionOpen =
true;
1796 std::unique_ptr<ExecutorProcessControl> EPC;
1797 std::unique_ptr<Platform>
P;
1801 std::vector<ResourceManager *> ResourceManagers;
1803 std::vector<JITDylibSP> JDs;
1807 mutable std::recursive_mutex OutstandingMUsMutex;
1808 std::vector<std::pair<std::unique_ptr<MaterializationUnit>,
1809 std::unique_ptr<MaterializationResponsibility>>>
1812 mutable std::mutex JITDispatchHandlersMutex;
1813 DenseMap<ExecutorAddr, std::shared_ptr<JITDispatchHandlerFunction>>
1814 JITDispatchHandlers;
1820 return make_error<ResourceTrackerDefunct>(
this);
1831template <
typename GeneratorT>
1833 auto &
G = *DefGenerator;
1835 assert(State == Open &&
"Cannot add generator to closed JITDylib");
1836 DefGenerators.push_back(std::move(DefGenerator));
1841template <
typename Func>
1843 ->
decltype(
F(std::declval<const JITDylibSearchOrder &>())) {
1844 assert(State == Open &&
"Cannot use link order of closed JITDylib");
1845 return ES.runSessionLocked([&]() {
return F(LinkOrder); });
1848template <
typename MaterializationUnitType>
1851 assert(MU &&
"Can not define with a null MU");
1853 if (MU->getSymbols().empty()) {
1856 dbgs() <<
"Warning: Discarding empty MU " << MU->getName() <<
" for "
1862 dbgs() <<
"Defining MU " << MU->getName() <<
" for " <<
getName()
1865 dbgs() <<
"default)";
1869 dbgs() <<
"0x0, default will be used)\n";
1873 assert(State == Open &&
"JD is defunct");
1875 if (
auto Err = defineImpl(*MU))
1882 if (
auto Err =
P->notifyAdding(*RT, *MU))
1886 installMaterializationUnit(std::move(MU), *RT);
1891template <
typename MaterializationUnitType>
1894 assert(MU &&
"Can not define with a null MU");
1896 if (MU->getSymbols().empty()) {
1899 dbgs() <<
"Warning: Discarding empty MU " << MU->getName() <<
getName()
1905 dbgs() <<
"Defining MU " << MU->getName() <<
" for " <<
getName()
1908 dbgs() <<
"default)";
1912 dbgs() <<
"0x0, default will be used)\n";
1916 assert(State == Open &&
"JD is defunct");
1918 if (
auto Err = defineImpl(*MU))
1925 if (
auto Err =
P->notifyAdding(*RT, *MU))
1929 installMaterializationUnit(std::move(MU), *RT);
1981 std::move(SymbolFlags));
1989 std::unique_ptr<MaterializationUnit> MU) {
Given that RA is a live value
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
This file defines the DenseSet and SmallDenseSet classes.
This file defines the RefCountedBase, ThreadSafeRefCountedBase, and IntrusiveRefCntPtr classes.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool erase(const KeyT &Val)
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Base class for user error types.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
Flags for symbols in the JIT.
Inheritance utility for extensible RTTI.
StringRef - Represent a constant reference to a string, i.e.
A thread-safe version of RefCountedBase.
Triple - Helper class for working with autoconf configuration names.
const std::string & getName() const
Get the name for this JITLinkDylib.
A MaterializationUnit implementation for pre-existing absolute symbols.
StringRef getName() const override
Return the name of this materialization unit.
A symbol query that returns results via a callback when results are ready.
bool isComplete() const
Returns true if all symbols covered by this query have been resolved.
void notifySymbolMetRequiredState(const SymbolStringPtr &Name, ExecutorSymbolDef Sym)
Notify the query that a requested symbol has reached the required state.
friend class JITSymbolResolverAdapter
Definition generators can be attached to JITDylibs to generate new definitions for otherwise unresolv...
virtual ~DefinitionGenerator()
virtual Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &LookupSet)=0
DefinitionGenerators should override this method to insert new definitions into the parent JITDylib.
An ExecutionSession represents a running JIT program.
Error endSession()
End the session.
ExecutorProcessControl & getExecutorProcessControl()
Get the ExecutorProcessControl object associated with this ExecutionSession.
unique_function< void(shared::WrapperFunctionResult)> SendResultFunction
Send a result to the remote.
void reportError(Error Err)
Report a error for this execution session.
void setPlatform(std::unique_ptr< Platform > P)
Set the Platform for this ExecutionSession.
const Triple & getTargetTriple() const
Return the triple for the executor.
std::function< void(Error)> ErrorReporter
For reporting errors.
ExecutionSession & setDispatchTask(DispatchTaskFunction DispatchTask)
Set the task dispatch function.
Platform * getPlatform()
Get the Platform for this session.
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
void lookupFlags(LookupKind K, JITDylibSearchOrder SearchOrder, SymbolLookupSet Symbols, unique_function< void(Expected< SymbolFlagsMap >)> OnComplete)
Search the given JITDylibs to find the flags associated with each of the given symbols.
shared::WrapperFunctionResult callWrapper(ExecutorAddr WrapperFnAddr, ArrayRef< char > ArgBuffer)
Run a wrapper function in the executor.
SymbolStringPtr intern(StringRef SymName)
Add a symbol name to the SymbolStringPool and return a pointer to it.
JITDylib * getJITDylibByName(StringRef Name)
Return a pointer to the "name" JITDylib.
void callWrapperAsync(ArgTs &&... Args)
Run a wrapper function in the executor.
static JITDispatchHandlerFunction wrapAsyncWithSPS(ClassT *Instance, void(ClassT::*Method)(MethodArgTs...))
Wrap a class method that takes concrete argument types (and a sender for a concrete return type) to p...
JITDylib & createBareJITDylib(std::string Name)
Add a new bare JITDylib to this ExecutionSession.
static JITDispatchHandlerFunction wrapAsyncWithSPS(HandlerT &&H)
Wrap a handler that takes concrete argument types (and a sender for a concrete return type) to produc...
void callSPSWrapperAsync(ExecutorAddr WrapperFnAddr, SendResultT &&SendResult, const ArgTs &...Args)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
DenseMap< SymbolStringPtr, JITDispatchHandlerFunction > JITDispatchHandlerAssociationMap
A map associating tag names with asynchronous wrapper function implementations in the JIT.
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Get the SymbolStringPool for this instance.
void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder, SymbolLookupSet Symbols, SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete, RegisterDependenciesFunction RegisterDependencies)
Search the given JITDylibs for the given symbols.
Error registerJITDispatchHandlers(JITDylib &JD, JITDispatchHandlerAssociationMap WFs)
For each tag symbol name, associate the corresponding AsyncHandlerWrapperFunction with the address of...
friend class MaterializationResponsibility
void registerResourceManager(ResourceManager &RM)
Register the given ResourceManager with this ExecutionSession.
~ExecutionSession()
Destroy an ExecutionSession.
void runJITDispatchHandler(SendResultFunction SendResult, ExecutorAddr HandlerFnTagAddr, ArrayRef< char > ArgBuffer)
Run a registered jit-side wrapper function.
unique_function< void(SendResultFunction SendResult, const char *ArgData, size_t ArgSize)> JITDispatchHandlerFunction
An asynchronous wrapper-function callable from the executor via jit-dispatch.
void deregisterResourceManager(ResourceManager &RM)
Deregister the given ResourceManager with this ExecutionSession.
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
void dump(raw_ostream &OS)
Dump the state of all the JITDylibs in this session.
friend class ResourceTracker
ExecutionSession & setErrorReporter(ErrorReporter ReportError)
Set the error reporter function.
Error removeJITDylibs(std::vector< JITDylibSP > JDsToRemove)
Removes the given JITDylibs from the ExecutionSession.
size_t getPageSize() const
Expected< JITDylib & > createJITDylib(std::string Name)
Add a new JITDylib to this ExecutionSession.
void dispatchTask(std::unique_ptr< Task > T)
Materialize the given unit.
unique_function< void(std::unique_ptr< Task > T)> DispatchTaskFunction
For dispatching ORC tasks (typically materialization tasks).
Error removeJITDylib(JITDylib &JD)
Calls removeJTIDylibs on the gives JITDylib.
Represents an address in the executor process.
ExecutorProcessControl supports interaction with a JIT target process.
Represents a defining location for a JIT symbol.
Used to notify a JITDylib that the given set of symbols failed to materialize.
const SymbolDependenceMap & getSymbols() const
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Represents a JIT'd dynamic library.
Error remove(const SymbolNameSet &Names)
Tries to remove the given symbols.
Error clear()
Calls remove on all trackers currently associated with this JITDylib.
JITDylib & operator=(JITDylib &&)=delete
void dump(raw_ostream &OS)
Dump current JITDylib state to OS.
friend class AsynchronousSymbolQuery
void replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD, JITDylibLookupFlags JDLookupFlags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Replace OldJD with NewJD in the link order if OldJD is present.
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
ExecutionSession & getExecutionSession() const
Get a reference to the ExecutionSession for this JITDylib.
void addToLinkOrder(const JITDylibSearchOrder &NewLinks)
Append the given JITDylibSearchOrder to the link order for this JITDylib (discarding any elements alr...
ResourceTrackerSP createResourceTracker()
Create a resource tracker for this JITDylib.
auto withLinkOrderDo(Func &&F) -> decltype(F(std::declval< const JITDylibSearchOrder & >()))
Do something with the link order (run under the session lock).
friend class MaterializationResponsibility
void removeFromLinkOrder(JITDylib &JD)
Remove the given JITDylib from the link order for this JITDylib if it is present.
void setLinkOrder(JITDylibSearchOrder NewSearchOrder, bool LinkAgainstThisJITDylibFirst=true)
Set the link order to be used when fixing up definitions in JITDylib.
Expected< std::vector< JITDylibSP > > getReverseDFSLinkOrder()
Rteurn this JITDylib and its transitive dependencies in reverse DFS order based on linkage relationsh...
friend class ExecutionSession
ResourceTrackerSP getDefaultResourceTracker()
Get the default resource tracker for this JITDylib.
GeneratorT & addGenerator(std::unique_ptr< GeneratorT > DefGenerator)
Adds a definition generator to this JITDylib and returns a referenece to it.
JITDylib(const JITDylib &)=delete
JITDylib & operator=(const JITDylib &)=delete
JITDylib(JITDylib &&)=delete
void removeGenerator(DefinitionGenerator &G)
Remove a definition generator from this JITDylib.
Expected< std::vector< JITDylibSP > > getDFSLinkOrder()
Return this JITDylib and its transitive dependencies in DFS order based on linkage relationships.
Wraps state for a lookup-in-progress.
void continueLookup(Error Err)
Continue the lookup.
LookupState & operator=(LookupState &&)
LookupState(LookupState &&)
Lookups are usually run on the current thread, but in some cases they may be run as tasks,...
LookupTask(LookupState LS)
void printDescription(raw_ostream &OS) override
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
MaterializationResponsibility & operator=(MaterializationResponsibility &&)=delete
ExecutionSession & getExecutionSession() const
Returns the ExecutionSession for this instance.
Error notifyResolved(const SymbolMap &Symbols)
Notifies the target JITDylib that the given symbols have been resolved.
Error notifyEmitted()
Notifies the target JITDylib (and any pending queries on that JITDylib) that all symbols covered by t...
void addDependenciesForAll(const SymbolDependenceMap &Dependencies)
Add dependencies that apply to all symbols covered by this instance.
~MaterializationResponsibility()
Destruct a MaterializationResponsibility instance.
void addDependencies(const SymbolStringPtr &Name, const SymbolDependenceMap &Dependencies)
Error replace(std::unique_ptr< MaterializationUnit > MU)
Transfers responsibility to the given MaterializationUnit for all symbols defined by that Materializa...
Error withResourceKeyDo(Func &&F) const
Runs the given callback under the session lock, passing in the associated ResourceKey.
Error defineMaterializing(SymbolFlagsMap SymbolFlags)
Attempt to claim responsibility for new definitions.
SymbolNameSet getRequestedSymbols() const
Returns the names of any symbols covered by this MaterializationResponsibility object that have queri...
Expected< std::unique_ptr< MaterializationResponsibility > > delegate(const SymbolNameSet &Symbols)
Delegates responsibility for the given symbols to the returned materialization responsibility.
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization pseudo-symbol, if any.
MaterializationResponsibility(MaterializationResponsibility &&)=delete
void failMaterialization()
Notify all not-yet-emitted covered by this MaterializationResponsibility instance that an error has o...
JITDylib & getTargetJITDylib() const
Returns the target JITDylib that these symbols are being materialized into.
const SymbolFlagsMap & getSymbols() const
Returns the symbol flags map for this responsibility instance.
void printDescription(raw_ostream &OS) override
MaterializationTask(std::unique_ptr< MaterializationUnit > MU, std::unique_ptr< MaterializationResponsibility > MR)
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
MaterializationUnit(Interface I)
virtual StringRef getName() const =0
Return the name of this materialization unit.
SymbolStringPtr InitSymbol
SymbolFlagsMap SymbolFlags
const SymbolFlagsMap & getSymbols() const
Return the set of symbols that this source provides.
virtual void materialize(std::unique_ptr< MaterializationResponsibility > R)=0
Implementations of this method should materialize all symbols in the materialzation unit,...
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization symbol for this MaterializationUnit (if any).
void doDiscard(const JITDylib &JD, const SymbolStringPtr &Name)
Called by JITDylibs to notify MaterializationUnits that the given symbol has been overridden.
virtual ~MaterializationUnit()=default
Errors of this type should be returned if a module fails to include definitions that are claimed by t...
const SymbolNameVector & getSymbols() const
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
void log(raw_ostream &OS) const override
Print an error message to an output stream.
MissingSymbolDefinitions(std::shared_ptr< SymbolStringPool > SSP, std::string ModuleName, SymbolNameVector Symbols)
const std::string & getModuleName() const
A materialization unit for symbol aliases.
StringRef getName() const override
Return the name of this materialization unit.
ReexportsGenerator can be used with JITDylib::addGenerator to automatically re-export a subset of the...
std::function< bool(SymbolStringPtr)> SymbolPredicate
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.
Listens for ResourceTracker operations.
virtual Error handleRemoveResources(JITDylib &JD, ResourceKey K)=0
virtual ~ResourceManager()
virtual void handleTransferResources(JITDylib &JD, ResourceKey DstK, ResourceKey SrcK)=0
void log(raw_ostream &OS) const override
Print an error message to an output stream.
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
API to remove / transfer ownership of JIT resources.
JITDylib & getJITDylib() const
Return the JITDylib targeted by this tracker.
ResourceTracker & operator=(const ResourceTracker &)=delete
ResourceKey getKeyUnsafe() const
Returns the key associated with this tracker.
void transferTo(ResourceTracker &DstRT)
Transfer all resources associated with this key to the given tracker, which must target the same JITD...
ResourceTracker & operator=(ResourceTracker &&)=delete
ResourceTracker(const ResourceTracker &)=delete
bool isDefunct() const
Return true if this tracker has become defunct.
ResourceTracker(ResourceTracker &&)=delete
Error withResourceKeyDo(Func &&F)
Runs the given callback under the session lock, passing in the associated ResourceKey.
Error remove()
Remove all resources associated with this key.
A set of symbols to look up, each associated with a SymbolLookupFlags value.
std::pair< SymbolStringPtr, SymbolLookupFlags > value_type
const_iterator begin() const
void removeDuplicates()
Remove any duplicate elements.
UnderlyingVector::const_iterator const_iterator
void sortByAddress()
Sort the lookup set by pointer value.
SymbolLookupSet(std::initializer_list< SymbolStringPtr > Names, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from an initializer list of SymbolStringPtrs.
UnderlyingVector::size_type size() const
SymbolLookupSet & add(SymbolStringPtr Name, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Add an element to the set.
SymbolLookupSet & append(SymbolLookupSet Other)
Quickly append one lookup set to another.
SymbolLookupSet(ArrayRef< SymbolStringPtr > Names, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from a vector of symbols with the given Flags used for each value.
void sortByName()
Sort the lookup set lexicographically.
void remove(iterator I)
Removes the element pointed to by the given iterator.
auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t< std::is_same< decltype(Body(std::declval< const SymbolStringPtr & >(), std::declval< SymbolLookupFlags >())), bool >::value >
Loop over the elements of this SymbolLookupSet, applying the Body function to each one.
bool containsDuplicates()
Returns true if this set contains any duplicates.
UnderlyingVector::iterator iterator
void remove_if(PredFn &&Pred)
Removes all elements matching the given predicate, which must be callable as bool(const SymbolStringP...
SymbolLookupSet(const SymbolNameSet &Names, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from a SymbolNameSet with the given Flags used for each value.
SymbolLookupSet(SymbolStringPtr Name, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
SymbolNameVector getSymbolNames() const
Construct a SymbolNameVector from this instance by dropping the Flags values.
const_iterator end() const
SymbolLookupSet()=default
auto forEachWithRemoval(BodyFn &&Body) -> std::enable_if_t< std::is_same< decltype(Body(std::declval< const SymbolStringPtr & >(), std::declval< SymbolLookupFlags >())), Expected< bool > >::value, Error >
Loop over the elements of this SymbolLookupSet, applying the Body function to each one.
static SymbolLookupSet fromMapKeys(const DenseMap< SymbolStringPtr, KeyT > &M, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from DenseMap keys.
void remove(UnderlyingVector::size_type I)
Removes the Ith element of the vector, replacing it with the last element.
std::vector< value_type > UnderlyingVector
Pointer to a pooled string representing a symbol name.
Used to notify clients that a set of symbols could not be removed.
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
void log(raw_ostream &OS) const override
Print an error message to an output stream.
const SymbolNameSet & getSymbols() const
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Used to notify clients when symbols can not be found during a lookup.
void log(raw_ostream &OS) const override
Print an error message to an output stream.
const SymbolNameVector & getSymbols() const
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
Errors of this type should be returned if a module contains definitions for symbols that are not clai...
UnexpectedSymbolDefinitions(std::shared_ptr< SymbolStringPool > SSP, std::string ModuleName, SymbolNameVector Symbols)
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
void log(raw_ostream &OS) const override
Print an error message to an output stream.
std::shared_ptr< SymbolStringPool > getSymbolStringPool()
const std::string & getModuleName() const
const SymbolNameVector & getSymbols() const
C++ wrapper function result: Same as CWrapperFunctionResult but auto-releases memory.
This class implements an extremely fast bulk output stream that can only output to a stream.
JITDylibSearchOrder makeJITDylibSearchOrder(ArrayRef< JITDylib * > JDs, JITDylibLookupFlags Flags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Convenience function for creating a search order from an ArrayRef of JITDylib*, all with the same fla...
std::vector< std::pair< JITDylib *, JITDylibLookupFlags > > JITDylibSearchOrder
A list of (JITDylib*, JITDylibLookupFlags) pairs to be used as a search order during symbol lookup.
std::function< void(const SymbolDependenceMap &)> RegisterDependenciesFunction
Callback to register the dependencies for a given query.
std::unique_ptr< ReExportsMaterializationUnit > symbolAliases(SymbolAliasMap Aliases)
Create a ReExportsMaterializationUnit with the given aliases.
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
IntrusiveRefCntPtr< ResourceTracker > ResourceTrackerSP
SymbolLookupFlags
Lookup flags that apply to each symbol in a lookup.
std::unique_ptr< ReExportsMaterializationUnit > reexports(JITDylib &SourceJD, SymbolAliasMap Aliases, JITDylibLookupFlags SourceJDLookupFlags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Create a materialization unit for re-exporting symbols from another JITDylib with alternative names/f...
JITDylibLookupFlags
Lookup flags that apply to each dylib in the search order for a lookup.
@ MatchExportedSymbolsOnly
DenseMap< SymbolStringPtr, ExecutorSymbolDef > SymbolMap
A map from symbol names (as SymbolStringPtrs) to JITSymbols (address/flags pairs).
DenseMap< SymbolStringPtr, JITSymbolFlags > SymbolFlagsMap
A map from symbol names (as SymbolStringPtrs) to JITSymbolFlags.
unique_function< void(Expected< SymbolMap >)> SymbolsResolvedCallback
Callback to notify client that symbols have been resolved.
DenseSet< SymbolStringPtr > SymbolNameSet
A set of symbol names (represented by SymbolStringPtrs for.
LookupKind
Describes the kind of lookup being performed.
RegisterDependenciesFunction NoDependenciesToRegister
This can be used as the value for a RegisterDependenciesFunction if there are no dependants to regist...
std::vector< SymbolStringPtr > SymbolNameVector
A vector of symbol names.
SymbolState
Represents the state that a symbol has reached during materialization.
@ Materializing
Added to the symbol table, never queried.
@ NeverSearched
No symbol should be in this state.
@ Ready
Emitted to memory, but waiting on transitive dependencies.
@ Emitted
Assigned address, still materializing.
@ Resolved
Queried, materialization begun.
DenseMap< JITDylib *, SymbolNameSet > SymbolDependenceMap
A map from JITDylibs to sets of symbols.
Expected< SymbolAliasMap > buildSimpleReexportsAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols)
Build a SymbolAliasMap for the common case where you want to re-export symbols from another JITDylib ...
This is an optimization pass for GlobalISel generic memory operations.
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
void sort(IteratorTy Start, IteratorTy End)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Implement std::hash so that hash_code can be used in STL containers.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Function object to check whether the first component of a container supported by std::get (like std::...
SymbolFlagsMap SymbolFlags
SymbolStringPtr InitSymbol
Interface(SymbolFlagsMap InitalSymbolFlags, SymbolStringPtr InitSymbol)
SymbolAliasMapEntry()=default
JITSymbolFlags AliasFlags
SymbolAliasMapEntry(SymbolStringPtr Aliasee, JITSymbolFlags AliasFlags)