12#include "llvm/Config/llvm-config.h"
18#include <condition_variable>
22#define DEBUG_TYPE "orc"
40void MaterializationUnit::anchor() {}
43 assert((
reinterpret_cast<uintptr_t
>(JD.get()) & 0x1) == 0 &&
44 "JITDylib must be two byte aligned");
46 JDAndFlag.store(
reinterpret_cast<uintptr_t
>(JD.get()));
62void ResourceTracker::makeDefunct() {
63 uintptr_t Val = JDAndFlag.load();
78 OS <<
"Resource tracker " << (
void *)RT.
get() <<
" became defunct";
82 std::shared_ptr<SymbolStringPool> SSP,
83 std::shared_ptr<SymbolDependenceMap> Symbols)
85 assert(this->SSP &&
"String pool cannot be null");
86 assert(!this->Symbols->empty() &&
"Can not fail to resolve an empty set");
90 for (
auto &[JD, Syms] : *this->Symbols)
95 for (
auto &[JD, Syms] : *Symbols)
104 OS <<
"Failed to materialize symbols: " << *Symbols;
108 std::shared_ptr<SymbolStringPool> SSP,
JITDylibSP JD,
110 std::string Explanation)
112 FailedSymbols(
std::
move(FailedSymbols)), BadDeps(
std::
move(BadDeps)),
113 Explanation(
std::
move(Explanation)) {}
120 OS <<
"In " << JD->getName() <<
", failed to materialize " << FailedSymbols
121 <<
", due to unsatisfied dependencies " << BadDeps;
122 if (!Explanation.empty())
123 OS <<
" (" << Explanation <<
")";
129 for (
auto &
Sym : Symbols)
130 this->Symbols.push_back(
Sym);
131 assert(!this->Symbols.
empty() &&
"Can not fail to resolve an empty set");
137 assert(!this->Symbols.empty() &&
"Can not fail to resolve an empty set");
145 OS <<
"Symbols not found: " << Symbols;
149 std::shared_ptr<SymbolStringPool> SSP,
SymbolNameSet Symbols)
151 assert(!this->Symbols.
empty() &&
"Can not fail to resolve an empty set");
159 OS <<
"Symbols could not be removed: " << Symbols;
183 : NotifyComplete(
std::
move(NotifyComplete)), RequiredState(RequiredState) {
185 "Cannot query for a symbols that have not reached the resolve state "
188 OutstandingSymbolsCount = Symbols.size();
190 for (
auto &[
Name, Flags] : Symbols)
198 "Resolving symbol outside the requested set");
200 "Redundantly resolving symbol Name");
204 if (
Sym.getFlags().hasMaterializationSideEffectsOnly())
207 I->second = std::move(
Sym);
208 --OutstandingSymbolsCount;
212 assert(OutstandingSymbolsCount == 0 &&
213 "Symbols remain, handleComplete called prematurely");
215 class RunQueryCompleteTask :
public Task {
217 RunQueryCompleteTask(
SymbolMap ResolvedSymbols,
219 : ResolvedSymbols(
std::
move(ResolvedSymbols)),
220 NotifyComplete(
std::
move(NotifyComplete)) {}
222 OS <<
"Execute query complete callback for " << ResolvedSymbols;
224 void run()
override { NotifyComplete(std::move(ResolvedSymbols)); }
231 auto T = std::make_unique<RunQueryCompleteTask>(std::move(ResolvedSymbols),
232 std::move(NotifyComplete));
237void AsynchronousSymbolQuery::handleFailed(Error Err) {
239 OutstandingSymbolsCount == 0 &&
240 "Query should already have been abandoned");
241 NotifyComplete(std::move(Err));
245void AsynchronousSymbolQuery::addQueryDependence(JITDylib &JD,
246 SymbolStringPtr
Name) {
249 assert(Added &&
"Duplicate dependence notification?");
252void AsynchronousSymbolQuery::removeQueryDependence(
253 JITDylib &JD,
const SymbolStringPtr &
Name) {
254 auto QRI = QueryRegistrations.
find(&JD);
255 assert(QRI != QueryRegistrations.
end() &&
256 "No dependencies registered for JD");
257 assert(QRI->second.count(
Name) &&
"No dependency on Name in JD");
258 QRI->second.erase(
Name);
259 if (QRI->second.empty())
260 QueryRegistrations.
erase(QRI);
263void AsynchronousSymbolQuery::dropSymbol(
const SymbolStringPtr &
Name) {
266 "Redundant removal of weakly-referenced symbol");
268 --OutstandingSymbolsCount;
271void AsynchronousSymbolQuery::detach() {
272 ResolvedSymbols.
clear();
273 OutstandingSymbolsCount = 0;
274 for (
auto &[JD, Syms] : QueryRegistrations)
275 JD->detachQueryHelper(*
this, Syms);
276 QueryRegistrations.clear();
284 return "<Absolute Symbols>";
287void AbsoluteSymbolsMaterializationUnit::materialize(
288 std::unique_ptr<MaterializationResponsibility> R) {
294 if (
auto Err = R->notifyResolved(Symbols)) {
295 R->getExecutionSession().reportError(std::move(Err));
296 R->failMaterialization();
299 if (
auto Err = R->notifyEmitted({})) {
300 R->getExecutionSession().reportError(std::move(Err));
301 R->failMaterialization();
306void AbsoluteSymbolsMaterializationUnit::discard(
const JITDylib &JD,
307 const SymbolStringPtr &
Name) {
312MaterializationUnit::Interface
313AbsoluteSymbolsMaterializationUnit::extractFlags(
const SymbolMap &Symbols) {
315 for (
const auto &[
Name, Def] : Symbols)
317 return MaterializationUnit::Interface(std::move(Flags),
nullptr);
324 SourceJDLookupFlags(SourceJDLookupFlags), Aliases(
std::
move(Aliases)) {}
327 return "<Reexports>";
330void ReExportsMaterializationUnit::materialize(
331 std::unique_ptr<MaterializationResponsibility> R) {
333 auto &ES = R->getTargetJITDylib().getExecutionSession();
334 JITDylib &TgtJD = R->getTargetJITDylib();
335 JITDylib &SrcJD = SourceJD ? *SourceJD : TgtJD;
340 auto RequestedSymbols = R->getRequestedSymbols();
343 for (
auto &
Name : RequestedSymbols) {
345 assert(
I != Aliases.
end() &&
"Symbol not found in aliases map?");
346 RequestedAliases[
Name] = std::move(
I->second);
352 dbgs() <<
"materializing reexports: target = " << TgtJD.
getName()
353 <<
", source = " << SrcJD.
getName() <<
" " << RequestedAliases
358 if (!Aliases.
empty()) {
359 auto Err = SourceJD ?
R->replace(
reexports(*SourceJD, std::move(Aliases),
360 SourceJDLookupFlags))
367 R->failMaterialization();
374 struct OnResolveInfo {
375 OnResolveInfo(std::unique_ptr<MaterializationResponsibility> R,
376 SymbolAliasMap Aliases)
379 std::unique_ptr<MaterializationResponsibility>
R;
381 std::vector<SymbolDependenceGroup> SDGs;
392 std::vector<std::pair<SymbolLookupSet, std::shared_ptr<OnResolveInfo>>>
394 while (!RequestedAliases.
empty()) {
396 SymbolLookupSet QuerySymbols;
400 for (
auto &KV : RequestedAliases) {
402 if (&SrcJD == &TgtJD && (QueryAliases.count(KV.second.Aliasee) ||
403 RequestedAliases.count(KV.second.Aliasee)))
406 ResponsibilitySymbols.
insert(KV.first);
407 QuerySymbols.add(KV.second.Aliasee,
408 KV.second.AliasFlags.hasMaterializationSideEffectsOnly()
411 QueryAliases[KV.first] = std::move(KV.second);
415 for (
auto &KV : QueryAliases)
416 RequestedAliases.erase(KV.first);
418 assert(!QuerySymbols.empty() &&
"Alias cycle detected!");
420 auto NewR =
R->delegate(ResponsibilitySymbols);
423 R->failMaterialization();
427 auto QueryInfo = std::make_shared<OnResolveInfo>(std::move(*NewR),
428 std::move(QueryAliases));
429 QueryInfos.push_back(
430 make_pair(std::move(QuerySymbols), std::move(QueryInfo)));
434 while (!QueryInfos.empty()) {
435 auto QuerySymbols = std::move(QueryInfos.back().first);
436 auto QueryInfo = std::move(QueryInfos.back().second);
438 QueryInfos.pop_back();
440 auto RegisterDependencies = [QueryInfo,
447 assert(Deps.size() == 1 && Deps.count(&SrcJD) &&
448 "Unexpected dependencies for reexports");
450 auto &SrcJDDeps = Deps.find(&SrcJD)->second;
452 for (
auto &[Alias, AliasInfo] : QueryInfo->Aliases)
453 if (SrcJDDeps.count(AliasInfo.Aliasee))
454 QueryInfo->SDGs.push_back({{Alias}, {{&SrcJD, {AliasInfo.Aliasee}}}});
457 auto OnComplete = [QueryInfo](Expected<SymbolMap>
Result) {
458 auto &ES = QueryInfo->R->getTargetJITDylib().getExecutionSession();
461 for (
auto &KV : QueryInfo->Aliases) {
462 assert((KV.second.AliasFlags.hasMaterializationSideEffectsOnly() ||
463 Result->count(KV.second.Aliasee)) &&
464 "Result map missing entry?");
466 if (KV.second.AliasFlags.hasMaterializationSideEffectsOnly())
469 ResolutionMap[KV.first] = {(*Result)[KV.second.Aliasee].getAddress(),
470 KV.second.AliasFlags};
472 if (
auto Err = QueryInfo->R->notifyResolved(ResolutionMap)) {
474 QueryInfo->R->failMaterialization();
477 if (
auto Err = QueryInfo->R->notifyEmitted(QueryInfo->SDGs)) {
479 QueryInfo->R->failMaterialization();
484 QueryInfo->R->failMaterialization();
491 std::move(RegisterDependencies));
495void ReExportsMaterializationUnit::discard(
const JITDylib &JD,
496 const SymbolStringPtr &
Name) {
498 "Symbol not covered by this MaterializationUnit");
502MaterializationUnit::Interface
503ReExportsMaterializationUnit::extractFlags(
const SymbolAliasMap &Aliases) {
505 for (
auto &KV : Aliases)
508 return MaterializationUnit::Interface(std::move(
SymbolFlags),
nullptr);
519 return Flags.takeError();
522 for (
auto &
Name : Symbols) {
523 assert(Flags->count(
Name) &&
"Missing entry in flags map");
542 virtual void complete(std::unique_ptr<InProgressLookupState> IPLS) = 0;
570 OnComplete(
std::
move(OnComplete)) {}
572 void complete(std::unique_ptr<InProgressLookupState> IPLS)
override {
573 auto &ES =
SearchOrder.front().first->getExecutionSession();
574 ES.OL_completeLookupFlags(std::move(IPLS), std::move(OnComplete));
577 void fail(
Error Err)
override { OnComplete(std::move(Err)); }
588 std::shared_ptr<AsynchronousSymbolQuery> Q,
592 Q(
std::
move(Q)), RegisterDependencies(
std::
move(RegisterDependencies)) {
595 void complete(std::unique_ptr<InProgressLookupState> IPLS)
override {
596 auto &ES =
SearchOrder.front().first->getExecutionSession();
597 ES.OL_completeLookup(std::move(IPLS), std::move(Q),
598 std::move(RegisterDependencies));
603 Q->handleFailed(std::move(Err));
607 std::shared_ptr<AsynchronousSymbolQuery> Q;
614 : SourceJD(SourceJD), SourceJDLookupFlags(SourceJDLookupFlags),
621 assert(&JD != &SourceJD &&
"Cannot re-export from the same dylib");
625 K, {{&SourceJD, JDLookupFlags}}, LookupSet);
627 return Flags.takeError();
631 for (
auto &KV : *Flags)
632 if (!Allow || Allow(KV.first))
635 if (AliasMap.empty())
645void LookupState::reset(InProgressLookupState *IPLS) { this->IPLS.reset(IPLS); }
653 assert(IPLS &&
"Cannot call continueLookup on empty LookupState");
654 auto &ES = IPLS->SearchOrder.begin()->first->getExecutionSession();
655 ES.OL_applyQueryPhase1(std::move(IPLS), std::move(Err));
659 std::deque<LookupState> LookupsToFail;
661 std::lock_guard<std::mutex> Lock(M);
662 std::swap(PendingLookups, LookupsToFail);
666 for (
auto &LS : LookupsToFail)
667 LS.continueLookup(make_error<StringError>(
668 "Query waiting on DefinitionGenerator that was destroyed",
677 std::vector<ResourceTrackerSP> TrackersToRemove;
679 assert(State != Closed &&
"JD is defunct");
680 for (
auto &KV : TrackerSymbols)
681 TrackersToRemove.push_back(KV.first);
686 for (
auto &RT : TrackersToRemove)
687 Err =
joinErrors(std::move(Err), RT->remove());
693 assert(State != Closed &&
"JD is defunct");
696 return DefaultTracker;
702 assert(State == Open &&
"JD is defunct");
711 std::shared_ptr<DefinitionGenerator> TmpDG;
714 assert(State == Open &&
"JD is defunct");
716 [&](
const std::shared_ptr<DefinitionGenerator> &
H) {
717 return H.get() == &
G;
719 assert(
I != DefGenerators.end() &&
"Generator not found");
720 TmpDG = std::move(*
I);
721 DefGenerators.erase(
I);
730 if (FromMR.RT->isDefunct())
731 return make_error<ResourceTrackerDefunct>(FromMR.RT);
733 std::vector<NonOwningSymbolStringPtr> AddedSyms;
734 std::vector<NonOwningSymbolStringPtr> RejectedWeakDefs;
736 for (
auto SFItr = SymbolFlags.begin(), SFEnd = SymbolFlags.end();
737 SFItr != SFEnd; ++SFItr) {
739 auto &Name = SFItr->first;
740 auto &Flags = SFItr->second;
742 auto EntryItr = Symbols.find(Name);
745 if (EntryItr != Symbols.end()) {
748 if (!Flags.isWeak()) {
750 for (auto &S : AddedSyms)
751 Symbols.erase(Symbols.find_as(S));
754 return make_error<DuplicateDefinition>(std::string(*Name));
758 RejectedWeakDefs.push_back(NonOwningSymbolStringPtr(Name));
769 while (!RejectedWeakDefs.empty()) {
770 SymbolFlags.erase(SymbolFlags.find_as(RejectedWeakDefs.back()));
771 RejectedWeakDefs.pop_back();
778Error JITDylib::replace(MaterializationResponsibility &FromMR,
779 std::unique_ptr<MaterializationUnit> MU) {
780 assert(MU !=
nullptr &&
"Can not replace with a null MaterializationUnit");
781 std::unique_ptr<MaterializationUnit> MustRunMU;
782 std::unique_ptr<MaterializationResponsibility> MustRunMR;
786 if (FromMR.RT->isDefunct())
787 return make_error<ResourceTrackerDefunct>(std::move(FromMR.RT));
790 for (
auto &KV : MU->getSymbols()) {
791 auto SymI = Symbols.find(KV.first);
792 assert(SymI != Symbols.end() &&
"Replacing unknown symbol");
793 assert(SymI->second.getState() == SymbolState::Materializing &&
794 "Can not replace a symbol that ha is not materializing");
795 assert(!SymI->second.hasMaterializerAttached() &&
796 "Symbol should not have materializer attached already");
797 assert(UnmaterializedInfos.count(KV.first) == 0 &&
798 "Symbol being replaced should have no UnmaterializedInfo");
806 for (
auto &KV : MU->getSymbols()) {
807 auto MII = MaterializingInfos.find(KV.first);
808 if (MII != MaterializingInfos.end()) {
809 if (MII->second.hasQueriesPending()) {
810 MustRunMR = ES.createMaterializationResponsibility(
811 *FromMR.RT, std::move(MU->SymbolFlags),
812 std::move(MU->InitSymbol));
813 MustRunMU = std::move(MU);
814 return Error::success();
820 auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU),
822 for (
auto &KV : UMI->MU->getSymbols()) {
823 auto SymI = Symbols.find(KV.first);
824 assert(SymI->second.getState() == SymbolState::Materializing &&
825 "Can not replace a symbol that is not materializing");
826 assert(!SymI->second.hasMaterializerAttached() &&
827 "Can not replace a symbol that has a materializer attached");
828 assert(UnmaterializedInfos.count(KV.first) == 0 &&
829 "Unexpected materializer entry in map");
830 SymI->second.setAddress(SymI->second.getAddress());
831 SymI->second.setMaterializerAttached(
true);
833 auto &UMIEntry = UnmaterializedInfos[KV.first];
834 assert((!UMIEntry || !UMIEntry->MU) &&
835 "Replacing symbol with materializer still attached");
846 assert(MustRunMR &&
"MustRunMU set implies MustRunMR set");
848 std::move(MustRunMU), std::move(MustRunMR)));
850 assert(!MustRunMR &&
"MustRunMU unset implies MustRunMR unset");
856Expected<std::unique_ptr<MaterializationResponsibility>>
857JITDylib::delegate(MaterializationResponsibility &FromMR,
858 SymbolFlagsMap SymbolFlags, SymbolStringPtr InitSymbol) {
861 [&]() -> Expected<std::unique_ptr<MaterializationResponsibility>> {
862 if (FromMR.RT->isDefunct())
863 return make_error<ResourceTrackerDefunct>(std::move(FromMR.RT));
865 return ES.createMaterializationResponsibility(
866 *FromMR.RT, std::move(SymbolFlags), std::move(InitSymbol));
871JITDylib::getRequestedSymbols(
const SymbolFlagsMap &SymbolFlags)
const {
875 for (
auto &KV : SymbolFlags) {
876 assert(Symbols.count(KV.first) &&
"JITDylib does not cover this symbol?");
877 assert(Symbols.find(KV.first)->second.getState() !=
878 SymbolState::NeverSearched &&
879 Symbols.find(KV.first)->second.getState() != SymbolState::Ready &&
880 "getRequestedSymbols can only be called for symbols that have "
881 "started materializing");
882 auto I = MaterializingInfos.find(KV.first);
883 if (
I == MaterializingInfos.end())
886 if (
I->second.hasQueriesPending())
887 RequestedSymbols.insert(KV.first);
890 return RequestedSymbols;
894Error JITDylib::resolve(MaterializationResponsibility &MR,
895 const SymbolMap &Resolved) {
896 AsynchronousSymbolQuerySet CompletedQueries;
899 if (MR.RT->isDefunct())
900 return make_error<ResourceTrackerDefunct>(MR.RT);
903 return make_error<StringError>(
"JITDylib " + getName() +
905 inconvertibleErrorCode());
907 struct WorklistEntry {
908 SymbolTable::iterator SymI;
909 ExecutorSymbolDef ResolvedSym;
912 SymbolNameSet SymbolsInErrorState;
913 std::vector<WorklistEntry> Worklist;
917 for (
const auto &KV : Resolved) {
919 assert(!KV.second.getFlags().hasError() &&
920 "Resolution result can not have error flag set");
922 auto SymI = Symbols.find(KV.first);
924 assert(SymI != Symbols.end() &&
"Symbol not found");
925 assert(!SymI->second.hasMaterializerAttached() &&
926 "Resolving symbol with materializer attached?");
927 assert(SymI->second.getState() == SymbolState::Materializing &&
928 "Symbol should be materializing");
929 assert(SymI->second.getAddress() == ExecutorAddr() &&
930 "Symbol has already been resolved");
932 if (SymI->second.getFlags().hasError())
933 SymbolsInErrorState.insert(KV.first);
935 auto Flags = KV.second.getFlags();
936 Flags &= ~JITSymbolFlags::Common;
938 (SymI->second.getFlags() & ~JITSymbolFlags::Common) &&
939 "Resolved flags should match the declared flags");
941 Worklist.push_back({SymI, {KV.second.getAddress(), Flags}});
946 if (!SymbolsInErrorState.empty()) {
947 auto FailedSymbolsDepMap = std::make_shared<SymbolDependenceMap>();
948 (*FailedSymbolsDepMap)[
this] = std::move(SymbolsInErrorState);
949 return make_error<FailedToMaterialize>(
950 getExecutionSession().getSymbolStringPool(),
951 std::move(FailedSymbolsDepMap));
954 while (!Worklist.empty()) {
955 auto SymI = Worklist.back().SymI;
956 auto ResolvedSym = Worklist.back().ResolvedSym;
959 auto &
Name = SymI->first;
962 JITSymbolFlags ResolvedFlags = ResolvedSym.getFlags();
963 SymI->second.setAddress(ResolvedSym.getAddress());
964 SymI->second.setFlags(ResolvedFlags);
965 SymI->second.setState(SymbolState::Resolved);
967 auto MII = MaterializingInfos.find(
Name);
968 if (MII == MaterializingInfos.end())
971 auto &
MI = MII->second;
972 for (
auto &Q :
MI.takeQueriesMeeting(SymbolState::Resolved)) {
973 Q->notifySymbolMetRequiredState(
Name, ResolvedSym);
974 Q->removeQueryDependence(*
this,
Name);
976 CompletedQueries.insert(std::move(Q));
980 return Error::success();
985 for (
auto &Q : CompletedQueries) {
986 assert(Q->isComplete() &&
"Q not completed");
987 Q->handleComplete(ES);
990 return Error::success();
993void JITDylib::unlinkMaterializationResponsibility(
994 MaterializationResponsibility &MR) {
996 auto I = TrackerMRs.find(MR.RT.get());
997 assert(
I != TrackerMRs.end() &&
"No MRs in TrackerMRs list for RT");
998 assert(
I->second.count(&MR) &&
"MR not in TrackerMRs list for RT");
999 I->second.erase(&MR);
1000 if (
I->second.empty())
1001 TrackerMRs.erase(MR.RT.get());
1005void JITDylib::shrinkMaterializationInfoMemory() {
1009 if (UnmaterializedInfos.empty())
1010 UnmaterializedInfos.clear();
1012 if (MaterializingInfos.empty())
1013 MaterializingInfos.clear();
1017 bool LinkAgainstThisJITDylibFirst) {
1019 assert(State == Open &&
"JD is defunct");
1020 if (LinkAgainstThisJITDylibFirst) {
1022 if (NewLinkOrder.empty() || NewLinkOrder.front().first !=
this)
1023 LinkOrder.push_back(
1024 std::make_pair(
this, JITDylibLookupFlags::MatchAllSymbols));
1027 LinkOrder = std::move(NewLinkOrder);
1033 for (
auto &KV : NewLinks) {
1038 LinkOrder.push_back(std::move(KV));
1050 assert(State == Open &&
"JD is defunct");
1051 for (
auto &KV : LinkOrder)
1052 if (KV.first == &OldJD) {
1053 KV = {&NewJD, JDLookupFlags};
1061 assert(State == Open &&
"JD is defunct");
1063 [&](
const JITDylibSearchOrder::value_type &KV) {
1064 return KV.first == &JD;
1066 if (
I != LinkOrder.end())
1073 assert(State == Open &&
"JD is defunct");
1074 using SymbolMaterializerItrPair =
1075 std::pair<SymbolTable::iterator, UnmaterializedInfosMap::iterator>;
1076 std::vector<SymbolMaterializerItrPair> SymbolsToRemove;
1080 for (
auto &
Name : Names) {
1081 auto I = Symbols.find(
Name);
1084 if (
I == Symbols.end()) {
1085 Missing.insert(
Name);
1090 if (
I->second.getState() != SymbolState::NeverSearched &&
1091 I->second.getState() != SymbolState::Ready) {
1096 auto UMII =
I->second.hasMaterializerAttached()
1097 ? UnmaterializedInfos.find(
Name)
1098 : UnmaterializedInfos.end();
1099 SymbolsToRemove.push_back(std::make_pair(
I, UMII));
1103 if (!Missing.empty())
1105 std::move(Missing));
1113 for (
auto &SymbolMaterializerItrPair : SymbolsToRemove) {
1114 auto UMII = SymbolMaterializerItrPair.second;
1117 if (UMII != UnmaterializedInfos.end()) {
1118 UMII->second->MU->doDiscard(*
this, UMII->first);
1119 UnmaterializedInfos.erase(UMII);
1122 auto SymI = SymbolMaterializerItrPair.first;
1123 Symbols.erase(SymI);
1126 shrinkMaterializationInfoMemory();
1128 return Error::success();
1134 OS <<
"JITDylib \"" <<
getName() <<
"\" (ES: "
1135 <<
format(
"0x%016" PRIx64,
reinterpret_cast<uintptr_t
>(&ES))
1149 if (State == Closed)
1151 OS <<
"Link order: " << LinkOrder <<
"\n"
1152 <<
"Symbol table:\n";
1155 std::vector<std::pair<SymbolStringPtr, SymbolTableEntry *>> SymbolsSorted;
1156 for (
auto &KV : Symbols)
1157 SymbolsSorted.emplace_back(KV.first, &KV.second);
1158 std::sort(SymbolsSorted.begin(), SymbolsSorted.end(),
1159 [](
const auto &L,
const auto &R) { return *L.first < *R.first; });
1161 for (
auto &KV : SymbolsSorted) {
1162 OS <<
" \"" << *KV.first <<
"\": ";
1163 if (
auto Addr = KV.second->getAddress())
1166 OS <<
"<not resolved> ";
1168 OS <<
" " << KV.second->getFlags() <<
" " << KV.second->getState();
1170 if (KV.second->hasMaterializerAttached()) {
1171 OS <<
" (Materializer ";
1172 auto I = UnmaterializedInfos.find(KV.first);
1173 assert(
I != UnmaterializedInfos.end() &&
1174 "Lazy symbol should have UnmaterializedInfo");
1175 OS <<
I->second->MU.get() <<
", " <<
I->second->MU->getName() <<
")\n";
1180 if (!MaterializingInfos.empty())
1181 OS <<
" MaterializingInfos entries:\n";
1182 for (
auto &KV : MaterializingInfos) {
1183 OS <<
" \"" << *KV.first <<
"\":\n"
1184 <<
" " << KV.second.pendingQueries().size()
1185 <<
" pending queries: { ";
1186 for (
const auto &Q : KV.second.pendingQueries())
1187 OS << Q.get() <<
" (" << Q->getRequiredState() <<
") ";
1188 OS <<
"}\n Defining EDU: ";
1189 if (KV.second.DefiningEDU) {
1190 OS << KV.second.DefiningEDU.get() <<
" { ";
1191 for (
auto &[
Name, Flags] : KV.second.DefiningEDU->Symbols)
1194 OS <<
" Dependencies:\n";
1195 if (!KV.second.DefiningEDU->Dependencies.empty()) {
1196 for (
auto &[DepJD, Deps] : KV.second.DefiningEDU->Dependencies) {
1197 OS <<
" " << DepJD->getName() <<
": [ ";
1198 for (
auto &Dep : Deps)
1206 OS <<
" Dependant EDUs:\n";
1207 if (!KV.second.DependantEDUs.empty()) {
1208 for (
auto &DependantEDU : KV.second.DependantEDUs) {
1209 OS <<
" " << DependantEDU <<
": "
1210 << DependantEDU->JD->getName() <<
" { ";
1211 for (
auto &[
Name, Flags] : DependantEDU->Symbols)
1217 assert((Symbols[KV.first].getState() != SymbolState::Ready ||
1218 (KV.second.pendingQueries().empty() && !KV.second.DefiningEDU &&
1219 !KV.second.DependantEDUs.empty())) &&
1220 "Stale materializing info entry");
1225void JITDylib::MaterializingInfo::addQuery(
1226 std::shared_ptr<AsynchronousSymbolQuery> Q) {
1230 [](
const std::shared_ptr<AsynchronousSymbolQuery> &V,
SymbolState S) {
1231 return V->getRequiredState() <= S;
1233 PendingQueries.insert(
I.base(), std::move(Q));
1236void JITDylib::MaterializingInfo::removeQuery(
1237 const AsynchronousSymbolQuery &Q) {
1240 PendingQueries, [&Q](
const std::shared_ptr<AsynchronousSymbolQuery> &V) {
1241 return V.get() == &Q;
1243 assert(
I != PendingQueries.end() &&
1244 "Query is not attached to this MaterializingInfo");
1245 PendingQueries.erase(
I);
1248JITDylib::AsynchronousSymbolQueryList
1249JITDylib::MaterializingInfo::takeQueriesMeeting(SymbolState RequiredState) {
1250 AsynchronousSymbolQueryList
Result;
1251 while (!PendingQueries.empty()) {
1252 if (PendingQueries.back()->getRequiredState() > RequiredState)
1255 Result.push_back(std::move(PendingQueries.back()));
1256 PendingQueries.pop_back();
1262JITDylib::JITDylib(ExecutionSession &ES, std::string
Name)
1267std::pair<JITDylib::AsynchronousSymbolQuerySet,
1268 std::shared_ptr<SymbolDependenceMap>>
1269JITDylib::IL_removeTracker(ResourceTracker &RT) {
1271 assert(State != Closed &&
"JD is defunct");
1276 if (&RT == DefaultTracker.
get()) {
1278 for (
auto &KV : TrackerSymbols)
1279 for (
auto &
Sym : KV.second)
1282 for (
auto &KV : Symbols) {
1283 auto &
Sym = KV.first;
1284 if (!TrackedSymbols.count(
Sym))
1285 SymbolsToRemove.push_back(
Sym);
1288 DefaultTracker.
reset();
1291 auto I = TrackerSymbols.find(&RT);
1292 if (
I != TrackerSymbols.end()) {
1293 SymbolsToRemove = std::move(
I->second);
1294 TrackerSymbols.erase(
I);
1299 for (
auto &
Sym : SymbolsToRemove) {
1300 assert(Symbols.count(
Sym) &&
"Symbol not in symbol table");
1303 auto MII = MaterializingInfos.
find(
Sym);
1304 if (MII != MaterializingInfos.
end())
1305 SymbolsToFail.push_back(
Sym);
1308 auto Result = ES.IL_failSymbols(*
this, std::move(SymbolsToFail));
1311 for (
auto &
Sym : SymbolsToRemove) {
1312 auto I = Symbols.find(
Sym);
1313 assert(
I != Symbols.end() &&
"Symbol not present in table");
1316 if (
I->second.hasMaterializerAttached()) {
1321 "Symbol has materializer attached");
1327 shrinkMaterializationInfoMemory();
1332void JITDylib::transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT) {
1333 assert(State != Closed &&
"JD is defunct");
1334 assert(&DstRT != &SrcRT &&
"No-op transfers shouldn't call transferTracker");
1335 assert(&DstRT.getJITDylib() ==
this &&
"DstRT is not for this JITDylib");
1336 assert(&SrcRT.getJITDylib() ==
this &&
"SrcRT is not for this JITDylib");
1339 for (
auto &KV : UnmaterializedInfos) {
1340 if (KV.second->RT == &SrcRT)
1341 KV.second->RT = &DstRT;
1346 auto I = TrackerMRs.find(&SrcRT);
1347 if (
I != TrackerMRs.end()) {
1348 auto &SrcMRs =
I->second;
1349 auto &DstMRs = TrackerMRs[&DstRT];
1350 for (
auto *MR : SrcMRs)
1353 DstMRs = std::move(SrcMRs);
1355 for (
auto *MR : SrcMRs)
1359 TrackerMRs.erase(&SrcRT);
1365 if (&DstRT == DefaultTracker.
get()) {
1366 TrackerSymbols.erase(&SrcRT);
1372 if (&SrcRT == DefaultTracker.
get()) {
1373 assert(!TrackerSymbols.count(&SrcRT) &&
1374 "Default tracker should not appear in TrackerSymbols");
1379 for (
auto &KV : TrackerSymbols)
1380 for (
auto &
Sym : KV.second)
1383 for (
auto &KV : Symbols) {
1384 auto &
Sym = KV.first;
1385 if (!CurrentlyTrackedSymbols.count(
Sym))
1386 SymbolsToTrack.push_back(
Sym);
1389 TrackerSymbols[&DstRT] = std::move(SymbolsToTrack);
1393 auto &DstTrackedSymbols = TrackerSymbols[&DstRT];
1397 auto SI = TrackerSymbols.find(&SrcRT);
1398 if (SI == TrackerSymbols.end())
1401 DstTrackedSymbols.reserve(DstTrackedSymbols.size() +
SI->second.size());
1402 for (
auto &
Sym :
SI->second)
1403 DstTrackedSymbols.push_back(std::move(
Sym));
1404 TrackerSymbols.erase(SI);
1407Error JITDylib::defineImpl(MaterializationUnit &MU) {
1411 std::vector<SymbolStringPtr> ExistingDefsOverridden;
1412 std::vector<SymbolStringPtr> MUDefsOverridden;
1414 for (
const auto &KV : MU.getSymbols()) {
1415 auto I = Symbols.find(KV.first);
1417 if (
I != Symbols.end()) {
1418 if (KV.second.isStrong()) {
1419 if (
I->second.getFlags().isStrong() ||
1421 Duplicates.insert(KV.first);
1424 "Overridden existing def should be in the never-searched "
1426 ExistingDefsOverridden.push_back(KV.first);
1429 MUDefsOverridden.push_back(KV.first);
1434 if (!Duplicates.empty()) {
1436 {
dbgs() <<
" Error: Duplicate symbols " << Duplicates <<
"\n"; });
1437 return make_error<DuplicateDefinition>(std::string(**Duplicates.begin()));
1442 if (!MUDefsOverridden.empty())
1443 dbgs() <<
" Defs in this MU overridden: " << MUDefsOverridden <<
"\n";
1445 for (
auto &S : MUDefsOverridden)
1446 MU.doDiscard(*
this, S);
1450 if (!ExistingDefsOverridden.empty())
1451 dbgs() <<
" Existing defs overridden by this MU: " << MUDefsOverridden
1454 for (
auto &S : ExistingDefsOverridden) {
1456 auto UMII = UnmaterializedInfos.find(S);
1457 assert(UMII != UnmaterializedInfos.end() &&
1458 "Overridden existing def should have an UnmaterializedInfo");
1459 UMII->second->MU->doDiscard(*
this, S);
1463 for (
auto &KV : MU.getSymbols()) {
1464 auto &SymEntry = Symbols[KV.first];
1465 SymEntry.setFlags(KV.second);
1467 SymEntry.setMaterializerAttached(
true);
1473void JITDylib::installMaterializationUnit(
1474 std::unique_ptr<MaterializationUnit> MU, ResourceTracker &RT) {
1477 if (&RT != DefaultTracker.
get()) {
1478 auto &TS = TrackerSymbols[&RT];
1479 TS.reserve(TS.size() + MU->getSymbols().size());
1480 for (
auto &KV : MU->getSymbols())
1481 TS.push_back(KV.first);
1484 auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU), &RT);
1485 for (
auto &KV : UMI->MU->getSymbols())
1486 UnmaterializedInfos[KV.first] = UMI;
1489void JITDylib::detachQueryHelper(AsynchronousSymbolQuery &Q,
1491 for (
auto &QuerySymbol : QuerySymbols) {
1493 "QuerySymbol does not have MaterializingInfo");
1494 auto &
MI = MaterializingInfos[QuerySymbol];
1507 std::mutex LookupMutex;
1508 std::condition_variable CV;
1512 dbgs() <<
"Issuing init-symbol lookup:\n";
1513 for (
auto &KV : InitSyms)
1514 dbgs() <<
" " << KV.first->getName() <<
": " << KV.second <<
"\n";
1517 for (
auto &KV : InitSyms) {
1518 auto *JD = KV.first;
1519 auto Names = std::move(KV.second);
1526 std::lock_guard<std::mutex> Lock(LookupMutex);
1530 "Duplicate JITDylib in lookup?");
1531 CompoundResult[JD] = std::move(*
Result);
1541 std::unique_lock<std::mutex> Lock(LookupMutex);
1542 CV.wait(Lock, [&] {
return Count == 0 || CompoundErr; });
1545 return std::move(CompoundErr);
1547 return std::move(CompoundResult);
1554 class TriggerOnComplete {
1557 TriggerOnComplete(OnCompleteFn OnComplete)
1558 : OnComplete(std::move(OnComplete)) {}
1559 ~TriggerOnComplete() { OnComplete(std::move(LookupResult)); }
1560 void reportResult(
Error Err) {
1561 std::lock_guard<std::mutex> Lock(ResultMutex);
1562 LookupResult =
joinErrors(std::move(LookupResult), std::move(Err));
1566 std::mutex ResultMutex;
1567 Error LookupResult{Error::success()};
1568 OnCompleteFn OnComplete;
1572 dbgs() <<
"Issuing init-symbol lookup:\n";
1573 for (
auto &KV : InitSyms)
1574 dbgs() <<
" " << KV.first->getName() <<
": " << KV.second <<
"\n";
1577 auto TOC = std::make_shared<TriggerOnComplete>(std::move(OnComplete));
1579 for (
auto &KV : InitSyms) {
1580 auto *JD = KV.first;
1581 auto Names = std::move(KV.second);
1587 TOC->reportResult(
Result.takeError());
1594 OS <<
"Materialization task: " << MU->getName() <<
" in "
1595 << MR->getTargetJITDylib().getName();
1607 this->EPC->ES =
this;
1613 "Session still open. Did you forget to call endSession?");
1617 LLVM_DEBUG(
dbgs() <<
"Ending ExecutionSession " <<
this <<
"\n");
1621#ifdef EXPENSIVE_CHECKS
1622 verifySessionState(
"Entering ExecutionSession::endSession");
1625 SessionOpen =
false;
1629 std::reverse(JDsToRemove.begin(), JDsToRemove.end());
1633 Err =
joinErrors(std::move(Err), EPC->disconnect());
1644 assert(!ResourceManagers.empty() &&
"No managers registered");
1645 if (ResourceManagers.back() == &RM)
1646 ResourceManagers.pop_back();
1649 assert(
I != ResourceManagers.end() &&
"RM not registered");
1650 ResourceManagers.erase(
I);
1657 for (
auto &JD : JDs)
1658 if (JD->getName() ==
Name)
1667 assert(SessionOpen &&
"Cannot create JITDylib after session is closed");
1676 if (
auto Err = P->setupJITDylib(JD))
1677 return std::move(Err);
1684 for (
auto &JD : JDsToRemove) {
1685 assert(JD->State == JITDylib::Open &&
"JD already closed");
1686 JD->State = JITDylib::Closing;
1688 assert(
I != JDs.end() &&
"JD does not appear in session JDs");
1695 for (
auto JD : JDsToRemove) {
1696 Err =
joinErrors(std::move(Err), JD->clear());
1698 Err =
joinErrors(std::move(Err), P->teardownJITDylib(*JD));
1703 for (
auto &JD : JDsToRemove) {
1704 assert(JD->State == JITDylib::Closing &&
"JD should be closing");
1705 JD->State = JITDylib::Closed;
1706 assert(JD->Symbols.empty() &&
"JD.Symbols is not empty after clear");
1707 assert(JD->UnmaterializedInfos.empty() &&
1708 "JD.UnmaterializedInfos is not empty after clear");
1709 assert(JD->MaterializingInfos.empty() &&
1710 "JD.MaterializingInfos is not empty after clear");
1711 assert(JD->TrackerSymbols.empty() &&
1712 "TrackerSymbols is not empty after clear");
1713 JD->DefGenerators.clear();
1714 JD->LinkOrder.clear();
1724 return std::vector<JITDylibSP>();
1726 auto &ES = JDs.
front()->getExecutionSession();
1727 return ES.runSessionLocked([&]() ->
Expected<std::vector<JITDylibSP>> {
1729 std::vector<JITDylibSP>
Result;
1731 for (
auto &JD : JDs) {
1733 if (JD->State != Open)
1734 return make_error<StringError>(
1735 "Error building link order: " + JD->getName() +
" is defunct",
1737 if (Visited.
count(JD.get()))
1742 Visited.
insert(JD.get());
1744 while (!WorkStack.empty()) {
1745 Result.push_back(std::move(WorkStack.back()));
1746 WorkStack.pop_back();
1748 for (auto &KV : llvm::reverse(Result.back()->LinkOrder)) {
1749 auto &JD = *KV.first;
1750 if (!Visited.insert(&JD).second)
1752 WorkStack.push_back(&JD);
1780 OL_applyQueryPhase1(std::make_unique<InProgressLookupFlagsState>(
1781 K, std::move(SearchOrder), std::move(LookupSet),
1782 std::move(OnComplete)),
1790 std::promise<MSVCPExpected<SymbolFlagsMap>> ResultP;
1791 OL_applyQueryPhase1(std::make_unique<InProgressLookupFlagsState>(
1792 K, std::move(SearchOrder), std::move(LookupSet),
1794 ResultP.set_value(std::move(
Result));
1798 auto ResultF = ResultP.get_future();
1799 return ResultF.get();
1810 dbgs() <<
"Looking up " << Symbols <<
" in " << SearchOrder
1811 <<
" (required state: " << RequiredState <<
")\n";
1818 dispatchOutstandingMUs();
1820 auto Unresolved = std::move(Symbols);
1821 auto Q = std::make_shared<AsynchronousSymbolQuery>(Unresolved, RequiredState,
1822 std::move(NotifyComplete));
1824 auto IPLS = std::make_unique<InProgressFullLookupState>(
1825 K, SearchOrder, std::move(Unresolved), RequiredState, std::move(Q),
1826 std::move(RegisterDependencies));
1836#if LLVM_ENABLE_THREADS
1838 std::promise<SymbolMap> PromisedResult;
1843 PromisedResult.set_value(std::move(*R));
1846 ResolutionError = R.takeError();
1860 ResolutionError = R.takeError();
1865 lookup(K, SearchOrder, std::move(Symbols), RequiredState, NotifyComplete,
1866 RegisterDependencies);
1868#if LLVM_ENABLE_THREADS
1869 auto ResultFuture = PromisedResult.get_future();
1870 auto Result = ResultFuture.get();
1872 if (ResolutionError)
1873 return std::move(ResolutionError);
1875 return std::move(
Result);
1878 if (ResolutionError)
1879 return std::move(ResolutionError);
1892 assert(ResultMap->size() == 1 &&
"Unexpected number of results");
1893 assert(ResultMap->count(
Name) &&
"Missing result for symbol");
1894 return std::move(ResultMap->begin()->second);
1896 return ResultMap.takeError();
1918 return TagAddrs.takeError();
1921 std::lock_guard<std::mutex> Lock(JITDispatchHandlersMutex);
1922 for (
auto &KV : *TagAddrs) {
1923 auto TagAddr = KV.second.getAddress();
1924 if (JITDispatchHandlers.count(TagAddr))
1925 return make_error<StringError>(
"Tag " +
formatv(
"{0:x16}", TagAddr) +
1926 " (for " + *KV.first +
1927 ") already registered",
1929 auto I = WFs.
find(KV.first);
1931 "JITDispatchHandler implementation missing");
1932 JITDispatchHandlers[KV.second.getAddress()] =
1933 std::make_shared<JITDispatchHandlerFunction>(std::move(
I->second));
1935 dbgs() <<
"Associated function tag \"" << *KV.first <<
"\" ("
1936 <<
formatv(
"{0:x}", KV.second.getAddress()) <<
") with handler\n";
1946 std::shared_ptr<JITDispatchHandlerFunction>
F;
1948 std::lock_guard<std::mutex> Lock(JITDispatchHandlersMutex);
1949 auto I = JITDispatchHandlers.find(HandlerFnTagAddr);
1950 if (
I != JITDispatchHandlers.end())
1955 (*F)(std::move(SendResult), ArgBuffer.
data(), ArgBuffer.
size());
1958 (
"No function registered for tag " +
1959 formatv(
"{0:x16}", HandlerFnTagAddr))
1965 for (
auto &JD : JDs)
1970#ifdef EXPENSIVE_CHECKS
1971bool ExecutionSession::verifySessionState(
Twine Phase) {
1978 for (
auto &JD : JDs) {
1981 auto &Stream =
errs();
1983 Stream <<
"ERROR: Bad ExecutionSession state detected " <<
Phase
1985 Stream <<
" In JITDylib " << JD->getName() <<
", ";
1990 if (JD->State != JITDylib::Open) {
1992 <<
"state is not Open, but JD is in ExecutionSession list.";
2000 for (
auto &[
Sym, Entry] : JD->Symbols) {
2003 if (Entry.getAddress()) {
2004 LogFailure() <<
"symbol " <<
Sym <<
" has state "
2006 <<
" (not-yet-resolved) but non-null address "
2007 << Entry.getAddress() <<
".\n";
2012 auto UMIItr = JD->UnmaterializedInfos.find(
Sym);
2013 if (
Entry.hasMaterializerAttached()) {
2014 if (UMIItr == JD->UnmaterializedInfos.end()) {
2015 LogFailure() <<
"symbol " <<
Sym
2016 <<
" entry claims materializer attached, but "
2017 "UnmaterializedInfos has no corresponding entry.\n";
2019 }
else if (UMIItr != JD->UnmaterializedInfos.end()) {
2022 <<
" entry claims no materializer attached, but "
2023 "UnmaterializedInfos has an unexpected entry for it.\n";
2029 for (
auto &[
Sym, UMI] : JD->UnmaterializedInfos) {
2030 auto SymItr = JD->Symbols.find(
Sym);
2031 if (SymItr == JD->Symbols.end()) {
2034 <<
" has UnmaterializedInfos entry, but no Symbols entry.\n";
2039 for (
auto &[
Sym, MII] : JD->MaterializingInfos) {
2041 auto SymItr = JD->Symbols.find(
Sym);
2042 if (SymItr == JD->Symbols.end()) {
2047 <<
" has MaterializingInfos entry, but no Symbols entry.\n";
2055 <<
" is in Ready state, should not have MaterializingInfo.\n";
2060 static_cast<std::underlying_type_t<SymbolState>
>(
2061 SymItr->second.getState()) + 1);
2062 for (
auto &Q : MII.PendingQueries) {
2063 if (Q->getRequiredState() != CurState) {
2064 if (Q->getRequiredState() > CurState)
2065 CurState = Q->getRequiredState();
2067 LogFailure() <<
"symbol " <<
Sym
2068 <<
" has stale or misordered queries.\n";
2076 if (MII.DefiningEDU) {
2078 EDUsToCheck.
insert(MII.DefiningEDU.get());
2080 if (MII.DefiningEDU->JD != JD.get()) {
2081 LogFailure() <<
"symbol " <<
Sym
2082 <<
" has DefiningEDU with incorrect JD"
2084 ?
" (JD not currently in ExecutionSession"
2092 <<
" has DefiningEDU, but is not in Emitted state.\n";
2098 for (
auto &DepEDU : MII.DependantEDUs) {
2100 LogFailure() <<
"symbol " <<
Sym <<
" has DependantEDU "
2101 << (
void *)DepEDU <<
" with JD (" << DepEDU->JD
2102 <<
") that isn't in ExecutionSession.\n";
2110 for (
auto *EDU : EDUsToCheck) {
2111 assert(EDU->JD->State == JITDylib::Open &&
"EDU->JD is not Open");
2113 auto LogFailure = [&]() -> raw_fd_ostream & {
2115 auto &Stream =
errs();
2116 Stream <<
"In EDU defining " << EDU->JD->getName() <<
": { ";
2117 for (
auto &[
Sym, Flags] : EDU->Symbols)
2118 Stream <<
Sym <<
" ";
2123 if (EDU->Symbols.empty())
2124 LogFailure() <<
"no symbols defined.\n";
2126 for (
auto &[
Sym, Flags] : EDU->Symbols) {
2128 LogFailure() <<
"null symbol defined.\n";
2130 if (!EDU->JD->Symbols.count(SymbolStringPtr(
Sym))) {
2131 LogFailure() <<
"symbol " <<
Sym
2132 <<
" isn't present in JD's symbol table.\n";
2138 for (
auto &[DepJD, Symbols] : EDU->Dependencies) {
2140 LogFailure() <<
"dependant symbols listed for JD that isn't in "
2141 "ExecutionSession.\n";
2143 for (
auto &DepSym : Symbols) {
2144 if (!DepJD->Symbols.count(SymbolStringPtr(DepSym))) {
2146 <<
"dependant symbol " << DepSym
2147 <<
" does not appear in symbol table for dependant JD "
2148 << DepJD->getName() <<
".\n";
2160void ExecutionSession::dispatchOutstandingMUs() {
2163 std::optional<std::pair<std::unique_ptr<MaterializationUnit>,
2164 std::unique_ptr<MaterializationResponsibility>>>
2168 std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
2169 if (!OutstandingMUs.empty()) {
2170 JMU.emplace(std::move(OutstandingMUs.back()));
2171 OutstandingMUs.pop_back();
2178 assert(JMU->first &&
"No MU?");
2179 LLVM_DEBUG(
dbgs() <<
" Dispatching \"" << JMU->first->getName() <<
"\"\n");
2180 dispatchTask(std::make_unique<MaterializationTask>(std::move(JMU->first),
2181 std::move(JMU->second)));
2183 LLVM_DEBUG(
dbgs() <<
"Done dispatching MaterializationUnits.\n");
2186Error ExecutionSession::removeResourceTracker(ResourceTracker &RT) {
2188 dbgs() <<
"In " << RT.getJITDylib().getName() <<
" removing tracker "
2189 <<
formatv(
"{0:x}", RT.getKeyUnsafe()) <<
"\n";
2191 std::vector<ResourceManager *> CurrentResourceManagers;
2193 JITDylib::AsynchronousSymbolQuerySet QueriesToFail;
2194 std::shared_ptr<SymbolDependenceMap> FailedSymbols;
2197 CurrentResourceManagers = ResourceManagers;
2199 std::tie(QueriesToFail, FailedSymbols) =
2200 RT.getJITDylib().IL_removeTracker(RT);
2205 auto &JD = RT.getJITDylib();
2206 for (
auto *L :
reverse(CurrentResourceManagers))
2208 L->handleRemoveResources(JD, RT.getKeyUnsafe()));
2210 for (
auto &Q : QueriesToFail)
2217void ExecutionSession::transferResourceTracker(ResourceTracker &DstRT,
2218 ResourceTracker &SrcRT) {
2220 dbgs() <<
"In " << SrcRT.getJITDylib().getName()
2221 <<
" transfering resources from tracker "
2222 <<
formatv(
"{0:x}", SrcRT.getKeyUnsafe()) <<
" to tracker "
2223 <<
formatv(
"{0:x}", DstRT.getKeyUnsafe()) <<
"\n";
2227 if (&DstRT == &SrcRT)
2230 assert(&DstRT.getJITDylib() == &SrcRT.getJITDylib() &&
2231 "Can't transfer resources between JITDylibs");
2233 SrcRT.makeDefunct();
2234 auto &JD = DstRT.getJITDylib();
2235 JD.transferTracker(DstRT, SrcRT);
2236 for (
auto *L :
reverse(ResourceManagers))
2237 L->handleTransferResources(JD, DstRT.getKeyUnsafe(),
2238 SrcRT.getKeyUnsafe());
2242void ExecutionSession::destroyResourceTracker(ResourceTracker &RT) {
2245 dbgs() <<
"In " << RT.getJITDylib().getName() <<
" destroying tracker "
2246 <<
formatv(
"{0:x}", RT.getKeyUnsafe()) <<
"\n";
2248 if (!RT.isDefunct())
2249 transferResourceTracker(*RT.getJITDylib().getDefaultResourceTracker(),
2254Error ExecutionSession::IL_updateCandidatesFor(
2256 SymbolLookupSet &Candidates, SymbolLookupSet *NonCandidates) {
2257 return Candidates.forEachWithRemoval(
2258 [&](
const SymbolStringPtr &
Name,
2262 auto SymI = JD.Symbols.find(
Name);
2263 if (SymI == JD.Symbols.end())
2271 if (!SymI->second.getFlags().isExported() &&
2274 NonCandidates->add(Name, SymLookupFlags);
2283 if (SymI->second.getFlags().hasMaterializationSideEffectsOnly() &&
2290 if (SymI->second.getFlags().hasError()) {
2291 auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
2292 (*FailedSymbolsMap)[&JD] = {Name};
2294 std::move(FailedSymbolsMap));
2302void ExecutionSession::OL_resumeLookupAfterGeneration(
2303 InProgressLookupState &IPLS) {
2306 "Should not be called for not-in-generator lookups");
2311 if (
auto DG = IPLS.CurDefGeneratorStack.back().lock()) {
2312 IPLS.CurDefGeneratorStack.pop_back();
2313 std::lock_guard<std::mutex> Lock(DG->M);
2317 if (DG->PendingLookups.empty()) {
2323 LS = std::move(DG->PendingLookups.front());
2324 DG->PendingLookups.pop_front();
2329 dispatchTask(std::make_unique<LookupTask>(std::move(LS)));
2333void ExecutionSession::OL_applyQueryPhase1(
2334 std::unique_ptr<InProgressLookupState> IPLS, Error Err) {
2337 dbgs() <<
"Entering OL_applyQueryPhase1:\n"
2338 <<
" Lookup kind: " << IPLS->K <<
"\n"
2339 <<
" Search order: " << IPLS->SearchOrder
2340 <<
", Current index = " << IPLS->CurSearchOrderIndex
2341 << (IPLS->NewJITDylib ?
" (entering new JITDylib)" :
"") <<
"\n"
2342 <<
" Lookup set: " << IPLS->LookupSet <<
"\n"
2343 <<
" Definition generator candidates: "
2344 << IPLS->DefGeneratorCandidates <<
"\n"
2345 <<
" Definition generator non-candidates: "
2346 << IPLS->DefGeneratorNonCandidates <<
"\n";
2350 OL_resumeLookupAfterGeneration(*IPLS);
2353 "Lookup should not be in InGenerator state here");
2360 while (IPLS->CurSearchOrderIndex != IPLS->SearchOrder.size()) {
2366 return IPLS->fail(std::move(Err));
2369 auto &KV = IPLS->SearchOrder[IPLS->CurSearchOrderIndex];
2370 auto &JD = *KV.first;
2371 auto JDLookupFlags = KV.second;
2374 dbgs() <<
"Visiting \"" << JD.getName() <<
"\" (" << JDLookupFlags
2375 <<
") with lookup set " << IPLS->LookupSet <<
":\n";
2379 if (IPLS->NewJITDylib) {
2383 SymbolLookupSet Tmp;
2384 std::swap(IPLS->DefGeneratorNonCandidates, Tmp);
2385 IPLS->DefGeneratorCandidates.append(std::move(Tmp));
2388 dbgs() <<
" First time visiting " << JD.getName()
2389 <<
", resetting candidate sets and building generator stack\n";
2394 IPLS->CurDefGeneratorStack.reserve(JD.DefGenerators.size());
2396 IPLS->CurDefGeneratorStack.push_back(DG);
2400 IPLS->NewJITDylib =
false;
2409 Err = IL_updateCandidatesFor(
2410 JD, JDLookupFlags, IPLS->DefGeneratorCandidates,
2411 JD.DefGenerators.empty() ?
nullptr
2412 : &IPLS->DefGeneratorNonCandidates);
2414 dbgs() <<
" Remaining candidates = " << IPLS->DefGeneratorCandidates
2422 IPLS->DefGeneratorCandidates.empty())
2423 OL_resumeLookupAfterGeneration(*IPLS);
2429 return IPLS->fail(std::move(Err));
2433 if (IPLS->CurDefGeneratorStack.empty())
2434 LLVM_DEBUG(
dbgs() <<
" No generators to run for this JITDylib.\n");
2435 else if (IPLS->DefGeneratorCandidates.empty())
2438 dbgs() <<
" Running " << IPLS->CurDefGeneratorStack.size()
2439 <<
" remaining generators for "
2440 << IPLS->DefGeneratorCandidates.size() <<
" candidates\n";
2442 while (!IPLS->CurDefGeneratorStack.empty() &&
2443 !IPLS->DefGeneratorCandidates.empty()) {
2444 auto DG = IPLS->CurDefGeneratorStack.back().lock();
2447 return IPLS->fail(make_error<StringError>(
2448 "DefinitionGenerator removed while lookup in progress",
2461 std::lock_guard<std::mutex> Lock(DG->M);
2463 DG->PendingLookups.push_back(std::move(IPLS));
2472 auto &LookupSet = IPLS->DefGeneratorCandidates;
2477 LLVM_DEBUG(
dbgs() <<
" Attempting to generate " << LookupSet <<
"\n");
2479 Err = DG->tryToGenerate(LS, K, JD, JDLookupFlags, LookupSet);
2480 IPLS = std::move(
LS.IPLS);
2486 OL_resumeLookupAfterGeneration(*IPLS);
2491 dbgs() <<
" Error attempting to generate " << LookupSet <<
"\n";
2493 assert(IPLS &&
"LS cannot be retained if error is returned");
2494 return IPLS->fail(std::move(Err));
2500 {
dbgs() <<
" LookupState captured. Exiting phase1 for now.\n"; });
2507 LLVM_DEBUG(
dbgs() <<
" Updating candidate set post-generation\n");
2508 Err = IL_updateCandidatesFor(
2509 JD, JDLookupFlags, IPLS->DefGeneratorCandidates,
2510 JD.DefGenerators.empty() ?
nullptr
2511 : &IPLS->DefGeneratorNonCandidates);
2516 LLVM_DEBUG(
dbgs() <<
" Error encountered while updating candidates\n");
2517 return IPLS->fail(std::move(Err));
2521 if (IPLS->DefGeneratorCandidates.empty() &&
2522 IPLS->DefGeneratorNonCandidates.empty()) {
2525 IPLS->CurSearchOrderIndex = IPLS->SearchOrder.size();
2531 ++IPLS->CurSearchOrderIndex;
2532 IPLS->NewJITDylib =
true;
2537 IPLS->DefGeneratorCandidates.remove_if(
2545 if (IPLS->DefGeneratorCandidates.empty()) {
2547 IPLS->complete(std::move(IPLS));
2549 LLVM_DEBUG(
dbgs() <<
"Phase 1 failed with unresolved symbols.\n");
2550 IPLS->fail(make_error<SymbolsNotFound>(
2555void ExecutionSession::OL_completeLookup(
2556 std::unique_ptr<InProgressLookupState> IPLS,
2557 std::shared_ptr<AsynchronousSymbolQuery> Q,
2561 dbgs() <<
"Entering OL_completeLookup:\n"
2562 <<
" Lookup kind: " << IPLS->K <<
"\n"
2563 <<
" Search order: " << IPLS->SearchOrder
2564 <<
", Current index = " << IPLS->CurSearchOrderIndex
2565 << (IPLS->NewJITDylib ?
" (entering new JITDylib)" :
"") <<
"\n"
2566 <<
" Lookup set: " << IPLS->LookupSet <<
"\n"
2567 <<
" Definition generator candidates: "
2568 << IPLS->DefGeneratorCandidates <<
"\n"
2569 <<
" Definition generator non-candidates: "
2570 << IPLS->DefGeneratorNonCandidates <<
"\n";
2573 bool QueryComplete =
false;
2574 DenseMap<JITDylib *, JITDylib::UnmaterializedInfosList> CollectedUMIs;
2577 for (
auto &KV : IPLS->SearchOrder) {
2578 auto &JD = *KV.first;
2579 auto JDLookupFlags = KV.second;
2581 dbgs() <<
"Visiting \"" << JD.getName() <<
"\" (" << JDLookupFlags
2582 <<
") with lookup set " << IPLS->LookupSet <<
":\n";
2585 auto Err = IPLS->LookupSet.forEachWithRemoval(
2586 [&](
const SymbolStringPtr &
Name,
2589 dbgs() <<
" Attempting to match \"" <<
Name <<
"\" ("
2590 << SymLookupFlags <<
")... ";
2595 auto SymI = JD.Symbols.find(
Name);
2596 if (SymI == JD.Symbols.end()) {
2603 if (!SymI->second.getFlags().isExported() &&
2615 if (SymI->second.getFlags().hasMaterializationSideEffectsOnly() &&
2619 "required, but symbol is has-side-effects-only\n";
2627 if (SymI->second.getFlags().hasError()) {
2629 auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
2630 (*FailedSymbolsMap)[&JD] = {
Name};
2631 return make_error<FailedToMaterialize>(
2639 if (SymI->second.getState() >= Q->getRequiredState()) {
2641 <<
"matched, symbol already in required state\n");
2642 Q->notifySymbolMetRequiredState(
Name, SymI->second.getSymbol());
2649 if (SymI->second.hasMaterializerAttached()) {
2650 assert(SymI->second.getAddress() == ExecutorAddr() &&
2651 "Symbol not resolved but already has address?");
2652 auto UMII = JD.UnmaterializedInfos.find(
Name);
2653 assert(UMII != JD.UnmaterializedInfos.end() &&
2654 "Lazy symbol should have UnmaterializedInfo");
2656 auto UMI = UMII->second;
2657 assert(UMI->MU &&
"Materializer should not be null");
2658 assert(UMI->RT &&
"Tracker should not be null");
2660 dbgs() <<
"matched, preparing to dispatch MU@" << UMI->MU.get()
2661 <<
" (" << UMI->MU->getName() <<
")\n";
2666 for (
auto &KV : UMI->MU->getSymbols()) {
2667 auto SymK = JD.Symbols.find(KV.first);
2668 assert(SymK != JD.Symbols.end() &&
2669 "No entry for symbol covered by MaterializationUnit");
2670 SymK->second.setMaterializerAttached(
false);
2672 JD.UnmaterializedInfos.erase(KV.first);
2676 CollectedUMIs[&JD].push_back(std::move(UMI));
2684 "By this line the symbol should be materializing");
2685 auto &
MI = JD.MaterializingInfos[
Name];
2687 Q->addQueryDependence(JD,
Name);
2692 JD.shrinkMaterializationInfoMemory();
2698 dbgs() <<
"Lookup failed. Detaching query and replacing MUs.\n";
2705 for (
auto &KV : CollectedUMIs) {
2706 auto &JD = *KV.first;
2707 for (
auto &UMI : KV.second)
2708 for (
auto &KV2 : UMI->MU->getSymbols()) {
2709 assert(!JD.UnmaterializedInfos.count(KV2.first) &&
2710 "Unexpected materializer in map");
2711 auto SymI = JD.Symbols.find(KV2.first);
2712 assert(SymI != JD.Symbols.end() &&
"Missing symbol entry");
2714 "Can not replace symbol that is not materializing");
2715 assert(!SymI->second.hasMaterializerAttached() &&
2716 "MaterializerAttached flag should not be set");
2717 SymI->second.setMaterializerAttached(
true);
2718 JD.UnmaterializedInfos[KV2.first] = UMI;
2726 LLVM_DEBUG(
dbgs() <<
"Stripping unmatched weakly-referenced symbols\n");
2727 IPLS->LookupSet.forEachWithRemoval(
2730 Q->dropSymbol(
Name);
2736 if (!IPLS->LookupSet.empty()) {
2739 IPLS->LookupSet.getSymbolNames());
2743 QueryComplete = Q->isComplete();
2746 dbgs() <<
"Query successfully "
2747 << (QueryComplete ?
"completed" :
"lodged") <<
"\n";
2751 if (!CollectedUMIs.empty()) {
2752 std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
2755 for (
auto &KV : CollectedUMIs) {
2757 auto &JD = *KV.first;
2758 dbgs() <<
" For " << JD.getName() <<
": Adding " << KV.second.size()
2761 for (
auto &UMI : KV.second) {
2762 auto MR = createMaterializationResponsibility(
2763 *UMI->RT, std::move(UMI->MU->SymbolFlags),
2764 std::move(UMI->MU->InitSymbol));
2765 OutstandingMUs.push_back(
2766 std::make_pair(std::move(UMI->MU), std::move(MR)));
2772 if (RegisterDependencies && !Q->QueryRegistrations.empty()) {
2774 RegisterDependencies(Q->QueryRegistrations);
2784 Q->handleFailed(std::move(LodgingErr));
2788 if (QueryComplete) {
2790 Q->handleComplete(*
this);
2793 dispatchOutstandingMUs();
2796void ExecutionSession::OL_completeLookupFlags(
2797 std::unique_ptr<InProgressLookupState> IPLS,
2798 unique_function<
void(Expected<SymbolFlagsMap>)> OnComplete) {
2802 dbgs() <<
"Entering OL_completeLookupFlags:\n"
2803 <<
" Lookup kind: " << IPLS->K <<
"\n"
2804 <<
" Search order: " << IPLS->SearchOrder
2805 <<
", Current index = " << IPLS->CurSearchOrderIndex
2806 << (IPLS->NewJITDylib ?
" (entering new JITDylib)" :
"") <<
"\n"
2807 <<
" Lookup set: " << IPLS->LookupSet <<
"\n"
2808 <<
" Definition generator candidates: "
2809 << IPLS->DefGeneratorCandidates <<
"\n"
2810 <<
" Definition generator non-candidates: "
2811 << IPLS->DefGeneratorNonCandidates <<
"\n";
2817 for (
auto &KV : IPLS->SearchOrder) {
2818 auto &JD = *KV.first;
2819 auto JDLookupFlags = KV.second;
2821 dbgs() <<
"Visiting \"" << JD.getName() <<
"\" (" << JDLookupFlags
2822 <<
") with lookup set " << IPLS->LookupSet <<
":\n";
2825 IPLS->LookupSet.forEachWithRemoval([&](
const SymbolStringPtr &
Name,
2828 dbgs() <<
" Attempting to match \"" <<
Name <<
"\" ("
2829 << SymLookupFlags <<
")... ";
2834 auto SymI = JD.Symbols.find(
Name);
2835 if (SymI == JD.Symbols.end()) {
2841 if (!SymI->second.getFlags().isExported() &&
2848 dbgs() <<
"matched, \"" <<
Name <<
"\" -> " << SymI->second.getFlags()
2857 IPLS->LookupSet.remove_if(
2862 if (!IPLS->LookupSet.empty()) {
2865 IPLS->LookupSet.getSymbolNames());
2874 OnComplete(std::move(
Result));
2877void ExecutionSession::OL_destroyMaterializationResponsibility(
2878 MaterializationResponsibility &MR) {
2880 assert(MR.SymbolFlags.empty() &&
2881 "All symbols should have been explicitly materialized or failed");
2882 MR.JD.unlinkMaterializationResponsibility(MR);
2886 const MaterializationResponsibility &MR) {
2887 return MR.JD.getRequestedSymbols(MR.SymbolFlags);
2890Error ExecutionSession::OL_notifyResolved(MaterializationResponsibility &MR,
2893 dbgs() <<
"In " << MR.JD.getName() <<
" resolving " << Symbols <<
"\n";
2896 for (
auto &KV : Symbols) {
2897 auto I = MR.SymbolFlags.find(KV.first);
2898 assert(
I != MR.SymbolFlags.end() &&
2899 "Resolving symbol outside this responsibility set");
2900 assert(!
I->second.hasMaterializationSideEffectsOnly() &&
2901 "Can't resolve materialization-side-effects-only symbol");
2904 "Resolving symbol with incorrect flags");
2908 return MR.JD.resolve(MR, Symbols);
2911template <
typename HandleNewDepFn>
2912void ExecutionSession::propagateExtraEmitDeps(
2913 std::deque<JITDylib::EmissionDepUnit *> Worklist, EDUInfosMap &EDUInfos,
2914 HandleNewDepFn HandleNewDep) {
2918 while (!Worklist.empty()) {
2919 auto &EDU = *Worklist.front();
2920 Worklist.pop_front();
2922 assert(EDUInfos.count(&EDU) &&
"No info entry for EDU");
2923 auto &EDUInfo = EDUInfos[&EDU];
2926 for (
auto *UserEDU : EDUInfo.IntraEmitUsers) {
2929 JITDylib::EmissionDepUnitInfo *UserEDUInfo =
nullptr;
2931 auto UserEDUInfoItr = EDUInfos.find(UserEDU);
2932 if (UserEDUInfoItr != EDUInfos.end())
2933 UserEDUInfo = &UserEDUInfoItr->second;
2936 for (
auto &[DepJD, Deps] : EDUInfo.NewDeps) {
2937 auto &UserEDUDepsForJD = UserEDU->Dependencies[DepJD];
2938 DenseSet<NonOwningSymbolStringPtr> *UserEDUNewDepsForJD =
nullptr;
2939 for (
auto Dep : Deps) {
2940 if (UserEDUDepsForJD.insert(Dep).second) {
2941 HandleNewDep(*UserEDU, *DepJD, Dep);
2943 if (!UserEDUNewDepsForJD) {
2946 if (UserEDUInfo->NewDeps.empty())
2947 Worklist.push_back(UserEDU);
2948 UserEDUNewDepsForJD = &UserEDUInfo->NewDeps[DepJD];
2951 UserEDUNewDepsForJD->insert(Dep);
2958 EDUInfo.NewDeps.clear();
2963ExecutionSession::EDUInfosMap ExecutionSession::simplifyDepGroups(
2964 MaterializationResponsibility &MR,
2965 ArrayRef<SymbolDependenceGroup> EmittedDeps) {
2967 auto &TargetJD = MR.getTargetJITDylib();
2971 DenseMap<JITDylib::EmissionDepUnit *, JITDylib::EmissionDepUnitInfo> EDUInfos;
2972 EDUInfos.reserve(EmittedDeps.size());
2973 DenseMap<NonOwningSymbolStringPtr, JITDylib::EmissionDepUnit *> EDUForSymbol;
2974 for (
auto &DG : EmittedDeps) {
2975 assert(!DG.Symbols.empty() &&
"DepGroup does not cover any symbols");
2978 if (DG.Dependencies.empty())
2981 auto TmpEDU = std::make_shared<JITDylib::EmissionDepUnit>(TargetJD);
2982 auto &EDUInfo = EDUInfos[TmpEDU.get()];
2983 EDUInfo.EDU = std::move(TmpEDU);
2984 for (
const auto &Symbol : DG.Symbols) {
2985 NonOwningSymbolStringPtr NonOwningSymbol(Symbol);
2986 assert(!EDUForSymbol.count(NonOwningSymbol) &&
2987 "Symbol should not appear in more than one SymbolDependenceGroup");
2988 assert(MR.getSymbols().count(Symbol) &&
2989 "Symbol in DepGroups not in the emitted set");
2990 auto NewlyEmittedItr = MR.getSymbols().find(Symbol);
2991 EDUInfo.EDU->Symbols[NonOwningSymbol] = NewlyEmittedItr->second;
2992 EDUForSymbol[NonOwningSymbol] = EDUInfo.EDU.get();
2998 DenseMap<NonOwningSymbolStringPtr, JITSymbolFlags> ResidualSymbolFlags;
2999 for (
auto &[
Sym, Flags] : MR.getSymbols()) {
3000 if (!EDUForSymbol.count(NonOwningSymbolStringPtr(
Sym)))
3001 ResidualSymbolFlags[NonOwningSymbolStringPtr(
Sym)] =
Flags;
3003 if (!ResidualSymbolFlags.empty()) {
3004 auto ResidualEDU = std::make_shared<JITDylib::EmissionDepUnit>(TargetJD);
3005 ResidualEDU->Symbols = std::move(ResidualSymbolFlags);
3006 auto &ResidualEDUInfo = EDUInfos[ResidualEDU.get()];
3007 ResidualEDUInfo.EDU = std::move(ResidualEDU);
3010 if (EDUInfos.size() == 1)
3014 for (
auto &[
Sym, Flags] : ResidualEDUInfo.EDU->Symbols)
3015 EDUForSymbol[
Sym] = ResidualEDUInfo.EDU.get();
3020 assert(EDUForSymbol.size() == MR.getSymbols().size() &&
3021 "MR symbols not fully covered by EDUs?");
3022 for (
auto &[
Sym, Flags] : MR.getSymbols()) {
3023 assert(EDUForSymbol.count(NonOwningSymbolStringPtr(
Sym)) &&
3024 "Sym in MR not covered by EDU");
3032 for (
auto &DG : EmittedDeps) {
3035 if (DG.Dependencies.empty())
3038 assert(EDUForSymbol.count(NonOwningSymbolStringPtr(*DG.Symbols.begin())) &&
3041 *EDUForSymbol.find(NonOwningSymbolStringPtr(*DG.Symbols.begin()))
3044 for (
auto &[DepJD, Deps] : DG.Dependencies) {
3045 DenseSet<NonOwningSymbolStringPtr> NewDepsForJD;
3047 assert(!Deps.empty() &&
"Dependence set for DepJD is empty");
3049 if (DepJD != &TargetJD) {
3052 for (
auto &Dep : Deps)
3053 NewDepsForJD.insert(NonOwningSymbolStringPtr(Dep));
3057 for (
auto &Dep : Deps) {
3058 NonOwningSymbolStringPtr NonOwningDep(Dep);
3059 auto I = EDUForSymbol.find(NonOwningDep);
3060 if (
I == EDUForSymbol.end()) {
3061 if (!MR.getSymbols().count(Dep))
3062 NewDepsForJD.insert(NonOwningDep);
3066 if (
I->second != &EDU)
3067 EDUInfos[
I->second].IntraEmitUsers.insert(&EDU);
3071 if (!NewDepsForJD.empty())
3072 EDU.Dependencies[DepJD] = std::move(NewDepsForJD);
3077 std::deque<JITDylib::EmissionDepUnit *> Worklist;
3078 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3081 if (!EDU->Dependencies.empty()) {
3082 auto I = EDUInfos.find(EDU);
3083 if (
I != EDUInfos.end()) {
3084 auto &EDUInfo =
I->second;
3085 if (!EDUInfo.IntraEmitUsers.empty()) {
3086 EDUInfo.NewDeps = EDU->Dependencies;
3087 Worklist.push_back(EDU);
3094 propagateExtraEmitDeps(
3096 [](JITDylib::EmissionDepUnit &,
JITDylib &, NonOwningSymbolStringPtr) {});
3101void ExecutionSession::IL_makeEDUReady(
3102 std::shared_ptr<JITDylib::EmissionDepUnit> EDU,
3103 JITDylib::AsynchronousSymbolQuerySet &Queries) {
3106 auto &JD = *EDU->JD;
3108 for (
auto &[
Sym, Flags] : EDU->Symbols) {
3109 assert(JD.Symbols.count(SymbolStringPtr(
Sym)) &&
3110 "JD does not have an entry for Sym");
3111 auto &
Entry = JD.Symbols[SymbolStringPtr(
Sym)];
3113 assert(((
Entry.getFlags().hasMaterializationSideEffectsOnly() &&
3117 "Emitting from state other than Resolved");
3121 auto MII = JD.MaterializingInfos.find(SymbolStringPtr(
Sym));
3124 if (MII == JD.MaterializingInfos.end())
3126 auto &
MI = MII->second;
3129 Q->notifySymbolMetRequiredState(SymbolStringPtr(
Sym),
Entry.getSymbol());
3130 if (Q->isComplete())
3132 Q->removeQueryDependence(JD, SymbolStringPtr(
Sym));
3135 JD.MaterializingInfos.erase(MII);
3138 JD.shrinkMaterializationInfoMemory();
3141void ExecutionSession::IL_makeEDUEmitted(
3142 std::shared_ptr<JITDylib::EmissionDepUnit> EDU,
3143 JITDylib::AsynchronousSymbolQuerySet &Queries) {
3146 auto &JD = *EDU->JD;
3148 for (
auto &[
Sym, Flags] : EDU->Symbols) {
3149 assert(JD.Symbols.count(SymbolStringPtr(
Sym)) &&
3150 "JD does not have an entry for Sym");
3151 auto &
Entry = JD.Symbols[SymbolStringPtr(
Sym)];
3153 assert(((
Entry.getFlags().hasMaterializationSideEffectsOnly() &&
3157 "Emitting from state other than Resolved");
3162 for (
auto &[
Sym, Flags] : EDU->Symbols) {
3163 assert(JD.Symbols.count(SymbolStringPtr(
Sym)) &&
3164 "JD does not have an entry for Sym");
3165 auto &
Entry = JD.Symbols[SymbolStringPtr(
Sym)];
3167 "Symbols for EDU in inconsistent state");
3168 assert(JD.MaterializingInfos.count(SymbolStringPtr(
Sym)) &&
3169 "Emitted symbol has no MI");
3170 auto MI = JD.MaterializingInfos[SymbolStringPtr(
Sym)];
3172 "Already-emitted symbol has waiting-on-emitted queries");
3179 auto &
MI = JD.MaterializingInfos[SymbolStringPtr(
Sym)];
3180 MI.DefiningEDU = EDU;
3183 Q->notifySymbolMetRequiredState(SymbolStringPtr(
Sym),
Entry.getSymbol());
3184 if (Q->isComplete())
3186 Q->removeQueryDependence(JD, SymbolStringPtr(
Sym));
3190 for (
auto &[DepJD, Deps] : EDU->Dependencies) {
3191 for (
auto &Dep : Deps)
3192 DepJD->MaterializingInfos[SymbolStringPtr(Dep)].DependantEDUs.insert(
3200bool ExecutionSession::IL_removeEDUDependence(JITDylib::EmissionDepUnit &EDU,
3202 NonOwningSymbolStringPtr DepSym,
3203 EDUInfosMap &EDUInfos) {
3204 assert(EDU.Dependencies.count(&DepJD) &&
3205 "JD does not appear in Dependencies of DependantEDU");
3206 assert(EDU.Dependencies[&DepJD].count(DepSym) &&
3207 "Symbol does not appear in Dependencies of DependantEDU");
3208 auto &JDDeps = EDU.Dependencies[&DepJD];
3209 JDDeps.erase(DepSym);
3210 if (JDDeps.empty()) {
3211 EDU.Dependencies.erase(&DepJD);
3212 if (EDU.Dependencies.empty()) {
3217 auto &DepEDUInfo = EDUInfos[&EDU];
3218 if (!DepEDUInfo.EDU) {
3219 assert(EDU.JD->Symbols.count(
3220 SymbolStringPtr(EDU.Symbols.begin()->first)) &&
3221 "Missing symbol entry for first symbol in EDU");
3222 auto DepEDUFirstMI = EDU.JD->MaterializingInfos.find(
3223 SymbolStringPtr(EDU.Symbols.begin()->first));
3224 assert(DepEDUFirstMI != EDU.JD->MaterializingInfos.end() &&
3225 "Missing MI for first symbol in DependantEDU");
3226 DepEDUInfo.EDU = DepEDUFirstMI->second.DefiningEDU;
3234Error ExecutionSession::makeJDClosedError(JITDylib::EmissionDepUnit &EDU,
3235 JITDylib &ClosedJD) {
3237 for (
auto &[
Sym, Flags] : EDU.Symbols)
3238 FailedSymbols.
insert(SymbolStringPtr(
Sym));
3240 for (
auto &Dep : EDU.Dependencies[&ClosedJD])
3241 BadDeps[&ClosedJD].
insert(SymbolStringPtr(Dep));
3242 return make_error<UnsatisfiedSymbolDependencies>(
3243 ClosedJD.getExecutionSession().getSymbolStringPool(), EDU.JD,
3244 std::move(FailedSymbols), std::move(BadDeps),
3245 ClosedJD.getName() +
" is closed");
3248Error ExecutionSession::makeUnsatisfiedDepsError(JITDylib::EmissionDepUnit &EDU,
3252 for (
auto &[
Sym, Flags] : EDU.Symbols)
3253 FailedSymbols.
insert(SymbolStringPtr(
Sym));
3255 BadDepsMap[&BadJD] = std::move(BadDeps);
3256 return make_error<UnsatisfiedSymbolDependencies>(
3257 BadJD.getExecutionSession().getSymbolStringPool(), &BadJD,
3258 std::move(FailedSymbols), std::move(BadDepsMap),
3259 "dependencies removed or in error state");
3262Expected<JITDylib::AsynchronousSymbolQuerySet>
3263ExecutionSession::IL_emit(MaterializationResponsibility &MR,
3264 EDUInfosMap EDUInfos) {
3266 if (MR.RT->isDefunct())
3267 return make_error<ResourceTrackerDefunct>(MR.RT);
3269 auto &TargetJD = MR.getTargetJITDylib();
3270 if (TargetJD.State != JITDylib::Open)
3271 return make_error<StringError>(
"JITDylib " + TargetJD.getName() +
3274#ifdef EXPENSIVE_CHECKS
3275 verifySessionState(
"entering ExecutionSession::IL_emit");
3284 std::deque<JITDylib::EmissionDepUnit *> Worklist;
3285 for (
auto &[EDU,
_] : EDUInfos)
3286 Worklist.push_back(EDU);
3288 for (
auto *EDU : Worklist) {
3289 auto *EDUInfo = &EDUInfos[EDU];
3291 SmallVector<JITDylib *> DepJDsToRemove;
3292 for (
auto &[DepJD, Deps] : EDU->Dependencies) {
3293 if (DepJD->State != JITDylib::Open)
3294 return makeJDClosedError(*EDU, *DepJD);
3297 SmallVector<NonOwningSymbolStringPtr> DepsToRemove;
3298 for (
auto &Dep : Deps) {
3299 auto DepEntryItr = DepJD->Symbols.
find(SymbolStringPtr(Dep));
3304 if (DepEntryItr == DepJD->Symbols.end() ||
3305 DepEntryItr->second.getFlags().hasError()) {
3306 BadDeps.insert(SymbolStringPtr(Dep));
3312 auto &DepEntry = DepEntryItr->second;
3314 EDUInfo->NewDeps[DepJD].insert(Dep);
3320 DepsToRemove.push_back(Dep);
3324 assert(!DepJD->MaterializingInfos.count(SymbolStringPtr(Dep)) &&
3325 "Unexpected MaterializationInfo attached to ready symbol");
3333 assert(DepJD->MaterializingInfos.count(SymbolStringPtr(Dep)) &&
3334 "Expected MaterializationInfo for emitted dependency");
3335 auto &DepMI = DepJD->MaterializingInfos[SymbolStringPtr(Dep)];
3336 assert(DepMI.DefiningEDU &&
3337 "Emitted symbol does not have a defining EDU");
3338 assert(!DepMI.DefiningEDU->Dependencies.empty() &&
3339 "Emitted symbol has empty dependencies (should be ready)");
3340 assert(DepMI.DependantEDUs.empty() &&
3341 "Already-emitted symbol has dependant EDUs?");
3342 auto &DepEDUInfo = EDUInfos[DepMI.DefiningEDU.get()];
3343 if (!DepEDUInfo.EDU) {
3346 EDUInfo = &EDUInfos[EDU];
3347 DepEDUInfo.EDU = DepMI.DefiningEDU;
3348 for (
auto &[DepDepJD, DepDeps] : DepEDUInfo.EDU->Dependencies) {
3349 if (DepDepJD == &TargetJD) {
3350 for (
auto &DepDep : DepDeps)
3351 if (!MR.getSymbols().count(SymbolStringPtr(DepDep)))
3352 DepEDUInfo.NewDeps[DepDepJD].insert(DepDep);
3354 DepEDUInfo.NewDeps[DepDepJD] = DepDeps;
3357 DepEDUInfo.IntraEmitUsers.insert(EDU);
3361 if (!BadDeps.empty())
3362 return makeUnsatisfiedDepsError(*EDU, *DepJD, std::move(BadDeps));
3365 for (
auto &Dep : DepsToRemove)
3370 DepJDsToRemove.push_back(DepJD);
3374 for (
auto &DepJD : DepJDsToRemove) {
3375 assert(EDU->Dependencies.count(DepJD) &&
3376 "Trying to remove non-existent dep entries");
3377 EDU->Dependencies.erase(DepJD);
3381 for (
auto &[
Sym, Flags] : EDU->Symbols) {
3382 assert(TargetJD.Symbols.count(SymbolStringPtr(
Sym)) &&
3383 "Sym not present in symbol table");
3384 assert((TargetJD.Symbols[SymbolStringPtr(
Sym)].getState() ==
3386 TargetJD.Symbols[SymbolStringPtr(
Sym)]
3388 .hasMaterializationSideEffectsOnly()) &&
3389 "Emitting symbol not in the resolved state");
3391 "Symbol is already in an error state");
3393 auto MII = TargetJD.MaterializingInfos.find(SymbolStringPtr(
Sym));
3394 if (MII == TargetJD.MaterializingInfos.end() ||
3395 MII->second.DependantEDUs.empty())
3398 for (
auto &DependantEDU : MII->second.DependantEDUs) {
3399 if (IL_removeEDUDependence(*DependantEDU, TargetJD,
Sym, EDUInfos))
3400 EDUInfo = &EDUInfos[EDU];
3401 EDUInfo->IntraEmitUsers.insert(DependantEDU);
3403 MII->second.DependantEDUs.clear();
3408 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3409 if (!EDUInfo.IntraEmitUsers.empty() && !EDU->Dependencies.empty()) {
3410 if (EDUInfo.NewDeps.empty())
3411 EDUInfo.NewDeps = EDU->Dependencies;
3412 Worklist.push_back(EDU);
3416 propagateExtraEmitDeps(
3418 [](JITDylib::EmissionDepUnit &EDU,
JITDylib &JD,
3419 NonOwningSymbolStringPtr
Sym) {
3420 JD.MaterializingInfos[SymbolStringPtr(
Sym)].DependantEDUs.insert(&EDU);
3423 JITDylib::AsynchronousSymbolQuerySet CompletedQueries;
3427 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3428 if (EDU->Dependencies.empty())
3429 IL_makeEDUReady(std::move(EDUInfo.EDU), CompletedQueries);
3431 IL_makeEDUEmitted(std::move(EDUInfo.EDU), CompletedQueries);
3434#ifdef EXPENSIVE_CHECKS
3435 verifySessionState(
"exiting ExecutionSession::IL_emit");
3438 return std::move(CompletedQueries);
3441Error ExecutionSession::OL_notifyEmitted(
3442 MaterializationResponsibility &MR,
3443 ArrayRef<SymbolDependenceGroup> DepGroups) {
3445 dbgs() <<
"In " << MR.JD.getName() <<
" emitting " << MR.SymbolFlags
3447 if (!DepGroups.empty()) {
3448 dbgs() <<
" Initial dependencies:\n";
3449 for (
auto &SDG : DepGroups) {
3450 dbgs() <<
" Symbols: " << SDG.Symbols
3451 <<
", Dependencies: " << SDG.Dependencies <<
"\n";
3458 for (
auto &DG : DepGroups) {
3459 for (
auto &
Sym : DG.Symbols) {
3461 "DG contains dependence for symbol outside this MR");
3463 "DG contains duplicate entries for Name");
3468 auto EDUInfos = simplifyDepGroups(MR, DepGroups);
3471 dbgs() <<
" Simplified dependencies:\n";
3472 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3473 dbgs() <<
" Symbols: { ";
3474 for (
auto &[
Sym, Flags] : EDU->Symbols)
3476 dbgs() <<
"}, Dependencies: { ";
3477 for (
auto &[DepJD, Deps] : EDU->Dependencies) {
3478 dbgs() <<
"(" << DepJD->getName() <<
", { ";
3479 for (
auto &Dep : Deps)
3480 dbgs() << Dep <<
" ";
3487 auto CompletedQueries =
3491 if (!CompletedQueries)
3492 return CompletedQueries.takeError();
3494 MR.SymbolFlags.clear();
3497 for (
auto &Q : *CompletedQueries) {
3498 assert(Q->isComplete() &&
"Q is not complete");
3499 Q->handleComplete(*
this);
3505Error ExecutionSession::OL_defineMaterializing(
3506 MaterializationResponsibility &MR,
SymbolFlagsMap NewSymbolFlags) {
3509 dbgs() <<
"In " << MR.JD.getName() <<
" defining materializing symbols "
3510 << NewSymbolFlags <<
"\n";
3512 if (
auto AcceptedDefs =
3513 MR.JD.defineMaterializing(MR, std::move(NewSymbolFlags))) {
3515 for (
auto &KV : *AcceptedDefs)
3516 MR.SymbolFlags.insert(KV);
3519 return AcceptedDefs.takeError();
3522std::pair<JITDylib::AsynchronousSymbolQuerySet,
3523 std::shared_ptr<SymbolDependenceMap>>
3524ExecutionSession::IL_failSymbols(JITDylib &JD,
3527#ifdef EXPENSIVE_CHECKS
3528 verifySessionState(
"entering ExecutionSession::IL_failSymbols");
3531 JITDylib::AsynchronousSymbolQuerySet FailedQueries;
3532 auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
3533 auto ExtractFailedQueries = [&](JITDylib::MaterializingInfo &
MI) {
3534 JITDylib::AsynchronousSymbolQueryList ToDetach;
3535 for (
auto &Q :
MI.pendingQueries()) {
3537 FailedQueries.insert(Q);
3538 ToDetach.push_back(Q);
3540 for (
auto &Q : ToDetach)
3542 assert(!
MI.hasQueriesPending() &&
"Queries still pending after detach");
3545 for (
auto &
Name : SymbolsToFail) {
3546 (*FailedSymbolsMap)[&JD].insert(
Name);
3549 auto SymI = JD.Symbols.find(
Name);
3558 if (SymI == JD.Symbols.end())
3560 auto &
Sym = SymI->second;
3564 if (
Sym.getFlags().hasError()) {
3566 "Symbol in error state still has MaterializingInfo");
3576 auto MII = JD.MaterializingInfos.find(
Name);
3577 if (MII == JD.MaterializingInfos.end())
3580 auto &
MI = MII->second;
3583 ExtractFailedQueries(
MI);
3585 if (
MI.DefiningEDU) {
3589 "Symbol with DefiningEDU should not have DependantEDUs");
3591 "Symbol has EDU, should have been emitted");
3592 assert(
MI.DefiningEDU->Symbols.count(NonOwningSymbolStringPtr(
Name)) &&
3593 "Symbol does not appear in its DefiningEDU");
3594 MI.DefiningEDU->Symbols.erase(NonOwningSymbolStringPtr(
Name));
3595 MI.DefiningEDU =
nullptr;
3602 for (
auto &DependantEDU :
MI.DependantEDUs) {
3605 for (
auto &[DepJD, DepSyms] : DependantEDU->Dependencies) {
3606 for (
auto DepSym : DepSyms) {
3609 if (DepJD == &JD && DepSym ==
Name)
3611 assert(DepJD->Symbols.count(SymbolStringPtr(DepSym)) &&
3612 "DepSym not in DepJD?");
3613 assert(DepJD->MaterializingInfos.count(SymbolStringPtr(DepSym)) &&
3614 "DependantEDU not registered with symbol it depends on");
3615 auto &SymMI = DepJD->MaterializingInfos[SymbolStringPtr(DepSym)];
3616 assert(SymMI.DependantEDUs.count(DependantEDU) &&
3617 "DependantEDU missing from DependantEDUs list");
3618 SymMI.DependantEDUs.erase(DependantEDU);
3624 auto &DepJD = *DependantEDU->JD;
3625 auto DepEDUSymbols = std::move(DependantEDU->Symbols);
3626 for (
auto &[DepName, Flags] : DepEDUSymbols) {
3627 auto DepSymItr = DepJD.Symbols.find(SymbolStringPtr(DepName));
3628 assert(DepSymItr != DepJD.Symbols.end() &&
3629 "Symbol not present in table");
3630 auto &DepSym = DepSymItr->second;
3633 "Symbol has EDU, should have been emitted");
3634 assert(!DepSym.getFlags().hasError() &&
3635 "Symbol is already in the error state?");
3637 (*FailedSymbolsMap)[&DepJD].insert(SymbolStringPtr(DepName));
3642 DepJD.MaterializingInfos.find(SymbolStringPtr(DepName));
3643 assert(DepMIItr != DepJD.MaterializingInfos.end() &&
3644 "Symbol has defining EDU but not MaterializingInfo");
3645 auto &DepMI = DepMIItr->second;
3646 assert(DepMI.DefiningEDU.get() == DependantEDU &&
3647 "Bad EDU dependence edge");
3648 assert(DepMI.DependantEDUs.empty() &&
3649 "Symbol was emitted, should not have any DependantEDUs");
3650 ExtractFailedQueries(DepMI);
3651 DepJD.MaterializingInfos.erase(SymbolStringPtr(DepName));
3654 DepJD.shrinkMaterializationInfoMemory();
3657 MI.DependantEDUs.clear();
3660 assert(!
MI.DefiningEDU &&
"DefiningEDU should have been reset");
3662 "DependantEDUs should have been removed above");
3664 "Can not delete MaterializingInfo with queries pending");
3665 JD.MaterializingInfos.erase(
Name);
3668 JD.shrinkMaterializationInfoMemory();
3670#ifdef EXPENSIVE_CHECKS
3671 verifySessionState(
"exiting ExecutionSession::IL_failSymbols");
3674 return std::make_pair(std::move(FailedQueries), std::move(FailedSymbolsMap));
3677void ExecutionSession::OL_notifyFailed(MaterializationResponsibility &MR) {
3680 dbgs() <<
"In " << MR.JD.getName() <<
" failing materialization for "
3681 << MR.SymbolFlags <<
"\n";
3684 if (MR.SymbolFlags.empty())
3688 for (
auto &[
Name, Flags] : MR.SymbolFlags)
3689 SymbolsToFail.push_back(
Name);
3690 MR.SymbolFlags.clear();
3692 JITDylib::AsynchronousSymbolQuerySet FailedQueries;
3693 std::shared_ptr<SymbolDependenceMap> FailedSymbols;
3697 if (MR.RT->isDefunct())
3698 return std::pair<JITDylib::AsynchronousSymbolQuerySet,
3699 std::shared_ptr<SymbolDependenceMap>>();
3700 return IL_failSymbols(MR.getTargetJITDylib(), SymbolsToFail);
3703 for (
auto &Q : FailedQueries)
3708Error ExecutionSession::OL_replace(MaterializationResponsibility &MR,
3709 std::unique_ptr<MaterializationUnit> MU) {
3710 for (
auto &KV : MU->getSymbols()) {
3711 assert(MR.SymbolFlags.count(KV.first) &&
3712 "Replacing definition outside this responsibility set");
3713 MR.SymbolFlags.erase(KV.first);
3716 if (MU->getInitializerSymbol() == MR.InitSymbol)
3717 MR.InitSymbol =
nullptr;
3719 LLVM_DEBUG(MR.JD.getExecutionSession().runSessionLocked([&]() {
3720 dbgs() <<
"In " << MR.JD.getName() <<
" replacing symbols with " << *MU
3724 return MR.JD.replace(MR, std::move(MU));
3727Expected<std::unique_ptr<MaterializationResponsibility>>
3728ExecutionSession::OL_delegate(MaterializationResponsibility &MR,
3731 SymbolStringPtr DelegatedInitSymbol;
3734 for (
auto &
Name : Symbols) {
3735 auto I = MR.SymbolFlags.find(
Name);
3736 assert(
I != MR.SymbolFlags.end() &&
3737 "Symbol is not tracked by this MaterializationResponsibility "
3740 DelegatedFlags[
Name] = std::move(
I->second);
3741 if (
Name == MR.InitSymbol)
3742 std::swap(MR.InitSymbol, DelegatedInitSymbol);
3744 MR.SymbolFlags.erase(
I);
3747 return MR.JD.delegate(MR, std::move(DelegatedFlags),
3748 std::move(DelegatedInitSymbol));
3752void ExecutionSession::dumpDispatchInfo(Task &
T) {
3754 dbgs() <<
"Dispatching: ";
3755 T.printDescription(
dbgs());
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
aarch64 falkor hwpf fix Falkor HW Prefetch Fix Late Phase
while(!ToSimplify.empty())
static StringRef getName(Value *V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static uint32_t getFlags(const Symbol *Sym)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
const T & front() const
front - Get the first element.
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
iterator find(const_arg_type_t< KeyT > Val)
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.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Helper for Errors used as out-parameters.
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.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Symbol info for RuntimeDyld.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
std::pair< iterator, bool > insert(const ValueT &V)
iterator find(const_arg_type_t< ValueT > V)
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
const std::string & getName() const
Get the name for this JITLinkDylib.
StringRef getName() const override
Return the name of this materialization unit.
AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols)
AsynchronousSymbolQuery(const SymbolLookupSet &Symbols, SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete)
Create a query for the given symbols.
void notifySymbolMetRequiredState(const SymbolStringPtr &Name, ExecutorSymbolDef Sym)
Notify the query that a requested symbol has reached the required state.
Definition generators can be attached to JITDylibs to generate new definitions for otherwise unresolv...
virtual ~DefinitionGenerator()
An ExecutionSession represents a running JIT program.
Error endSession()
End the session.
void reportError(Error Err)
Report a error for this execution session.
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.
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.
JITDylib & createBareJITDylib(std::string Name)
Add a new bare JITDylib to this ExecutionSession.
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...
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.
void deregisterResourceManager(ResourceManager &RM)
Deregister the given ResourceManager with this ExecutionSession.
ExecutionSession(std::unique_ptr< ExecutorProcessControl > EPC)
Construct an ExecutionSession with the given ExecutorProcessControl object.
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.
Error removeJITDylibs(std::vector< JITDylibSP > JDsToRemove)
Removes the given JITDylibs from the ExecutionSession.
Expected< JITDylib & > createJITDylib(std::string Name)
Add a new JITDylib to this ExecutionSession.
void dispatchTask(std::unique_ptr< Task > T)
Materialize the given unit.
Represents an address in the executor process.
Represents a defining location for a JIT symbol.
FailedToMaterialize(std::shared_ptr< SymbolStringPool > SSP, std::shared_ptr< SymbolDependenceMap > 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.
InProgressFullLookupState(LookupKind K, JITDylibSearchOrder SearchOrder, SymbolLookupSet LookupSet, SymbolState RequiredState, std::shared_ptr< AsynchronousSymbolQuery > Q, RegisterDependenciesFunction RegisterDependencies)
void complete(std::unique_ptr< InProgressLookupState > IPLS) override
void fail(Error Err) override
void complete(std::unique_ptr< InProgressLookupState > IPLS) override
void fail(Error Err) override
InProgressLookupFlagsState(LookupKind K, JITDylibSearchOrder SearchOrder, SymbolLookupSet LookupSet, unique_function< void(Expected< SymbolFlagsMap >)> OnComplete)
virtual ~InProgressLookupState()=default
SymbolLookupSet DefGeneratorCandidates
JITDylibSearchOrder SearchOrder
std::vector< std::weak_ptr< DefinitionGenerator > > CurDefGeneratorStack
size_t CurSearchOrderIndex
SymbolLookupSet LookupSet
virtual void complete(std::unique_ptr< InProgressLookupState > IPLS)=0
InProgressLookupState(LookupKind K, JITDylibSearchOrder SearchOrder, SymbolLookupSet LookupSet, SymbolState RequiredState)
SymbolState RequiredState
SymbolLookupSet DefGeneratorNonCandidates
virtual void fail(Error Err)=0
enum llvm::orc::InProgressLookupState::@471 GenState
Represents a JIT'd dynamic library.
Error clear()
Calls remove on all trackers currently associated with this JITDylib.
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.
ResourceTrackerSP createResourceTracker()
Create a resource tracker for this JITDylib.
Expected< std::vector< JITDylibSP > > getReverseDFSLinkOrder()
Rteurn this JITDylib and its transitive dependencies in reverse DFS order based on linkage relationsh...
ResourceTrackerSP getDefaultResourceTracker()
Get the default resource tracker for this JITDylib.
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 &&)
void printDescription(raw_ostream &OS) override
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
void printDescription(raw_ostream &OS) override
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
SymbolFlagsMap SymbolFlags
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.
Non-owning SymbolStringPool entry pointer.
StringRef getName() const override
Return the name of this materialization unit.
ReExportsMaterializationUnit(JITDylib *SourceJD, JITDylibLookupFlags SourceJDLookupFlags, SymbolAliasMap Aliases)
SourceJD is allowed to be nullptr, in which case the source JITDylib is taken to be whatever JITDylib...
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.
ReexportsGenerator(JITDylib &SourceJD, JITDylibLookupFlags SourceJDLookupFlags, SymbolPredicate Allow=SymbolPredicate())
Create a reexports generator.
Listens for ResourceTracker operations.
virtual ~ResourceManager()
ResourceTrackerDefunct(ResourceTrackerSP RT)
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.
void transferTo(ResourceTracker &DstRT)
Transfer all resources associated with this key to the given tracker, which must target the same JITD...
ResourceTracker(const ResourceTracker &)=delete
Error remove()
Remove all resources associated with this key.
A set of symbols to look up, each associated with a SymbolLookupFlags value.
static SymbolLookupSet fromMapKeys(const DenseMap< SymbolStringPtr, ValT > &M, SymbolLookupFlags Flags=SymbolLookupFlags::RequiredSymbol)
Construct a SymbolLookupSet from DenseMap keys.
Pointer to a pooled string representing a symbol name.
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.
SymbolsCouldNotBeRemoved(std::shared_ptr< SymbolStringPool > SSP, SymbolNameSet Symbols)
void log(raw_ostream &OS) const override
Print an error message to an output stream.
SymbolsNotFound(std::shared_ptr< SymbolStringPool > SSP, SymbolNameSet Symbols)
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Represents an abstract task for ORC to run.
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.
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.
UnsatisfiedSymbolDependencies(std::shared_ptr< SymbolStringPool > SSP, JITDylibSP JD, SymbolNameSet FailedSymbols, SymbolDependenceMap BadDeps, std::string Explanation)
static WrapperFunctionResult createOutOfBandError(const char *Msg)
Create an out-of-band error by copying the given string.
A raw_ostream that writes to a file descriptor.
This class implements an extremely fast bulk output stream that can only output to a stream.
IntrusiveRefCntPtr< JITDylib > JITDylibSP
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.
@ MissingSymbolDefinitions
@ UnexpectedSymbolDefinitions
std::unique_ptr< ReExportsMaterializationUnit > symbolAliases(SymbolAliasMap Aliases)
Create a ReExportsMaterializationUnit with the given aliases.
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...
DenseMap< SymbolStringPtr, SymbolAliasMapEntry > SymbolAliasMap
A map of Symbols to (Symbol, Flags) pairs.
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.
std::error_code orcError(OrcErrorCode ErrCode)
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 ...
NodeAddr< DefNode * > Def
This is an optimization pass for GlobalISel generic memory operations.
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
auto reverse(ContainerTy &&C)
Error joinErrors(Error E1, Error E2)
Concatenate errors.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
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.