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;
441 :
public ErrorInfo<UnsatisfiedSymbolDependencies> {
448 std::string Explanation);
453 std::shared_ptr<SymbolStringPool> SSP;
457 std::string Explanation;
474 std::shared_ptr<SymbolStringPool> SSP;
491 std::shared_ptr<SymbolStringPool> SSP;
513 std::shared_ptr<SymbolStringPool> SSP;
536 std::shared_ptr<SymbolStringPool> SSP;
572 return RT->withResourceKeyDo(std::forward<Func>(
F));
674 : JD(RT->getJITDylib()), RT(
std::
move(RT)),
675 SymbolFlags(
std::
move(SymbolFlags)), InitSymbol(
std::
move(InitSymbol)) {
676 assert(!this->SymbolFlags.
empty() &&
"Materializing nothing?");
682 SymbolStringPtr InitSymbol;
706 "If set, InitSymbol should appear in InitialSymbolFlags map");
732 materialize(std::unique_ptr<MaterializationResponsibility> R) = 0;
740 dbgs() <<
"In " <<
getName() <<
": discarding init symbol \""
745 discard(JD, std::move(
Name));
753 virtual void anchor();
773 void materialize(std::unique_ptr<MaterializationResponsibility> R)
override;
790inline std::unique_ptr<AbsoluteSymbolsMaterializationUnit>
792 return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
815 void materialize(std::unique_ptr<MaterializationResponsibility> R)
override;
836inline std::unique_ptr<ReExportsMaterializationUnit>
838 return std::make_unique<ReExportsMaterializationUnit>(
845inline std::unique_ptr<ReExportsMaterializationUnit>
849 return std::make_unique<ReExportsMaterializationUnit>(
850 &SourceJD, SourceJDLookupFlags, std::move(Aliases));
893 bool isComplete()
const {
return OutstandingSymbolsCount == 0; }
899 SymbolState getRequiredState() {
return RequiredState; }
901 void addQueryDependence(
JITDylib &JD, SymbolStringPtr
Name);
903 void removeQueryDependence(
JITDylib &JD,
const SymbolStringPtr &
Name);
905 void dropSymbol(
const SymbolStringPtr &
Name);
907 void handleFailed(
Error Err);
914 size_t OutstandingSymbolsCount;
936 LookupState(std::unique_ptr<InProgressLookupState> IPLS);
941 std::unique_ptr<InProgressLookupState> IPLS;
965 std::deque<LookupState> PendingLookups;
1048 template <
typename GeneratorT>
1049 GeneratorT &
addGenerator(std::unique_ptr<GeneratorT> DefGenerator);
1082 bool LinkAgainstThisJITDylibFirst =
true);
1118 template <
typename Func>
1120 ->
decltype(
F(std::declval<const JITDylibSearchOrder &>()));
1132 template <
typename MaterializationUnitType>
1133 Error define(std::unique_ptr<MaterializationUnitType> &&MU,
1146 template <
typename MaterializationUnitType>
1147 Error define(std::unique_ptr<MaterializationUnitType> &MU,
1198 using AsynchronousSymbolQuerySet =
1199 std::set<std::shared_ptr<AsynchronousSymbolQuery>>;
1201 using AsynchronousSymbolQueryList =
1202 std::vector<std::shared_ptr<AsynchronousSymbolQuery>>;
1204 struct UnmaterializedInfo {
1205 UnmaterializedInfo(std::unique_ptr<MaterializationUnit> MU,
1207 : MU(
std::
move(MU)), RT(RT) {}
1209 std::unique_ptr<MaterializationUnit> MU;
1210 ResourceTracker *RT;
1213 using UnmaterializedInfosMap =
1214 DenseMap<SymbolStringPtr, std::shared_ptr<UnmaterializedInfo>>;
1216 using UnmaterializedInfosList =
1217 std::vector<std::shared_ptr<UnmaterializedInfo>>;
1219 struct EmissionDepUnit {
1220 EmissionDepUnit(JITDylib &JD) : JD(&JD) {}
1222 JITDylib *JD =
nullptr;
1223 DenseMap<NonOwningSymbolStringPtr, JITSymbolFlags> Symbols;
1224 DenseMap<JITDylib *, DenseSet<NonOwningSymbolStringPtr>> Dependencies;
1227 struct EmissionDepUnitInfo {
1228 std::shared_ptr<EmissionDepUnit> EDU;
1229 DenseSet<EmissionDepUnit *> IntraEmitUsers;
1230 DenseMap<JITDylib *, DenseSet<NonOwningSymbolStringPtr>> NewDeps;
1239 struct MaterializingInfo {
1240 std::shared_ptr<EmissionDepUnit> DefiningEDU;
1241 DenseSet<EmissionDepUnit *> DependantEDUs;
1243 void addQuery(std::shared_ptr<AsynchronousSymbolQuery> Q);
1245 AsynchronousSymbolQueryList takeQueriesMeeting(
SymbolState RequiredState);
1246 AsynchronousSymbolQueryList takeAllPendingQueries() {
1247 return std::move(PendingQueries);
1249 bool hasQueriesPending()
const {
return !PendingQueries.empty(); }
1250 const AsynchronousSymbolQueryList &pendingQueries()
const {
1251 return PendingQueries;
1254 AsynchronousSymbolQueryList PendingQueries;
1257 using MaterializingInfosMap = DenseMap<SymbolStringPtr, MaterializingInfo>;
1259 class SymbolTableEntry {
1261 SymbolTableEntry() =
default;
1262 SymbolTableEntry(JITSymbolFlags Flags)
1264 MaterializerAttached(
false) {}
1266 ExecutorAddr getAddress()
const {
return Addr; }
1267 JITSymbolFlags getFlags()
const {
return Flags; }
1270 bool hasMaterializerAttached()
const {
return MaterializerAttached; }
1272 void setAddress(ExecutorAddr Addr) { this->Addr =
Addr; }
1273 void setFlags(JITSymbolFlags Flags) { this->Flags =
Flags; }
1275 assert(
static_cast<uint8_t
>(State) < (1 << 6) &&
1276 "State does not fit in bitfield");
1277 this->State =
static_cast<uint8_t
>(State);
1280 void setMaterializerAttached(
bool MaterializerAttached) {
1281 this->MaterializerAttached = MaterializerAttached;
1284 ExecutorSymbolDef getSymbol()
const {
return {
Addr,
Flags}; }
1288 JITSymbolFlags
Flags;
1290 uint8_t MaterializerAttached : 1;
1293 using SymbolTable = DenseMap<SymbolStringPtr, SymbolTableEntry>;
1297 std::pair<AsynchronousSymbolQuerySet, std::shared_ptr<SymbolDependenceMap>>
1298 removeTracker(ResourceTracker &RT);
1300 void transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT);
1302 Error defineImpl(MaterializationUnit &MU);
1304 void installMaterializationUnit(std::unique_ptr<MaterializationUnit> MU,
1305 ResourceTracker &RT);
1310 void transferEmittedNodeDependencies(MaterializingInfo &DependantMI,
1311 const SymbolStringPtr &DependantName,
1312 MaterializingInfo &EmittedMI);
1314 Expected<SymbolFlagsMap>
1319 std::unique_ptr<MaterializationUnit> MU);
1321 Expected<std::unique_ptr<MaterializationResponsibility>>
1323 SymbolStringPtr InitSymbol);
1327 void addDependencies(
const SymbolStringPtr &Name,
1335 enum { Open, Closing, Closed } State = Open;
1336 std::mutex GeneratorsMutex;
1337 SymbolTable Symbols;
1338 UnmaterializedInfosMap UnmaterializedInfos;
1339 MaterializingInfosMap MaterializingInfos;
1340 std::vector<std::shared_ptr<DefinitionGenerator>> DefGenerators;
1345 DenseMap<ResourceTracker *, SymbolNameVector> TrackerSymbols;
1346 DenseMap<ResourceTracker *, DenseSet<MaterializationResponsibility *>>
1399 std::unique_ptr<MaterializationResponsibility> MR)
1402 void run()
override;
1405 std::unique_ptr<MaterializationUnit> MU;
1406 std::unique_ptr<MaterializationResponsibility> MR;
1418 void run()
override;
1447 const char *ArgData,
size_t ArgSize)>;
1478 return EPC->getSymbolStringPool();
1493 std::lock_guard<std::recursive_mutex> Lock(SessionMutex);
1556 this->ReportError = std::move(ReportError);
1567 this->DispatchTask = std::move(DispatchTask);
1643 assert(
T &&
"T must be non-null");
1645 DispatchTask(std::move(
T));
1657 template <
typename... ArgTs>
1659 EPC->callWrapperAsync(std::forward<ArgTs>(Args)...);
1670 return EPC->callWrapper(WrapperFnAddr, ArgBuffer);
1675 template <
typename SPSSignature,
typename SendResultT,
typename... ArgTs>
1677 const ArgTs &...Args) {
1678 EPC->callSPSWrapperAsync<SPSSignature, SendResultT, ArgTs...>(
1679 WrapperFnAddr, std::forward<SendResultT>(SendResult), Args...);
1687 template <
typename SPSSignature,
typename... WrapperCallArgTs>
1689 WrapperCallArgTs &&...WrapperCallArgs) {
1690 return EPC->callSPSWrapper<SPSSignature, WrapperCallArgTs...>(
1691 WrapperFnAddr, std::forward<WrapperCallArgTs>(WrapperCallArgs)...);
1701 template <
typename SPSSignature,
typename HandlerT>
1703 return [
H = std::forward<HandlerT>(
H)](
1705 const char *ArgData,
size_t ArgSize)
mutable {
1707 std::move(SendResult));
1718 template <
typename SPSSignature,
typename ClassT,
typename... MethodArgTs>
1721 return wrapAsyncWithSPS<SPSSignature>(
1722 [Instance, Method](MethodArgTs &&...MethodArgs) {
1723 (Instance->*Method)(std::forward<MethodArgTs>(MethodArgs)...);
1750 static void logErrorsToStdErr(
Error Err) {
1754 static void runOnCurrentThread(std::unique_ptr<Task>
T) {
T->run(); }
1756 void dispatchOutstandingMUs();
1758 static std::unique_ptr<MaterializationResponsibility>
1761 SymbolStringPtr InitSymbol) {
1762 auto &JD = RT.getJITDylib();
1763 std::unique_ptr<MaterializationResponsibility> MR(
1765 std::move(InitSymbol)));
1766 JD.TrackerMRs[&RT].insert(MR.get());
1780 SymbolLookupSet &Candidates,
1781 SymbolLookupSet *NonCandidates);
1784 void OL_resumeLookupAfterGeneration(InProgressLookupState &IPLS);
1789 void OL_applyQueryPhase1(std::unique_ptr<InProgressLookupState> IPLS,
1796 void OL_completeLookup(std::unique_ptr<InProgressLookupState> IPLS,
1797 std::shared_ptr<AsynchronousSymbolQuery> Q,
1802 void OL_completeLookupFlags(
1803 std::unique_ptr<InProgressLookupState> IPLS,
1804 unique_function<
void(Expected<SymbolFlagsMap>)> OnComplete);
1807 void OL_destroyMaterializationResponsibility(
1814 DenseMap<JITDylib::EmissionDepUnit *, JITDylib::EmissionDepUnitInfo>;
1816 template <
typename HandleNewDepFn>
1817 void propagateExtraEmitDeps(std::deque<JITDylib::EmissionDepUnit *> Worklist,
1818 EDUInfosMap &EDUInfos,
1819 HandleNewDepFn HandleNewDep);
1821 ArrayRef<SymbolDependenceGroup> EmittedDeps);
1822 void IL_makeEDUReady(std::shared_ptr<JITDylib::EmissionDepUnit> EDU,
1823 JITDylib::AsynchronousSymbolQuerySet &Queries);
1824 void IL_makeEDUEmitted(std::shared_ptr<JITDylib::EmissionDepUnit> EDU,
1825 JITDylib::AsynchronousSymbolQuerySet &Queries);
1826 bool IL_removeEDUDependence(JITDylib::EmissionDepUnit &EDU,
JITDylib &DepJD,
1827 NonOwningSymbolStringPtr DepSym,
1828 EDUInfosMap &EDUInfos);
1830 static Error makeJDClosedError(JITDylib::EmissionDepUnit &EDU,
1832 static Error makeUnsatisfiedDepsError(JITDylib::EmissionDepUnit &EDU,
1835 Expected<JITDylib::AsynchronousSymbolQuerySet>
1838 ArrayRef<SymbolDependenceGroup> EmittedDeps);
1843 std::pair<JITDylib::AsynchronousSymbolQuerySet,
1844 std::shared_ptr<SymbolDependenceMap>>
1848 std::unique_ptr<MaterializationUnit> MU);
1849 Expected<std::unique_ptr<MaterializationResponsibility>>
1853 void dumpDispatchInfo(Task &
T);
1856 mutable std::recursive_mutex SessionMutex;
1857 bool SessionOpen =
true;
1858 std::unique_ptr<ExecutorProcessControl> EPC;
1859 std::unique_ptr<Platform>
P;
1863 std::vector<ResourceManager *> ResourceManagers;
1865 std::vector<JITDylibSP> JDs;
1869 mutable std::recursive_mutex OutstandingMUsMutex;
1870 std::vector<std::pair<std::unique_ptr<MaterializationUnit>,
1871 std::unique_ptr<MaterializationResponsibility>>>
1874 mutable std::mutex JITDispatchHandlersMutex;
1875 DenseMap<ExecutorAddr, std::shared_ptr<JITDispatchHandlerFunction>>
1876 JITDispatchHandlers;
1882 return make_error<ResourceTrackerDefunct>(
this);
1893template <
typename GeneratorT>
1895 auto &
G = *DefGenerator;
1897 assert(State == Open &&
"Cannot add generator to closed JITDylib");
1898 DefGenerators.push_back(std::move(DefGenerator));
1903template <
typename Func>
1905 ->
decltype(
F(std::declval<const JITDylibSearchOrder &>())) {
1906 assert(State == Open &&
"Cannot use link order of closed JITDylib");
1907 return ES.runSessionLocked([&]() {
return F(LinkOrder); });
1910template <
typename MaterializationUnitType>
1913 assert(MU &&
"Can not define with a null MU");
1915 if (MU->getSymbols().empty()) {
1918 dbgs() <<
"Warning: Discarding empty MU " << MU->getName() <<
" for "
1924 dbgs() <<
"Defining MU " << MU->getName() <<
" for " <<
getName()
1927 dbgs() <<
"default)";
1931 dbgs() <<
"0x0, default will be used)\n";
1935 assert(State == Open &&
"JD is defunct");
1937 if (
auto Err = defineImpl(*MU))
1944 if (
auto Err =
P->notifyAdding(*RT, *MU))
1948 installMaterializationUnit(std::move(MU), *RT);
1953template <
typename MaterializationUnitType>
1956 assert(MU &&
"Can not define with a null MU");
1958 if (MU->getSymbols().empty()) {
1961 dbgs() <<
"Warning: Discarding empty MU " << MU->getName() <<
getName()
1967 dbgs() <<
"Defining MU " << MU->getName() <<
" for " <<
getName()
1970 dbgs() <<
"default)";
1974 dbgs() <<
"0x0, default will be used)\n";
1978 assert(State == Open &&
"JD is defunct");
1980 if (
auto Err = defineImpl(*MU))
1987 if (
auto Err =
P->notifyAdding(*RT, *MU))
1991 installMaterializationUnit(std::move(MU), *RT);
2044 std::move(SymbolFlags));
2052 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.
~MaterializationResponsibility()
Destruct a MaterializationResponsibility instance.
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
Error notifyEmitted(ArrayRef< SymbolDependenceGroup > DepGroups)
Notifies the target JITDylib (and any pending queries on that JITDylib) that all symbols covered by t...
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
Used to report failure due to unsatisfiable symbol dependencies.
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.
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)
A set of symbols and the their dependencies.
SymbolDependenceMap Dependencies