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 &KV : *this->Symbols)
95 for (
auto &KV : *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 &KV : 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 &KV : QueryRegistrations)
275 KV.first->detachQueryHelper(*
this, KV.second);
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 &KV : Symbols)
316 Flags[KV.first] = KV.second.getFlags();
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());
1006 bool LinkAgainstThisJITDylibFirst) {
1008 assert(State == Open &&
"JD is defunct");
1009 if (LinkAgainstThisJITDylibFirst) {
1011 if (NewLinkOrder.empty() || NewLinkOrder.front().first !=
this)
1012 LinkOrder.push_back(
1013 std::make_pair(
this, JITDylibLookupFlags::MatchAllSymbols));
1016 LinkOrder = std::move(NewLinkOrder);
1022 for (
auto &KV : NewLinks) {
1027 LinkOrder.push_back(std::move(KV));
1039 assert(State == Open &&
"JD is defunct");
1040 for (
auto &KV : LinkOrder)
1041 if (KV.first == &OldJD) {
1042 KV = {&NewJD, JDLookupFlags};
1050 assert(State == Open &&
"JD is defunct");
1052 [&](
const JITDylibSearchOrder::value_type &KV) {
1053 return KV.first == &JD;
1055 if (
I != LinkOrder.end())
1062 assert(State == Open &&
"JD is defunct");
1063 using SymbolMaterializerItrPair =
1064 std::pair<SymbolTable::iterator, UnmaterializedInfosMap::iterator>;
1065 std::vector<SymbolMaterializerItrPair> SymbolsToRemove;
1069 for (
auto &
Name : Names) {
1070 auto I = Symbols.find(
Name);
1073 if (
I == Symbols.end()) {
1074 Missing.insert(
Name);
1079 if (
I->second.getState() != SymbolState::NeverSearched &&
1080 I->second.getState() != SymbolState::Ready) {
1085 auto UMII =
I->second.hasMaterializerAttached()
1086 ? UnmaterializedInfos.find(
Name)
1087 : UnmaterializedInfos.end();
1088 SymbolsToRemove.push_back(std::make_pair(
I, UMII));
1092 if (!Missing.empty())
1094 std::move(Missing));
1102 for (
auto &SymbolMaterializerItrPair : SymbolsToRemove) {
1103 auto UMII = SymbolMaterializerItrPair.second;
1106 if (UMII != UnmaterializedInfos.end()) {
1107 UMII->second->MU->doDiscard(*
this, UMII->first);
1108 UnmaterializedInfos.erase(UMII);
1111 auto SymI = SymbolMaterializerItrPair.first;
1112 Symbols.erase(SymI);
1115 return Error::success();
1121 OS <<
"JITDylib \"" <<
getName() <<
"\" (ES: "
1122 <<
format(
"0x%016" PRIx64,
reinterpret_cast<uintptr_t
>(&ES))
1136 if (State == Closed)
1138 OS <<
"Link order: " << LinkOrder <<
"\n"
1139 <<
"Symbol table:\n";
1142 std::vector<std::pair<SymbolStringPtr, SymbolTableEntry *>> SymbolsSorted;
1143 for (
auto &KV : Symbols)
1144 SymbolsSorted.emplace_back(KV.first, &KV.second);
1145 std::sort(SymbolsSorted.begin(), SymbolsSorted.end(),
1146 [](
const auto &L,
const auto &R) { return *L.first < *R.first; });
1148 for (
auto &KV : SymbolsSorted) {
1149 OS <<
" \"" << *KV.first <<
"\": ";
1150 if (
auto Addr = KV.second->getAddress())
1153 OS <<
"<not resolved> ";
1155 OS <<
" " << KV.second->getFlags() <<
" " << KV.second->getState();
1157 if (KV.second->hasMaterializerAttached()) {
1158 OS <<
" (Materializer ";
1159 auto I = UnmaterializedInfos.find(KV.first);
1160 assert(
I != UnmaterializedInfos.end() &&
1161 "Lazy symbol should have UnmaterializedInfo");
1162 OS <<
I->second->MU.get() <<
", " <<
I->second->MU->getName() <<
")\n";
1167 if (!MaterializingInfos.empty())
1168 OS <<
" MaterializingInfos entries:\n";
1169 for (
auto &KV : MaterializingInfos) {
1170 OS <<
" \"" << *KV.first <<
"\":\n"
1171 <<
" " << KV.second.pendingQueries().size()
1172 <<
" pending queries: { ";
1173 for (
const auto &Q : KV.second.pendingQueries())
1174 OS << Q.get() <<
" (" << Q->getRequiredState() <<
") ";
1175 OS <<
"}\n Defining EDU: ";
1176 if (KV.second.DefiningEDU) {
1177 OS << KV.second.DefiningEDU.get() <<
" { ";
1178 for (
auto &[
Name, Flags] : KV.second.DefiningEDU->Symbols)
1181 OS <<
" Dependencies:\n";
1182 if (!KV.second.DefiningEDU->Dependencies.empty()) {
1183 for (
auto &[DepJD, Deps] : KV.second.DefiningEDU->Dependencies) {
1184 OS <<
" " << DepJD->getName() <<
": [ ";
1185 for (
auto &Dep : Deps)
1193 OS <<
" Dependant EDUs:\n";
1194 if (!KV.second.DependantEDUs.empty()) {
1195 for (
auto &DependantEDU : KV.second.DependantEDUs) {
1196 OS <<
" " << DependantEDU <<
": "
1197 << DependantEDU->JD->getName() <<
" { ";
1198 for (
auto &[
Name, Flags] : DependantEDU->Symbols)
1204 assert((Symbols[KV.first].getState() != SymbolState::Ready ||
1205 (KV.second.pendingQueries().empty() && !KV.second.DefiningEDU &&
1206 !KV.second.DependantEDUs.empty())) &&
1207 "Stale materializing info entry");
1212void JITDylib::MaterializingInfo::addQuery(
1213 std::shared_ptr<AsynchronousSymbolQuery> Q) {
1217 [](
const std::shared_ptr<AsynchronousSymbolQuery> &V,
SymbolState S) {
1218 return V->getRequiredState() <= S;
1220 PendingQueries.insert(
I.base(), std::move(Q));
1223void JITDylib::MaterializingInfo::removeQuery(
1224 const AsynchronousSymbolQuery &Q) {
1227 PendingQueries, [&Q](
const std::shared_ptr<AsynchronousSymbolQuery> &V) {
1228 return V.get() == &Q;
1230 assert(
I != PendingQueries.end() &&
1231 "Query is not attached to this MaterializingInfo");
1232 PendingQueries.erase(
I);
1235JITDylib::AsynchronousSymbolQueryList
1236JITDylib::MaterializingInfo::takeQueriesMeeting(SymbolState RequiredState) {
1237 AsynchronousSymbolQueryList
Result;
1238 while (!PendingQueries.empty()) {
1239 if (PendingQueries.back()->getRequiredState() > RequiredState)
1242 Result.push_back(std::move(PendingQueries.back()));
1243 PendingQueries.pop_back();
1249JITDylib::JITDylib(ExecutionSession &ES, std::string
Name)
1254std::pair<JITDylib::AsynchronousSymbolQuerySet,
1255 std::shared_ptr<SymbolDependenceMap>>
1256JITDylib::removeTracker(ResourceTracker &RT) {
1258 assert(State != Closed &&
"JD is defunct");
1263 if (&RT == DefaultTracker.
get()) {
1265 for (
auto &KV : TrackerSymbols)
1266 for (
auto &
Sym : KV.second)
1269 for (
auto &KV : Symbols) {
1270 auto &
Sym = KV.first;
1271 if (!TrackedSymbols.count(
Sym))
1272 SymbolsToRemove.push_back(
Sym);
1275 DefaultTracker.
reset();
1278 auto I = TrackerSymbols.find(&RT);
1279 if (
I != TrackerSymbols.end()) {
1280 SymbolsToRemove = std::move(
I->second);
1281 TrackerSymbols.erase(
I);
1286 for (
auto &
Sym : SymbolsToRemove) {
1287 assert(Symbols.count(
Sym) &&
"Symbol not in symbol table");
1290 auto MII = MaterializingInfos.
find(
Sym);
1291 if (MII != MaterializingInfos.
end())
1292 SymbolsToFail.push_back(
Sym);
1295 AsynchronousSymbolQuerySet QueriesToFail;
1296 auto Result = ES.runSessionLocked(
1297 [&]() {
return ES.IL_failSymbols(*
this, std::move(SymbolsToFail)); });
1300 for (
auto &
Sym : SymbolsToRemove) {
1301 auto I = Symbols.find(
Sym);
1302 assert(
I != Symbols.end() &&
"Symbol not present in table");
1305 if (
I->second.hasMaterializerAttached()) {
1310 "Symbol has materializer attached");
1319void JITDylib::transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT) {
1320 assert(State != Closed &&
"JD is defunct");
1321 assert(&DstRT != &SrcRT &&
"No-op transfers shouldn't call transferTracker");
1322 assert(&DstRT.getJITDylib() ==
this &&
"DstRT is not for this JITDylib");
1323 assert(&SrcRT.getJITDylib() ==
this &&
"SrcRT is not for this JITDylib");
1326 for (
auto &KV : UnmaterializedInfos) {
1327 if (KV.second->RT == &SrcRT)
1328 KV.second->RT = &DstRT;
1333 auto I = TrackerMRs.find(&SrcRT);
1334 if (
I != TrackerMRs.end()) {
1335 auto &SrcMRs =
I->second;
1336 auto &DstMRs = TrackerMRs[&DstRT];
1337 for (
auto *MR : SrcMRs)
1340 DstMRs = std::move(SrcMRs);
1342 for (
auto *MR : SrcMRs)
1346 TrackerMRs.erase(&SrcRT);
1352 if (&DstRT == DefaultTracker.
get()) {
1353 TrackerSymbols.erase(&SrcRT);
1359 if (&SrcRT == DefaultTracker.
get()) {
1360 assert(!TrackerSymbols.count(&SrcRT) &&
1361 "Default tracker should not appear in TrackerSymbols");
1366 for (
auto &KV : TrackerSymbols)
1367 for (
auto &
Sym : KV.second)
1370 for (
auto &KV : Symbols) {
1371 auto &
Sym = KV.first;
1372 if (!CurrentlyTrackedSymbols.count(
Sym))
1373 SymbolsToTrack.push_back(
Sym);
1376 TrackerSymbols[&DstRT] = std::move(SymbolsToTrack);
1380 auto &DstTrackedSymbols = TrackerSymbols[&DstRT];
1384 auto SI = TrackerSymbols.find(&SrcRT);
1385 if (SI == TrackerSymbols.end())
1388 DstTrackedSymbols.reserve(DstTrackedSymbols.size() +
SI->second.size());
1389 for (
auto &
Sym :
SI->second)
1390 DstTrackedSymbols.push_back(std::move(
Sym));
1391 TrackerSymbols.erase(SI);
1394Error JITDylib::defineImpl(MaterializationUnit &MU) {
1399 std::vector<SymbolStringPtr> ExistingDefsOverridden;
1400 std::vector<SymbolStringPtr> MUDefsOverridden;
1402 for (
const auto &KV : MU.getSymbols()) {
1403 auto I = Symbols.find(KV.first);
1405 if (
I != Symbols.end()) {
1406 if (KV.second.isStrong()) {
1407 if (
I->second.getFlags().isStrong() ||
1409 Duplicates.insert(KV.first);
1412 "Overridden existing def should be in the never-searched "
1414 ExistingDefsOverridden.push_back(KV.first);
1417 MUDefsOverridden.push_back(KV.first);
1422 if (!Duplicates.empty()) {
1424 {
dbgs() <<
" Error: Duplicate symbols " << Duplicates <<
"\n"; });
1425 return make_error<DuplicateDefinition>(std::string(**Duplicates.begin()));
1430 if (!MUDefsOverridden.empty())
1431 dbgs() <<
" Defs in this MU overridden: " << MUDefsOverridden <<
"\n";
1433 for (
auto &S : MUDefsOverridden)
1434 MU.doDiscard(*
this, S);
1438 if (!ExistingDefsOverridden.empty())
1439 dbgs() <<
" Existing defs overridden by this MU: " << MUDefsOverridden
1442 for (
auto &S : ExistingDefsOverridden) {
1444 auto UMII = UnmaterializedInfos.find(S);
1445 assert(UMII != UnmaterializedInfos.end() &&
1446 "Overridden existing def should have an UnmaterializedInfo");
1447 UMII->second->MU->doDiscard(*
this, S);
1451 for (
auto &KV : MU.getSymbols()) {
1452 auto &SymEntry = Symbols[KV.first];
1453 SymEntry.setFlags(KV.second);
1455 SymEntry.setMaterializerAttached(
true);
1461void JITDylib::installMaterializationUnit(
1462 std::unique_ptr<MaterializationUnit> MU, ResourceTracker &RT) {
1465 if (&RT != DefaultTracker.
get()) {
1466 auto &TS = TrackerSymbols[&RT];
1467 TS.reserve(TS.size() + MU->getSymbols().size());
1468 for (
auto &KV : MU->getSymbols())
1469 TS.push_back(KV.first);
1472 auto UMI = std::make_shared<UnmaterializedInfo>(std::move(MU), &RT);
1473 for (
auto &KV : UMI->MU->getSymbols())
1474 UnmaterializedInfos[KV.first] = UMI;
1477void JITDylib::detachQueryHelper(AsynchronousSymbolQuery &Q,
1479 for (
auto &QuerySymbol : QuerySymbols) {
1481 "QuerySymbol does not have MaterializingInfo");
1482 auto &
MI = MaterializingInfos[QuerySymbol];
1495 std::mutex LookupMutex;
1496 std::condition_variable CV;
1500 dbgs() <<
"Issuing init-symbol lookup:\n";
1501 for (
auto &KV : InitSyms)
1502 dbgs() <<
" " << KV.first->getName() <<
": " << KV.second <<
"\n";
1505 for (
auto &KV : InitSyms) {
1506 auto *JD = KV.first;
1507 auto Names = std::move(KV.second);
1514 std::lock_guard<std::mutex> Lock(LookupMutex);
1518 "Duplicate JITDylib in lookup?");
1519 CompoundResult[JD] = std::move(*
Result);
1529 std::unique_lock<std::mutex> Lock(LookupMutex);
1530 CV.wait(Lock, [&] {
return Count == 0 || CompoundErr; });
1533 return std::move(CompoundErr);
1535 return std::move(CompoundResult);
1542 class TriggerOnComplete {
1545 TriggerOnComplete(OnCompleteFn OnComplete)
1546 : OnComplete(std::move(OnComplete)) {}
1547 ~TriggerOnComplete() { OnComplete(std::move(LookupResult)); }
1548 void reportResult(
Error Err) {
1549 std::lock_guard<std::mutex> Lock(ResultMutex);
1550 LookupResult =
joinErrors(std::move(LookupResult), std::move(Err));
1554 std::mutex ResultMutex;
1555 Error LookupResult{Error::success()};
1556 OnCompleteFn OnComplete;
1560 dbgs() <<
"Issuing init-symbol lookup:\n";
1561 for (
auto &KV : InitSyms)
1562 dbgs() <<
" " << KV.first->getName() <<
": " << KV.second <<
"\n";
1565 auto TOC = std::make_shared<TriggerOnComplete>(std::move(OnComplete));
1567 for (
auto &KV : InitSyms) {
1568 auto *JD = KV.first;
1569 auto Names = std::move(KV.second);
1575 TOC->reportResult(
Result.takeError());
1582 OS <<
"Materialization task: " << MU->getName() <<
" in "
1583 << MR->getTargetJITDylib().getName();
1595 this->EPC->ES =
this;
1601 "Session still open. Did you forget to call endSession?");
1605 LLVM_DEBUG(
dbgs() <<
"Ending ExecutionSession " <<
this <<
"\n");
1608 SessionOpen =
false;
1612 std::reverse(JDsToRemove.begin(), JDsToRemove.end());
1616 Err =
joinErrors(std::move(Err), EPC->disconnect());
1627 assert(!ResourceManagers.empty() &&
"No managers registered");
1628 if (ResourceManagers.back() == &RM)
1629 ResourceManagers.pop_back();
1632 assert(
I != ResourceManagers.end() &&
"RM not registered");
1633 ResourceManagers.erase(
I);
1640 for (
auto &JD : JDs)
1641 if (JD->getName() ==
Name)
1650 assert(SessionOpen &&
"Cannot create JITDylib after session is closed");
1659 if (
auto Err = P->setupJITDylib(JD))
1660 return std::move(Err);
1668 for (
auto &JD : JDsToRemove) {
1669 assert(JD->State == JITDylib::Open &&
"JD already closed");
1670 JD->State = JITDylib::Closing;
1672 assert(
I != JDs.end() &&
"JD does not appear in session JDs");
1679 for (
auto JD : JDsToRemove) {
1680 Err =
joinErrors(std::move(Err), JD->clear());
1682 Err =
joinErrors(std::move(Err), P->teardownJITDylib(*JD));
1687 for (
auto &JD : JDsToRemove) {
1688 assert(JD->State == JITDylib::Closing &&
"JD should be closing");
1689 JD->State = JITDylib::Closed;
1690 assert(JD->Symbols.empty() &&
"JD.Symbols is not empty after clear");
1691 assert(JD->UnmaterializedInfos.empty() &&
1692 "JD.UnmaterializedInfos is not empty after clear");
1693 assert(JD->MaterializingInfos.empty() &&
1694 "JD.MaterializingInfos is not empty after clear");
1695 assert(JD->TrackerSymbols.empty() &&
1696 "TrackerSymbols is not empty after clear");
1697 JD->DefGenerators.clear();
1698 JD->LinkOrder.clear();
1708 return std::vector<JITDylibSP>();
1710 auto &ES = JDs.
front()->getExecutionSession();
1711 return ES.runSessionLocked([&]() ->
Expected<std::vector<JITDylibSP>> {
1713 std::vector<JITDylibSP>
Result;
1715 for (
auto &JD : JDs) {
1717 if (JD->State != Open)
1718 return make_error<StringError>(
1719 "Error building link order: " + JD->getName() +
" is defunct",
1721 if (Visited.
count(JD.get()))
1726 Visited.
insert(JD.get());
1728 while (!WorkStack.empty()) {
1729 Result.push_back(std::move(WorkStack.back()));
1730 WorkStack.pop_back();
1732 for (auto &KV : llvm::reverse(Result.back()->LinkOrder)) {
1733 auto &JD = *KV.first;
1734 if (!Visited.insert(&JD).second)
1736 WorkStack.push_back(&JD);
1764 OL_applyQueryPhase1(std::make_unique<InProgressLookupFlagsState>(
1765 K, std::move(SearchOrder), std::move(LookupSet),
1766 std::move(OnComplete)),
1774 std::promise<MSVCPExpected<SymbolFlagsMap>> ResultP;
1775 OL_applyQueryPhase1(std::make_unique<InProgressLookupFlagsState>(
1776 K, std::move(SearchOrder), std::move(LookupSet),
1778 ResultP.set_value(std::move(
Result));
1782 auto ResultF = ResultP.get_future();
1783 return ResultF.get();
1794 dbgs() <<
"Looking up " << Symbols <<
" in " << SearchOrder
1795 <<
" (required state: " << RequiredState <<
")\n";
1802 dispatchOutstandingMUs();
1804 auto Unresolved = std::move(Symbols);
1805 auto Q = std::make_shared<AsynchronousSymbolQuery>(Unresolved, RequiredState,
1806 std::move(NotifyComplete));
1808 auto IPLS = std::make_unique<InProgressFullLookupState>(
1809 K, SearchOrder, std::move(Unresolved), RequiredState, std::move(Q),
1810 std::move(RegisterDependencies));
1820#if LLVM_ENABLE_THREADS
1822 std::promise<SymbolMap> PromisedResult;
1827 PromisedResult.set_value(std::move(*R));
1830 ResolutionError = R.takeError();
1844 ResolutionError = R.takeError();
1849 lookup(K, SearchOrder, std::move(Symbols), RequiredState, NotifyComplete,
1850 RegisterDependencies);
1852#if LLVM_ENABLE_THREADS
1853 auto ResultFuture = PromisedResult.get_future();
1854 auto Result = ResultFuture.get();
1856 if (ResolutionError)
1857 return std::move(ResolutionError);
1859 return std::move(
Result);
1862 if (ResolutionError)
1863 return std::move(ResolutionError);
1876 assert(ResultMap->size() == 1 &&
"Unexpected number of results");
1877 assert(ResultMap->count(
Name) &&
"Missing result for symbol");
1878 return std::move(ResultMap->begin()->second);
1880 return ResultMap.takeError();
1902 return TagAddrs.takeError();
1905 std::lock_guard<std::mutex> Lock(JITDispatchHandlersMutex);
1906 for (
auto &KV : *TagAddrs) {
1907 auto TagAddr = KV.second.getAddress();
1908 if (JITDispatchHandlers.count(TagAddr))
1909 return make_error<StringError>(
"Tag " +
formatv(
"{0:x16}", TagAddr) +
1910 " (for " + *KV.first +
1911 ") already registered",
1913 auto I = WFs.
find(KV.first);
1915 "JITDispatchHandler implementation missing");
1916 JITDispatchHandlers[KV.second.getAddress()] =
1917 std::make_shared<JITDispatchHandlerFunction>(std::move(
I->second));
1919 dbgs() <<
"Associated function tag \"" << *KV.first <<
"\" ("
1920 <<
formatv(
"{0:x}", KV.second.getAddress()) <<
") with handler\n";
1930 std::shared_ptr<JITDispatchHandlerFunction>
F;
1932 std::lock_guard<std::mutex> Lock(JITDispatchHandlersMutex);
1933 auto I = JITDispatchHandlers.find(HandlerFnTagAddr);
1934 if (
I != JITDispatchHandlers.end())
1939 (*F)(std::move(SendResult), ArgBuffer.
data(), ArgBuffer.
size());
1942 (
"No function registered for tag " +
1943 formatv(
"{0:x16}", HandlerFnTagAddr))
1949 for (
auto &JD : JDs)
1954void ExecutionSession::dispatchOutstandingMUs() {
1957 std::optional<std::pair<std::unique_ptr<MaterializationUnit>,
1958 std::unique_ptr<MaterializationResponsibility>>>
1962 std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
1963 if (!OutstandingMUs.empty()) {
1964 JMU.emplace(std::move(OutstandingMUs.back()));
1965 OutstandingMUs.pop_back();
1972 assert(JMU->first &&
"No MU?");
1973 LLVM_DEBUG(
dbgs() <<
" Dispatching \"" << JMU->first->getName() <<
"\"\n");
1974 dispatchTask(std::make_unique<MaterializationTask>(std::move(JMU->first),
1975 std::move(JMU->second)));
1977 LLVM_DEBUG(
dbgs() <<
"Done dispatching MaterializationUnits.\n");
1980Error ExecutionSession::removeResourceTracker(ResourceTracker &RT) {
1982 dbgs() <<
"In " << RT.getJITDylib().getName() <<
" removing tracker "
1983 <<
formatv(
"{0:x}", RT.getKeyUnsafe()) <<
"\n";
1985 std::vector<ResourceManager *> CurrentResourceManagers;
1987 JITDylib::AsynchronousSymbolQuerySet QueriesToFail;
1988 std::shared_ptr<SymbolDependenceMap> FailedSymbols;
1991 CurrentResourceManagers = ResourceManagers;
1993 std::tie(QueriesToFail, FailedSymbols) = RT.getJITDylib().removeTracker(RT);
1998 auto &JD = RT.getJITDylib();
1999 for (
auto *L :
reverse(CurrentResourceManagers))
2001 L->handleRemoveResources(JD, RT.getKeyUnsafe()));
2003 for (
auto &Q : QueriesToFail)
2010void ExecutionSession::transferResourceTracker(ResourceTracker &DstRT,
2011 ResourceTracker &SrcRT) {
2013 dbgs() <<
"In " << SrcRT.getJITDylib().getName()
2014 <<
" transfering resources from tracker "
2015 <<
formatv(
"{0:x}", SrcRT.getKeyUnsafe()) <<
" to tracker "
2016 <<
formatv(
"{0:x}", DstRT.getKeyUnsafe()) <<
"\n";
2020 if (&DstRT == &SrcRT)
2023 assert(&DstRT.getJITDylib() == &SrcRT.getJITDylib() &&
2024 "Can't transfer resources between JITDylibs");
2026 SrcRT.makeDefunct();
2027 auto &JD = DstRT.getJITDylib();
2028 JD.transferTracker(DstRT, SrcRT);
2029 for (
auto *L :
reverse(ResourceManagers))
2030 L->handleTransferResources(JD, DstRT.getKeyUnsafe(),
2031 SrcRT.getKeyUnsafe());
2035void ExecutionSession::destroyResourceTracker(ResourceTracker &RT) {
2038 dbgs() <<
"In " << RT.getJITDylib().getName() <<
" destroying tracker "
2039 <<
formatv(
"{0:x}", RT.getKeyUnsafe()) <<
"\n";
2041 if (!RT.isDefunct())
2042 transferResourceTracker(*RT.getJITDylib().getDefaultResourceTracker(),
2047Error ExecutionSession::IL_updateCandidatesFor(
2049 SymbolLookupSet &Candidates, SymbolLookupSet *NonCandidates) {
2050 return Candidates.forEachWithRemoval(
2051 [&](
const SymbolStringPtr &
Name,
2055 auto SymI = JD.Symbols.find(
Name);
2056 if (SymI == JD.Symbols.end())
2064 if (!SymI->second.getFlags().isExported() &&
2067 NonCandidates->add(Name, SymLookupFlags);
2076 if (SymI->second.getFlags().hasMaterializationSideEffectsOnly() &&
2083 if (SymI->second.getFlags().hasError()) {
2084 auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
2085 (*FailedSymbolsMap)[&JD] = {Name};
2087 std::move(FailedSymbolsMap));
2095void ExecutionSession::OL_resumeLookupAfterGeneration(
2096 InProgressLookupState &IPLS) {
2099 "Should not be called for not-in-generator lookups");
2104 if (
auto DG = IPLS.CurDefGeneratorStack.back().lock()) {
2105 IPLS.CurDefGeneratorStack.pop_back();
2106 std::lock_guard<std::mutex> Lock(DG->M);
2110 if (DG->PendingLookups.empty()) {
2116 LS = std::move(DG->PendingLookups.front());
2117 DG->PendingLookups.pop_front();
2122 dispatchTask(std::make_unique<LookupTask>(std::move(LS)));
2126void ExecutionSession::OL_applyQueryPhase1(
2127 std::unique_ptr<InProgressLookupState> IPLS, Error Err) {
2130 dbgs() <<
"Entering OL_applyQueryPhase1:\n"
2131 <<
" Lookup kind: " << IPLS->K <<
"\n"
2132 <<
" Search order: " << IPLS->SearchOrder
2133 <<
", Current index = " << IPLS->CurSearchOrderIndex
2134 << (IPLS->NewJITDylib ?
" (entering new JITDylib)" :
"") <<
"\n"
2135 <<
" Lookup set: " << IPLS->LookupSet <<
"\n"
2136 <<
" Definition generator candidates: "
2137 << IPLS->DefGeneratorCandidates <<
"\n"
2138 <<
" Definition generator non-candidates: "
2139 << IPLS->DefGeneratorNonCandidates <<
"\n";
2143 OL_resumeLookupAfterGeneration(*IPLS);
2146 "Lookup should not be in InGenerator state here");
2153 while (IPLS->CurSearchOrderIndex != IPLS->SearchOrder.size()) {
2159 return IPLS->fail(std::move(Err));
2162 auto &KV = IPLS->SearchOrder[IPLS->CurSearchOrderIndex];
2163 auto &JD = *KV.first;
2164 auto JDLookupFlags = KV.second;
2167 dbgs() <<
"Visiting \"" << JD.getName() <<
"\" (" << JDLookupFlags
2168 <<
") with lookup set " << IPLS->LookupSet <<
":\n";
2172 if (IPLS->NewJITDylib) {
2176 SymbolLookupSet Tmp;
2177 std::swap(IPLS->DefGeneratorNonCandidates, Tmp);
2178 IPLS->DefGeneratorCandidates.append(std::move(Tmp));
2181 dbgs() <<
" First time visiting " << JD.getName()
2182 <<
", resetting candidate sets and building generator stack\n";
2187 IPLS->CurDefGeneratorStack.reserve(JD.DefGenerators.size());
2189 IPLS->CurDefGeneratorStack.push_back(DG);
2193 IPLS->NewJITDylib =
false;
2202 Err = IL_updateCandidatesFor(
2203 JD, JDLookupFlags, IPLS->DefGeneratorCandidates,
2204 JD.DefGenerators.empty() ?
nullptr
2205 : &IPLS->DefGeneratorNonCandidates);
2207 dbgs() <<
" Remaining candidates = " << IPLS->DefGeneratorCandidates
2215 IPLS->DefGeneratorCandidates.empty())
2216 OL_resumeLookupAfterGeneration(*IPLS);
2222 return IPLS->fail(std::move(Err));
2226 if (IPLS->CurDefGeneratorStack.empty())
2227 LLVM_DEBUG(
dbgs() <<
" No generators to run for this JITDylib.\n");
2228 else if (IPLS->DefGeneratorCandidates.empty())
2231 dbgs() <<
" Running " << IPLS->CurDefGeneratorStack.size()
2232 <<
" remaining generators for "
2233 << IPLS->DefGeneratorCandidates.size() <<
" candidates\n";
2235 while (!IPLS->CurDefGeneratorStack.empty() &&
2236 !IPLS->DefGeneratorCandidates.empty()) {
2237 auto DG = IPLS->CurDefGeneratorStack.back().lock();
2240 return IPLS->fail(make_error<StringError>(
2241 "DefinitionGenerator removed while lookup in progress",
2254 std::lock_guard<std::mutex> Lock(DG->M);
2256 DG->PendingLookups.push_back(std::move(IPLS));
2265 auto &LookupSet = IPLS->DefGeneratorCandidates;
2270 LLVM_DEBUG(
dbgs() <<
" Attempting to generate " << LookupSet <<
"\n");
2272 Err = DG->tryToGenerate(LS, K, JD, JDLookupFlags, LookupSet);
2273 IPLS = std::move(
LS.IPLS);
2279 OL_resumeLookupAfterGeneration(*IPLS);
2284 dbgs() <<
" Error attempting to generate " << LookupSet <<
"\n";
2286 assert(IPLS &&
"LS cannot be retained if error is returned");
2287 return IPLS->fail(std::move(Err));
2293 {
dbgs() <<
" LookupState captured. Exiting phase1 for now.\n"; });
2300 LLVM_DEBUG(
dbgs() <<
" Updating candidate set post-generation\n");
2301 Err = IL_updateCandidatesFor(
2302 JD, JDLookupFlags, IPLS->DefGeneratorCandidates,
2303 JD.DefGenerators.empty() ?
nullptr
2304 : &IPLS->DefGeneratorNonCandidates);
2309 LLVM_DEBUG(
dbgs() <<
" Error encountered while updating candidates\n");
2310 return IPLS->fail(std::move(Err));
2314 if (IPLS->DefGeneratorCandidates.empty() &&
2315 IPLS->DefGeneratorNonCandidates.empty()) {
2318 IPLS->CurSearchOrderIndex = IPLS->SearchOrder.size();
2324 ++IPLS->CurSearchOrderIndex;
2325 IPLS->NewJITDylib =
true;
2330 IPLS->DefGeneratorCandidates.remove_if(
2338 if (IPLS->DefGeneratorCandidates.empty()) {
2340 IPLS->complete(std::move(IPLS));
2342 LLVM_DEBUG(
dbgs() <<
"Phase 1 failed with unresolved symbols.\n");
2343 IPLS->fail(make_error<SymbolsNotFound>(
2348void ExecutionSession::OL_completeLookup(
2349 std::unique_ptr<InProgressLookupState> IPLS,
2350 std::shared_ptr<AsynchronousSymbolQuery> Q,
2354 dbgs() <<
"Entering OL_completeLookup:\n"
2355 <<
" Lookup kind: " << IPLS->K <<
"\n"
2356 <<
" Search order: " << IPLS->SearchOrder
2357 <<
", Current index = " << IPLS->CurSearchOrderIndex
2358 << (IPLS->NewJITDylib ?
" (entering new JITDylib)" :
"") <<
"\n"
2359 <<
" Lookup set: " << IPLS->LookupSet <<
"\n"
2360 <<
" Definition generator candidates: "
2361 << IPLS->DefGeneratorCandidates <<
"\n"
2362 <<
" Definition generator non-candidates: "
2363 << IPLS->DefGeneratorNonCandidates <<
"\n";
2366 bool QueryComplete =
false;
2367 DenseMap<JITDylib *, JITDylib::UnmaterializedInfosList> CollectedUMIs;
2370 for (
auto &KV : IPLS->SearchOrder) {
2371 auto &JD = *KV.first;
2372 auto JDLookupFlags = KV.second;
2374 dbgs() <<
"Visiting \"" << JD.getName() <<
"\" (" << JDLookupFlags
2375 <<
") with lookup set " << IPLS->LookupSet <<
":\n";
2378 auto Err = IPLS->LookupSet.forEachWithRemoval(
2379 [&](
const SymbolStringPtr &
Name,
2382 dbgs() <<
" Attempting to match \"" <<
Name <<
"\" ("
2383 << SymLookupFlags <<
")... ";
2388 auto SymI = JD.Symbols.find(
Name);
2389 if (SymI == JD.Symbols.end()) {
2396 if (!SymI->second.getFlags().isExported() &&
2408 if (SymI->second.getFlags().hasMaterializationSideEffectsOnly() &&
2412 "required, but symbol is has-side-effects-only\n";
2420 if (SymI->second.getFlags().hasError()) {
2422 auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
2423 (*FailedSymbolsMap)[&JD] = {
Name};
2424 return make_error<FailedToMaterialize>(
2432 if (SymI->second.getState() >= Q->getRequiredState()) {
2434 <<
"matched, symbol already in required state\n");
2435 Q->notifySymbolMetRequiredState(
Name, SymI->second.getSymbol());
2442 if (SymI->second.hasMaterializerAttached()) {
2443 assert(SymI->second.getAddress() == ExecutorAddr() &&
2444 "Symbol not resolved but already has address?");
2445 auto UMII = JD.UnmaterializedInfos.find(
Name);
2446 assert(UMII != JD.UnmaterializedInfos.end() &&
2447 "Lazy symbol should have UnmaterializedInfo");
2449 auto UMI = UMII->second;
2450 assert(UMI->MU &&
"Materializer should not be null");
2451 assert(UMI->RT &&
"Tracker should not be null");
2453 dbgs() <<
"matched, preparing to dispatch MU@" << UMI->MU.get()
2454 <<
" (" << UMI->MU->getName() <<
")\n";
2459 for (
auto &KV : UMI->MU->getSymbols()) {
2460 auto SymK = JD.Symbols.find(KV.first);
2461 assert(SymK != JD.Symbols.end() &&
2462 "No entry for symbol covered by MaterializationUnit");
2463 SymK->second.setMaterializerAttached(
false);
2465 JD.UnmaterializedInfos.erase(KV.first);
2469 CollectedUMIs[&JD].push_back(std::move(UMI));
2477 "By this line the symbol should be materializing");
2478 auto &
MI = JD.MaterializingInfos[
Name];
2480 Q->addQueryDependence(JD,
Name);
2489 dbgs() <<
"Lookup failed. Detaching query and replacing MUs.\n";
2496 for (
auto &KV : CollectedUMIs) {
2497 auto &JD = *KV.first;
2498 for (
auto &UMI : KV.second)
2499 for (
auto &KV2 : UMI->MU->getSymbols()) {
2500 assert(!JD.UnmaterializedInfos.count(KV2.first) &&
2501 "Unexpected materializer in map");
2502 auto SymI = JD.Symbols.find(KV2.first);
2503 assert(SymI != JD.Symbols.end() &&
"Missing symbol entry");
2505 "Can not replace symbol that is not materializing");
2506 assert(!SymI->second.hasMaterializerAttached() &&
2507 "MaterializerAttached flag should not be set");
2508 SymI->second.setMaterializerAttached(
true);
2509 JD.UnmaterializedInfos[KV2.first] = UMI;
2517 LLVM_DEBUG(
dbgs() <<
"Stripping unmatched weakly-referenced symbols\n");
2518 IPLS->LookupSet.forEachWithRemoval(
2521 Q->dropSymbol(
Name);
2527 if (!IPLS->LookupSet.empty()) {
2530 IPLS->LookupSet.getSymbolNames());
2534 QueryComplete = Q->isComplete();
2537 dbgs() <<
"Query successfully "
2538 << (QueryComplete ?
"completed" :
"lodged") <<
"\n";
2542 if (!CollectedUMIs.empty()) {
2543 std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
2546 for (
auto &KV : CollectedUMIs) {
2548 auto &JD = *KV.first;
2549 dbgs() <<
" For " << JD.getName() <<
": Adding " << KV.second.size()
2552 for (
auto &UMI : KV.second) {
2553 auto MR = createMaterializationResponsibility(
2554 *UMI->RT, std::move(UMI->MU->SymbolFlags),
2555 std::move(UMI->MU->InitSymbol));
2556 OutstandingMUs.push_back(
2557 std::make_pair(std::move(UMI->MU), std::move(MR)));
2563 if (RegisterDependencies && !Q->QueryRegistrations.empty()) {
2565 RegisterDependencies(Q->QueryRegistrations);
2575 Q->handleFailed(std::move(LodgingErr));
2579 if (QueryComplete) {
2581 Q->handleComplete(*
this);
2584 dispatchOutstandingMUs();
2587void ExecutionSession::OL_completeLookupFlags(
2588 std::unique_ptr<InProgressLookupState> IPLS,
2589 unique_function<
void(Expected<SymbolFlagsMap>)> OnComplete) {
2593 dbgs() <<
"Entering OL_completeLookupFlags:\n"
2594 <<
" Lookup kind: " << IPLS->K <<
"\n"
2595 <<
" Search order: " << IPLS->SearchOrder
2596 <<
", Current index = " << IPLS->CurSearchOrderIndex
2597 << (IPLS->NewJITDylib ?
" (entering new JITDylib)" :
"") <<
"\n"
2598 <<
" Lookup set: " << IPLS->LookupSet <<
"\n"
2599 <<
" Definition generator candidates: "
2600 << IPLS->DefGeneratorCandidates <<
"\n"
2601 <<
" Definition generator non-candidates: "
2602 << IPLS->DefGeneratorNonCandidates <<
"\n";
2608 for (
auto &KV : IPLS->SearchOrder) {
2609 auto &JD = *KV.first;
2610 auto JDLookupFlags = KV.second;
2612 dbgs() <<
"Visiting \"" << JD.getName() <<
"\" (" << JDLookupFlags
2613 <<
") with lookup set " << IPLS->LookupSet <<
":\n";
2616 IPLS->LookupSet.forEachWithRemoval([&](
const SymbolStringPtr &
Name,
2619 dbgs() <<
" Attempting to match \"" <<
Name <<
"\" ("
2620 << SymLookupFlags <<
")... ";
2625 auto SymI = JD.Symbols.find(
Name);
2626 if (SymI == JD.Symbols.end()) {
2632 if (!SymI->second.getFlags().isExported() &&
2639 dbgs() <<
"matched, \"" <<
Name <<
"\" -> " << SymI->second.getFlags()
2648 IPLS->LookupSet.remove_if(
2653 if (!IPLS->LookupSet.empty()) {
2656 IPLS->LookupSet.getSymbolNames());
2665 OnComplete(std::move(
Result));
2668void ExecutionSession::OL_destroyMaterializationResponsibility(
2669 MaterializationResponsibility &MR) {
2671 assert(MR.SymbolFlags.empty() &&
2672 "All symbols should have been explicitly materialized or failed");
2673 MR.JD.unlinkMaterializationResponsibility(MR);
2677 const MaterializationResponsibility &MR) {
2678 return MR.JD.getRequestedSymbols(MR.SymbolFlags);
2681Error ExecutionSession::OL_notifyResolved(MaterializationResponsibility &MR,
2684 dbgs() <<
"In " << MR.JD.getName() <<
" resolving " << Symbols <<
"\n";
2687 for (
auto &KV : Symbols) {
2688 auto I = MR.SymbolFlags.find(KV.first);
2689 assert(
I != MR.SymbolFlags.end() &&
2690 "Resolving symbol outside this responsibility set");
2691 assert(!
I->second.hasMaterializationSideEffectsOnly() &&
2692 "Can't resolve materialization-side-effects-only symbol");
2695 "Resolving symbol with incorrect flags");
2699 return MR.JD.resolve(MR, Symbols);
2702template <
typename HandleNewDepFn>
2703void ExecutionSession::propagateExtraEmitDeps(
2704 std::deque<JITDylib::EmissionDepUnit *> Worklist, EDUInfosMap &EDUInfos,
2705 HandleNewDepFn HandleNewDep) {
2709 while (!Worklist.empty()) {
2710 auto &EDU = *Worklist.front();
2711 Worklist.pop_front();
2713 assert(EDUInfos.count(&EDU) &&
"No info entry for EDU");
2714 auto &EDUInfo = EDUInfos[&EDU];
2717 for (
auto *UserEDU : EDUInfo.IntraEmitUsers) {
2720 JITDylib::EmissionDepUnitInfo *UserEDUInfo =
nullptr;
2722 auto UserEDUInfoItr = EDUInfos.find(UserEDU);
2723 if (UserEDUInfoItr != EDUInfos.end())
2724 UserEDUInfo = &UserEDUInfoItr->second;
2727 for (
auto &[DepJD, Deps] : EDUInfo.NewDeps) {
2728 auto &UserEDUDepsForJD = UserEDU->Dependencies[DepJD];
2729 DenseSet<NonOwningSymbolStringPtr> *UserEDUNewDepsForJD =
nullptr;
2730 for (
auto Dep : Deps) {
2731 if (UserEDUDepsForJD.insert(Dep).second) {
2732 HandleNewDep(*UserEDU, *DepJD, Dep);
2734 if (!UserEDUNewDepsForJD) {
2737 if (UserEDUInfo->NewDeps.empty())
2738 Worklist.push_back(UserEDU);
2739 UserEDUNewDepsForJD = &UserEDUInfo->NewDeps[DepJD];
2742 UserEDUNewDepsForJD->insert(Dep);
2749 EDUInfo.NewDeps.clear();
2754ExecutionSession::EDUInfosMap ExecutionSession::simplifyDepGroups(
2755 MaterializationResponsibility &MR,
2756 ArrayRef<SymbolDependenceGroup> EmittedDeps) {
2758 auto &TargetJD = MR.getTargetJITDylib();
2762 DenseMap<JITDylib::EmissionDepUnit *, JITDylib::EmissionDepUnitInfo> EDUInfos;
2763 EDUInfos.reserve(EmittedDeps.size());
2764 DenseMap<NonOwningSymbolStringPtr, JITDylib::EmissionDepUnit *> EDUForSymbol;
2765 for (
auto &DG : EmittedDeps) {
2766 assert(!DG.Symbols.empty() &&
"DepGroup does not cover any symbols");
2769 if (DG.Dependencies.empty())
2772 auto TmpEDU = std::make_shared<JITDylib::EmissionDepUnit>(TargetJD);
2773 auto &EDUInfo = EDUInfos[TmpEDU.get()];
2774 EDUInfo.EDU = std::move(TmpEDU);
2775 for (
const auto &Symbol : DG.Symbols) {
2776 NonOwningSymbolStringPtr NonOwningSymbol(Symbol);
2777 assert(!EDUForSymbol.count(NonOwningSymbol) &&
2778 "Symbol should not appear in more than one SymbolDependenceGroup");
2779 assert(MR.getSymbols().count(Symbol) &&
2780 "Symbol in DepGroups not in the emitted set");
2781 auto NewlyEmittedItr = MR.getSymbols().find(Symbol);
2782 EDUInfo.EDU->Symbols[NonOwningSymbol] = NewlyEmittedItr->second;
2783 EDUForSymbol[NonOwningSymbol] = EDUInfo.EDU.get();
2789 DenseMap<NonOwningSymbolStringPtr, JITSymbolFlags> ResidualSymbolFlags;
2790 for (
auto &[
Sym, Flags] : MR.getSymbols()) {
2791 if (!EDUForSymbol.count(NonOwningSymbolStringPtr(
Sym)))
2792 ResidualSymbolFlags[NonOwningSymbolStringPtr(
Sym)] =
Flags;
2794 if (!ResidualSymbolFlags.empty()) {
2795 auto ResidualEDU = std::make_shared<JITDylib::EmissionDepUnit>(TargetJD);
2796 ResidualEDU->Symbols = std::move(ResidualSymbolFlags);
2797 auto &ResidualEDUInfo = EDUInfos[ResidualEDU.get()];
2798 ResidualEDUInfo.EDU = std::move(ResidualEDU);
2801 if (EDUInfos.size() == 1)
2805 for (
auto &[
Sym, Flags] : ResidualEDUInfo.EDU->Symbols)
2806 EDUForSymbol[
Sym] = ResidualEDUInfo.EDU.get();
2811 assert(EDUForSymbol.size() == MR.getSymbols().size() &&
2812 "MR symbols not fully covered by EDUs?");
2813 for (
auto &[
Sym, Flags] : MR.getSymbols()) {
2814 assert(EDUForSymbol.count(NonOwningSymbolStringPtr(
Sym)) &&
2815 "Sym in MR not covered by EDU");
2823 for (
auto &DG : EmittedDeps) {
2826 if (DG.Dependencies.empty())
2829 assert(EDUForSymbol.count(NonOwningSymbolStringPtr(*DG.Symbols.begin())) &&
2832 *EDUForSymbol.find(NonOwningSymbolStringPtr(*DG.Symbols.begin()))
2835 for (
auto &[DepJD, Deps] : DG.Dependencies) {
2836 DenseSet<NonOwningSymbolStringPtr> NewDepsForJD;
2838 assert(!Deps.empty() &&
"Dependence set for DepJD is empty");
2840 if (DepJD != &TargetJD) {
2843 for (
auto &Dep : Deps)
2844 NewDepsForJD.insert(NonOwningSymbolStringPtr(Dep));
2848 for (
auto &Dep : Deps) {
2849 NonOwningSymbolStringPtr NonOwningDep(Dep);
2850 auto I = EDUForSymbol.find(NonOwningDep);
2851 if (
I == EDUForSymbol.end()) {
2852 if (!MR.getSymbols().count(Dep))
2853 NewDepsForJD.insert(NonOwningDep);
2857 if (
I->second != &EDU)
2858 EDUInfos[
I->second].IntraEmitUsers.insert(&EDU);
2862 if (!NewDepsForJD.empty())
2863 EDU.Dependencies[DepJD] = std::move(NewDepsForJD);
2868 std::deque<JITDylib::EmissionDepUnit *> Worklist;
2869 for (
auto &[EDU, EDUInfo] : EDUInfos) {
2872 if (!EDU->Dependencies.empty()) {
2873 auto I = EDUInfos.find(EDU);
2874 if (
I != EDUInfos.end()) {
2875 auto &EDUInfo =
I->second;
2876 if (!EDUInfo.IntraEmitUsers.empty()) {
2877 EDUInfo.NewDeps = EDU->Dependencies;
2878 Worklist.push_back(EDU);
2885 propagateExtraEmitDeps(
2887 [](JITDylib::EmissionDepUnit &,
JITDylib &, NonOwningSymbolStringPtr) {});
2892void ExecutionSession::IL_makeEDUReady(
2893 std::shared_ptr<JITDylib::EmissionDepUnit> EDU,
2894 JITDylib::AsynchronousSymbolQuerySet &Queries) {
2897 auto &JD = *EDU->JD;
2899 for (
auto &[
Sym, Flags] : EDU->Symbols) {
2900 assert(JD.Symbols.count(SymbolStringPtr(
Sym)) &&
2901 "JD does not have an entry for Sym");
2902 auto &Entry = JD.Symbols[SymbolStringPtr(
Sym)];
2904 assert(((Entry.getFlags().hasMaterializationSideEffectsOnly() &&
2908 "Emitting from state other than Resolved");
2912 auto MII = JD.MaterializingInfos.find(SymbolStringPtr(
Sym));
2915 if (MII == JD.MaterializingInfos.end())
2917 auto &
MI = MII->second;
2920 Q->notifySymbolMetRequiredState(SymbolStringPtr(
Sym), Entry.getSymbol());
2921 if (Q->isComplete())
2923 Q->removeQueryDependence(JD, SymbolStringPtr(
Sym));
2926 JD.MaterializingInfos.erase(MII);
2930void ExecutionSession::IL_makeEDUEmitted(
2931 std::shared_ptr<JITDylib::EmissionDepUnit> EDU,
2932 JITDylib::AsynchronousSymbolQuerySet &Queries) {
2935 auto &JD = *EDU->JD;
2937 for (
auto &[
Sym, Flags] : EDU->Symbols) {
2938 assert(JD.Symbols.count(SymbolStringPtr(
Sym)) &&
2939 "JD does not have an entry for Sym");
2940 auto &Entry = JD.Symbols[SymbolStringPtr(
Sym)];
2942 assert(((Entry.getFlags().hasMaterializationSideEffectsOnly() &&
2946 "Emitting from state other than Resolved");
2951 for (
auto &[
Sym, Flags] : EDU->Symbols) {
2952 assert(JD.Symbols.count(SymbolStringPtr(
Sym)) &&
2953 "JD does not have an entry for Sym");
2954 auto &Entry = JD.Symbols[SymbolStringPtr(
Sym)];
2956 "Symbols for EDU in inconsistent state");
2957 assert(JD.MaterializingInfos.count(SymbolStringPtr(
Sym)) &&
2958 "Emitted symbol has no MI");
2959 auto MI = JD.MaterializingInfos[SymbolStringPtr(
Sym)];
2961 "Already-emitted symbol has waiting-on-emitted queries");
2968 auto &
MI = JD.MaterializingInfos[SymbolStringPtr(
Sym)];
2969 MI.DefiningEDU = EDU;
2972 Q->notifySymbolMetRequiredState(SymbolStringPtr(
Sym), Entry.getSymbol());
2973 if (Q->isComplete())
2975 Q->removeQueryDependence(JD, SymbolStringPtr(
Sym));
2979 for (
auto &[DepJD, Deps] : EDU->Dependencies) {
2980 for (
auto &Dep : Deps)
2981 DepJD->MaterializingInfos[SymbolStringPtr(Dep)].DependantEDUs.insert(
2989bool ExecutionSession::IL_removeEDUDependence(JITDylib::EmissionDepUnit &EDU,
2991 NonOwningSymbolStringPtr DepSym,
2992 EDUInfosMap &EDUInfos) {
2993 assert(EDU.Dependencies.count(&DepJD) &&
2994 "JD does not appear in Dependencies of DependantEDU");
2995 assert(EDU.Dependencies[&DepJD].count(DepSym) &&
2996 "Symbol does not appear in Dependencies of DependantEDU");
2997 auto &JDDeps = EDU.Dependencies[&DepJD];
2998 JDDeps.erase(DepSym);
2999 if (JDDeps.empty()) {
3000 EDU.Dependencies.erase(&DepJD);
3001 if (EDU.Dependencies.empty()) {
3006 auto &DepEDUInfo = EDUInfos[&EDU];
3007 if (!DepEDUInfo.EDU) {
3008 assert(EDU.JD->Symbols.count(
3009 SymbolStringPtr(EDU.Symbols.begin()->first)) &&
3010 "Missing symbol entry for first symbol in EDU");
3011 auto DepEDUFirstMI = EDU.JD->MaterializingInfos.find(
3012 SymbolStringPtr(EDU.Symbols.begin()->first));
3013 assert(DepEDUFirstMI != EDU.JD->MaterializingInfos.end() &&
3014 "Missing MI for first symbol in DependantEDU");
3015 DepEDUInfo.EDU = DepEDUFirstMI->second.DefiningEDU;
3023Error ExecutionSession::makeJDClosedError(JITDylib::EmissionDepUnit &EDU,
3024 JITDylib &ClosedJD) {
3026 for (
auto &[
Sym, Flags] : EDU.Symbols)
3027 FailedSymbols.
insert(SymbolStringPtr(
Sym));
3029 for (
auto &Dep : EDU.Dependencies[&ClosedJD])
3030 BadDeps[&ClosedJD].
insert(SymbolStringPtr(Dep));
3031 return make_error<UnsatisfiedSymbolDependencies>(
3032 ClosedJD.getExecutionSession().getSymbolStringPool(), EDU.JD,
3033 std::move(FailedSymbols), std::move(BadDeps),
3034 ClosedJD.getName() +
" is closed");
3037Error ExecutionSession::makeUnsatisfiedDepsError(JITDylib::EmissionDepUnit &EDU,
3041 for (
auto &[
Sym, Flags] : EDU.Symbols)
3042 FailedSymbols.
insert(SymbolStringPtr(
Sym));
3044 BadDepsMap[&BadJD] = std::move(BadDeps);
3045 return make_error<UnsatisfiedSymbolDependencies>(
3046 BadJD.getExecutionSession().getSymbolStringPool(), &BadJD,
3047 std::move(FailedSymbols), std::move(BadDepsMap),
3048 "dependencies removed or in error state");
3051Expected<JITDylib::AsynchronousSymbolQuerySet>
3052ExecutionSession::IL_emit(MaterializationResponsibility &MR,
3053 EDUInfosMap EDUInfos) {
3055 if (MR.RT->isDefunct())
3056 return make_error<ResourceTrackerDefunct>(MR.RT);
3058 auto &TargetJD = MR.getTargetJITDylib();
3059 if (TargetJD.State != JITDylib::Open)
3060 return make_error<StringError>(
"JITDylib " + TargetJD.getName() +
3070 std::deque<JITDylib::EmissionDepUnit *> Worklist;
3071 for (
auto &[EDU,
_] : EDUInfos)
3072 Worklist.push_back(EDU);
3074 for (
auto *EDU : Worklist) {
3075 auto *EDUInfo = &EDUInfos[EDU];
3077 SmallVector<JITDylib *> DepJDsToRemove;
3078 for (
auto &[DepJD, Deps] : EDU->Dependencies) {
3079 if (DepJD->State != JITDylib::Open)
3080 return makeJDClosedError(*EDU, *DepJD);
3083 SmallVector<NonOwningSymbolStringPtr> DepsToRemove;
3084 for (
auto &Dep : Deps) {
3085 auto DepEntryItr = DepJD->Symbols.
find(SymbolStringPtr(Dep));
3090 if (DepEntryItr == DepJD->Symbols.end() ||
3091 DepEntryItr->second.getFlags().hasError()) {
3092 BadDeps.insert(SymbolStringPtr(Dep));
3098 auto &DepEntry = DepEntryItr->second;
3100 EDUInfo->NewDeps[DepJD].insert(Dep);
3106 DepsToRemove.push_back(Dep);
3110 assert(!DepJD->MaterializingInfos.count(SymbolStringPtr(Dep)) &&
3111 "Unexpected MaterializationInfo attached to ready symbol");
3119 assert(DepJD->MaterializingInfos.count(SymbolStringPtr(Dep)) &&
3120 "Expected MaterializationInfo for emitted dependency");
3121 auto &DepMI = DepJD->MaterializingInfos[SymbolStringPtr(Dep)];
3122 assert(DepMI.DefiningEDU &&
3123 "Emitted symbol does not have a defining EDU");
3124 assert(!DepMI.DefiningEDU->Dependencies.empty() &&
3125 "Emitted symbol has empty dependencies (should be ready)");
3126 assert(DepMI.DependantEDUs.empty() &&
3127 "Already-emitted symbol has dependant EDUs?");
3128 auto &DepEDUInfo = EDUInfos[DepMI.DefiningEDU.get()];
3129 if (!DepEDUInfo.EDU) {
3132 EDUInfo = &EDUInfos[EDU];
3133 DepEDUInfo.EDU = DepMI.DefiningEDU;
3134 for (
auto &[DepDepJD, DepDeps] : DepEDUInfo.EDU->Dependencies) {
3135 if (DepDepJD == &TargetJD) {
3136 for (
auto &DepDep : DepDeps)
3137 if (!MR.getSymbols().count(SymbolStringPtr(DepDep)))
3138 DepEDUInfo.NewDeps[DepDepJD].insert(DepDep);
3140 DepEDUInfo.NewDeps[DepDepJD] = DepDeps;
3143 DepEDUInfo.IntraEmitUsers.insert(EDU);
3147 if (!BadDeps.empty())
3148 return makeUnsatisfiedDepsError(*EDU, *DepJD, std::move(BadDeps));
3151 for (
auto &Dep : DepsToRemove)
3156 DepJDsToRemove.push_back(DepJD);
3160 for (
auto &DepJD : DepJDsToRemove) {
3161 assert(EDU->Dependencies.count(DepJD) &&
3162 "Trying to remove non-existent dep entries");
3163 EDU->Dependencies.erase(DepJD);
3167 for (
auto &[
Sym, Flags] : EDU->Symbols) {
3168 assert(TargetJD.Symbols.count(SymbolStringPtr(
Sym)) &&
3169 "Sym not present in symbol table");
3170 assert((TargetJD.Symbols[SymbolStringPtr(
Sym)].getState() ==
3172 TargetJD.Symbols[SymbolStringPtr(
Sym)]
3174 .hasMaterializationSideEffectsOnly()) &&
3175 "Emitting symbol not in the resolved state");
3177 "Symbol is already in an error state");
3179 auto MII = TargetJD.MaterializingInfos.find(SymbolStringPtr(
Sym));
3180 if (MII == TargetJD.MaterializingInfos.end() ||
3181 MII->second.DependantEDUs.empty())
3184 for (
auto &DependantEDU : MII->second.DependantEDUs) {
3185 if (IL_removeEDUDependence(*DependantEDU, TargetJD,
Sym, EDUInfos))
3186 EDUInfo = &EDUInfos[EDU];
3187 EDUInfo->IntraEmitUsers.insert(DependantEDU);
3189 MII->second.DependantEDUs.clear();
3194 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3195 if (!EDUInfo.IntraEmitUsers.empty() && !EDU->Dependencies.empty()) {
3196 if (EDUInfo.NewDeps.empty())
3197 EDUInfo.NewDeps = EDU->Dependencies;
3198 Worklist.push_back(EDU);
3202 propagateExtraEmitDeps(
3204 [](JITDylib::EmissionDepUnit &EDU,
JITDylib &JD,
3205 NonOwningSymbolStringPtr
Sym) {
3206 JD.MaterializingInfos[SymbolStringPtr(
Sym)].DependantEDUs.insert(&EDU);
3209 JITDylib::AsynchronousSymbolQuerySet CompletedQueries;
3213 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3214 if (EDU->Dependencies.empty())
3215 IL_makeEDUReady(std::move(EDUInfo.EDU), CompletedQueries);
3217 IL_makeEDUEmitted(std::move(EDUInfo.EDU), CompletedQueries);
3220 return std::move(CompletedQueries);
3223Error ExecutionSession::OL_notifyEmitted(
3224 MaterializationResponsibility &MR,
3225 ArrayRef<SymbolDependenceGroup> DepGroups) {
3227 dbgs() <<
"In " << MR.JD.getName() <<
" emitting " << MR.SymbolFlags
3229 if (!DepGroups.empty()) {
3230 dbgs() <<
" Initial dependencies:\n";
3231 for (
auto &SDG : DepGroups) {
3232 dbgs() <<
" Symbols: " << SDG.Symbols
3233 <<
", Dependencies: " << SDG.Dependencies <<
"\n";
3240 for (
auto &DG : DepGroups) {
3241 for (
auto &
Sym : DG.Symbols) {
3243 "DG contains dependence for symbol outside this MR");
3245 "DG contains duplicate entries for Name");
3250 auto EDUInfos = simplifyDepGroups(MR, DepGroups);
3253 dbgs() <<
" Simplified dependencies:\n";
3254 for (
auto &[EDU, EDUInfo] : EDUInfos) {
3255 dbgs() <<
" Symbols: { ";
3256 for (
auto &[
Sym, Flags] : EDU->Symbols)
3258 dbgs() <<
"}, Dependencies: { ";
3259 for (
auto &[DepJD, Deps] : EDU->Dependencies) {
3260 dbgs() <<
"(" << DepJD->getName() <<
", { ";
3261 for (
auto &Dep : Deps)
3262 dbgs() << Dep <<
" ";
3269 auto CompletedQueries =
3273 if (!CompletedQueries)
3274 return CompletedQueries.takeError();
3276 MR.SymbolFlags.clear();
3279 for (
auto &Q : *CompletedQueries) {
3280 assert(Q->isComplete() &&
"Q is not complete");
3281 Q->handleComplete(*
this);
3287Error ExecutionSession::OL_defineMaterializing(
3288 MaterializationResponsibility &MR,
SymbolFlagsMap NewSymbolFlags) {
3291 dbgs() <<
"In " << MR.JD.getName() <<
" defining materializing symbols "
3292 << NewSymbolFlags <<
"\n";
3294 if (
auto AcceptedDefs =
3295 MR.JD.defineMaterializing(MR, std::move(NewSymbolFlags))) {
3297 for (
auto &KV : *AcceptedDefs)
3298 MR.SymbolFlags.insert(KV);
3301 return AcceptedDefs.takeError();
3304std::pair<JITDylib::AsynchronousSymbolQuerySet,
3305 std::shared_ptr<SymbolDependenceMap>>
3306ExecutionSession::IL_failSymbols(JITDylib &JD,
3308 JITDylib::AsynchronousSymbolQuerySet FailedQueries;
3309 auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
3310 auto ExtractFailedQueries = [&](JITDylib::MaterializingInfo &
MI) {
3311 JITDylib::AsynchronousSymbolQueryList ToDetach;
3312 for (
auto &Q :
MI.pendingQueries()) {
3314 FailedQueries.insert(Q);
3315 ToDetach.push_back(Q);
3317 for (
auto &Q : ToDetach)
3319 assert(!
MI.hasQueriesPending() &&
"Queries still pending after detach");
3322 for (
auto &
Name : SymbolsToFail) {
3323 (*FailedSymbolsMap)[&JD].insert(
Name);
3326 auto SymI = JD.Symbols.find(
Name);
3335 if (SymI == JD.Symbols.end())
3337 auto &
Sym = SymI->second;
3341 if (
Sym.getFlags().hasError()) {
3343 "Symbol in error state still has MaterializingInfo");
3353 auto MII = JD.MaterializingInfos.find(
Name);
3354 if (MII == JD.MaterializingInfos.end())
3357 auto &
MI = MII->second;
3360 ExtractFailedQueries(
MI);
3362 if (
MI.DefiningEDU) {
3366 "Symbol with DefiningEDU should not have DependantEDUs");
3368 "Symbol has EDU, should have been emitted");
3369 assert(
MI.DefiningEDU->Symbols.count(NonOwningSymbolStringPtr(
Name)) &&
3370 "Symbol does not appear in its DefiningEDU");
3371 MI.DefiningEDU->Symbols.erase(NonOwningSymbolStringPtr(
Name));
3372 MI.DefiningEDU =
nullptr;
3379 for (
auto &DependantEDU :
MI.DependantEDUs) {
3382 for (
auto &[JD, Syms] : DependantEDU->Dependencies) {
3383 for (
auto Sym : Syms) {
3384 assert(JD->Symbols.count(SymbolStringPtr(
Sym)) &&
"Sym not in JD?");
3385 assert(JD->MaterializingInfos.count(SymbolStringPtr(
Sym)) &&
3386 "DependantEDU not registered with symbol it depends on");
3387 auto SymMI = JD->MaterializingInfos[SymbolStringPtr(
Sym)];
3388 assert(SymMI.DependantEDUs.count(DependantEDU) &&
3389 "DependantEDU missing from DependantEDUs list");
3390 SymMI.DependantEDUs.erase(DependantEDU);
3396 auto &DepJD = *DependantEDU->JD;
3397 auto DepEDUSymbols = std::move(DependantEDU->Symbols);
3398 for (
auto &[DepName, Flags] : DepEDUSymbols) {
3399 auto DepSymItr = DepJD.Symbols.find(SymbolStringPtr(DepName));
3400 assert(DepSymItr != DepJD.Symbols.end() &&
3401 "Symbol not present in table");
3402 auto &DepSym = DepSymItr->second;
3405 "Symbol has EDU, should have been emitted");
3406 assert(!DepSym.getFlags().hasError() &&
3407 "Symbol is already in the error state?");
3409 (*FailedSymbolsMap)[&DepJD].insert(SymbolStringPtr(DepName));
3414 DepJD.MaterializingInfos.find(SymbolStringPtr(DepName));
3415 assert(DepMIItr != DepJD.MaterializingInfos.end() &&
3416 "Symbol has defining EDU but not MaterializingInfo");
3417 auto &DepMI = DepMIItr->second;
3418 assert(DepMI.DefiningEDU.get() == DependantEDU &&
3419 "Bad EDU dependence edge");
3420 assert(DepMI.DependantEDUs.empty() &&
3421 "Symbol was emitted, should not have any DependantEDUs");
3422 ExtractFailedQueries(DepMI);
3423 DepJD.MaterializingInfos.erase(SymbolStringPtr(DepName));
3427 MI.DependantEDUs.clear();
3430 assert(!
MI.DefiningEDU &&
"DefiningEDU should have been reset");
3432 "DependantEDUs should have been removed above");
3434 "Can not delete MaterializingInfo with queries pending");
3435 JD.MaterializingInfos.erase(
Name);
3438 return std::make_pair(std::move(FailedQueries), std::move(FailedSymbolsMap));
3441void ExecutionSession::OL_notifyFailed(MaterializationResponsibility &MR) {
3444 dbgs() <<
"In " << MR.JD.getName() <<
" failing materialization for "
3445 << MR.SymbolFlags <<
"\n";
3448 if (MR.SymbolFlags.empty())
3452 for (
auto &[
Name, Flags] : MR.SymbolFlags)
3453 SymbolsToFail.push_back(
Name);
3454 MR.SymbolFlags.clear();
3456 JITDylib::AsynchronousSymbolQuerySet FailedQueries;
3457 std::shared_ptr<SymbolDependenceMap> FailedSymbols;
3461 if (MR.RT->isDefunct())
3462 return std::pair<JITDylib::AsynchronousSymbolQuerySet,
3463 std::shared_ptr<SymbolDependenceMap>>();
3464 return IL_failSymbols(MR.getTargetJITDylib(), SymbolsToFail);
3467 for (
auto &Q : FailedQueries)
3472Error ExecutionSession::OL_replace(MaterializationResponsibility &MR,
3473 std::unique_ptr<MaterializationUnit> MU) {
3474 for (
auto &KV : MU->getSymbols()) {
3475 assert(MR.SymbolFlags.count(KV.first) &&
3476 "Replacing definition outside this responsibility set");
3477 MR.SymbolFlags.erase(KV.first);
3480 if (MU->getInitializerSymbol() == MR.InitSymbol)
3481 MR.InitSymbol =
nullptr;
3483 LLVM_DEBUG(MR.JD.getExecutionSession().runSessionLocked([&]() {
3484 dbgs() <<
"In " << MR.JD.getName() <<
" replacing symbols with " << *MU
3488 return MR.JD.replace(MR, std::move(MU));
3491Expected<std::unique_ptr<MaterializationResponsibility>>
3492ExecutionSession::OL_delegate(MaterializationResponsibility &MR,
3495 SymbolStringPtr DelegatedInitSymbol;
3498 for (
auto &
Name : Symbols) {
3499 auto I = MR.SymbolFlags.find(
Name);
3500 assert(
I != MR.SymbolFlags.end() &&
3501 "Symbol is not tracked by this MaterializationResponsibility "
3504 DelegatedFlags[
Name] = std::move(
I->second);
3505 if (
Name == MR.InitSymbol)
3506 std::swap(MR.InitSymbol, DelegatedInitSymbol);
3508 MR.SymbolFlags.erase(
I);
3511 return MR.JD.delegate(MR, std::move(DelegatedFlags),
3512 std::move(DelegatedInitSymbol));
3516void ExecutionSession::dumpDispatchInfo(Task &
T) {
3518 dbgs() <<
"Dispatching: ";
3519 T.printDescription(
dbgs());
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
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.
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
enum llvm::orc::InProgressLookupState::@465 GenState
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
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, KeyT > &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.
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 ...
This is an optimization pass for GlobalISel generic memory operations.
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
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...
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.
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.