[ORC] Switch to shared_ptr ownership for AsynchronousSymbolQueries.

Queries need to stay alive until each owner has set the values they are
responsible for.

llvm-svn: 325179

5 files changed, 39 insertions, 35 deletions

diff --git a/llvm/lib/ExecutionEngine/Orc/Core.cpp b/llvm/lib/ExecutionEngine/Orc/Core.cpp
index 886bd7e7915..37133b7aa85 100644
--- a/llvm/lib/ExecutionEngine/Orc/Core.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/Core.cpp
@@ -64,9 +64,9 @@ void AsynchronousSymbolQuery::notifySymbolFinalized() {
     NotifySymbolsReady(Error::success());
 }
 
-VSO::MaterializationInfo::MaterializationInfo(JITSymbolFlags Flags,
-                                              AsynchronousSymbolQuery &Query)
-    : Flags(std::move(Flags)), PendingResolution({&Query}) {}
+VSO::MaterializationInfo::MaterializationInfo(
+    JITSymbolFlags Flags, std::shared_ptr<AsynchronousSymbolQuery> Query)
+    : Flags(std::move(Flags)), PendingResolution({std::move(Query)}) {}
 
 JITSymbolFlags VSO::MaterializationInfo::getFlags() const { return Flags; }
 
@@ -74,13 +74,13 @@ JITTargetAddress VSO::MaterializationInfo::getAddress() const {
   return Address;
 }
 
-void VSO::MaterializationInfo::query(SymbolStringPtr Name,
-                                     AsynchronousSymbolQuery &Query) {
+void VSO::MaterializationInfo::query(
+    SymbolStringPtr Name, std::shared_ptr<AsynchronousSymbolQuery> Query) {
   if (Address != 0) {
-    Query.setDefinition(Name, JITEvaluatedSymbol(Address, Flags));
-    PendingFinalization.push_back(&Query);
+    Query->setDefinition(Name, JITEvaluatedSymbol(Address, Flags));
+    PendingFinalization.push_back(std::move(Query));
   } else
-    PendingResolution.push_back(&Query);
+    PendingResolution.push_back(std::move(Query));
 }
 
 void VSO::MaterializationInfo::resolve(SymbolStringPtr Name,
@@ -88,15 +88,15 @@ void VSO::MaterializationInfo::resolve(SymbolStringPtr Name,
   // FIXME: Sanity check flags?
   Flags = Sym.getFlags();
   Address = Sym.getAddress();
-  for (auto *Query : PendingResolution) {
+  for (auto &Query : PendingResolution) {
     Query->setDefinition(Name, std::move(Sym));
-    PendingFinalization.push_back(Query);
+    PendingFinalization.push_back(std::move(Query));
   }
   PendingResolution = {};
 }
 
 void VSO::MaterializationInfo::finalize() {
-  for (auto *Query : PendingFinalization)
+  for (auto &Query : PendingFinalization)
     Query->notifySymbolFinalized();
   PendingFinalization = {};
 }
@@ -140,19 +140,20 @@ void VSO::SymbolTableEntry::replaceWithSource(VSO &V, SymbolStringPtr Name,
   this->Source = &NewSource;
 }
 
-SymbolSource *VSO::SymbolTableEntry::query(SymbolStringPtr Name,
-                                           AsynchronousSymbolQuery &Query) {
+SymbolSource *
+VSO::SymbolTableEntry::query(SymbolStringPtr Name,
+                             std::shared_ptr<AsynchronousSymbolQuery> Query) {
   if (Flags.isMaterializing()) {
-    MatInfo->query(std::move(Name), Query);
+    MatInfo->query(std::move(Name), std::move(Query));
     return nullptr;
   } else if (Flags.isMaterialized()) {
-    Query.setDefinition(std::move(Name), JITEvaluatedSymbol(Address, Flags));
-    Query.notifySymbolFinalized();
+    Query->setDefinition(std::move(Name), JITEvaluatedSymbol(Address, Flags));
+    Query->notifySymbolFinalized();
     return nullptr;
   }
   SymbolSource *S = Source;
   new (&MatInfo) std::unique_ptr<MaterializationInfo>(
-      llvm::make_unique<MaterializationInfo>(Flags, Query));
+      llvm::make_unique<MaterializationInfo>(Flags, std::move(Query)));
   Flags |= JITSymbolFlags::Materializing;
   return S;
 }
@@ -307,7 +308,7 @@ SymbolNameSet VSO::lookupFlags(SymbolFlagsMap &Flags, SymbolNameSet Names) {
   return Names;
 }
 
-VSO::LookupResult VSO::lookup(AsynchronousSymbolQuery &Query,
+VSO::LookupResult VSO::lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
                               SymbolNameSet Names) {
   SourceWorkMap MaterializationWork;
 
diff --git a/llvm/lib/ExecutionEngine/Orc/Legacy.cpp b/llvm/lib/ExecutionEngine/Orc/Legacy.cpp
index 240e0f8ba1d..a2413703f13 100644
--- a/llvm/lib/ExecutionEngine/Orc/Legacy.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/Legacy.cpp
@@ -41,9 +41,10 @@ JITSymbolResolverAdapter::lookup(const LookupSet &Symbols) {
                           "legacy resolver received on-ready error:\n");
   };
 
-  AsynchronousSymbolQuery Query(InternedSymbols, OnResolve, OnReady);
+  auto Query = std::make_shared<AsynchronousSymbolQuery>(InternedSymbols,
+                                                         OnResolve, OnReady);
 
-  auto UnresolvedSymbols = R.lookup(Query, InternedSymbols);
+  auto UnresolvedSymbols = R.lookup(std::move(Query), InternedSymbols);
 
   if (!UnresolvedSymbols.empty()) {
     std::string ErrorMsg = "Unresolved symbols: ";
diff --git a/llvm/lib/ExecutionEngine/Orc/NullResolver.cpp b/llvm/lib/ExecutionEngine/Orc/NullResolver.cpp
index 59f7414df71..872efea5fc8 100644
--- a/llvm/lib/ExecutionEngine/Orc/NullResolver.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/NullResolver.cpp
@@ -19,8 +19,9 @@ SymbolNameSet NullResolver::lookupFlags(SymbolFlagsMap &Flags,
   return Symbols;
 }
 
-SymbolNameSet NullResolver::lookup(AsynchronousSymbolQuery &Query,
-                                   SymbolNameSet Symbols) {
+SymbolNameSet
+NullResolver::lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
+                     SymbolNameSet Symbols) {
   assert(Symbols.empty() && "Null resolver: Symbols must be empty");
   return Symbols;
 }
diff --git a/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
index 22b618931e3..499708e7847 100644
--- a/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
+++ b/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
@@ -147,20 +147,21 @@ private:
       return SymbolsNotFound;
     }
 
-    orc::SymbolNameSet lookup(orc::AsynchronousSymbolQuery &Query,
-                              orc::SymbolNameSet Symbols) override {
+    orc::SymbolNameSet
+    lookup(std::shared_ptr<orc::AsynchronousSymbolQuery> Query,
+           orc::SymbolNameSet Symbols) override {
       orc::SymbolNameSet UnresolvedSymbols;
 
       for (auto &S : Symbols) {
         if (auto Sym = findSymbol(*S)) {
           if (auto Addr = Sym.getAddress())
-            Query.setDefinition(S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
+            Query->setDefinition(S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
           else {
-            Query.setFailed(Addr.takeError());
+            Query->setFailed(Addr.takeError());
             return orc::SymbolNameSet();
           }
         } else if (auto Err = Sym.takeError()) {
-          Query.setFailed(std::move(Err));
+          Query->setFailed(std::move(Err));
           return orc::SymbolNameSet();
         } else
           UnresolvedSymbols.insert(S);
diff --git a/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h b/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
index f024674cafe..579d68b1333 100644
--- a/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
+++ b/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
@@ -166,32 +166,32 @@ class OrcMCJITReplacement : public ExecutionEngine {
       return UnresolvedSymbols;
     }
 
-    SymbolNameSet lookup(AsynchronousSymbolQuery &Query,
+    SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Query,
                          SymbolNameSet Symbols) override {
       SymbolNameSet UnresolvedSymbols;
 
       for (auto &S : Symbols) {
         if (auto Sym = M.findMangledSymbol(*S)) {
           if (auto Addr = Sym.getAddress())
-            Query.setDefinition(S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
+            Query->setDefinition(S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
           else {
-            Query.setFailed(Addr.takeError());
+            Query->setFailed(Addr.takeError());
             return SymbolNameSet();
           }
         } else if (auto Err = Sym.takeError()) {
-          Query.setFailed(std::move(Err));
+          Query->setFailed(std::move(Err));
           return SymbolNameSet();
         } else {
           if (auto Sym2 = M.ClientResolver->findSymbol(*S)) {
             if (auto Addr = Sym2.getAddress())
-              Query.setDefinition(S,
-                                  JITEvaluatedSymbol(*Addr, Sym2.getFlags()));
+              Query->setDefinition(S,
+                                   JITEvaluatedSymbol(*Addr, Sym2.getFlags()));
             else {
-              Query.setFailed(Addr.takeError());
+              Query->setFailed(Addr.takeError());
               return SymbolNameSet();
             }
           } else if (auto Err = Sym2.takeError()) {
-            Query.setFailed(std::move(Err));
+            Query->setFailed(std::move(Err));
             return SymbolNameSet();
           } else
             UnresolvedSymbols.insert(S);