1 files changed, 0 insertions, 216 deletions
diff --git a/gnu/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp b/gnu/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
deleted file mode 100644
index 299d76183cd..00000000000
--- a/gnu/llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===-- RTDyldObjectLinkingLayer.cpp - RuntimeDyld backed ORC ObjectLayer -===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
-
-namespace {
-
-using namespace llvm;
-using namespace llvm::orc;
-
-class JITDylibSearchOrderResolver : public JITSymbolResolver {
-public:
-  JITDylibSearchOrderResolver(MaterializationResponsibility &MR) : MR(MR) {}
-
-  void lookup(const LookupSet &Symbols, OnResolvedFunction OnResolved) {
-    auto &ES = MR.getTargetJITDylib().getExecutionSession();
-    SymbolNameSet InternedSymbols;
-
-    // Intern the requested symbols: lookup takes interned strings.
-    for (auto &S : Symbols)
-      InternedSymbols.insert(ES.intern(S));
-
-    // Build an OnResolve callback to unwrap the interned strings and pass them
-    // to the OnResolved callback.
-    // FIXME: Switch to move capture of OnResolved once we have c++14.
-    auto OnResolvedWithUnwrap =
-        [OnResolved](Expected<SymbolMap> InternedResult) {
-          if (!InternedResult) {
-            OnResolved(InternedResult.takeError());
-            return;
-          }
-
-          LookupResult Result;
-          for (auto &KV : *InternedResult)
-            Result[*KV.first] = std::move(KV.second);
-          OnResolved(Result);
-        };
-
-    // We're not waiting for symbols to be ready. Just log any errors.
-    auto OnReady = [&ES](Error Err) { ES.reportError(std::move(Err)); };
-
-    // Register dependencies for all symbols contained in this set.
-    auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
-      MR.addDependenciesForAll(Deps);
-    };
-
-    JITDylibSearchList SearchOrder;
-    MR.getTargetJITDylib().withSearchOrderDo(
-        [&](const JITDylibSearchList &JDs) { SearchOrder = JDs; });
-    ES.lookup(SearchOrder, InternedSymbols, OnResolvedWithUnwrap, OnReady,
-              RegisterDependencies);
-  }
-
-  Expected<LookupSet> getResponsibilitySet(const LookupSet &Symbols) {
-    LookupSet Result;
-
-    for (auto &KV : MR.getSymbols()) {
-      if (Symbols.count(*KV.first))
-        Result.insert(*KV.first);
-    }
-
-    return Result;
-  }
-
-private:
-  MaterializationResponsibility &MR;
-};
-
-} // end anonymous namespace
-
-namespace llvm {
-namespace orc {
-
-RTDyldObjectLinkingLayer::RTDyldObjectLinkingLayer(
-    ExecutionSession &ES, GetMemoryManagerFunction GetMemoryManager,
-    NotifyLoadedFunction NotifyLoaded, NotifyEmittedFunction NotifyEmitted)
-    : ObjectLayer(ES), GetMemoryManager(GetMemoryManager),
-      NotifyLoaded(std::move(NotifyLoaded)),
-      NotifyEmitted(std::move(NotifyEmitted)) {}
-
-void RTDyldObjectLinkingLayer::emit(MaterializationResponsibility R,
-                                    std::unique_ptr<MemoryBuffer> O) {
-  assert(O && "Object must not be null");
-
-  // This method launches an asynchronous link step that will fulfill our
-  // materialization responsibility. We need to switch R to be heap
-  // allocated before that happens so it can live as long as the asynchronous
-  // link needs it to (i.e. it must be able to outlive this method).
-  auto SharedR = std::make_shared<MaterializationResponsibility>(std::move(R));
-
-  auto &ES = getExecutionSession();
-
-  auto Obj = object::ObjectFile::createObjectFile(*O);
-
-  if (!Obj) {
-    getExecutionSession().reportError(Obj.takeError());
-    SharedR->failMaterialization();
-    return;
-  }
-
-  // Collect the internal symbols from the object file: We will need to
-  // filter these later.
-  auto InternalSymbols = std::make_shared<std::set<StringRef>>();
-  {
-    for (auto &Sym : (*Obj)->symbols()) {
-      if (!(Sym.getFlags() & object::BasicSymbolRef::SF_Global)) {
-        if (auto SymName = Sym.getName())
-          InternalSymbols->insert(*SymName);
-        else {
-          ES.reportError(SymName.takeError());
-          R.failMaterialization();
-          return;
-        }
-      }
-    }
-  }
-
-  auto K = R.getVModuleKey();
-  RuntimeDyld::MemoryManager *MemMgr = nullptr;
-
-  // Create a record a memory manager for this object.
-  {
-    auto Tmp = GetMemoryManager();
-    std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
-    MemMgrs.push_back(std::move(Tmp));
-    MemMgr = MemMgrs.back().get();
-  }
-
-  JITDylibSearchOrderResolver Resolver(*SharedR);
-
-  /* Thoughts on proper cross-dylib weak symbol handling:
-   *
-   * Change selection of canonical defs to be a manually triggered process, and
-   * add a 'canonical' bit to symbol definitions. When canonical def selection
-   * is triggered, sweep the JITDylibs to mark defs as canonical, discard
-   * duplicate defs.
-   */
-  jitLinkForORC(
-      **Obj, std::move(O), *MemMgr, Resolver, ProcessAllSections,
-      [this, K, SharedR, &Obj, InternalSymbols](
-          std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
-          std::map<StringRef, JITEvaluatedSymbol> ResolvedSymbols) {
-        return onObjLoad(K, *SharedR, **Obj, std::move(LoadedObjInfo),
-                         ResolvedSymbols, *InternalSymbols);
-      },
-      [this, K, SharedR](Error Err) {
-        onObjEmit(K, *SharedR, std::move(Err));
-      });
-}
-
-Error RTDyldObjectLinkingLayer::onObjLoad(
-    VModuleKey K, MaterializationResponsibility &R, object::ObjectFile &Obj,
-    std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
-    std::map<StringRef, JITEvaluatedSymbol> Resolved,
-    std::set<StringRef> &InternalSymbols) {
-  SymbolFlagsMap ExtraSymbolsToClaim;
-  SymbolMap Symbols;
-  for (auto &KV : Resolved) {
-    // Scan the symbols and add them to the Symbols map for resolution.
-
-    // We never claim internal symbols.
-    if (InternalSymbols.count(KV.first))
-      continue;
-
-    auto InternedName = getExecutionSession().intern(KV.first);
-    auto Flags = KV.second.getFlags();
-
-    // Override object flags and claim responsibility for symbols if
-    // requested.
-    if (OverrideObjectFlags || AutoClaimObjectSymbols) {
-      auto I = R.getSymbols().find(InternedName);
-
-      if (OverrideObjectFlags && I != R.getSymbols().end())
-        Flags = JITSymbolFlags::stripTransientFlags(I->second);
-      else if (AutoClaimObjectSymbols && I == R.getSymbols().end())
-        ExtraSymbolsToClaim[InternedName] = Flags;
-    }
-
-    Symbols[InternedName] = JITEvaluatedSymbol(KV.second.getAddress(), Flags);
-  }
-
-  if (!ExtraSymbolsToClaim.empty())
-    if (auto Err = R.defineMaterializing(ExtraSymbolsToClaim))
-      return Err;
-
-  R.resolve(Symbols);
-
-  if (NotifyLoaded)
-    NotifyLoaded(K, Obj, *LoadedObjInfo);
-
-  return Error::success();
-}
-
-void RTDyldObjectLinkingLayer::onObjEmit(VModuleKey K,
-                                          MaterializationResponsibility &R,
-                                          Error Err) {
-  if (Err) {
-    getExecutionSession().reportError(std::move(Err));
-    R.failMaterialization();
-    return;
-  }
-
-  R.emit();
-
-  if (NotifyEmitted)
-    NotifyEmitted(K);
-}
-
-} // End namespace orc.
-} // End namespace llvm.