Remove LLVM 8.0.1 files.

1 files changed, 0 insertions, 379 deletions

diff --git a/gnu/llvm/tools/lld/lib/ReaderWriter/MachO/StubsPass.cpp b/gnu/llvm/tools/lld/lib/ReaderWriter/MachO/StubsPass.cpp
deleted file mode 100644
index 04c586df336..00000000000
--- a/gnu/llvm/tools/lld/lib/ReaderWriter/MachO/StubsPass.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-//===- lib/ReaderWriter/MachO/StubsPass.cpp ---------------------*- C++ -*-===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This linker pass updates call-sites which have references to shared library
-// atoms to instead have a reference to a stub (PLT entry) for the specified
-// symbol.  Each file format defines a subclass of StubsPass which implements
-// the abstract methods for creating the file format specific StubAtoms.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ArchHandler.h"
-#include "File.h"
-#include "MachOPasses.h"
-#include "lld/Common/LLVM.h"
-#include "lld/Core/DefinedAtom.h"
-#include "lld/Core/File.h"
-#include "lld/Core/Reference.h"
-#include "lld/Core/Simple.h"
-#include "lld/ReaderWriter/MachOLinkingContext.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallVector.h"
-
-namespace lld {
-namespace mach_o {
-
-//
-//  Lazy Pointer Atom created by the stubs pass.
-//
-class LazyPointerAtom : public SimpleDefinedAtom {
-public:
-  LazyPointerAtom(const File &file, bool is64)
-    : SimpleDefinedAtom(file), _is64(is64) { }
-
-  ~LazyPointerAtom() override = default;
-
-  ContentType contentType() const override {
-    return DefinedAtom::typeLazyPointer;
-  }
-
-  Alignment alignment() const override {
-    return _is64 ? 8 : 4;
-  }
-
-  uint64_t size() const override {
-    return _is64 ? 8 : 4;
-  }
-
-  ContentPermissions permissions() const override {
-    return DefinedAtom::permRW_;
-  }
-
-  ArrayRef<uint8_t> rawContent() const override {
-    static const uint8_t zeros[] =
-        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    return llvm::makeArrayRef(zeros, size());
-  }
-
-private:
-  const bool _is64;
-};
-
-//
-//  NonLazyPointer (GOT) Atom created by the stubs pass.
-//
-class NonLazyPointerAtom : public SimpleDefinedAtom {
-public:
-  NonLazyPointerAtom(const File &file, bool is64, ContentType contentType)
-    : SimpleDefinedAtom(file), _is64(is64), _contentType(contentType) { }
-
-  ~NonLazyPointerAtom() override = default;
-
-  ContentType contentType() const override {
-    return _contentType;
-  }
-
-  Alignment alignment() const override {
-    return _is64 ? 8 : 4;
-  }
-
-  uint64_t size() const override {
-    return _is64 ? 8 : 4;
-  }
-
-  ContentPermissions permissions() const override {
-    return DefinedAtom::permRW_;
-  }
-
-  ArrayRef<uint8_t> rawContent() const override {
-    static const uint8_t zeros[] =
-        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    return llvm::makeArrayRef(zeros, size());
-  }
-
-private:
-  const bool _is64;
-  const ContentType _contentType;
-};
-
-//
-// Stub Atom created by the stubs pass.
-//
-class StubAtom : public SimpleDefinedAtom {
-public:
-  StubAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
-      : SimpleDefinedAtom(file), _stubInfo(stubInfo){ }
-
-  ~StubAtom() override = default;
-
-  ContentType contentType() const override {
-    return DefinedAtom::typeStub;
-  }
-
-  Alignment alignment() const override {
-    return 1 << _stubInfo.codeAlignment;
-  }
-
-  uint64_t size() const override {
-    return _stubInfo.stubSize;
-  }
-
-  ContentPermissions permissions() const override {
-    return DefinedAtom::permR_X;
-  }
-
-  ArrayRef<uint8_t> rawContent() const override {
-    return llvm::makeArrayRef(_stubInfo.stubBytes, _stubInfo.stubSize);
-  }
-
-private:
-  const ArchHandler::StubInfo   &_stubInfo;
-};
-
-//
-// Stub Helper Atom created by the stubs pass.
-//
-class StubHelperAtom : public SimpleDefinedAtom {
-public:
-  StubHelperAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
-      : SimpleDefinedAtom(file), _stubInfo(stubInfo) { }
-
-  ~StubHelperAtom() override = default;
-
-  ContentType contentType() const override {
-    return DefinedAtom::typeStubHelper;
-  }
-
-  Alignment alignment() const override {
-    return 1 << _stubInfo.codeAlignment;
-  }
-
-  uint64_t size() const override {
-    return _stubInfo.stubHelperSize;
-  }
-
-  ContentPermissions permissions() const override {
-    return DefinedAtom::permR_X;
-  }
-
-  ArrayRef<uint8_t> rawContent() const override {
-    return llvm::makeArrayRef(_stubInfo.stubHelperBytes,
-                              _stubInfo.stubHelperSize);
-  }
-
-private:
-  const ArchHandler::StubInfo   &_stubInfo;
-};
-
-//
-// Stub Helper Common Atom created by the stubs pass.
-//
-class StubHelperCommonAtom : public SimpleDefinedAtom {
-public:
-  StubHelperCommonAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
-      : SimpleDefinedAtom(file), _stubInfo(stubInfo) { }
-
-  ~StubHelperCommonAtom() override = default;
-
-  ContentType contentType() const override {
-    return DefinedAtom::typeStubHelper;
-  }
-
-  Alignment alignment() const override {
-    return 1 << _stubInfo.stubHelperCommonAlignment;
-  }
-
-  uint64_t size() const override {
-    return _stubInfo.stubHelperCommonSize;
-  }
-
-  ContentPermissions permissions() const override {
-    return DefinedAtom::permR_X;
-  }
-
-  ArrayRef<uint8_t> rawContent() const override {
-    return llvm::makeArrayRef(_stubInfo.stubHelperCommonBytes,
-                        _stubInfo.stubHelperCommonSize);
-  }
-
-private:
-  const ArchHandler::StubInfo   &_stubInfo;
-};
-
-class StubsPass : public Pass {
-public:
-  StubsPass(const MachOLinkingContext &context)
-      : _ctx(context), _archHandler(_ctx.archHandler()),
-        _stubInfo(_archHandler.stubInfo()),
-        _file(*_ctx.make_file<MachOFile>("<mach-o Stubs pass>")) {
-    _file.setOrdinal(_ctx.getNextOrdinalAndIncrement());
-  }
-
-  llvm::Error perform(SimpleFile &mergedFile) override {
-    // Skip this pass if output format uses text relocations instead of stubs.
-    if (!this->noTextRelocs())
-      return llvm::Error::success();
-
-    // Scan all references in all atoms.
-    for (const DefinedAtom *atom : mergedFile.defined()) {
-      for (const Reference *ref : *atom) {
-        // Look at call-sites.
-        if (!this->isCallSite(*ref))
-          continue;
-        const Atom *target = ref->target();
-        assert(target != nullptr);
-        if (isa<SharedLibraryAtom>(target)) {
-          // Calls to shared libraries go through stubs.
-          _targetToUses[target].push_back(ref);
-          continue;
-        }
-        const DefinedAtom *defTarget = dyn_cast<DefinedAtom>(target);
-        if (defTarget && defTarget->interposable() != DefinedAtom::interposeNo){
-          // Calls to interposable functions in same linkage unit must also go
-          // through a stub.
-          assert(defTarget->scope() != DefinedAtom::scopeTranslationUnit);
-          _targetToUses[target].push_back(ref);
-        }
-      }
-    }
-
-    // Exit early if no stubs needed.
-    if (_targetToUses.empty())
-      return llvm::Error::success();
-
-    // First add help-common and GOT slots used by lazy binding.
-    SimpleDefinedAtom *helperCommonAtom =
-        new (_file.allocator()) StubHelperCommonAtom(_file, _stubInfo);
-    SimpleDefinedAtom *helperCacheNLPAtom =
-        new (_file.allocator()) NonLazyPointerAtom(_file, _ctx.is64Bit(),
-                                    _stubInfo.stubHelperImageCacheContentType);
-    SimpleDefinedAtom *helperBinderNLPAtom =
-        new (_file.allocator()) NonLazyPointerAtom(_file, _ctx.is64Bit(),
-                                    _stubInfo.stubHelperImageCacheContentType);
-    addReference(helperCommonAtom, _stubInfo.stubHelperCommonReferenceToCache,
-                 helperCacheNLPAtom);
-    addOptReference(
-        helperCommonAtom, _stubInfo.stubHelperCommonReferenceToCache,
-        _stubInfo.optStubHelperCommonReferenceToCache, helperCacheNLPAtom);
-    addReference(helperCommonAtom, _stubInfo.stubHelperCommonReferenceToBinder,
-                 helperBinderNLPAtom);
-    addOptReference(
-        helperCommonAtom, _stubInfo.stubHelperCommonReferenceToBinder,
-        _stubInfo.optStubHelperCommonReferenceToBinder, helperBinderNLPAtom);
-    mergedFile.addAtom(*helperCommonAtom);
-    mergedFile.addAtom(*helperBinderNLPAtom);
-    mergedFile.addAtom(*helperCacheNLPAtom);
-
-    // Add reference to dyld_stub_binder in libSystem.dylib
-    auto I = std::find_if(
-        mergedFile.sharedLibrary().begin(), mergedFile.sharedLibrary().end(),
-        [&](const SharedLibraryAtom *atom) {
-          return atom->name().equals(_stubInfo.binderSymbolName);
-        });
-    assert(I != mergedFile.sharedLibrary().end() &&
-           "dyld_stub_binder not found");
-    addReference(helperBinderNLPAtom, _stubInfo.nonLazyPointerReferenceToBinder, *I);
-
-    // Sort targets by name, so stubs and lazy pointers are consistent
-    std::vector<const Atom *> targetsNeedingStubs;
-    for (auto it : _targetToUses)
-      targetsNeedingStubs.push_back(it.first);
-    std::sort(targetsNeedingStubs.begin(), targetsNeedingStubs.end(),
-              [](const Atom * left, const Atom * right) {
-      return (left->name().compare(right->name()) < 0);
-    });
-
-    // Make and append stubs, lazy pointers, and helpers in alphabetical order.
-    unsigned lazyOffset = 0;
-    for (const Atom *target : targetsNeedingStubs) {
-      auto *stub = new (_file.allocator()) StubAtom(_file, _stubInfo);
-      auto *lp =
-          new (_file.allocator()) LazyPointerAtom(_file, _ctx.is64Bit());
-      auto *helper = new (_file.allocator()) StubHelperAtom(_file, _stubInfo);
-
-      addReference(stub, _stubInfo.stubReferenceToLP, lp);
-      addOptReference(stub, _stubInfo.stubReferenceToLP,
-                      _stubInfo.optStubReferenceToLP, lp);
-      addReference(lp, _stubInfo.lazyPointerReferenceToHelper, helper);
-      addReference(lp, _stubInfo.lazyPointerReferenceToFinal, target);
-      addReference(helper, _stubInfo.stubHelperReferenceToImm, helper);
-      addReferenceAddend(helper, _stubInfo.stubHelperReferenceToImm, helper,
-                         lazyOffset);
-      addReference(helper, _stubInfo.stubHelperReferenceToHelperCommon,
-                   helperCommonAtom);
-
-      mergedFile.addAtom(*stub);
-      mergedFile.addAtom(*lp);
-      mergedFile.addAtom(*helper);
-
-      // Update each reference to use stub.
-      for (const Reference *ref : _targetToUses[target]) {
-        assert(ref->target() == target);
-        // Switch call site to reference stub atom instead.
-        const_cast<Reference *>(ref)->setTarget(stub);
-      }
-
-      // Calculate new offset
-      lazyOffset += target->name().size() + 12;
-    }
-
-    return llvm::Error::success();
-  }
-
-private:
-  bool noTextRelocs() {
-    return true;
-  }
-
-  bool isCallSite(const Reference &ref) {
-    return _archHandler.isCallSite(ref);
-  }
-
-  void addReference(SimpleDefinedAtom* atom,
-                    const ArchHandler::ReferenceInfo &refInfo,
-                    const lld::Atom* target) {
-    atom->addReference(Reference::KindNamespace::mach_o,
-                      refInfo.arch, refInfo.kind, refInfo.offset,
-                      target, refInfo.addend);
-  }
-
-  void addReferenceAddend(SimpleDefinedAtom *atom,
-                          const ArchHandler::ReferenceInfo &refInfo,
-                          const lld::Atom *target, uint64_t addend) {
-    atom->addReference(Reference::KindNamespace::mach_o, refInfo.arch,
-                       refInfo.kind, refInfo.offset, target, addend);
-  }
-
-   void addOptReference(SimpleDefinedAtom* atom,
-                    const ArchHandler::ReferenceInfo &refInfo,
-                    const ArchHandler::OptionalRefInfo &optRef,
-                    const lld::Atom* target) {
-      if (!optRef.used)
-        return;
-    atom->addReference(Reference::KindNamespace::mach_o,
-                      refInfo.arch, optRef.kind, optRef.offset,
-                      target, optRef.addend);
-  }
-
-  typedef llvm::DenseMap<const Atom*,
-                         llvm::SmallVector<const Reference *, 8>> TargetToUses;
-
-  const MachOLinkingContext &_ctx;
-  mach_o::ArchHandler                            &_archHandler;
-  const ArchHandler::StubInfo                    &_stubInfo;
-  MachOFile                                      &_file;
-  TargetToUses                                    _targetToUses;
-};
-
-void addStubsPass(PassManager &pm, const MachOLinkingContext &ctx) {
-  pm.add(std::unique_ptr<Pass>(new StubsPass(ctx)));
-}
-
-} // end namespace mach_o
-} // end namespace lld