[ORC] Revert r322913 while I investigate an ASan failure.

llvm-svn: 322914

9 files changed, 180 insertions, 257 deletions

diff --git a/llvm/lib/ExecutionEngine/ExecutionEngine.cpp b/llvm/lib/ExecutionEngine/ExecutionEngine.cpp
index e4efc15f2ae..233ece29422 100644
--- a/llvm/lib/ExecutionEngine/ExecutionEngine.cpp
+++ b/llvm/lib/ExecutionEngine/ExecutionEngine.cpp
@@ -49,13 +49,14 @@ STATISTIC(NumGlobals  , "Number of global vars initialized");
 ExecutionEngine *(*ExecutionEngine::MCJITCtor)(
     std::unique_ptr<Module> M, std::string *ErrorStr,
     std::shared_ptr<MCJITMemoryManager> MemMgr,
-    std::shared_ptr<LegacyJITSymbolResolver> Resolver,
+
+    std::shared_ptr<JITSymbolResolver> Resolver,
     std::unique_ptr<TargetMachine> TM) = nullptr;
 
 ExecutionEngine *(*ExecutionEngine::OrcMCJITReplacementCtor)(
-    std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MemMgr,
-    std::shared_ptr<LegacyJITSymbolResolver> Resolver,
-    std::unique_ptr<TargetMachine> TM) = nullptr;
+  std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MemMgr,
+  std::shared_ptr<JITSymbolResolver> Resolver,
+  std::unique_ptr<TargetMachine> TM) = nullptr;
 
 ExecutionEngine *(*ExecutionEngine::InterpCtor)(std::unique_ptr<Module> M,
                                                 std::string *ErrorStr) =nullptr;
@@ -501,9 +502,9 @@ EngineBuilder::setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM) {
   return *this;
 }
 
-EngineBuilder &
-EngineBuilder::setSymbolResolver(std::unique_ptr<LegacyJITSymbolResolver> SR) {
-  Resolver = std::shared_ptr<LegacyJITSymbolResolver>(std::move(SR));
+EngineBuilder&
+EngineBuilder::setSymbolResolver(std::unique_ptr<JITSymbolResolver> SR) {
+  Resolver = std::shared_ptr<JITSymbolResolver>(std::move(SR));
   return *this;
 }
 
diff --git a/llvm/lib/ExecutionEngine/MCJIT/MCJIT.cpp b/llvm/lib/ExecutionEngine/MCJIT/MCJIT.cpp
index 438e656b60f..f7b8a3b657e 100644
--- a/llvm/lib/ExecutionEngine/MCJIT/MCJIT.cpp
+++ b/llvm/lib/ExecutionEngine/MCJIT/MCJIT.cpp
@@ -39,10 +39,11 @@ static struct RegisterJIT {
 extern "C" void LLVMLinkInMCJIT() {
 }
 
-ExecutionEngine *
-MCJIT::createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
+ExecutionEngine*
+MCJIT::createJIT(std::unique_ptr<Module> M,
+                 std::string *ErrorStr,
                  std::shared_ptr<MCJITMemoryManager> MemMgr,
-                 std::shared_ptr<LegacyJITSymbolResolver> Resolver,
+                 std::shared_ptr<JITSymbolResolver> Resolver,
                  std::unique_ptr<TargetMachine> TM) {
   // Try to register the program as a source of symbols to resolve against.
   //
@@ -63,7 +64,7 @@ MCJIT::createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
 
 MCJIT::MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> TM,
              std::shared_ptr<MCJITMemoryManager> MemMgr,
-             std::shared_ptr<LegacyJITSymbolResolver> Resolver)
+             std::shared_ptr<JITSymbolResolver> Resolver)
     : ExecutionEngine(TM->createDataLayout(), std::move(M)), TM(std::move(TM)),
       Ctx(nullptr), MemMgr(std::move(MemMgr)),
       Resolver(*this, std::move(Resolver)), Dyld(*this->MemMgr, this->Resolver),
diff --git a/llvm/lib/ExecutionEngine/MCJIT/MCJIT.h b/llvm/lib/ExecutionEngine/MCJIT/MCJIT.h
index 110cfa675cf..daf578f5daa 100644
--- a/llvm/lib/ExecutionEngine/MCJIT/MCJIT.h
+++ b/llvm/lib/ExecutionEngine/MCJIT/MCJIT.h
@@ -26,11 +26,11 @@ class MCJIT;
 // functions across modules that it owns.  It aggregates the memory manager
 // that is passed in to the MCJIT constructor and defers most functionality
 // to that object.
-class LinkingSymbolResolver : public LegacyJITSymbolResolver {
+class LinkingSymbolResolver : public JITSymbolResolver {
 public:
   LinkingSymbolResolver(MCJIT &Parent,
-                        std::shared_ptr<LegacyJITSymbolResolver> Resolver)
-      : ParentEngine(Parent), ClientResolver(std::move(Resolver)) {}
+                        std::shared_ptr<JITSymbolResolver> Resolver)
+    : ParentEngine(Parent), ClientResolver(std::move(Resolver)) {}
 
   JITSymbol findSymbol(const std::string &Name) override;
 
@@ -41,7 +41,7 @@ public:
 
 private:
   MCJIT &ParentEngine;
-  std::shared_ptr<LegacyJITSymbolResolver> ClientResolver;
+  std::shared_ptr<JITSymbolResolver> ClientResolver;
 };
 
 // About Module states: added->loaded->finalized.
@@ -67,7 +67,7 @@ private:
 class MCJIT : public ExecutionEngine {
   MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> tm,
         std::shared_ptr<MCJITMemoryManager> MemMgr,
-        std::shared_ptr<LegacyJITSymbolResolver> Resolver);
+        std::shared_ptr<JITSymbolResolver> Resolver);
 
   typedef llvm::SmallPtrSet<Module *, 4> ModulePtrSet;
 
@@ -300,10 +300,11 @@ public:
     MCJITCtor = createJIT;
   }
 
-  static ExecutionEngine *
-  createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
+  static ExecutionEngine*
+  createJIT(std::unique_ptr<Module> M,
+            std::string *ErrorStr,
             std::shared_ptr<MCJITMemoryManager> MemMgr,
-            std::shared_ptr<LegacyJITSymbolResolver> Resolver,
+            std::shared_ptr<JITSymbolResolver> Resolver,
             std::unique_ptr<TargetMachine> TM);
 
   // @}
diff --git a/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
index 05b1f47eb5b..405970e063d 100644
--- a/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
+++ b/llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
@@ -196,7 +196,7 @@ public:
     return mapError(IndirectStubsMgr->updatePointer(Name, Addr));
   }
 
-  std::shared_ptr<LegacyJITSymbolResolver>
+  std::shared_ptr<JITSymbolResolver>
   createResolver(LLVMOrcSymbolResolverFn ExternalResolver,
                  void *ExternalResolverCtx) {
     return orc::createLambdaResolver(
diff --git a/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h b/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
index 166d1369c72..1dc8d4ac7bc 100644
--- a/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
+++ b/llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
@@ -138,7 +138,7 @@ class OrcMCJITReplacement : public ExecutionEngine {
     std::shared_ptr<MCJITMemoryManager> ClientMM;
   };
 
-  class LinkingResolver : public LegacyJITSymbolResolver {
+  class LinkingResolver : public JITSymbolResolver {
   public:
     LinkingResolver(OrcMCJITReplacement &M) : M(M) {}
 
@@ -160,19 +160,20 @@ private:
   static ExecutionEngine *
   createOrcMCJITReplacement(std::string *ErrorMsg,
                             std::shared_ptr<MCJITMemoryManager> MemMgr,
-                            std::shared_ptr<LegacyJITSymbolResolver> Resolver,
+                            std::shared_ptr<JITSymbolResolver> Resolver,
                             std::unique_ptr<TargetMachine> TM) {
     return new OrcMCJITReplacement(std::move(MemMgr), std::move(Resolver),
                                    std::move(TM));
   }
 
 public:
-  OrcMCJITReplacement(std::shared_ptr<MCJITMemoryManager> MemMgr,
-                      std::shared_ptr<LegacyJITSymbolResolver> ClientResolver,
-                      std::unique_ptr<TargetMachine> TM)
+  OrcMCJITReplacement(
+      std::shared_ptr<MCJITMemoryManager> MemMgr,
+      std::shared_ptr<JITSymbolResolver> ClientResolver,
+      std::unique_ptr<TargetMachine> TM)
       : ExecutionEngine(TM->createDataLayout()), TM(std::move(TM)),
-        MemMgr(
-            std::make_shared<MCJITReplacementMemMgr>(*this, std::move(MemMgr))),
+        MemMgr(std::make_shared<MCJITReplacementMemMgr>(*this,
+                                                        std::move(MemMgr))),
         Resolver(std::make_shared<LinkingResolver>(*this)),
         ClientResolver(std::move(ClientResolver)), NotifyObjectLoaded(*this),
         NotifyFinalized(*this),
@@ -377,7 +378,7 @@ private:
   std::unique_ptr<TargetMachine> TM;
   std::shared_ptr<MCJITReplacementMemMgr> MemMgr;
   std::shared_ptr<LinkingResolver> Resolver;
-  std::shared_ptr<LegacyJITSymbolResolver> ClientResolver;
+  std::shared_ptr<JITSymbolResolver> ClientResolver;
   Mangler Mang;
 
   // IMPORTANT: ShouldDelete *must* come before LocalModules: The shared_ptr
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
index 670c6d2fa3f..87059ef2b88 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
@@ -47,53 +47,3 @@ ARMJITSymbolFlags llvm::ARMJITSymbolFlags::fromObjectSymbol(
     Flags |= ARMJITSymbolFlags::Thumb;
   return Flags;
 }
-
-/// @brief Performs lookup by, for each symbol, first calling
-///        findSymbolInLogicalDylib and if that fails calling
-///        findSymbol.
-Expected<JITSymbolResolver::LookupResult>
-LegacyJITSymbolResolver::lookup(const SymbolNameSet &Symbols) {
-  JITSymbolResolver::LookupResult Result;
-  for (auto &Symbol : Symbols) {
-    std::string SymName = Symbol.str();
-    if (auto Sym = findSymbolInLogicalDylib(SymName)) {
-      if (auto AddrOrErr = Sym.getAddress())
-        Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
-      else
-        return AddrOrErr.takeError();
-    } else if (auto Err = Sym.takeError())
-      return std::move(Err);
-    else {
-      // findSymbolInLogicalDylib failed. Lets try findSymbol.
-      if (auto Sym = findSymbol(SymName)) {
-        if (auto AddrOrErr = Sym.getAddress())
-          Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
-        else
-          return AddrOrErr.takeError();
-      } else if (auto Err = Sym.takeError())
-        return std::move(Err);
-      else
-        return make_error<StringError>("Symbol not found: " + Symbol,
-                                       inconvertibleErrorCode());
-    }
-  }
-
-  return std::move(Result);
-}
-
-/// @brief Performs flags lookup by calling findSymbolInLogicalDylib and
-///        returning the flags value for that symbol.
-Expected<JITSymbolResolver::LookupFlagsResult>
-LegacyJITSymbolResolver::lookupFlags(const SymbolNameSet &Symbols) {
-  JITSymbolResolver::LookupFlagsResult Result;
-
-  for (auto &Symbol : Symbols) {
-    std::string SymName = Symbol.str();
-    if (auto Sym = findSymbolInLogicalDylib(SymName))
-      Result[Symbol] = Sym.getFlags();
-    else if (auto Err = Sym.takeError())
-      return std::move(Err);
-  }
-
-  return std::move(Result);
-}
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
index ce8d480a408..3a025f4c026 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
@@ -202,33 +202,7 @@ RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) {
   ObjSectionToIDMap LocalSections;
 
   // Common symbols requiring allocation, with their sizes and alignments
-  CommonSymbolList CommonSymbolsToAllocate;
-
-  uint64_t CommonSize = 0;
-  uint32_t CommonAlign = 0;
-
-  // First, collect all weak and common symbols. We need to know if stronger
-  // definitions occur elsewhere.
-  JITSymbolResolver::LookupFlagsResult SymbolFlags;
-  {
-    JITSymbolResolver::SymbolNameSet Symbols;
-    for (auto &Sym : Obj.symbols()) {
-      uint32_t Flags = Sym.getFlags();
-      if ((Flags & SymbolRef::SF_Common) || (Flags & SymbolRef::SF_Weak)) {
-        // Get symbol name.
-        StringRef Name;
-        if (auto NameOrErr = Sym.getName())
-          Symbols.insert(*NameOrErr);
-        else
-          return NameOrErr.takeError();
-      }
-    }
-
-    if (auto FlagsResultOrErr = Resolver.lookupFlags(Symbols))
-      SymbolFlags = std::move(*FlagsResultOrErr);
-    else
-      return FlagsResultOrErr.takeError();
-  }
+  CommonSymbolList CommonSymbols;
 
   // Parse symbols
   DEBUG(dbgs() << "Parse symbols:\n");
@@ -240,108 +214,102 @@ RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) {
     if (Flags & SymbolRef::SF_Undefined)
       continue;
 
-    // Get the symbol type.
-    object::SymbolRef::Type SymType;
-    if (auto SymTypeOrErr = I->getType())
-      SymType = *SymTypeOrErr;
-    else
-      return SymTypeOrErr.takeError();
+    if (Flags & SymbolRef::SF_Common)
+      CommonSymbols.push_back(*I);
+    else {
 
-    // Get symbol name.
-    StringRef Name;
-    if (auto NameOrErr = I->getName())
-      Name = *NameOrErr;
-    else
-      return NameOrErr.takeError();
-
-    // Compute JIT symbol flags.
-    JITSymbolFlags JITSymFlags = getJITSymbolFlags(*I);
-
-    // If this is a weak definition, check to see if there's a strong one.
-    // If there is, skip this symbol (we won't be providing it: the strong
-    // definition will). If there's no strong definition, make this definition
-    // strong.
-    if (JITSymFlags.isWeak() || JITSymFlags.isCommon()) {
-      // First check whether there's already a definition in this instance.
-      // FIXME: Override existing weak definitions with strong ones.
-      if (GlobalSymbolTable.count(Name))
-        continue;
-
-      // Then check whether we found flags for an existing symbol during the
-      // flags lookup earlier.
-      auto FlagsI = SymbolFlags.find(Name);
-      if (FlagsI == SymbolFlags.end() ||
-          (JITSymFlags.isWeak() && !FlagsI->second.isStrong()) ||
-          (JITSymFlags.isCommon() && FlagsI->second.isCommon())) {
-        if (JITSymFlags.isWeak())
-          JITSymFlags &= ~JITSymbolFlags::Weak;
-        if (JITSymFlags.isCommon()) {
-          JITSymFlags &= ~JITSymbolFlags::Common;
-          uint32_t Align = I->getAlignment();
-          uint64_t Size = I->getCommonSize();
-          if (!CommonAlign)
-            CommonAlign = Align;
-          CommonSize += alignTo(CommonSize, Align) + Size;
-          CommonSymbolsToAllocate.push_back(*I);
-        }
-      } else
-        continue;
-    }
-
-    if (Flags & SymbolRef::SF_Absolute &&
-        SymType != object::SymbolRef::ST_File) {
-      uint64_t Addr = 0;
-      if (auto AddrOrErr = I->getAddress())
-        Addr = *AddrOrErr;
+      // Get the symbol type.
+      object::SymbolRef::Type SymType;
+      if (auto SymTypeOrErr = I->getType())
+        SymType =  *SymTypeOrErr;
       else
-        return AddrOrErr.takeError();
-
-      unsigned SectionID = AbsoluteSymbolSection;
-
-      DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name
-                   << " SID: " << SectionID
-                   << " Offset: " << format("%p", (uintptr_t)Addr)
-                   << " flags: " << Flags << "\n");
-      GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, JITSymFlags);
-    } else if (SymType == object::SymbolRef::ST_Function ||
-               SymType == object::SymbolRef::ST_Data ||
-               SymType == object::SymbolRef::ST_Unknown ||
-               SymType == object::SymbolRef::ST_Other) {
-
-      section_iterator SI = Obj.section_end();
-      if (auto SIOrErr = I->getSection())
-        SI = *SIOrErr;
+        return SymTypeOrErr.takeError();
+
+      // Get symbol name.
+      StringRef Name;
+      if (auto NameOrErr = I->getName())
+        Name = *NameOrErr;
       else
-        return SIOrErr.takeError();
+        return NameOrErr.takeError();
+
+      // Compute JIT symbol flags.
+      JITSymbolFlags JITSymFlags = getJITSymbolFlags(*I);
+
+      // If this is a weak definition, check to see if there's a strong one.
+      // If there is, skip this symbol (we won't be providing it: the strong
+      // definition will). If there's no strong definition, make this definition
+      // strong.
+      if (JITSymFlags.isWeak()) {
+        // First check whether there's already a definition in this instance.
+        // FIXME: Override existing weak definitions with strong ones.
+        if (GlobalSymbolTable.count(Name))
+          continue;
+        // Then check the symbol resolver to see if there's a definition
+        // elsewhere in this logical dylib.
+        if (auto Sym = Resolver.findSymbolInLogicalDylib(Name)) {
+          if (Sym.getFlags().isStrong())
+            continue;
+        } else if (auto Err = Sym.takeError())
+          return std::move(Err);
+        // else
+        JITSymFlags &= ~JITSymbolFlags::Weak;
+      }
 
-      if (SI == Obj.section_end())
-        continue;
+      if (Flags & SymbolRef::SF_Absolute &&
+          SymType != object::SymbolRef::ST_File) {
+        uint64_t Addr = 0;
+        if (auto AddrOrErr = I->getAddress())
+          Addr = *AddrOrErr;
+        else
+          return AddrOrErr.takeError();
+
+        unsigned SectionID = AbsoluteSymbolSection;
+
+        DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name
+                     << " SID: " << SectionID << " Offset: "
+                     << format("%p", (uintptr_t)Addr)
+                     << " flags: " << Flags << "\n");
+        GlobalSymbolTable[Name] =
+          SymbolTableEntry(SectionID, Addr, JITSymFlags);
+      } else if (SymType == object::SymbolRef::ST_Function ||
+                 SymType == object::SymbolRef::ST_Data ||
+                 SymType == object::SymbolRef::ST_Unknown ||
+                 SymType == object::SymbolRef::ST_Other) {
+
+        section_iterator SI = Obj.section_end();
+        if (auto SIOrErr = I->getSection())
+          SI = *SIOrErr;
+        else
+          return SIOrErr.takeError();
 
-      // Get symbol offset.
-      uint64_t SectOffset;
-      if (auto Err = getOffset(*I, *SI, SectOffset))
-        return std::move(Err);
+        if (SI == Obj.section_end())
+          continue;
 
-      bool IsCode = SI->isText();
-      unsigned SectionID;
-      if (auto SectionIDOrErr =
-              findOrEmitSection(Obj, *SI, IsCode, LocalSections))
-        SectionID = *SectionIDOrErr;
-      else
-        return SectionIDOrErr.takeError();
+        // Get symbol offset.
+        uint64_t SectOffset;
+        if (auto Err = getOffset(*I, *SI, SectOffset))
+          return std::move(Err);
+
+        bool IsCode = SI->isText();
+        unsigned SectionID;
+        if (auto SectionIDOrErr = findOrEmitSection(Obj, *SI, IsCode,
+                                                    LocalSections))
+          SectionID = *SectionIDOrErr;
+        else
+          return SectionIDOrErr.takeError();
 
-      DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
-                   << " SID: " << SectionID
-                   << " Offset: " << format("%p", (uintptr_t)SectOffset)
-                   << " flags: " << Flags << "\n");
-      GlobalSymbolTable[Name] =
+        DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
+                     << " SID: " << SectionID << " Offset: "
+                     << format("%p", (uintptr_t)SectOffset)
+                     << " flags: " << Flags << "\n");
+        GlobalSymbolTable[Name] =
           SymbolTableEntry(SectionID, SectOffset, JITSymFlags);
+      }
     }
   }
 
   // Allocate common symbols
-  if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
-                                   CommonAlign))
+  if (auto Err = emitCommonSymbols(Obj, CommonSymbols))
     return std::move(Err);
 
   // Parse and process relocations
@@ -653,12 +621,45 @@ JITSymbolFlags RuntimeDyldImpl::getJITSymbolFlags(const BasicSymbolRef &SR) {
 }
 
 Error RuntimeDyldImpl::emitCommonSymbols(const ObjectFile &Obj,
-                                         CommonSymbolList &SymbolsToAllocate,
-                                         uint64_t CommonSize,
-                                         uint32_t CommonAlign) {
-  if (SymbolsToAllocate.empty())
+                                         CommonSymbolList &CommonSymbols) {
+  if (CommonSymbols.empty())
     return Error::success();
 
+  uint64_t CommonSize = 0;
+  uint32_t CommonAlign = CommonSymbols.begin()->getAlignment();
+  CommonSymbolList SymbolsToAllocate;
+
+  DEBUG(dbgs() << "Processing common symbols...\n");
+
+  for (const auto &Sym : CommonSymbols) {
+    StringRef Name;
+    if (auto NameOrErr = Sym.getName())
+      Name = *NameOrErr;
+    else
+      return NameOrErr.takeError();
+
+    // Skip common symbols already elsewhere.
+    if (GlobalSymbolTable.count(Name)) {
+      DEBUG(dbgs() << "\tSkipping already emitted common symbol '" << Name
+                   << "'\n");
+      continue;
+    }
+
+    if (auto Sym = Resolver.findSymbolInLogicalDylib(Name)) {
+      if (!Sym.getFlags().isCommon()) {
+        DEBUG(dbgs() << "\tSkipping common symbol '" << Name
+                     << "' in favor of stronger definition.\n");
+        continue;
+      }
+    }
+    uint32_t Align = Sym.getAlignment();
+    uint64_t Size = Sym.getCommonSize();
+
+    CommonSize = alignTo(CommonSize, Align) + Size;
+
+    SymbolsToAllocate.push_back(Sym);
+  }
+
   // Allocate memory for the section
   unsigned SectionID = Sections.size();
   uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
@@ -996,40 +997,7 @@ void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
 }
 
 Error RuntimeDyldImpl::resolveExternalSymbols() {
-  JITSymbolResolver::LookupResult ExternalSymbolMap;
-
-  // Resolution can trigger emission of more symbols, so iterate until
-  // we've resolved *everything*.
-  {
-    JITSymbolResolver::SymbolNameSet ResolvedSymbols;
-
-    while (true) {
-      JITSymbolResolver::SymbolNameSet NewSymbols;
-
-      for (auto &RelocKV : ExternalSymbolRelocations) {
-        StringRef Name = RelocKV.first();
-        if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
-            !ResolvedSymbols.count(Name))
-          NewSymbols.insert(Name);
-      }
-
-      if (NewSymbols.empty())
-        break;
-
-      auto NewResolverResults = Resolver.lookup(NewSymbols);
-      if (!NewResolverResults)
-        return NewResolverResults.takeError();
-
-      for (auto &RRKV : *NewResolverResults) {
-        assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
-        ExternalSymbolMap.insert(RRKV);
-        ResolvedSymbols.insert(RRKV.first);
-      }
-    }
-  }
-
   while (!ExternalSymbolRelocations.empty()) {
-
     StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
 
     StringRef Name = i->first();
@@ -1044,10 +1012,29 @@ Error RuntimeDyldImpl::resolveExternalSymbols() {
       JITSymbolFlags Flags;
       RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
       if (Loc == GlobalSymbolTable.end()) {
-        auto RRI = ExternalSymbolMap.find(Name);
-        assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
-        Addr = RRI->second.getAddress();
-        Flags = RRI->second.getFlags();
+        // This is an external symbol, try to get its address from the symbol
+        // resolver.
+        // First search for the symbol in this logical dylib.
+        if (auto Sym = Resolver.findSymbolInLogicalDylib(Name.data())) {
+          if (auto AddrOrErr = Sym.getAddress()) {
+            Addr = *AddrOrErr;
+            Flags = Sym.getFlags();
+          } else
+            return AddrOrErr.takeError();
+        } else if (auto Err = Sym.takeError())
+          return Err;
+
+        // If that fails, try searching for an external symbol.
+        if (!Addr) {
+          if (auto Sym = Resolver.findSymbol(Name.data())) {
+            if (auto AddrOrErr = Sym.getAddress()) {
+              Addr = *AddrOrErr;
+              Flags = Sym.getFlags();
+            } else
+              return AddrOrErr.takeError();
+          } else if (auto Err = Sym.takeError())
+            return Err;
+        }
         // The call to getSymbolAddress may have caused additional modules to
         // be loaded, which may have added new entries to the
         // ExternalSymbolRelocations map.  Consquently, we need to update our
@@ -1108,7 +1095,6 @@ uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
 
 void RuntimeDyld::MemoryManager::anchor() {}
 void JITSymbolResolver::anchor() {}
-void LegacyJITSymbolResolver::anchor() {}
 
 RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
                          JITSymbolResolver &Resolver)
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
index 0f4534f2c9f..5bc7434e703 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
@@ -731,14 +731,7 @@ bool RuntimeDyldCheckerImpl::checkAllRulesInBuffer(StringRef RulePrefix,
 bool RuntimeDyldCheckerImpl::isSymbolValid(StringRef Symbol) const {
   if (getRTDyld().getSymbol(Symbol))
     return true;
-  JITSymbolResolver::SymbolNameSet Symbols({Symbol});
-  auto Result = getRTDyld().Resolver.lookup(Symbols);
-  if (!Result) {
-    logAllUnhandledErrors(Result.takeError(), errs(), "RTDyldChecker: ");
-    return false;
-  }
-  assert(Result->count(Symbol) && "Missing symbol result");
-  return true;
+  return !!getRTDyld().Resolver.findSymbol(Symbol);
 }
 
 uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(StringRef Symbol) const {
@@ -749,16 +742,7 @@ uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(StringRef Symbol) const {
 uint64_t RuntimeDyldCheckerImpl::getSymbolRemoteAddr(StringRef Symbol) const {
   if (auto InternalSymbol = getRTDyld().getSymbol(Symbol))
     return InternalSymbol.getAddress();
-
-  JITSymbolResolver::SymbolNameSet Symbols({Symbol});
-  auto Result = getRTDyld().Resolver.lookup(Symbols);
-  if (!Result) {
-    logAllUnhandledErrors(Result.takeError(), errs(), "RTDyldChecker: ");
-    return 0;
-  }
-  auto I = Result->find(Symbol);
-  assert(I != Result->end() && "Missing symbol result");
-  return I->second.getAddress();
+  return cantFail(getRTDyld().Resolver.findSymbol(Symbol).getAddress());
 }
 
 uint64_t RuntimeDyldCheckerImpl::readMemoryAtAddr(uint64_t SrcAddr,
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
index e940004bb2e..e046a8504e9 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
@@ -385,8 +385,7 @@ protected:
   /// new section for them and update the symbol mappings in the object and
   /// symbol table.
   Error emitCommonSymbols(const ObjectFile &Obj,
-                          CommonSymbolList &CommonSymbols, uint64_t CommonSize,
-                          uint32_t CommonAlign);
+                          CommonSymbolList &CommonSymbols);
 
   /// \brief Emits section data from the object file to the MemoryManager.
   /// \param IsCode if it's true then allocateCodeSection() will be