<div dir="ltr">Hi Reid,<div><br></div><div>No worries. Thanks for doing that!</div><div><br></div><div>I'll investigate and re-apply once I have a fix.</div><div><br></div><div>Cheers,</div><div>Lang.</div></div><br><div class="gmail_quote"><div dir="ltr">On Fri, Jul 20, 2018 at 1:28 PM Reid Kleckner <<a href="mailto:rnk@google.com">rnk@google.com</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr">I had to revert this in r337608 because it broke the LLVM_ENABLE_THREADS=OFF build. Unfortunately, the two code paths are very different, and I couldn't find a quick fix.<br></div><br><div class="gmail_quote"><div dir="ltr">On Fri, Jul 20, 2018 at 11:37 AM Lang Hames via llvm-commits <<a href="mailto:llvm-commits@lists.llvm.org" target="_blank">llvm-commits@lists.llvm.org</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: lhames<br>
Date: Fri Jul 20 11:31:53 2018<br>
New Revision: 337595<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=337595&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project?rev=337595&view=rev</a><br>
Log:<br>
[ORC] Add new symbol lookup methods to ExecutionSessionBase in preparation for<br>
deprecating SymbolResolver and AsynchronousSymbolQuery.<br>
<br>
Both lookup overloads take a VSO search order to perform the lookup. The first<br>
overload is non-blocking and takes OnResolved and OnReady callbacks. The second<br>
is blocking, takes a boolean flag to indicate whether to wait until all symbols<br>
are ready, and returns a SymbolMap. Both overloads take a RegisterDependencies<br>
function to register symbol dependencies (if any) on the query.<br>
<br>
Modified:<br>
llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h<br>
llvm/trunk/include/llvm/ExecutionEngine/Orc/Legacy.h<br>
llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp<br>
llvm/trunk/lib/ExecutionEngine/Orc/Legacy.cpp<br>
llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h<br>
llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h<br>
llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp<br>
llvm/trunk/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp<br>
llvm/trunk/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp<br>
<br>
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h (original)<br>
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/Core.h Fri Jul 20 11:31:53 2018<br>
@@ -69,8 +69,23 @@ raw_ostream &operator<<(raw_ostream &OS,<br>
/// A list of VSO pointers.<br>
using VSOList = std::vector<VSO *>;<br>
<br>
+/// Render a VSOList.<br>
raw_ostream &operator<<(raw_ostream &OS, const VSOList &VSOs);<br>
<br>
+/// Callback to notify client that symbols have been resolved.<br>
+using SymbolsResolvedCallback = std::function<void(Expected<SymbolMap>)>;<br>
+<br>
+/// Callback to notify client that symbols are ready for execution.<br>
+using SymbolsReadyCallback = std::function<void(Error)>;<br>
+<br>
+/// Callback to register the dependencies for a given query.<br>
+using RegisterDependenciesFunction =<br>
+ std::function<void(const SymbolDependenceMap &)>;<br>
+<br>
+/// This can be used as the value for a RegisterDependenciesFunction if there<br>
+/// are no dependants to register with.<br>
+extern RegisterDependenciesFunction NoDependenciesToRegister;<br>
+<br>
/// Used to notify a VSO that the given set of symbols failed to materialize.<br>
class FailedToMaterialize : public ErrorInfo<FailedToMaterialize> {<br>
public:<br>
@@ -122,6 +137,9 @@ public:<br>
/// into.<br>
VSO &getTargetVSO() const { return V; }<br>
<br>
+ /// Returns the symbol flags map for this responsibility instance.<br>
+ SymbolFlagsMap getSymbols() { return SymbolFlags; }<br>
+<br>
/// Returns the names of any symbols covered by this<br>
/// MaterializationResponsibility object that have queries pending. This<br>
/// information can be used to return responsibility for unrequested symbols<br>
@@ -223,6 +241,9 @@ private:<br>
virtual void discard(const VSO &V, SymbolStringPtr Name) = 0;<br>
};<br>
<br>
+using MaterializationUnitList =<br>
+ std::vector<std::unique_ptr<MaterializationUnit>>;<br>
+<br>
/// A MaterializationUnit implementation for pre-existing absolute symbols.<br>
///<br>
/// All symbols will be resolved and marked ready as soon as the unit is<br>
@@ -322,6 +343,9 @@ buildSimpleReexportsAliasMap(VSO &Source<br>
<br>
/// Base utilities for ExecutionSession.<br>
class ExecutionSessionBase {<br>
+ // FIXME: Remove this when we remove the old ORC layers.<br>
+ friend class VSO;<br>
+<br>
public:<br>
/// For reporting errors.<br>
using ErrorReporter = std::function<void(Error)>;<br>
@@ -372,11 +396,50 @@ public:<br>
void releaseVModule(VModuleKey Key) { /* FIXME: Recycle keys */<br>
}<br>
<br>
- /// Cause the given query to fail with the given Error.<br>
- ///<br>
- /// This should only be used by legacy APIs and will be deprecated in the<br>
- /// future.<br>
- void failQuery(AsynchronousSymbolQuery &Q, Error Err);<br>
+ void legacyFailQuery(AsynchronousSymbolQuery &Q, Error Err);<br>
+<br>
+ using LegacyAsyncLookupFunction = std::function<SymbolNameSet(<br>
+ std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Names)>;<br>
+<br>
+ /// A legacy lookup function for JITSymbolResolverAdapter.<br>
+ /// Do not use -- this will be removed soon.<br>
+ Expected<SymbolMap><br>
+ legacyLookup(ExecutionSessionBase &ES, LegacyAsyncLookupFunction AsyncLookup,<br>
+ SymbolNameSet Names, bool WaiUntilReady,<br>
+ RegisterDependenciesFunction RegisterDependencies);<br>
+<br>
+ /// Search the given VSO list for the given symbols.<br>
+ ///<br>
+ ///<br>
+ /// The OnResolve callback will be called once all requested symbols are<br>
+ /// resolved, or if an error occurs prior to resolution.<br>
+ ///<br>
+ /// The OnReady callback will be called once all requested symbols are ready,<br>
+ /// or if an error occurs after resolution but before all symbols are ready.<br>
+ ///<br>
+ /// If all symbols are found, the RegisterDependencies function will be called<br>
+ /// while the session lock is held. This gives clients a chance to register<br>
+ /// dependencies for on the queried symbols for any symbols they are<br>
+ /// materializing (if a MaterializationResponsibility instance is present,<br>
+ /// this can be implemented by calling<br>
+ /// MaterializationResponsibility::addDependencies). If there are no<br>
+ /// dependenant symbols for this query (e.g. it is being made by a top level<br>
+ /// client to get an address to call) then the value NoDependenciesToRegister<br>
+ /// can be used.<br>
+ void lookup(const VSOList &VSOs, const SymbolNameSet &Symbols,<br>
+ SymbolsResolvedCallback OnResolve, SymbolsReadyCallback OnReady,<br>
+ RegisterDependenciesFunction RegisterDependencies);<br>
+<br>
+ /// Blocking version of lookup above. Returns the resolved symbol map.<br>
+ /// If WaitUntilReady is true (the default), will not return until all<br>
+ /// requested symbols are ready (or an error occurs). If WaitUntilReady is<br>
+ /// false, will return as soon as all requested symbols are resolved,<br>
+ /// or an error occurs. If WaitUntilReady is false and an error occurs<br>
+ /// after resolution, the function will return a success value, but the<br>
+ /// error will be reported via reportErrors.<br>
+ Expected<SymbolMap> lookup(const VSOList &VSOs, const SymbolNameSet &Symbols,<br>
+ RegisterDependenciesFunction RegisterDependencies,<br>
+ bool WaitUntilReady = true);<br>
<br>
/// Materialize the given unit.<br>
void dispatchMaterialization(VSO &V,<br>
@@ -394,12 +457,20 @@ private:<br>
MU->doMaterialize(V);<br>
}<br>
<br>
+ void runOutstandingMUs();<br>
+<br>
mutable std::recursive_mutex SessionMutex;<br>
std::shared_ptr<SymbolStringPool> SSP;<br>
VModuleKey LastKey = 0;<br>
ErrorReporter ReportError = logErrorsToStdErr;<br>
DispatchMaterializationFunction DispatchMaterialization =<br>
materializeOnCurrentThread;<br>
+<br>
+ // FIXME: Remove this (and runOutstandingMUs) once the linking layer works<br>
+ // with callbacks from asynchronous queries.<br>
+ mutable std::recursive_mutex OutstandingMUsMutex;<br>
+ std::vector<std::pair<VSO *, std::unique_ptr<MaterializationUnit>>><br>
+ OutstandingMUs;<br>
};<br>
<br>
/// A symbol query that returns results via a callback when results are<br>
@@ -411,21 +482,6 @@ class AsynchronousSymbolQuery {<br>
friend class VSO;<br>
<br>
public:<br>
- class ResolutionResult {<br>
- public:<br>
- ResolutionResult(SymbolMap Symbols, const SymbolDependenceMap &Dependencies)<br>
- : Symbols(std::move(Symbols)), Dependencies(Dependencies) {}<br>
-<br>
- SymbolMap Symbols;<br>
- const SymbolDependenceMap &Dependencies;<br>
- };<br>
-<br>
- /// Callback to notify client that symbols have been resolved.<br>
- using SymbolsResolvedCallback =<br>
- std::function<void(Expected<ResolutionResult>)>;<br>
-<br>
- /// Callback to notify client that symbols are ready for execution.<br>
- using SymbolsReadyCallback = std::function<void(Error)>;<br>
<br>
/// Create a query for the given symbols, notify-resolved and<br>
/// notify-ready callbacks.<br>
@@ -485,6 +541,7 @@ private:<br>
class VSO {<br>
friend class AsynchronousSymbolQuery;<br>
friend class ExecutionSession;<br>
+ friend class ExecutionSessionBase;<br>
friend class MaterializationResponsibility;<br>
public:<br>
using FallbackDefinitionGeneratorFunction =<br>
@@ -493,9 +550,6 @@ public:<br>
using AsynchronousSymbolQuerySet =<br>
std::set<std::shared_ptr<AsynchronousSymbolQuery>>;<br>
<br>
- using MaterializationUnitList =<br>
- std::vector<std::unique_ptr<MaterializationUnit>>;<br>
-<br>
VSO(const VSO &) = delete;<br>
VSO &operator=(const VSO &) = delete;<br>
VSO(VSO &&) = delete;<br>
@@ -547,8 +601,10 @@ public:<br>
void removeFromSearchOrder(VSO &V);<br>
<br>
/// Do something with the search order (run under the session lock).<br>
- template <typename Func> void withSearchOrderDo(Func F) {<br>
- ES.runSessionLocked([&]() { F(SearchOrder); });<br>
+ template <typename Func><br>
+ auto withSearchOrderDo(Func &&F)<br>
+ -> decltype(F(std::declval<const VSOList &>())) {<br>
+ return ES.runSessionLocked([&]() { return F(SearchOrder); });<br>
}<br>
<br>
/// Define all symbols provided by the materialization unit to be part<br>
@@ -579,6 +635,10 @@ public:<br>
/// the flags for each symbol in Flags. Returns any unresolved symbols.<br>
SymbolFlagsMap lookupFlags(const SymbolNameSet &Names);<br>
<br>
+ /// Dump current VSO state to OS.<br>
+ void dump(raw_ostream &OS);<br>
+<br>
+ /// FIXME: Remove this when we remove the old ORC layers.<br>
/// Search the given VSOs in order for the symbols in Symbols. Results<br>
/// (once they become available) will be returned via the given Query.<br>
///<br>
@@ -586,11 +646,8 @@ public:<br>
/// and the query will not be applied. The Query is not failed and can be<br>
/// re-used in a subsequent lookup once the symbols have been added, or<br>
/// manually failed.<br>
- SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Q,<br>
- SymbolNameSet Names);<br>
-<br>
- /// Dump current VSO state to OS.<br>
- void dump(raw_ostream &OS);<br>
+ SymbolNameSet legacyLookup(std::shared_ptr<AsynchronousSymbolQuery> Q,<br>
+ SymbolNameSet Names);<br>
<br>
private:<br>
using AsynchronousSymbolQueryList =<br>
@@ -629,6 +686,12 @@ private:<br>
SymbolNameSet lookupFlagsImpl(SymbolFlagsMap &Flags,<br>
const SymbolNameSet &Names);<br>
<br>
+ void lodgeQuery(std::shared_ptr<AsynchronousSymbolQuery> &Q,<br>
+ SymbolNameSet &Unresolved, MaterializationUnitList &MUs);<br>
+<br>
+ void lodgeQueryImpl(std::shared_ptr<AsynchronousSymbolQuery> &Q,<br>
+ SymbolNameSet &Unresolved, MaterializationUnitList &MUs);<br>
+<br>
LookupImplActionFlags<br>
lookupImpl(std::shared_ptr<AsynchronousSymbolQuery> &Q,<br>
std::vector<std::unique_ptr<MaterializationUnit>> &MUs,<br>
@@ -647,8 +710,8 @@ private:<br>
<br>
SymbolNameSet getRequestedSymbols(const SymbolFlagsMap &SymbolFlags);<br>
<br>
- void addDependencies(const SymbolFlagsMap &Dependents,<br>
- const SymbolDependenceMap &Dependencies);<br>
+ void addDependencies(const SymbolStringPtr &Name,<br>
+ const SymbolDependenceMap &Dependants);<br>
<br>
void resolve(const SymbolMap &Resolved);<br>
<br>
@@ -656,8 +719,6 @@ private:<br>
<br>
void notifyFailed(const SymbolNameSet &FailedSymbols);<br>
<br>
- void runOutstandingMUs();<br>
-<br>
ExecutionSessionBase &ES;<br>
std::string VSOName;<br>
SymbolMap Symbols;<br>
@@ -665,11 +726,6 @@ private:<br>
MaterializingInfosMap MaterializingInfos;<br>
FallbackDefinitionGeneratorFunction FallbackDefinitionGenerator;<br>
VSOList SearchOrder;<br>
-<br>
- // FIXME: Remove this (and runOutstandingMUs) once the linking layer works<br>
- // with callbacks from asynchronous queries.<br>
- mutable std::recursive_mutex OutstandingMUsMutex;<br>
- std::vector<std::unique_ptr<MaterializationUnit>> OutstandingMUs;<br>
};<br>
<br>
/// An ExecutionSession represents a running JIT program.<br>
@@ -693,15 +749,6 @@ private:<br>
std::vector<std::unique_ptr<VSO>> VSOs;<br>
};<br>
<br>
-using AsynchronousLookupFunction = std::function<SymbolNameSet(<br>
- std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Names)>;<br>
-<br>
-/// Perform a blocking lookup on the given symbols.<br>
-Expected<SymbolMap> blockingLookup(ExecutionSessionBase &ES,<br>
- AsynchronousLookupFunction AsyncLookup,<br>
- SymbolNameSet Names, bool WaiUntilReady,<br>
- MaterializationResponsibility *MR = nullptr);<br>
-<br>
/// Look up the given names in the given VSOs.<br>
/// VSOs will be searched in order and no VSO pointer may be null.<br>
/// All symbols must be found within the given VSOs or an error<br>
<br>
Modified: llvm/trunk/include/llvm/ExecutionEngine/Orc/Legacy.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/Legacy.h?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/Orc/Legacy.h?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/include/llvm/ExecutionEngine/Orc/Legacy.h (original)<br>
+++ llvm/trunk/include/llvm/ExecutionEngine/Orc/Legacy.h Fri Jul 20 11:31:53 2018<br>
@@ -146,11 +146,11 @@ lookupWithLegacyFn(ExecutionSession &ES,<br>
Query.notifySymbolReady();<br>
NewSymbolsResolved = true;<br>
} else {<br>
- ES.failQuery(Query, Addr.takeError());<br>
+ ES.legacyFailQuery(Query, Addr.takeError());<br>
return SymbolNameSet();<br>
}<br>
} else if (auto Err = Sym.takeError()) {<br>
- ES.failQuery(Query, std::move(Err));<br>
+ ES.legacyFailQuery(Query, std::move(Err));<br>
return SymbolNameSet();<br>
} else<br>
SymbolsNotFound.insert(S);<br>
<br>
Modified: llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp (original)<br>
+++ llvm/trunk/lib/ExecutionEngine/Orc/Core.cpp Fri Jul 20 11:31:53 2018<br>
@@ -23,6 +23,9 @@ namespace orc {<br>
char FailedToMaterialize::ID = 0;<br>
char SymbolsNotFound::ID = 0;<br>
<br>
+RegisterDependenciesFunction NoDependenciesToRegister =<br>
+ RegisterDependenciesFunction();<br>
+<br>
void MaterializationUnit::anchor() {}<br>
<br>
raw_ostream &operator<<(raw_ostream &OS, const JITSymbolFlags &Flags) {<br>
@@ -138,20 +141,361 @@ void SymbolsNotFound::log(raw_ostream &O<br>
OS << "Symbols not found: " << Symbols;<br>
}<br>
<br>
-void ExecutionSessionBase::failQuery(AsynchronousSymbolQuery &Q, Error Err) {<br>
- bool DeliveredError = true;<br>
- runSessionLocked([&]() -> void {<br>
+void ExecutionSessionBase::legacyFailQuery(AsynchronousSymbolQuery &Q,<br>
+ Error Err) {<br>
+ assert(!!Err && "Error should be in failure state");<br>
+<br>
+ bool SendErrorToQuery;<br>
+ runSessionLocked([&]() {<br>
Q.detach();<br>
- if (Q.canStillFail())<br>
- Q.handleFailed(std::move(Err));<br>
- else<br>
- DeliveredError = false;<br>
+ SendErrorToQuery = Q.canStillFail();<br>
});<br>
<br>
- if (!DeliveredError)<br>
+ if (SendErrorToQuery)<br>
+ Q.handleFailed(std::move(Err));<br>
+ else<br>
reportError(std::move(Err));<br>
}<br>
<br>
+Expected<SymbolMap> ExecutionSessionBase::legacyLookup(<br>
+ ExecutionSessionBase &ES, LegacyAsyncLookupFunction AsyncLookup,<br>
+ SymbolNameSet Names, bool WaitUntilReady,<br>
+ RegisterDependenciesFunction RegisterDependencies) {<br>
+#if LLVM_ENABLE_THREADS<br>
+ // In the threaded case we use promises to return the results.<br>
+ std::promise<SymbolMap> PromisedResult;<br>
+ std::mutex ErrMutex;<br>
+ Error ResolutionError = Error::success();<br>
+ std::promise<void> PromisedReady;<br>
+ Error ReadyError = Error::success();<br>
+ auto OnResolve = [&](Expected<SymbolMap> R) {<br>
+ if (R)<br>
+ PromisedResult.set_value(std::move(*R));<br>
+ else {<br>
+ {<br>
+ ErrorAsOutParameter _(&ResolutionError);<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ ResolutionError = R.takeError();<br>
+ }<br>
+ PromisedResult.set_value(SymbolMap());<br>
+ }<br>
+ };<br>
+<br>
+ std::function<void(Error)> OnReady;<br>
+ if (WaitUntilReady) {<br>
+ OnReady = [&](Error Err) {<br>
+ if (Err) {<br>
+ ErrorAsOutParameter _(&ReadyError);<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ ReadyError = std::move(Err);<br>
+ }<br>
+ PromisedReady.set_value();<br>
+ };<br>
+ } else {<br>
+ OnReady = [&](Error Err) {<br>
+ if (Err)<br>
+ ES.reportError(std::move(Err));<br>
+ };<br>
+ }<br>
+<br>
+#else<br>
+ SymbolMap Result;<br>
+ Error ResolutionError = Error::success();<br>
+ Error ReadyError = Error::success();<br>
+<br>
+ auto OnResolve = [&](Expected<SymbolMap> R) {<br>
+ ErrorAsOutParameter _(&ResolutionError);<br>
+ if (R)<br>
+ Result = std::move(*R);<br>
+ else<br>
+ ResolutionError = R.takeError();<br>
+ };<br>
+<br>
+ std::function<void(Error)> OnReady;<br>
+ if (WaitUntilReady) {<br>
+ OnReady = [&](Error Err) {<br>
+ ErrorAsOutParameter _(&ReadyError);<br>
+ if (Err)<br>
+ ReadyError = std::move(Err);<br>
+ };<br>
+ } else {<br>
+ OnReady = [&](Error Err) {<br>
+ if (Err)<br>
+ ES.reportError(std::move(Err));<br>
+ };<br>
+ }<br>
+#endif<br>
+<br>
+ auto Query = std::make_shared<AsynchronousSymbolQuery>(<br>
+ Names, std::move(OnResolve), std::move(OnReady));<br>
+ // FIXME: This should be run session locked along with the registration code<br>
+ // and error reporting below.<br>
+ SymbolNameSet UnresolvedSymbols = AsyncLookup(Query, std::move(Names));<br>
+<br>
+ // If the query was lodged successfully then register the dependencies,<br>
+ // otherwise fail it with an error.<br>
+ if (UnresolvedSymbols.empty())<br>
+ RegisterDependencies(Query->QueryRegistrations);<br>
+ else {<br>
+ bool DeliverError = runSessionLocked([&]() {<br>
+ Query->detach();<br>
+ return Query->canStillFail();<br>
+ });<br>
+ auto Err = make_error<SymbolsNotFound>(std::move(UnresolvedSymbols));<br>
+ if (DeliverError)<br>
+ Query->handleFailed(std::move(Err));<br>
+ else<br>
+ ES.reportError(std::move(Err));<br>
+ }<br>
+<br>
+#if LLVM_ENABLE_THREADS<br>
+ auto ResultFuture = PromisedResult.get_future();<br>
+ auto Result = ResultFuture.get();<br>
+<br>
+ {<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ if (ResolutionError) {<br>
+ // ReadyError will never be assigned. Consume the success value.<br>
+ cantFail(std::move(ReadyError));<br>
+ return std::move(ResolutionError);<br>
+ }<br>
+ }<br>
+<br>
+ if (WaitUntilReady) {<br>
+ auto ReadyFuture = PromisedReady.get_future();<br>
+ ReadyFuture.get();<br>
+<br>
+ {<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ if (ReadyError)<br>
+ return std::move(ReadyError);<br>
+ }<br>
+ } else<br>
+ cantFail(std::move(ReadyError));<br>
+<br>
+ return std::move(Result);<br>
+<br>
+#else<br>
+ if (ResolutionError) {<br>
+ // ReadyError will never be assigned. Consume the success value.<br>
+ cantFail(std::move(ReadyError));<br>
+ return std::move(ResolutionError);<br>
+ }<br>
+<br>
+ if (ReadyError)<br>
+ return std::move(ReadyError);<br>
+<br>
+ return Result;<br>
+#endif<br>
+}<br>
+<br>
+void ExecutionSessionBase::lookup(<br>
+ const VSOList &VSOs, const SymbolNameSet &Symbols,<br>
+ SymbolsResolvedCallback OnResolve, SymbolsReadyCallback OnReady,<br>
+ RegisterDependenciesFunction RegisterDependencies) {<br>
+<br>
+ // lookup can be re-entered recursively if running on a single thread. Run any<br>
+ // outstanding MUs in case this query depends on them, otherwise the main<br>
+ // thread will starve waiting for a result from an MU that it failed to run.<br>
+ runOutstandingMUs();<br>
+<br>
+ auto Unresolved = std::move(Symbols);<br>
+ std::map<VSO *, MaterializationUnitList> MUsMap;<br>
+ auto Q = std::make_shared<AsynchronousSymbolQuery>(<br>
+ Symbols, std::move(OnResolve), std::move(OnReady));<br>
+ bool QueryIsFullyResolved = false;<br>
+ bool QueryIsFullyReady = false;<br>
+ bool QueryFailed = false;<br>
+<br>
+ runSessionLocked([&]() {<br>
+ for (auto *V : VSOs) {<br>
+ assert(V && "VSOList entries must not be null");<br>
+ assert(!MUsMap.count(V) &&<br>
+ "VSOList should not contain duplicate entries");<br>
+ V->lodgeQuery(Q, Unresolved, MUsMap[V]);<br>
+ }<br>
+<br>
+ if (Unresolved.empty()) {<br>
+ // Query lodged successfully.<br>
+<br>
+ // Record whether this query is fully ready / resolved. We will use<br>
+ // this to call handleFullyResolved/handleFullyReady outside the session<br>
+ // lock.<br>
+ QueryIsFullyResolved = Q->isFullyResolved();<br>
+ QueryIsFullyReady = Q->isFullyReady();<br>
+<br>
+ // Call the register dependencies function.<br>
+ if (RegisterDependencies && !Q->QueryRegistrations.empty())<br>
+ RegisterDependencies(Q->QueryRegistrations);<br>
+ } else {<br>
+ // Query failed due to unresolved symbols.<br>
+ QueryFailed = true;<br>
+<br>
+ // Disconnect the query from its dependencies.<br>
+ Q->detach();<br>
+<br>
+ // Replace the MUs.<br>
+ for (auto &KV : MUsMap)<br>
+ for (auto &MU : KV.second)<br>
+ KV.first->replace(std::move(MU));<br>
+ }<br>
+ });<br>
+<br>
+ if (QueryFailed) {<br>
+ Q->handleFailed(make_error<SymbolsNotFound>(std::move(Unresolved)));<br>
+ return;<br>
+ } else {<br>
+ if (QueryIsFullyResolved)<br>
+ Q->handleFullyResolved();<br>
+ if (QueryIsFullyReady)<br>
+ Q->handleFullyReady();<br>
+ }<br>
+<br>
+ // Move the MUs to the OutstandingMUs list, then materialize.<br>
+ {<br>
+ std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);<br>
+<br>
+ for (auto &KV : MUsMap)<br>
+ for (auto &MU : KV.second)<br>
+ OutstandingMUs.push_back(std::make_pair(KV.first, std::move(MU)));<br>
+ }<br>
+<br>
+ runOutstandingMUs();<br>
+}<br>
+<br>
+Expected<SymbolMap><br>
+ExecutionSessionBase::lookup(const VSOList &VSOs, const SymbolNameSet &Symbols,<br>
+ RegisterDependenciesFunction RegisterDependencies,<br>
+ bool WaitUntilReady) {<br>
+#if LLVM_ENABLE_THREADS<br>
+ // In the threaded case we use promises to return the results.<br>
+ std::promise<SymbolMap> PromisedResult;<br>
+ std::mutex ErrMutex;<br>
+ Error ResolutionError = Error::success();<br>
+ std::promise<void> PromisedReady;<br>
+ Error ReadyError = Error::success();<br>
+ auto OnResolve = [&](Expected<SymbolMap> R) {<br>
+ if (R)<br>
+ PromisedResult.set_value(std::move(*R));<br>
+ else {<br>
+ {<br>
+ ErrorAsOutParameter _(&ResolutionError);<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ ResolutionError = R.takeError();<br>
+ }<br>
+ PromisedResult.set_value(SymbolMap());<br>
+ }<br>
+ };<br>
+<br>
+ std::function<void(Error)> OnReady;<br>
+ if (WaitUntilReady) {<br>
+ OnReady = [&](Error Err) {<br>
+ if (Err) {<br>
+ ErrorAsOutParameter _(&ReadyError);<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ ReadyError = std::move(Err);<br>
+ }<br>
+ PromisedReady.set_value();<br>
+ };<br>
+ } else {<br>
+ OnReady = [&](Error Err) {<br>
+ if (Err)<br>
+ reportError(std::move(Err));<br>
+ };<br>
+ }<br>
+<br>
+#else<br>
+ SymbolMap Result;<br>
+ Error ResolutionError = Error::success();<br>
+ Error ReadyError = Error::success();<br>
+<br>
+ auto OnResolve = [&](Expected<SymbolMap> R) {<br>
+ ErrorAsOutParameter _(&ResolutionError);<br>
+ if (R)<br>
+ Result = std::move(R->Symbols);<br>
+ else<br>
+ ResolutionError = R.takeError();<br>
+ };<br>
+<br>
+ std::function<void(Error)> OnReady;<br>
+ if (WaitUntilReady) {<br>
+ OnReady = [&](Error Err) {<br>
+ ErrorAsOutParameter _(&ReadyError);<br>
+ if (Err)<br>
+ ReadyError = std::move(Err);<br>
+ };<br>
+ } else {<br>
+ OnReady = [&](Error Err) {<br>
+ if (Err)<br>
+ reportError(std::move(Err));<br>
+ };<br>
+ }<br>
+#endif<br>
+<br>
+ // Perform the asynchronous lookup.<br>
+ lookup(VSOs, Symbols, OnResolve, OnReady, RegisterDependencies);<br>
+<br>
+#if LLVM_ENABLE_THREADS<br>
+ auto ResultFuture = PromisedResult.get_future();<br>
+ auto Result = ResultFuture.get();<br>
+<br>
+ {<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ if (ResolutionError) {<br>
+ // ReadyError will never be assigned. Consume the success value.<br>
+ cantFail(std::move(ReadyError));<br>
+ return std::move(ResolutionError);<br>
+ }<br>
+ }<br>
+<br>
+ if (WaitUntilReady) {<br>
+ auto ReadyFuture = PromisedReady.get_future();<br>
+ ReadyFuture.get();<br>
+<br>
+ {<br>
+ std::lock_guard<std::mutex> Lock(ErrMutex);<br>
+ if (ReadyError)<br>
+ return std::move(ReadyError);<br>
+ }<br>
+ } else<br>
+ cantFail(std::move(ReadyError));<br>
+<br>
+ return std::move(Result);<br>
+<br>
+#else<br>
+ if (ResolutionError) {<br>
+ // ReadyError will never be assigned. Consume the success value.<br>
+ cantFail(std::move(ReadyError));<br>
+ return std::move(ResolutionError);<br>
+ }<br>
+<br>
+ if (ReadyError)<br>
+ return std::move(ReadyError);<br>
+<br>
+ return Result;<br>
+#endif<br>
+}<br>
+<br>
+void ExecutionSessionBase::runOutstandingMUs() {<br>
+ while (1) {<br>
+ std::pair<VSO *, std::unique_ptr<MaterializationUnit>> VSOAndMU;<br>
+<br>
+ {<br>
+ std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);<br>
+ if (!OutstandingMUs.empty()) {<br>
+ VSOAndMU = std::move(OutstandingMUs.back());<br>
+ OutstandingMUs.pop_back();<br>
+ }<br>
+ }<br>
+<br>
+ if (VSOAndMU.first) {<br>
+ assert(VSOAndMU.second && "VSO, but no MU?");<br>
+ dispatchMaterialization(*VSOAndMU.first, std::move(VSOAndMU.second));<br>
+ } else<br>
+ break;<br>
+ }<br>
+}<br>
+<br>
AsynchronousSymbolQuery::AsynchronousSymbolQuery(<br>
const SymbolNameSet &Symbols, SymbolsResolvedCallback NotifySymbolsResolved,<br>
SymbolsReadyCallback NotifySymbolsReady)<br>
@@ -161,12 +505,6 @@ AsynchronousSymbolQuery::AsynchronousSym<br>
<br>
for (auto &S : Symbols)<br>
ResolvedSymbols[S] = nullptr;<br>
-<br>
- // If the query is empty it is trivially resolved/ready.<br>
- if (Symbols.empty()) {<br>
- handleFullyResolved();<br>
- handleFullyReady();<br>
- }<br>
}<br>
<br>
void AsynchronousSymbolQuery::resolve(const SymbolStringPtr &Name,<br>
@@ -183,8 +521,7 @@ void AsynchronousSymbolQuery::handleFull<br>
assert(NotYetResolvedCount == 0 && "Not fully resolved?");<br>
assert(NotifySymbolsResolved &&<br>
"NotifySymbolsResolved already called or error occurred");<br>
- NotifySymbolsResolved(<br>
- ResolutionResult(std::move(ResolvedSymbols), QueryRegistrations));<br>
+ NotifySymbolsResolved(std::move(ResolvedSymbols));<br>
NotifySymbolsResolved = SymbolsResolvedCallback();<br>
}<br>
<br>
@@ -349,7 +686,8 @@ MaterializationResponsibility::delegate(<br>
<br>
void MaterializationResponsibility::addDependencies(<br>
const SymbolDependenceMap &Dependencies) {<br>
- V.addDependencies(SymbolFlags, Dependencies);<br>
+ for (auto &KV : SymbolFlags)<br>
+ V.addDependencies(KV.first, Dependencies);<br>
}<br>
<br>
AbsoluteSymbolsMaterializationUnit::AbsoluteSymbolsMaterializationUnit(<br>
@@ -384,8 +722,9 @@ ReExportsMaterializationUnit::ReExportsM<br>
void ReExportsMaterializationUnit::materialize(<br>
MaterializationResponsibility R) {<br>
<br>
- VSO &SrcV = SourceVSO ? *SourceVSO : R.getTargetVSO();<br>
- auto &ES = SrcV.getExecutionSession();<br>
+ auto &ES = R.getTargetVSO().getExecutionSession();<br>
+ VSO &TgtV = R.getTargetVSO();<br>
+ VSO &SrcV = SourceVSO ? *SourceVSO : TgtV;<br>
<br>
// Find the set of requested aliases and aliasees. Return any unrequested<br>
// aliases back to the VSO so as to not prematurely materialize any aliasees.<br>
@@ -434,9 +773,8 @@ void ReExportsMaterializationUnit::mater<br>
auto Tmp = I++;<br>
<br>
// Chain detected. Skip this symbol for this round.<br>
- if (&SrcV == &R.getTargetVSO() &&<br>
- (QueryAliases.count(Tmp->second.Aliasee) ||<br>
- RequestedAliases.count(Tmp->second.Aliasee)))<br>
+ if (&SrcV == &TgtV && (QueryAliases.count(Tmp->second.Aliasee) ||<br>
+ RequestedAliases.count(Tmp->second.Aliasee)))<br>
continue;<br>
<br>
ResponsibilitySymbols.insert(Tmp->first);<br>
@@ -459,49 +797,32 @@ void ReExportsMaterializationUnit::mater<br>
<br>
QueryInfos.pop_back();<br>
<br>
- auto OnResolve =<br>
- [QueryInfo,<br>
- &SrcV](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {<br>
- if (RR) {<br>
- SymbolMap ResolutionMap;<br>
- SymbolNameSet Resolved;<br>
- for (auto &KV : QueryInfo->Aliases) {<br>
- assert(RR->Symbols.count(KV.second.Aliasee) &&<br>
- "Result map missing entry?");<br>
- ResolutionMap[KV.first] = JITEvaluatedSymbol(<br>
- RR->Symbols[KV.second.Aliasee].getAddress(),<br>
- KV.second.AliasFlags);<br>
-<br>
- // FIXME: We're creating a SymbolFlagsMap and a std::map of<br>
- // std::sets just to add one dependency here. This needs a<br>
- // re-think.<br>
- Resolved.insert(KV.first);<br>
- }<br>
- QueryInfo->R.resolve(ResolutionMap);<br>
+ auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {<br>
+ R.addDependencies(Deps);<br>
+ };<br>
<br>
- SymbolDependenceMap Deps;<br>
- Deps[&SrcV] = std::move(Resolved);<br>
- QueryInfo->R.addDependencies(Deps);<br>
-<br>
- QueryInfo->R.finalize();<br>
- } else {<br>
- auto &ES = QueryInfo->R.getTargetVSO().getExecutionSession();<br>
- ES.reportError(RR.takeError());<br>
- QueryInfo->R.failMaterialization();<br>
- }<br>
- };<br>
+ auto OnResolve = [QueryInfo](Expected<SymbolMap> Result) {<br>
+ if (Result) {<br>
+ SymbolMap ResolutionMap;<br>
+ for (auto &KV : QueryInfo->Aliases) {<br>
+ assert(Result->count(KV.second.Aliasee) &&<br>
+ "Result map missing entry?");<br>
+ ResolutionMap[KV.first] = JITEvaluatedSymbol(<br>
+ (*Result)[KV.second.Aliasee].getAddress(), KV.second.AliasFlags);<br>
+ }<br>
+ QueryInfo->R.resolve(ResolutionMap);<br>
+ QueryInfo->R.finalize();<br>
+ } else {<br>
+ auto &ES = QueryInfo->R.getTargetVSO().getExecutionSession();<br>
+ ES.reportError(Result.takeError());<br>
+ QueryInfo->R.failMaterialization();<br>
+ }<br>
+ };<br>
<br>
auto OnReady = [&ES](Error Err) { ES.reportError(std::move(Err)); };<br>
<br>
- auto Q = std::make_shared<AsynchronousSymbolQuery>(<br>
- QuerySymbols, std::move(OnResolve), std::move(OnReady));<br>
-<br>
- auto Unresolved = SrcV.lookup(Q, std::move(QuerySymbols));<br>
-<br>
- if (!Unresolved.empty()) {<br>
- ES.failQuery(*Q, make_error<SymbolsNotFound>(std::move(Unresolved)));<br>
- return;<br>
- }<br>
+ ES.lookup({&SrcV}, QuerySymbols, std::move(OnResolve), std::move(OnReady),<br>
+ std::move(RegisterDependencies));<br>
}<br>
}<br>
<br>
@@ -642,40 +963,35 @@ SymbolNameSet VSO::getRequestedSymbols(c<br>
});<br>
}<br>
<br>
-void VSO::addDependencies(const SymbolFlagsMap &Dependants,<br>
+void VSO::addDependencies(const SymbolStringPtr &Name,<br>
const SymbolDependenceMap &Dependencies) {<br>
- ES.runSessionLocked([&, this]() {<br>
- for (auto &KV : Dependants) {<br>
- const auto &Name = KV.first;<br>
- assert(Symbols.count(Name) && "Name not in symbol table");<br>
- assert((Symbols[Name].getFlags().isLazy() ||<br>
- Symbols[Name].getFlags().isMaterializing()) &&<br>
- "Symbol is not lazy or materializing");<br>
-<br>
- auto &MI = MaterializingInfos[Name];<br>
- assert(!MI.IsFinalized && "Can not add dependencies to finalized symbol");<br>
-<br>
- for (auto &KV : Dependencies) {<br>
- assert(KV.first && "Null VSO in dependency?");<br>
- auto &OtherVSO = *KV.first;<br>
- auto &DepsOnOtherVSO = MI.UnfinalizedDependencies[&OtherVSO];<br>
-<br>
- for (auto &OtherSymbol : KV.second) {<br>
- auto &OtherMI = OtherVSO.MaterializingInfos[OtherSymbol];<br>
-<br>
- if (OtherMI.IsFinalized)<br>
- transferFinalizedNodeDependencies(MI, Name, OtherMI);<br>
- else if (&OtherVSO != this || OtherSymbol != Name) {<br>
- OtherMI.Dependants[this].insert(Name);<br>
- DepsOnOtherVSO.insert(OtherSymbol);<br>
- }<br>
- }<br>
-<br>
- if (DepsOnOtherVSO.empty())<br>
- MI.UnfinalizedDependencies.erase(&OtherVSO);<br>
+ assert(Symbols.count(Name) && "Name not in symbol table");<br>
+ assert((Symbols[Name].getFlags().isLazy() ||<br>
+ Symbols[Name].getFlags().isMaterializing()) &&<br>
+ "Symbol is not lazy or materializing");<br>
+<br>
+ auto &MI = MaterializingInfos[Name];<br>
+ assert(!MI.IsFinalized && "Can not add dependencies to finalized symbol");<br>
+<br>
+ for (auto &KV : Dependencies) {<br>
+ assert(KV.first && "Null VSO in dependency?");<br>
+ auto &OtherVSO = *KV.first;<br>
+ auto &DepsOnOtherVSO = MI.UnfinalizedDependencies[&OtherVSO];<br>
+<br>
+ for (auto &OtherSymbol : KV.second) {<br>
+ auto &OtherMI = OtherVSO.MaterializingInfos[OtherSymbol];<br>
+<br>
+ if (OtherMI.IsFinalized)<br>
+ transferFinalizedNodeDependencies(MI, Name, OtherMI);<br>
+ else if (&OtherVSO != this || OtherSymbol != Name) {<br>
+ OtherMI.Dependants[this].insert(Name);<br>
+ DepsOnOtherVSO.insert(OtherSymbol);<br>
}<br>
}<br>
- });<br>
+<br>
+ if (DepsOnOtherVSO.empty())<br>
+ MI.UnfinalizedDependencies.erase(&OtherVSO);<br>
+ }<br>
}<br>
<br>
void VSO::resolve(const SymbolMap &Resolved) {<br>
@@ -856,25 +1172,6 @@ void VSO::notifyFailed(const SymbolNameS<br>
Q->handleFailed(make_error<FailedToMaterialize>(FailedSymbols));<br>
}<br>
<br>
-void VSO::runOutstandingMUs() {<br>
- while (1) {<br>
- std::unique_ptr<MaterializationUnit> MU;<br>
-<br>
- {<br>
- std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);<br>
- if (!OutstandingMUs.empty()) {<br>
- MU = std::move(OutstandingMUs.back());<br>
- OutstandingMUs.pop_back();<br>
- }<br>
- }<br>
-<br>
- if (MU)<br>
- ES.dispatchMaterialization(*this, std::move(MU));<br>
- else<br>
- break;<br>
- }<br>
-}<br>
-<br>
void VSO::setSearchOrder(VSOList NewSearchOrder, bool SearchThisVSOFirst) {<br>
if (SearchThisVSOFirst && NewSearchOrder.front() != this)<br>
NewSearchOrder.insert(NewSearchOrder.begin(), this);<br>
@@ -939,11 +1236,89 @@ SymbolNameSet VSO::lookupFlagsImpl(Symbo<br>
return Unresolved;<br>
}<br>
<br>
-SymbolNameSet VSO::lookup(std::shared_ptr<AsynchronousSymbolQuery> Q,<br>
- SymbolNameSet Names) {<br>
+void VSO::lodgeQuery(std::shared_ptr<AsynchronousSymbolQuery> &Q,<br>
+ SymbolNameSet &Unresolved, MaterializationUnitList &MUs) {<br>
assert(Q && "Query can not be null");<br>
<br>
- runOutstandingMUs();<br>
+ lodgeQueryImpl(Q, Unresolved, MUs);<br>
+ if (FallbackDefinitionGenerator && !Unresolved.empty()) {<br>
+ auto FallbackDefs = FallbackDefinitionGenerator(*this, Unresolved);<br>
+ if (!FallbackDefs.empty()) {<br>
+ for (auto &D : FallbackDefs)<br>
+ Unresolved.erase(D);<br>
+ lodgeQueryImpl(Q, FallbackDefs, MUs);<br>
+ assert(FallbackDefs.empty() &&<br>
+ "All fallback defs should have been found by lookupImpl");<br>
+ }<br>
+ }<br>
+}<br>
+<br>
+void VSO::lodgeQueryImpl(<br>
+ std::shared_ptr<AsynchronousSymbolQuery> &Q, SymbolNameSet &Unresolved,<br>
+ std::vector<std::unique_ptr<MaterializationUnit>> &MUs) {<br>
+ for (auto I = Unresolved.begin(), E = Unresolved.end(); I != E;) {<br>
+ auto TmpI = I++;<br>
+ auto Name = *TmpI;<br>
+<br>
+ // Search for the name in Symbols. Skip it if not found.<br>
+ auto SymI = Symbols.find(Name);<br>
+ if (SymI == Symbols.end())<br>
+ continue;<br>
+<br>
+ // If we found Name in V, remove it frome the Unresolved set and add it<br>
+ // to the added set.<br>
+ Unresolved.erase(TmpI);<br>
+<br>
+ // If the symbol has an address then resolve it.<br>
+ if (SymI->second.getAddress() != 0)<br>
+ Q->resolve(Name, SymI->second);<br>
+<br>
+ // If the symbol is lazy, get the MaterialiaztionUnit for it.<br>
+ if (SymI->second.getFlags().isLazy()) {<br>
+ assert(SymI->second.getAddress() == 0 &&<br>
+ "Lazy symbol should not have a resolved address");<br>
+ assert(!SymI->second.getFlags().isMaterializing() &&<br>
+ "Materializing and lazy should not both be set");<br>
+ auto UMII = UnmaterializedInfos.find(Name);<br>
+ assert(UMII != UnmaterializedInfos.end() &&<br>
+ "Lazy symbol should have UnmaterializedInfo");<br>
+ auto MU = std::move(UMII->second->MU);<br>
+ assert(MU != nullptr && "Materializer should not be null");<br>
+<br>
+ // Move all symbols associated with this MaterializationUnit into<br>
+ // materializing state.<br>
+ for (auto &KV : MU->getSymbols()) {<br>
+ auto SymK = Symbols.find(KV.first);<br>
+ auto Flags = SymK->second.getFlags();<br>
+ Flags &= ~JITSymbolFlags::Lazy;<br>
+ Flags |= JITSymbolFlags::Materializing;<br>
+ SymK->second.setFlags(Flags);<br>
+ UnmaterializedInfos.erase(KV.first);<br>
+ }<br>
+<br>
+ // Add MU to the list of MaterializationUnits to be materialized.<br>
+ MUs.push_back(std::move(MU));<br>
+ } else if (!SymI->second.getFlags().isMaterializing()) {<br>
+ // The symbol is neither lazy nor materializing. Finalize it and<br>
+ // continue.<br>
+ Q->notifySymbolReady();<br>
+ continue;<br>
+ }<br>
+<br>
+ // Add the query to the PendingQueries list.<br>
+ assert(SymI->second.getFlags().isMaterializing() &&<br>
+ "By this line the symbol should be materializing");<br>
+ auto &MI = MaterializingInfos[Name];<br>
+ MI.PendingQueries.push_back(Q);<br>
+ Q->addQueryDependence(*this, Name);<br>
+ }<br>
+}<br>
+<br>
+SymbolNameSet VSO::legacyLookup(std::shared_ptr<AsynchronousSymbolQuery> Q,<br>
+ SymbolNameSet Names) {<br>
+ assert(Q && "Query can not be null");<br>
+<br>
+ ES.runOutstandingMUs();<br>
<br>
LookupImplActionFlags ActionFlags = None;<br>
std::vector<std::unique_ptr<MaterializationUnit>> MUs;<br>
@@ -978,11 +1353,11 @@ SymbolNameSet VSO::lookup(std::shared_pt<br>
// callbacks from asynchronous queries.<br>
// Add MUs to the OutstandingMUs list.<br>
{<br>
- std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);<br>
+ std::lock_guard<std::recursive_mutex> Lock(ES.OutstandingMUsMutex);<br>
for (auto &MU : MUs)<br>
- OutstandingMUs.push_back(std::move(MU));<br>
+ ES.OutstandingMUs.push_back(make_pair(this, std::move(MU)));<br>
}<br>
- runOutstandingMUs();<br>
+ ES.runOutstandingMUs();<br>
<br>
// Dispatch any required MaterializationUnits for materialization.<br>
// for (auto &MU : MUs)<br>
@@ -1243,133 +1618,6 @@ VSO &ExecutionSession::createVSO(std::st<br>
});<br>
}<br>
<br>
-Expected<SymbolMap> blockingLookup(ExecutionSessionBase &ES,<br>
- AsynchronousLookupFunction AsyncLookup,<br>
- SymbolNameSet Names, bool WaitUntilReady,<br>
- MaterializationResponsibility *MR) {<br>
-<br>
-#if LLVM_ENABLE_THREADS<br>
- // In the threaded case we use promises to return the results.<br>
- std::promise<SymbolMap> PromisedResult;<br>
- std::mutex ErrMutex;<br>
- Error ResolutionError = Error::success();<br>
- std::promise<void> PromisedReady;<br>
- Error ReadyError = Error::success();<br>
- auto OnResolve =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- if (Result) {<br>
- if (MR)<br>
- MR->addDependencies(Result->Dependencies);<br>
- PromisedResult.set_value(std::move(Result->Symbols));<br>
- } else {<br>
- {<br>
- ErrorAsOutParameter _(&ResolutionError);<br>
- std::lock_guard<std::mutex> Lock(ErrMutex);<br>
- ResolutionError = Result.takeError();<br>
- }<br>
- PromisedResult.set_value(SymbolMap());<br>
- }<br>
- };<br>
-<br>
- std::function<void(Error)> OnReady;<br>
- if (WaitUntilReady) {<br>
- OnReady = [&](Error Err) {<br>
- if (Err) {<br>
- ErrorAsOutParameter _(&ReadyError);<br>
- std::lock_guard<std::mutex> Lock(ErrMutex);<br>
- ReadyError = std::move(Err);<br>
- }<br>
- PromisedReady.set_value();<br>
- };<br>
- } else {<br>
- OnReady = [&](Error Err) {<br>
- if (Err)<br>
- ES.reportError(std::move(Err));<br>
- };<br>
- }<br>
-<br>
-#else<br>
- SymbolMap Result;<br>
- Error ResolutionError = Error::success();<br>
- Error ReadyError = Error::success();<br>
-<br>
- auto OnResolve = [&](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {<br>
- ErrorAsOutParameter _(&ResolutionError);<br>
- if (R) {<br>
- if (MR)<br>
- MR->addDependencies(R->Dependencies);<br>
- Result = std::move(R->Symbols);<br>
- } else<br>
- ResolutionError = R.takeError();<br>
- };<br>
-<br>
- std::function<void(Error)> OnReady;<br>
- if (WaitUntilReady) {<br>
- OnReady = [&](Error Err) {<br>
- ErrorAsOutParameter _(&ReadyError);<br>
- if (Err)<br>
- ReadyError = std::move(Err);<br>
- };<br>
- } else {<br>
- OnReady = [&](Error Err) {<br>
- if (Err)<br>
- ES.reportError(std::move(Err));<br>
- };<br>
- }<br>
-#endif<br>
-<br>
- auto Query = std::make_shared<AsynchronousSymbolQuery>(<br>
- Names, std::move(OnResolve), std::move(OnReady));<br>
-<br>
- SymbolNameSet UnresolvedSymbols = AsyncLookup(Query, std::move(Names));<br>
-<br>
- // If there are unresolved symbols then the query will never return.<br>
- // Fail it with ES.failQuery.<br>
- if (!UnresolvedSymbols.empty())<br>
- ES.failQuery(*Query,<br>
- make_error<SymbolsNotFound>(std::move(UnresolvedSymbols)));<br>
-<br>
-#if LLVM_ENABLE_THREADS<br>
- auto ResultFuture = PromisedResult.get_future();<br>
- auto Result = ResultFuture.get();<br>
-<br>
- {<br>
- std::lock_guard<std::mutex> Lock(ErrMutex);<br>
- if (ResolutionError) {<br>
- // ReadyError will never be assigned. Consume the success value.<br>
- cantFail(std::move(ReadyError));<br>
- return std::move(ResolutionError);<br>
- }<br>
- }<br>
-<br>
- if (WaitUntilReady) {<br>
- auto ReadyFuture = PromisedReady.get_future();<br>
- ReadyFuture.get();<br>
-<br>
- {<br>
- std::lock_guard<std::mutex> Lock(ErrMutex);<br>
- if (ReadyError)<br>
- return std::move(ReadyError);<br>
- }<br>
- } else<br>
- cantFail(std::move(ReadyError));<br>
-<br>
- return std::move(Result);<br>
-<br>
-#else<br>
- if (ResolutionError) {<br>
- // ReadyError will never be assigned. Consume the success value.<br>
- cantFail(std::move(ReadyError));<br>
- return std::move(ResolutionError);<br>
- }<br>
-<br>
- if (ReadyError)<br>
- return std::move(ReadyError);<br>
-<br>
- return Result;<br>
-#endif<br>
-}<br>
-<br>
Expected<SymbolMap> lookup(const VSOList &VSOs, SymbolNameSet Names) {<br>
<br>
if (VSOs.empty())<br>
@@ -1377,18 +1625,7 @@ Expected<SymbolMap> lookup(const VSOList<br>
<br>
auto &ES = (*VSOs.begin())->getExecutionSession();<br>
<br>
- auto LookupFn = [&](std::shared_ptr<AsynchronousSymbolQuery> Q,<br>
- SymbolNameSet Unresolved) {<br>
- for (auto *V : VSOs) {<br>
- assert(V && "VSOs entries must not be null");<br>
- if (Unresolved.empty())<br>
- break;<br>
- Unresolved = V->lookup(Q, std::move(Unresolved));<br>
- }<br>
- return Unresolved;<br>
- };<br>
-<br>
- return blockingLookup(ES, std::move(LookupFn), Names, true);<br>
+ return ES.lookup(VSOs, Names, NoDependenciesToRegister, true);<br>
}<br>
<br>
/// Look up a symbol by searching a list of VSOs.<br>
<br>
Modified: llvm/trunk/lib/ExecutionEngine/Orc/Legacy.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/Legacy.cpp?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/Legacy.cpp?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/ExecutionEngine/Orc/Legacy.cpp (original)<br>
+++ llvm/trunk/lib/ExecutionEngine/Orc/Legacy.cpp Fri Jul 20 11:31:53 2018<br>
@@ -29,8 +29,14 @@ JITSymbolResolverAdapter::lookup(const L<br>
return R.lookup(std::move(Q), std::move(Unresolved));<br>
};<br>
<br>
- auto InternedResult = blockingLookup(ES, std::move(LookupFn),<br>
- std::move(InternedSymbols), false, MR);<br>
+ auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {<br>
+ if (MR)<br>
+ MR->addDependencies(Deps);<br>
+ };<br>
+<br>
+ auto InternedResult =<br>
+ ES.legacyLookup(ES, std::move(LookupFn), std::move(InternedSymbols),<br>
+ false, RegisterDependencies);<br>
<br>
if (!InternedResult)<br>
return InternedResult.takeError();<br>
<br>
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h (original)<br>
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcCBindingsStack.h Fri Jul 20 11:31:53 2018<br>
@@ -156,11 +156,11 @@ private:<br>
Query->resolve(S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));<br>
Query->notifySymbolReady();<br>
} else {<br>
- Stack.ES.failQuery(*Query, Addr.takeError());<br>
+ Stack.ES.legacyFailQuery(*Query, Addr.takeError());<br>
return orc::SymbolNameSet();<br>
}<br>
} else if (auto Err = Sym.takeError()) {<br>
- Stack.ES.failQuery(*Query, std::move(Err));<br>
+ Stack.ES.legacyFailQuery(*Query, std::move(Err));<br>
return orc::SymbolNameSet();<br>
} else<br>
UnresolvedSymbols.insert(S);<br>
<br>
Modified: llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h (original)<br>
+++ llvm/trunk/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h Fri Jul 20 11:31:53 2018<br>
@@ -178,11 +178,11 @@ class OrcMCJITReplacement : public Execu<br>
Query->notifySymbolReady();<br>
NewSymbolsResolved = true;<br>
} else {<br>
- M.ES.failQuery(*Query, Addr.takeError());<br>
+ M.ES.legacyFailQuery(*Query, Addr.takeError());<br>
return SymbolNameSet();<br>
}<br>
} else if (auto Err = Sym.takeError()) {<br>
- M.ES.failQuery(*Query, std::move(Err));<br>
+ M.ES.legacyFailQuery(*Query, std::move(Err));<br>
return SymbolNameSet();<br>
} else {<br>
if (auto Sym2 = M.ClientResolver->findSymbol(*S)) {<br>
@@ -191,11 +191,11 @@ class OrcMCJITReplacement : public Execu<br>
Query->notifySymbolReady();<br>
NewSymbolsResolved = true;<br>
} else {<br>
- M.ES.failQuery(*Query, Addr.takeError());<br>
+ M.ES.legacyFailQuery(*Query, Addr.takeError());<br>
return SymbolNameSet();<br>
}<br>
} else if (auto Err = Sym2.takeError()) {<br>
- M.ES.failQuery(*Query, std::move(Err));<br>
+ M.ES.legacyFailQuery(*Query, std::move(Err));<br>
return SymbolNameSet();<br>
} else<br>
UnresolvedSymbols.insert(S);<br>
<br>
Modified: llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp (original)<br>
+++ llvm/trunk/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp Fri Jul 20 11:31:53 2018<br>
@@ -16,30 +16,23 @@ using namespace llvm::orc;<br>
<br>
class VSOSearchOrderResolver : public JITSymbolResolver {<br>
public:<br>
- VSOSearchOrderResolver(ExecutionSession &ES,<br>
- MaterializationResponsibility &MR)<br>
- : ES(ES), MR(MR) {}<br>
+ VSOSearchOrderResolver(MaterializationResponsibility &MR) : MR(MR) {}<br>
<br>
Expected<LookupResult> lookup(const LookupSet &Symbols) {<br>
+ auto &ES = MR.getTargetVSO().getExecutionSession();<br>
SymbolNameSet InternedSymbols;<br>
<br>
for (auto &S : Symbols)<br>
InternedSymbols.insert(ES.getSymbolStringPool().intern(S));<br>
<br>
- auto AsyncLookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Q,<br>
- SymbolNameSet Names) {<br>
- SymbolNameSet Unresolved = std::move(Names);<br>
- MR.getTargetVSO().withSearchOrderDo([&](const VSOList &SearchOrder) {<br>
- for (auto *V : SearchOrder) {<br>
- assert(V && "VSOList entry can not be null");<br>
- Unresolved = V->lookup(Q, std::move(Unresolved));<br>
- }<br>
- });<br>
- return Unresolved;<br>
+ auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {<br>
+ MR.addDependencies(Deps);<br>
};<br>
<br>
- auto InternedResult = blockingLookup(<br>
- ES, std::move(AsyncLookup), std::move(InternedSymbols), false, &MR);<br>
+ auto InternedResult =<br>
+ MR.getTargetVSO().withSearchOrderDo([&](const VSOList &VSOs) {<br>
+ return ES.lookup(VSOs, InternedSymbols, RegisterDependencies, false);<br>
+ });<br>
<br>
if (!InternedResult)<br>
return InternedResult.takeError();<br>
@@ -52,6 +45,8 @@ public:<br>
}<br>
<br>
Expected<LookupFlagsResult> lookupFlags(const LookupSet &Symbols) {<br>
+ auto &ES = MR.getTargetVSO().getExecutionSession();<br>
+<br>
SymbolNameSet InternedSymbols;<br>
<br>
for (auto &S : Symbols)<br>
@@ -75,7 +70,6 @@ public:<br>
}<br>
<br>
private:<br>
- ExecutionSession &ES;<br>
MaterializationResponsibility &MR;<br>
};<br>
<br>
@@ -106,7 +100,7 @@ void RTDyldObjectLinkingLayer2::emit(Mat<br>
<br>
auto MemoryManager = GetMemoryManager(K);<br>
<br>
- VSOSearchOrderResolver Resolver(ES, R);<br>
+ VSOSearchOrderResolver Resolver(R);<br>
auto RTDyld = llvm::make_unique<RuntimeDyld>(*MemoryManager, Resolver);<br>
RTDyld->setProcessAllSections(ProcessAllSections);<br>
<br>
<br>
Modified: llvm/trunk/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp (original)<br>
+++ llvm/trunk/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp Fri Jul 20 11:31:53 2018<br>
@@ -59,51 +59,57 @@ private:<br>
DestructorFunction Destructor;<br>
};<br>
<br>
-<br>
-TEST_F(CoreAPIsStandardTest, AsynchronousSymbolQuerySuccessfulResolutionOnly) {<br>
+TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) {<br>
bool OnResolutionRun = false;<br>
bool OnReadyRun = false;<br>
- auto OnResolution =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";<br>
- auto &Resolved = Result->Symbols;<br>
- auto I = Resolved.find(Foo);<br>
- EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";<br>
- EXPECT_EQ(I->second.getAddress(), FooAddr)<br>
- << "Resolution returned incorrect result";<br>
- OnResolutionRun = true;<br>
- };<br>
+<br>
+ auto OnResolution = [&](Expected<SymbolMap> Result) {<br>
+ EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";<br>
+ auto &Resolved = *Result;<br>
+ auto I = Resolved.find(Foo);<br>
+ EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";<br>
+ EXPECT_EQ(I->second.getAddress(), FooAddr)<br>
+ << "Resolution returned incorrect result";<br>
+ OnResolutionRun = true;<br>
+ };<br>
auto OnReady = [&](Error Err) {<br>
cantFail(std::move(Err));<br>
OnReadyRun = true;<br>
};<br>
<br>
- AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);<br>
+ std::shared_ptr<MaterializationResponsibility> FooMR;<br>
<br>
- Q.resolve(Foo, FooSym);<br>
+ cantFail(V.define(llvm::make_unique<SimpleMaterializationUnit>(<br>
+ SymbolFlagsMap({{Foo, FooSym.getFlags()}}),<br>
+ [&](MaterializationResponsibility R) {<br>
+ FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));<br>
+ })));<br>
<br>
- EXPECT_TRUE(Q.isFullyResolved()) << "Expected query to be fully resolved";<br>
+ ES.lookup({&V}, {Foo}, OnResolution, OnReady, NoDependenciesToRegister);<br>
<br>
- if (!Q.isFullyResolved())<br>
- return;<br>
+ EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet";<br>
+ EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";<br>
<br>
- Q.handleFullyResolved();<br>
+ FooMR->resolve({{Foo, FooSym}});<br>
<br>
- EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";<br>
- EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";<br>
+ EXPECT_TRUE(OnResolutionRun) << "Should have been resolved";<br>
+ EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";<br>
+<br>
+ FooMR->finalize();<br>
+<br>
+ EXPECT_TRUE(OnReadyRun) << "Should have been marked ready";<br>
}<br>
<br>
TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {<br>
bool OnResolutionRun = false;<br>
bool OnReadyRun = false;<br>
<br>
- auto OnResolution =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";<br>
- auto Msg = toString(Result.takeError());<br>
- EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";<br>
- OnResolutionRun = true;<br>
- };<br>
+ auto OnResolution = [&](Expected<SymbolMap> Result) {<br>
+ EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";<br>
+ auto Msg = toString(Result.takeError());<br>
+ EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";<br>
+ OnResolutionRun = true;<br>
+ };<br>
auto OnReady = [&](Error Err) {<br>
cantFail(std::move(Err));<br>
OnReadyRun = true;<br>
@@ -111,62 +117,28 @@ TEST_F(CoreAPIsStandardTest, ExecutionSe<br>
<br>
AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);<br>
<br>
- ES.failQuery(Q, make_error<StringError>("xyz", inconvertibleErrorCode()));<br>
+ ES.legacyFailQuery(Q,<br>
+ make_error<StringError>("xyz", inconvertibleErrorCode()));<br>
<br>
EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";<br>
EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";<br>
}<br>
<br>
-TEST_F(CoreAPIsStandardTest, SimpleAsynchronousSymbolQueryAgainstVSO) {<br>
- bool OnResolutionRun = false;<br>
+TEST_F(CoreAPIsStandardTest, EmptyLookup) {<br>
+ bool OnResolvedRun = false;<br>
bool OnReadyRun = false;<br>
<br>
- auto OnResolution =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- EXPECT_TRUE(!!Result) << "Query unexpectedly returned error";<br>
- auto &Resolved = Result->Symbols;<br>
- auto I = Resolved.find(Foo);<br>
- EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";<br>
- EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())<br>
- << "Resolution returned incorrect result";<br>
- OnResolutionRun = true;<br>
- };<br>
+ auto OnResolution = [&](Expected<SymbolMap> Result) {<br>
+ cantFail(std::move(Result));<br>
+ OnResolvedRun = true;<br>
+ };<br>
<br>
auto OnReady = [&](Error Err) {<br>
cantFail(std::move(Err));<br>
OnReadyRun = true;<br>
};<br>
<br>
- SymbolNameSet Names({Foo});<br>
-<br>
- auto Q =<br>
- std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);<br>
-<br>
- auto Defs = absoluteSymbols({{Foo, FooSym}});<br>
- cantFail(V.define(Defs));<br>
- assert(Defs == nullptr && "Defs should have been accepted");<br>
- V.lookup(Q, Names);<br>
-<br>
- EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";<br>
- EXPECT_TRUE(OnReadyRun) << "OnReady was not run";<br>
-}<br>
-<br>
-TEST_F(CoreAPIsStandardTest, EmptyVSOAndQueryLookup) {<br>
- bool OnResolvedRun = false;<br>
- bool OnReadyRun = false;<br>
-<br>
- auto Q = std::make_shared<AsynchronousSymbolQuery>(<br>
- SymbolNameSet(),<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {<br>
- cantFail(std::move(RR));<br>
- OnResolvedRun = true;<br>
- },<br>
- [&](Error Err) {<br>
- cantFail(std::move(Err));<br>
- OnReadyRun = true;<br>
- });<br>
-<br>
- V.lookup(std::move(Q), {});<br>
+ ES.lookup({&V}, {}, OnResolution, OnReady, NoDependenciesToRegister);<br>
<br>
EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";<br>
EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";<br>
@@ -182,8 +154,8 @@ TEST_F(CoreAPIsStandardTest, ChainedVSOL<br>
<br>
auto Q = std::make_shared<AsynchronousSymbolQuery>(<br>
SymbolNameSet({Foo}),<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {<br>
- cantFail(std::move(RR));<br>
+ [&](Expected<SymbolMap> Result) {<br>
+ cantFail(std::move(Result));<br>
OnResolvedRun = true;<br>
},<br>
[&](Error Err) {<br>
@@ -191,7 +163,7 @@ TEST_F(CoreAPIsStandardTest, ChainedVSOL<br>
OnReadyRun = true;<br>
});<br>
<br>
- V2.lookup(Q, V.lookup(Q, {Foo}));<br>
+ V2.legacyLookup(Q, V.legacyLookup(Q, {Foo}));<br>
<br>
EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";<br>
EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";<br>
@@ -268,20 +240,15 @@ TEST_F(CoreAPIsStandardTest, TestTrivial<br>
cantFail(V.define(FooMU));<br>
<br>
bool FooReady = false;<br>
- auto Q =<br>
- std::make_shared<AsynchronousSymbolQuery>(<br>
- SymbolNameSet({ Foo }),<br>
- [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {<br>
- cantFail(std::move(R));<br>
- },<br>
- [&](Error Err) {<br>
- cantFail(std::move(Err));<br>
- FooReady = true;<br>
- });<br>
+ auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); };<br>
+ auto OnReady = [&](Error Err) {<br>
+ cantFail(std::move(Err));<br>
+ FooReady = true;<br>
+ };<br>
<br>
- V.lookup(std::move(Q), { Foo });<br>
+ ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),<br>
+ NoDependenciesToRegister);<br>
<br>
- FooR->addDependencies({{&V, {Foo}}});<br>
FooR->resolve({{Foo, FooSym}});<br>
FooR->finalize();<br>
<br>
@@ -323,54 +290,52 @@ TEST_F(CoreAPIsStandardTest, TestCircula<br>
// Query each of the symbols to trigger materialization.<br>
bool FooResolved = false;<br>
bool FooReady = false;<br>
- auto FooQ = std::make_shared<AsynchronousSymbolQuery>(<br>
- SymbolNameSet({Foo}),<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {<br>
- cantFail(std::move(RR));<br>
- FooResolved = true;<br>
- },<br>
- [&](Error Err) {<br>
- cantFail(std::move(Err));<br>
- FooReady = true;<br>
- });<br>
- {<br>
- auto Unresolved = V.lookup(FooQ, {Foo});<br>
- EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Foo\"";<br>
- }<br>
+<br>
+ auto OnFooResolution = [&](Expected<SymbolMap> Result) {<br>
+ cantFail(std::move(Result));<br>
+ FooResolved = true;<br>
+ };<br>
+<br>
+ auto OnFooReady = [&](Error Err) {<br>
+ cantFail(std::move(Err));<br>
+ FooReady = true;<br>
+ };<br>
+<br>
+ // Issue a lookup for Foo. Use NoDependenciesToRegister: We're going to add<br>
+ // the dependencies manually below.<br>
+ ES.lookup({&V}, {Foo}, std::move(OnFooResolution), std::move(OnFooReady),<br>
+ NoDependenciesToRegister);<br>
<br>
bool BarResolved = false;<br>
bool BarReady = false;<br>
- auto BarQ = std::make_shared<AsynchronousSymbolQuery>(<br>
- SymbolNameSet({Bar}),<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {<br>
- cantFail(std::move(RR));<br>
- BarResolved = true;<br>
- },<br>
- [&](Error Err) {<br>
- cantFail(std::move(Err));<br>
- BarReady = true;<br>
- });<br>
- {<br>
- auto Unresolved = V.lookup(BarQ, {Bar});<br>
- EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Bar\"";<br>
- }<br>
+ auto OnBarResolution = [&](Expected<SymbolMap> Result) {<br>
+ cantFail(std::move(Result));<br>
+ BarResolved = true;<br>
+ };<br>
+<br>
+ auto OnBarReady = [&](Error Err) {<br>
+ cantFail(std::move(Err));<br>
+ BarReady = true;<br>
+ };<br>
+<br>
+ ES.lookup({&V}, {Bar}, std::move(OnBarResolution), std::move(OnBarReady),<br>
+ NoDependenciesToRegister);<br>
<br>
bool BazResolved = false;<br>
bool BazReady = false;<br>
- auto BazQ = std::make_shared<AsynchronousSymbolQuery>(<br>
- SymbolNameSet({Baz}),<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {<br>
- cantFail(std::move(RR));<br>
- BazResolved = true;<br>
- },<br>
- [&](Error Err) {<br>
- cantFail(std::move(Err));<br>
- BazReady = true;<br>
- });<br>
- {<br>
- auto Unresolved = V.lookup(BazQ, {Baz});<br>
- EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Baz\"";<br>
- }<br>
+<br>
+ auto OnBazResolution = [&](Expected<SymbolMap> Result) {<br>
+ cantFail(std::move(Result));<br>
+ BazResolved = true;<br>
+ };<br>
+<br>
+ auto OnBazReady = [&](Error Err) {<br>
+ cantFail(std::move(Err));<br>
+ BazReady = true;<br>
+ };<br>
+<br>
+ ES.lookup({&V}, {Baz}, std::move(OnBazResolution), std::move(OnBazReady),<br>
+ NoDependenciesToRegister);<br>
<br>
// Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.<br>
FooR->addDependencies({{&V, SymbolNameSet({Bar})}});<br>
@@ -478,28 +443,23 @@ TEST_F(CoreAPIsStandardTest, AddAndMater<br>
bool OnResolutionRun = false;<br>
bool OnReadyRun = false;<br>
<br>
- auto OnResolution =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";<br>
- auto I = Result->Symbols.find(Foo);<br>
- EXPECT_NE(I, Result->Symbols.end())<br>
- << "Could not find symbol definition";<br>
- EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())<br>
- << "Resolution returned incorrect result";<br>
- OnResolutionRun = true;<br>
- };<br>
+ auto OnResolution = [&](Expected<SymbolMap> Result) {<br>
+ EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";<br>
+ auto I = Result->find(Foo);<br>
+ EXPECT_NE(I, Result->end()) << "Could not find symbol definition";<br>
+ EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())<br>
+ << "Resolution returned incorrect result";<br>
+ OnResolutionRun = true;<br>
+ };<br>
<br>
auto OnReady = [&](Error Err) {<br>
cantFail(std::move(Err));<br>
OnReadyRun = true;<br>
};<br>
<br>
- auto Q =<br>
- std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);<br>
+ ES.lookup({&V}, Names, std::move(OnResolution), std::move(OnReady),<br>
+ NoDependenciesToRegister);<br>
<br>
- auto Unresolved = V.lookup(std::move(Q), Names);<br>
-<br>
- EXPECT_TRUE(Unresolved.empty()) << "Could not find Foo in dylib";<br>
EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";<br>
EXPECT_TRUE(BarDiscarded) << "Bar was not discarded";<br>
EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";<br>
@@ -714,13 +674,14 @@ TEST_F(CoreAPIsStandardTest, TestMateria<br>
});<br>
<br>
cantFail(V.define(MU));<br>
- auto Q = std::make_shared<AsynchronousSymbolQuery>(<br>
- SymbolNameSet({Foo}),<br>
- [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {<br>
- cantFail(std::move(R));<br>
- },<br>
- [](Error Err) { cantFail(std::move(Err)); });<br>
- V.lookup(std::move(Q), SymbolNameSet({Foo}));<br>
+ auto OnResolution = [](Expected<SymbolMap> Result) {<br>
+ cantFail(std::move(Result));<br>
+ };<br>
+<br>
+ auto OnReady = [](Error Err) { cantFail(std::move(Err)); };<br>
+<br>
+ ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),<br>
+ NoDependenciesToRegister);<br>
<br>
auto MU2 = llvm::make_unique<SimpleMaterializationUnit>(<br>
SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),<br>
<br>
Modified: llvm/trunk/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp?rev=337595&r1=337594&r2=337595&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp?rev=337595&r1=337594&r2=337595&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp (original)<br>
+++ llvm/trunk/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp Fri Jul 20 11:31:53 2018<br>
@@ -24,7 +24,7 @@ TEST_F(LegacyAPIsStandardTest, TestLambd<br>
auto Resolver = createSymbolResolver(<br>
[&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },<br>
[&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {<br>
- return V.lookup(std::move(Q), Symbols);<br>
+ return V.legacyLookup(std::move(Q), Symbols);<br>
});<br>
<br>
SymbolNameSet Symbols({Foo, Bar, Baz});<br>
@@ -42,21 +42,17 @@ TEST_F(LegacyAPIsStandardTest, TestLambd<br>
<br>
bool OnResolvedRun = false;<br>
<br>
- auto OnResolved =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- OnResolvedRun = true;<br>
- EXPECT_TRUE(!!Result) << "Unexpected error";<br>
- EXPECT_EQ(Result->Symbols.size(), 2U)<br>
- << "Unexpected number of resolved symbols";<br>
- EXPECT_EQ(Result->Symbols.count(Foo), 1U)<br>
- << "Missing lookup result for foo";<br>
- EXPECT_EQ(Result->Symbols.count(Bar), 1U)<br>
- << "Missing lookup result for bar";<br>
- EXPECT_EQ(Result->Symbols[Foo].getAddress(), FooSym.getAddress())<br>
- << "Incorrect address for foo";<br>
- EXPECT_EQ(Result->Symbols[Bar].getAddress(), BarSym.getAddress())<br>
- << "Incorrect address for bar";<br>
- };<br>
+ auto OnResolved = [&](Expected<SymbolMap> Result) {<br>
+ OnResolvedRun = true;<br>
+ EXPECT_TRUE(!!Result) << "Unexpected error";<br>
+ EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";<br>
+ EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";<br>
+ EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";<br>
+ EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())<br>
+ << "Incorrect address for foo";<br>
+ EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())<br>
+ << "Incorrect address for bar";<br>
+ };<br>
auto OnReady = [&](Error Err) {<br>
EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";<br>
};<br>
@@ -85,7 +81,7 @@ TEST(LegacyAPIInteropTest, QueryAgainstV<br>
<br>
auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,<br>
SymbolNameSet Symbols) {<br>
- return V.lookup(std::move(Query), Symbols);<br>
+ return V.legacyLookup(std::move(Query), Symbols);<br>
};<br>
<br>
auto UnderlyingResolver =<br>
@@ -158,22 +154,18 @@ TEST(LegacyAPIInteropTset, LegacyLookupH<br>
<br>
bool OnResolvedRun = false;<br>
bool OnReadyRun = false;<br>
- auto OnResolved =<br>
- [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {<br>
- OnResolvedRun = true;<br>
- EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";<br>
-<br>
- auto &Resolved = Result->Symbols;<br>
- EXPECT_EQ(Resolved.size(), 2U) << "Wrong number of symbols resolved";<br>
- EXPECT_EQ(Resolved.count(Foo), 1U) << "Result for foo missing";<br>
- EXPECT_EQ(Resolved.count(Bar), 1U) << "Result for bar missing";<br>
- EXPECT_EQ(Resolved[Foo].getAddress(), FooAddr)<br>
- << "Wrong address for foo";<br>
- EXPECT_EQ(Resolved[Foo].getFlags(), FooFlags) << "</blockquote></div>
</blockquote></div>