[llvm] 758d54b - [ORC] Add support for removing JITDylibs.
Lang Hames via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 1 22:37:02 PST 2021
Author: Lang Hames
Date: 2021-12-02T17:36:32+11:00
New Revision: 758d54b462ffc480d6cb860984b8aa062925a396
URL: https://github.com/llvm/llvm-project/commit/758d54b462ffc480d6cb860984b8aa062925a396
DIFF: https://github.com/llvm/llvm-project/commit/758d54b462ffc480d6cb860984b8aa062925a396.diff
LOG: [ORC] Add support for removing JITDylibs.
This allows JITDylibs to be removed from the ExecutionSession. Calling
ExecutionSession::removeJITDylib will disconnect the JITDylib from the
ExecutionSession and clear it (removing all trackers associated with it). The
JITDylib object will then be destroyed as soon as the last JITDylibSP pointing
at it is destroyed.
Added:
Modified:
llvm/include/llvm/ExecutionEngine/Orc/Core.h
llvm/lib/ExecutionEngine/Orc/Core.cpp
llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ExecutionEngine/Orc/Core.h b/llvm/include/llvm/ExecutionEngine/Orc/Core.h
index 8ca2725566c5..2180be3341e1 100644
--- a/llvm/include/llvm/ExecutionEngine/Orc/Core.h
+++ b/llvm/include/llvm/ExecutionEngine/Orc/Core.h
@@ -915,12 +915,26 @@ class DefinitionGenerator {
const SymbolLookupSet &LookupSet) = 0;
};
-/// A symbol table that supports asynchoronous symbol queries.
+/// Represents a JIT'd dynamic library.
///
-/// Represents a virtual shared object. Instances can not be copied or moved, so
-/// their addresses may be used as keys for resource management.
-/// JITDylib state changes must be made via an ExecutionSession to guarantee
-/// that they are synchronized with respect to other JITDylib operations.
+/// This class aims to mimic the behavior of a regular dylib or shared object,
+/// but without requiring the contained program representations to be compiled
+/// up-front. The JITDylib's content is defined by adding MaterializationUnits,
+/// and contained MaterializationUnits will typically rely on the JITDylib's
+/// links-against order to resolve external references (similar to a regular
+/// dylib).
+///
+/// The JITDylib object is a thin wrapper that references state held by the
+/// ExecutionSession. JITDylibs can be removed, clearing this underlying state
+/// and leaving the JITDylib object in a defunct state. In this state the
+/// JITDylib's name is guaranteed to remain accessible. If the ExecutionSession
+/// is still alive then other operations are callable but will return an Error
+/// or null result (depending on the API). It is illegal to call any operation
+/// other than getName on a JITDylib after the ExecutionSession has been torn
+/// down.
+///
+/// JITDylibs cannot be moved or copied. Their address is stable, and useful as
+/// a key in some JIT data structures.
class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
public jitlink::JITLinkDylib {
friend class AsynchronousSymbolQuery;
@@ -933,10 +947,21 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
JITDylib &operator=(const JITDylib &) = delete;
JITDylib(JITDylib &&) = delete;
JITDylib &operator=(JITDylib &&) = delete;
+ ~JITDylib();
/// Get a reference to the ExecutionSession for this JITDylib.
+ ///
+ /// It is legal to call this method on a defunct JITDylib, however the result
+ /// will only usable if the ExecutionSession is still alive. If this JITDylib
+ /// is held by an error that may have torn down the JIT then the result
+ /// should not be used.
ExecutionSession &getExecutionSession() const { return ES; }
+ /// Dump current JITDylib state to OS.
+ ///
+ /// It is legal to call this method on a defunct JITDylib.
+ void dump(raw_ostream &OS);
+
/// Calls remove on all trackers currently associated with this JITDylib.
/// Does not run static deinits.
///
@@ -944,12 +969,21 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
/// added concurrently while the clear is underway, and the newly added
/// code will *not* be cleared. Adding new code concurrently with a clear
/// is usually a bug and should be avoided.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
Error clear();
/// Get the default resource tracker for this JITDylib.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
ResourceTrackerSP getDefaultResourceTracker();
/// Create a resource tracker for this JITDylib.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
ResourceTrackerSP createResourceTracker();
/// Adds a definition generator to this JITDylib and returns a referenece to
@@ -958,6 +992,9 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
/// When JITDylibs are searched during lookup, if no existing definition of
/// a symbol is found, then any generators that have been added are run (in
/// the order that they were added) to potentially generate a definition.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
template <typename GeneratorT>
GeneratorT &addGenerator(std::unique_ptr<GeneratorT> DefGenerator);
@@ -965,6 +1002,9 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
///
/// The given generator must exist in this JITDylib's generators list (i.e.
/// have been added and not yet removed).
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
void removeGenerator(DefinitionGenerator &G);
/// Set the link order to be used when fixing up definitions in JITDylib.
@@ -985,26 +1025,41 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
/// as the first in the link order (instead of this dylib) ensures that
/// definitions within this dylib resolve to the lazy-compiling stubs,
/// rather than immediately materializing the definitions in this dylib.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
void setLinkOrder(JITDylibSearchOrder NewSearchOrder,
bool LinkAgainstThisJITDylibFirst = true);
/// Add the given JITDylib to the link order for definitions in this
/// JITDylib.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
void addToLinkOrder(JITDylib &JD,
JITDylibLookupFlags JDLookupFlags =
JITDylibLookupFlags::MatchExportedSymbolsOnly);
/// Replace OldJD with NewJD in the link order if OldJD is present.
/// Otherwise this operation is a no-op.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
void replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD,
JITDylibLookupFlags JDLookupFlags =
JITDylibLookupFlags::MatchExportedSymbolsOnly);
/// Remove the given JITDylib from the link order for this JITDylib if it is
/// present. Otherwise this operation is a no-op.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
void removeFromLinkOrder(JITDylib &JD);
/// Do something with the link order (run under the session lock).
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
template <typename Func>
auto withLinkOrderDo(Func &&F)
-> decltype(F(std::declval<const JITDylibSearchOrder &>()));
@@ -1016,6 +1071,9 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
///
/// This overload always takes ownership of the MaterializationUnit. If any
/// errors occur, the MaterializationUnit consumed.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
template <typename MaterializationUnitType>
Error define(std::unique_ptr<MaterializationUnitType> &&MU,
ResourceTrackerSP RT = nullptr);
@@ -1027,6 +1085,9 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
/// generated. If an error occurs, ownership remains with the caller. This
/// may allow the caller to modify the MaterializationUnit to correct the
/// issue, then re-call define.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
template <typename MaterializationUnitType>
Error define(std::unique_ptr<MaterializationUnitType> &MU,
ResourceTrackerSP RT = nullptr);
@@ -1041,28 +1102,40 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
///
/// On success, all symbols are removed. On failure, the JITDylib state is
/// left unmodified (no symbols are removed).
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
Error remove(const SymbolNameSet &Names);
- /// Dump current JITDylib state to OS.
- void dump(raw_ostream &OS);
-
/// Returns the given JITDylibs and all of their transitive dependencies in
/// DFS order (based on linkage relationships). Each JITDylib will appear
/// only once.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
static std::vector<JITDylibSP> getDFSLinkOrder(ArrayRef<JITDylibSP> JDs);
/// Returns the given JITDylibs and all of their transitive dependensies in
/// reverse DFS order (based on linkage relationships). Each JITDylib will
/// appear only once.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
static std::vector<JITDylibSP>
getReverseDFSLinkOrder(ArrayRef<JITDylibSP> JDs);
/// Return this JITDylib and its transitive dependencies in DFS order
/// based on linkage relationships.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
std::vector<JITDylibSP> getDFSLinkOrder();
/// Rteurn this JITDylib and its transitive dependencies in reverse DFS order
/// based on linkage relationships.
+ ///
+ /// It is illegal to call this method on a defunct JITDylib and the client
+ /// is responsible for ensuring that they do not do so.
std::vector<JITDylibSP> getReverseDFSLinkOrder();
private:
@@ -1198,8 +1271,8 @@ class JITDylib : public ThreadSafeRefCountedBase<JITDylib>,
failSymbols(FailedSymbolsWorklist);
ExecutionSession &ES;
+ enum { Open, Closing, Closed } State = Open;
std::mutex GeneratorsMutex;
- bool Open = true;
SymbolTable Symbols;
UnmaterializedInfosMap UnmaterializedInfos;
MaterializingInfosMap MaterializingInfos;
@@ -1365,6 +1438,18 @@ class ExecutionSession {
/// If no Platform is attached this call is equivalent to createBareJITDylib.
Expected<JITDylib &> createJITDylib(std::string Name);
+ /// Closes the given JITDylib.
+ ///
+ /// This method clears all resources held for the JITDylib, puts it in the
+ /// closed state, and clears all references held by the ExecutionSession and
+ /// other JITDylibs. No further code can be added to the JITDylib, and the
+ /// object will be freed once any remaining JITDylibSPs to it are destroyed.
+ ///
+ /// This method does *not* run static destructors.
+ ///
+ /// This method can only be called once for each JITDylib.
+ Error removeJITDylib(JITDylib &JD);
+
/// Set the error reporter function.
ExecutionSession &setErrorReporter(ErrorReporter ReportError) {
this->ReportError = std::move(ReportError);
@@ -1681,6 +1766,7 @@ template <typename GeneratorT>
GeneratorT &JITDylib::addGenerator(std::unique_ptr<GeneratorT> DefGenerator) {
auto &G = *DefGenerator;
ES.runSessionLocked([&] {
+ assert(State == Open && "Cannot add generator to closed JITDylib");
DefGenerators.push_back(std::move(DefGenerator));
});
return G;
@@ -1689,6 +1775,7 @@ GeneratorT &JITDylib::addGenerator(std::unique_ptr<GeneratorT> DefGenerator) {
template <typename Func>
auto JITDylib::withLinkOrderDo(Func &&F)
-> decltype(F(std::declval<const JITDylibSearchOrder &>())) {
+ assert(State == Open && "Cannot use link order of closed JITDylib");
return ES.runSessionLocked([&]() { return F(LinkOrder); });
}
@@ -1717,6 +1804,8 @@ Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &&MU,
});
return ES.runSessionLocked([&, this]() -> Error {
+ assert(State == Open && "JD is defunct");
+
if (auto Err = defineImpl(*MU))
return Err;
@@ -1758,6 +1847,8 @@ Error JITDylib::define(std::unique_ptr<MaterializationUnitType> &MU,
});
return ES.runSessionLocked([&, this]() -> Error {
+ assert(State == Open && "JD is defunct");
+
if (auto Err = defineImpl(*MU))
return Err;
diff --git a/llvm/lib/ExecutionEngine/Orc/Core.cpp b/llvm/lib/ExecutionEngine/Orc/Core.cpp
index 15648a8541cc..f2017ed00f40 100644
--- a/llvm/lib/ExecutionEngine/Orc/Core.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/Core.cpp
@@ -612,9 +612,14 @@ void LookupState::continueLookup(Error Err) {
DefinitionGenerator::~DefinitionGenerator() {}
+JITDylib::~JITDylib() {
+ LLVM_DEBUG(dbgs() << "Destroying JITDylib " << getName() << "\n");
+}
+
Error JITDylib::clear() {
std::vector<ResourceTrackerSP> TrackersToRemove;
ES.runSessionLocked([&]() {
+ assert(State != Closed && "JD is defunct");
for (auto &KV : TrackerSymbols)
TrackersToRemove.push_back(KV.first);
TrackersToRemove.push_back(getDefaultResourceTracker());
@@ -628,6 +633,7 @@ Error JITDylib::clear() {
ResourceTrackerSP JITDylib::getDefaultResourceTracker() {
return ES.runSessionLocked([this] {
+ assert(State != Closed && "JD is defunct");
if (!DefaultTracker)
DefaultTracker = new ResourceTracker(this);
return DefaultTracker;
@@ -636,6 +642,7 @@ ResourceTrackerSP JITDylib::getDefaultResourceTracker() {
ResourceTrackerSP JITDylib::createResourceTracker() {
return ES.runSessionLocked([this] {
+ assert(State == Open && "JD is defunct");
ResourceTrackerSP RT = new ResourceTracker(this);
return RT;
});
@@ -643,6 +650,7 @@ ResourceTrackerSP JITDylib::createResourceTracker() {
void JITDylib::removeGenerator(DefinitionGenerator &G) {
ES.runSessionLocked([&] {
+ assert(State == Open && "JD is defunct");
auto I = llvm::find_if(DefGenerators,
[&](const std::shared_ptr<DefinitionGenerator> &H) {
return H.get() == &G;
@@ -902,6 +910,11 @@ Error JITDylib::resolve(MaterializationResponsibility &MR,
if (MR.RT->isDefunct())
return make_error<ResourceTrackerDefunct>(MR.RT);
+ if (State != Open)
+ return make_error<StringError>("JITDylib " + getName() +
+ " is defunct",
+ inconvertibleErrorCode());
+
struct WorklistEntry {
SymbolTable::iterator SymI;
JITEvaluatedSymbol ResolvedSym;
@@ -998,6 +1011,11 @@ Error JITDylib::emit(MaterializationResponsibility &MR,
if (MR.RT->isDefunct())
return make_error<ResourceTrackerDefunct>(MR.RT);
+ if (State != Open)
+ return make_error<StringError>("JITDylib " + getName() +
+ " is defunct",
+ inconvertibleErrorCode());
+
SymbolNameSet SymbolsInErrorState;
std::vector<SymbolTable::iterator> Worklist;
@@ -1164,8 +1182,16 @@ JITDylib::failSymbols(FailedSymbolsWorklist Worklist) {
(*FailedSymbolsMap)[&JD].insert(Name);
- assert(JD.Symbols.count(Name) && "No symbol table entry for Name");
- auto &Sym = JD.Symbols[Name];
+ // Look up the symbol to fail.
+ auto SymI = JD.Symbols.find(Name);
+
+ // It's possible that this symbol has already been removed, e.g. if a
+ // materialization failure happens concurrently with a ResourceTracker or
+ // JITDylib removal. In that case we can safely skip this symbol and
+ // continue.
+ if (SymI == JD.Symbols.end())
+ continue;
+ auto &Sym = SymI->second;
// Move the symbol into the error state.
// Note that this may be redundant: The symbol might already have been
@@ -1262,6 +1288,7 @@ JITDylib::failSymbols(FailedSymbolsWorklist Worklist) {
void JITDylib::setLinkOrder(JITDylibSearchOrder NewLinkOrder,
bool LinkAgainstThisJITDylibFirst) {
ES.runSessionLocked([&]() {
+ assert(State == Open && "JD is defunct");
if (LinkAgainstThisJITDylibFirst) {
LinkOrder.clear();
if (NewLinkOrder.empty() || NewLinkOrder.front().first != this)
@@ -1280,6 +1307,7 @@ void JITDylib::addToLinkOrder(JITDylib &JD, JITDylibLookupFlags JDLookupFlags) {
void JITDylib::replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD,
JITDylibLookupFlags JDLookupFlags) {
ES.runSessionLocked([&]() {
+ assert(State == Open && "JD is defunct");
for (auto &KV : LinkOrder)
if (KV.first == &OldJD) {
KV = {&NewJD, JDLookupFlags};
@@ -1290,6 +1318,7 @@ void JITDylib::replaceInLinkOrder(JITDylib &OldJD, JITDylib &NewJD,
void JITDylib::removeFromLinkOrder(JITDylib &JD) {
ES.runSessionLocked([&]() {
+ assert(State == Open && "JD is defunct");
auto I = llvm::find_if(LinkOrder,
[&](const JITDylibSearchOrder::value_type &KV) {
return KV.first == &JD;
@@ -1301,6 +1330,7 @@ void JITDylib::removeFromLinkOrder(JITDylib &JD) {
Error JITDylib::remove(const SymbolNameSet &Names) {
return ES.runSessionLocked([&]() -> Error {
+ assert(State == Open && "JD is defunct");
using SymbolMaterializerItrPair =
std::pair<SymbolTable::iterator, UnmaterializedInfosMap::iterator>;
std::vector<SymbolMaterializerItrPair> SymbolsToRemove;
@@ -1360,8 +1390,23 @@ Error JITDylib::remove(const SymbolNameSet &Names) {
void JITDylib::dump(raw_ostream &OS) {
ES.runSessionLocked([&, this]() {
OS << "JITDylib \"" << getName() << "\" (ES: "
- << format("0x%016" PRIx64, reinterpret_cast<uintptr_t>(&ES)) << "):\n"
- << "Link order: " << LinkOrder << "\n"
+ << format("0x%016" PRIx64, reinterpret_cast<uintptr_t>(&ES))
+ << ", State = ";
+ switch (State) {
+ case Open:
+ OS << "Open";
+ break;
+ case Closing:
+ OS << "Closing";
+ break;
+ case Closed:
+ OS << "Closed";
+ break;
+ }
+ OS << ")\n";
+ if (State == Closed)
+ return;
+ OS << "Link order: " << LinkOrder << "\n"
<< "Symbol table:\n";
for (auto &KV : Symbols) {
@@ -1453,6 +1498,7 @@ std::pair<JITDylib::AsynchronousSymbolQuerySet,
std::shared_ptr<SymbolDependenceMap>>
JITDylib::removeTracker(ResourceTracker &RT) {
// Note: Should be called under the session lock.
+ assert(State != Closed && "JD is defunct");
SymbolNameVector SymbolsToRemove;
std::vector<std::pair<JITDylib *, SymbolStringPtr>> SymbolsToFail;
@@ -1513,6 +1559,7 @@ JITDylib::removeTracker(ResourceTracker &RT) {
}
void JITDylib::transferTracker(ResourceTracker &DstRT, ResourceTracker &SrcRT) {
+ assert(State != Closed && "JD is defunct");
assert(&DstRT != &SrcRT && "No-op transfers shouldn't call transferTracker");
assert(&DstRT.getJITDylib() == this && "DstRT is not for this JITDylib");
assert(&SrcRT.getJITDylib() == this && "SrcRT is not for this JITDylib");
@@ -1873,6 +1920,40 @@ Expected<JITDylib &> ExecutionSession::createJITDylib(std::string Name) {
return JD;
}
+Error ExecutionSession::removeJITDylib(JITDylib &JD) {
+ // Keep JD alive throughout this routine, even if all other references
+ // have been dropped.
+ JITDylibSP JDKeepAlive = &JD;
+
+ // Set JD to 'Closing' state and remove JD from the ExecutionSession.
+ runSessionLocked([&] {
+ assert(JD.State == JITDylib::Open && "JD already closed");
+ JD.State = JITDylib::Closing;
+ auto I = llvm::find(JDs, &JD);
+ assert(I != JDs.end() && "JD does not appear in session JDs");
+ JDs.erase(I);
+ });
+
+ // Clear the JITDylib.
+ auto Err = JD.clear();
+
+ // Set JD to closed state. Clear remaining data structures.
+ runSessionLocked([&] {
+ assert(JD.State == JITDylib::Closing && "JD should be closing");
+ JD.State = JITDylib::Closed;
+ assert(JD.Symbols.empty() && "JD.Symbols is not empty after clear");
+ assert(JD.UnmaterializedInfos.empty() &&
+ "JD.UnmaterializedInfos is not empty after clear");
+ assert(JD.MaterializingInfos.empty() &&
+ "JD.MaterializingInfos is not empty after clear");
+ assert(JD.TrackerSymbols.empty() &&
+ "TrackerSymbols is not empty after clear");
+ JD.DefGenerators.clear();
+ JD.LinkOrder.clear();
+ });
+ return Err;
+}
+
std::vector<JITDylibSP> JITDylib::getDFSLinkOrder(ArrayRef<JITDylibSP> JDs) {
if (JDs.empty())
return {};
@@ -1884,6 +1965,8 @@ std::vector<JITDylibSP> JITDylib::getDFSLinkOrder(ArrayRef<JITDylibSP> JDs) {
for (auto &JD : JDs) {
+ assert(JD->State == Open && "JD is defunct");
+
if (Visited.count(JD.get()))
continue;
diff --git a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
index 020a261ac238..9e3e35c63927 100644
--- a/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
@@ -1496,4 +1496,57 @@ TEST(JITDylibTest, GetDFSLinkOrderCycle) {
<< "Incorrect DFS link order for libC";
}
+TEST_F(CoreAPIsStandardTest, RemoveJITDylibs) {
+ // Foo will be fully materialized.
+ cantFail(JD.define(absoluteSymbols({{Foo, FooSym}})));
+
+ // Bar should not be materialized at all.
+ bool BarMaterializerDestroyed = false;
+ cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
+ SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
+ [&](std::unique_ptr<MaterializationResponsibility> MR) {
+ llvm_unreachable("Unexpected call to materialize");
+ },
+ nullptr,
+ [](const JITDylib &, SymbolStringPtr Name) {
+ llvm_unreachable("Unexpected call to discard");
+ },
+ [&]() { BarMaterializerDestroyed = true; })));
+
+ // Baz will be in the materializing state.
+ std::unique_ptr<MaterializationResponsibility> BazMR;
+ cantFail(JD.define(std::make_unique<SimpleMaterializationUnit>(
+ SymbolFlagsMap({{Baz, BazSym.getFlags()}}),
+ [&](std::unique_ptr<MaterializationResponsibility> MR) {
+ BazMR = std::move(MR);
+ })));
+
+ // Lookup to force materialization of Foo.
+ cantFail(ES.lookup(makeJITDylibSearchOrder(&JD), {Foo}));
+
+ // Start a lookup to force materialization of Baz.
+ bool BazLookupFailed = false;
+ ES.lookup(
+ LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet({Baz}),
+ SymbolState::Ready,
+ [&](Expected<SymbolMap> Result) {
+ if (!Result) {
+ BazLookupFailed = true;
+ consumeError(Result.takeError());
+ }
+ },
+ NoDependenciesToRegister);
+
+ // Remove the JITDylib.
+ auto Err = ES.removeJITDylib(JD);
+ EXPECT_THAT_ERROR(std::move(Err), Succeeded());
+
+ EXPECT_TRUE(BarMaterializerDestroyed);
+ EXPECT_TRUE(BazLookupFailed);
+
+ EXPECT_THAT_ERROR(BazMR->notifyResolved({{Baz, BazSym}}), Failed());
+
+ BazMR->failMaterialization();
+}
+
} // namespace
More information about the llvm-commits
mailing list