LLD: Merge MutableFile with SimpleFile

[ruiu]

Summary

SimpleFile is the only derived class of MutableFile.
This patch removes reduces the height of class hierarchy by
removing MutableFile class.

[atanasyan]

Nice!

LGTM

include/lld/Core/File.h

private:
   mutable std::string _archiveMemberPath;
   Kind              _kind;
   mutable uint64_t  _ordinal;
   std::shared_ptr<MemoryBuffer> _sharedMemoryBuffer;
   llvm::Optional<std::error_code> _lastError;
   std::mutex _parseMutex;
 };
 
-/// \brief A mutable File.
-class MutableFile : public File {
-public:
-  /// \brief Add an atom to the file. Invalidates iterators for all returned
-  /// containters.
-  virtual void addAtom(const Atom&) = 0;
-
-  typedef range<std::vector<const DefinedAtom *>::iterator> DefinedAtomRange;
-  virtual DefinedAtomRange definedAtoms() = 0;
-
-  virtual void
-  removeDefinedAtomsIf(std::function<bool(const DefinedAtom *)> pred) = 0;
-
-protected:
-  /// \brief only subclasses of MutableFile can be instantiated
-  MutableFile(StringRef p) : File(p, kindObject) {}
-};
-
 /// An ErrorFile represents a file that doesn't exist.
 /// If you try to parse a file which doesn't exist, an instance of this
 /// class will be returned. That's parse method always returns an error.
 /// This is useful to delay erroring on non-existent files, so that we
 /// can do unit testing a driver using non-existing file paths.
 class ErrorFile : public File {
 public:
   ErrorFile(StringRef path, std::error_code ec)

include/lld/Core/Pass.h

 
 #include "lld/Core/Atom.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/range.h"
 #include <vector>
 
 namespace lld {
-class MutableFile;
+class SimpleFile;
 
 /// Once the core linking is done (which resolves references, coalesces atoms
 /// and produces a complete Atom graph), the linker runs a series of passes
 /// on the Atom graph. The graph is modeled as a File, which means the pass
 /// has access to all the atoms and to File level attributes. Each pass does
 /// a particular transformation to the Atom graph or to the File attributes.
 ///
 /// This is the abstract base class for all passes.  A Pass does its
 /// actual work in it perform() method.  It can iterator over Atoms in the
 /// graph using the *begin()/*end() atom iterator of the File.  It can add
 /// new Atoms to the graph using the File's addAtom() method.
 class Pass {
 public:
   virtual ~Pass() { }
 
   /// Do the actual work of the Pass.
-  virtual void perform(std::unique_ptr<MutableFile> &mergedFile) = 0;
+  virtual void perform(std::unique_ptr<SimpleFile> &mergedFile) = 0;
 
 protected:
   // Only subclassess can be instantiated.
   Pass() { }
 };
 
 } // namespace lld
 
 #endif // LLD_CORE_PASS_H

include/lld/Core/PassManager.h

 #define LLD_CORE_PASS_MANAGER_H
 
 #include "lld/Core/LLVM.h"
 #include "lld/Core/Pass.h"
 #include <memory>
 #include <vector>
 
 namespace lld {
-class MutableFile;
+class SimpleFile;
 class Pass;
 
 /// \brief Owns and runs a collection of passes.
 ///
 /// This class is currently just a container for passes and a way to run them.
 ///
 /// In the future this should handle timing pass runs, running parallel passes,
 /// and validate/satisfy pass dependencies.
 class PassManager {
 public:
   void add(std::unique_ptr<Pass> pass) {
     _passes.push_back(std::move(pass));
   }
 
-  std::error_code runOnFile(std::unique_ptr<MutableFile> &file) {
+  std::error_code runOnFile(std::unique_ptr<SimpleFile> &file) {
     for (std::unique_ptr<Pass> &pass : _passes)
       pass->perform(file);
     return std::error_code();
   }
 
 private:
   /// \brief Passes in the order they should run.
   std::vector<std::unique_ptr<Pass>> _passes;
 };
 } // end namespace lld
 
 #endif

include/lld/Core/Resolver.h

public:
   bool handleArchiveFile(File &);
 
   // Handle a shared library file.
   void handleSharedLibrary(File &);
 
   /// @brief do work of merging and resolving and return list
   bool resolve();
 
-  std::unique_ptr<MutableFile> resultFile() { return std::move(_result); }
+  std::unique_ptr<SimpleFile> resultFile() { return std::move(_result); }
 
 private:
   typedef std::function<void(StringRef, bool)> UndefCallback;
 
   bool undefinesAdded(int begin, int end);
   File *getFile(int &index);
 
   /// \brief Add section group/.gnu.linkonce if it does not exist previously.

include/lld/Core/Simple.h

 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Reference.h"
 #include "lld/Core/UndefinedAtom.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 
 namespace lld {
 
-class SimpleFile : public MutableFile {
+class SimpleFile : public File {
 public:
-  SimpleFile(StringRef path) : MutableFile(path) {}
+  SimpleFile(StringRef path) : File(path, kindObject) {}
 
-  void addAtom(const Atom &atom) override {
+  void addAtom(const Atom &atom) {
     if (auto *defAtom = dyn_cast<DefinedAtom>(&atom)) {
       _definedAtoms._atoms.push_back(defAtom);
     } else if (auto *undefAtom = dyn_cast<UndefinedAtom>(&atom)) {
       _undefinedAtoms._atoms.push_back(undefAtom);
     } else if (auto *shlibAtom = dyn_cast<SharedLibraryAtom>(&atom)) {
       _sharedLibraryAtoms._atoms.push_back(shlibAtom);
     } else if (auto *absAtom = dyn_cast<AbsoluteAtom>(&atom)) {
       _absoluteAtoms._atoms.push_back(absAtom);
     } else {
       llvm_unreachable("atom has unknown definition kind");
     }
   }
 
-  void
-  removeDefinedAtomsIf(std::function<bool(const DefinedAtom *)> pred) override {
+  void removeDefinedAtomsIf(std::function<bool(const DefinedAtom *)> pred) {
     auto &atoms = _definedAtoms._atoms;
     auto newEnd = std::remove_if(atoms.begin(), atoms.end(), pred);
     atoms.erase(newEnd, atoms.end());
   }
 
   const atom_collection<DefinedAtom> &defined() const override {
     return _definedAtoms;
   }
 
   const atom_collection<UndefinedAtom> &undefined() const override {
     return _undefinedAtoms;
   }
 
   const atom_collection<SharedLibraryAtom> &sharedLibrary() const override {
     return _sharedLibraryAtoms;
   }
 
   const atom_collection<AbsoluteAtom> &absolute() const override {
     return _absoluteAtoms;
   }
 
-  DefinedAtomRange definedAtoms() override {
-    return make_range(_definedAtoms._atoms);
-  }
+  typedef range<std::vector<const DefinedAtom *>::iterator> DefinedAtomRange;
+  DefinedAtomRange definedAtoms() { return make_range(_definedAtoms._atoms); }
 
 private:
   atom_collection_vector<DefinedAtom>        _definedAtoms;
   atom_collection_vector<UndefinedAtom>      _undefinedAtoms;
   atom_collection_vector<SharedLibraryAtom>  _sharedLibraryAtoms;
   atom_collection_vector<AbsoluteAtom>       _absoluteAtoms;
 };
 

lib/Driver/Driver.cpp

bool Driver::link(LinkingContext &ctx, raw_ostream &diagnostics) {
 
   // Do core linking.
   ScopedTask resolveTask(getDefaultDomain(), "Resolve");
   Resolver resolver(ctx);
   if (!resolver.resolve()) {
     ctx.getTaskGroup().sync();
     return false;
   }
-  std::unique_ptr<MutableFile> merged = resolver.resultFile();
+  std::unique_ptr<SimpleFile> merged = resolver.resultFile();
   resolveTask.end();
 
   // Run passes on linked atoms.
   ScopedTask passTask(getDefaultDomain(), "Passes");
   PassManager pm;
   ctx.addPasses(pm);
   pm.runOnFile(merged);
   passTask.end();

lib/ReaderWriter/CoreLinkingContext.cpp

 private:
   const File &_file;
   uint32_t _ordinal;
 };
 
 class OrderPass : public Pass {
 public:
   /// Sorts atoms by position
-  void perform(std::unique_ptr<MutableFile> &file) override {
-    MutableFile::DefinedAtomRange defined = file->definedAtoms();
+  void perform(std::unique_ptr<SimpleFile> &file) override {
+    SimpleFile::DefinedAtomRange defined = file->definedAtoms();
     std::sort(defined.begin(), defined.end(), DefinedAtom::compareByPosition);
   }
 };
 
 } // anonymous namespace
 
 CoreLinkingContext::CoreLinkingContext() {}
 

lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp

public:
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
   /// to handleReference may modify the reference itself and/or create new
   /// atoms which must be stored in one of the maps below.
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  void perform(std::unique_ptr<MutableFile> &mf) override {
+  void perform(std::unique_ptr<SimpleFile> &mf) override {
     ScopedTask task(getDefaultDomain(), "AArch64 GOT/PLT Pass");
     DEBUG_WITH_TYPE(
         "AArch64", llvm::dbgs() << "Undefined Atoms"
                                 << "\n";
         for (const auto &atom
              : mf->undefined()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         } llvm::dbgs()

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

public:
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
   /// to handleReference may modify the reference itself and/or create new
   /// atoms which must be stored in one of the maps below.
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  void perform(std::unique_ptr<MutableFile> &mf) override {
+  void perform(std::unique_ptr<SimpleFile> &mf) override {
     ScopedTask task(getDefaultDomain(), "ARM GOT/PLT Pass");
     DEBUG_WITH_TYPE(
         "ARM", llvm::dbgs() << "Undefined Atoms" << "\n";
         for (const auto &atom
              : mf->undefined()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         }
 

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

public:
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
   /// to handleReference may modify the reference itself and/or create new
   /// atoms which must be stored in one of the maps below.
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  void perform(std::unique_ptr<MutableFile> &mf) override {
+  void perform(std::unique_ptr<SimpleFile> &mf) override {
     // Process all references.
     for (const auto &atom : mf->defined())
       for (const auto &ref : *atom)
         handleReference(*atom, *ref);
 
     // Add all created atoms to the link.
     uint64_t ordinal = 0;
     if (_plt0) {

lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.h

 
 #include "lld/Core/Pass.h"
 
 namespace lld {
 namespace elf {
 /// \brief This pass sorts atoms in .{ctors,dtors}.<priority> sections.
 class MipsCtorsOrderPass : public Pass {
 public:
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override;
+  void perform(std::unique_ptr<SimpleFile> &mergedFile) override;
 };
 }
 }
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.cpp

 //===- lib/ReaderWriter/ELF/Mips/Mips/CtorsOrderPass.cpp ------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MipsCtorsOrderPass.h"
+#include "lld/Core/Simple.h"
 #include <algorithm>
 #include <climits>
 
 using namespace lld;
 using namespace lld::elf;
 
 static bool matchCrtObjName(StringRef objName, StringRef objPath) {
   if (!objPath.endswith(".o"))
static int32_t getSectionPriority(StringRef path, StringRef sectionName) {
 
   int32_t priority = std::numeric_limits<int32_t>::min() + 1;
   if (!num.empty())
     num.getAsInteger(10, priority);
 
   return priority;
 }
 
-void MipsCtorsOrderPass::perform(std::unique_ptr<MutableFile> &f) {
+void MipsCtorsOrderPass::perform(std::unique_ptr<SimpleFile> &f) {
   auto definedAtoms = f->definedAtoms();
 
   auto last = std::stable_partition(definedAtoms.begin(), definedAtoms.end(),
                                     [](const DefinedAtom *atom) {
     if (atom->sectionChoice() != DefinedAtom::sectionCustomRequired)
       return false;
 
     StringRef name = atom->customSectionName();

lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp

public:
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 template <typename ELFT> class RelocationPass : public Pass {
 public:
   RelocationPass(MipsLinkingContext &ctx);
 
-  void perform(std::unique_ptr<MutableFile> &mf) override;
+  void perform(std::unique_ptr<SimpleFile> &mf) override;
 
 private:
   /// \brief Reference to the linking context.
   const MipsLinkingContext &_ctx;
 
   /// \brief Owner of all the Atoms created by this pass.
   RelocationPassFile _file;
 

 RelocationPass<ELFT>::RelocationPass(MipsLinkingContext &ctx)
     : _ctx(ctx), _file(ctx) {
   _localGotVector.push_back(new (_file._alloc) GOT0Atom<ELFT>(_file));
   _localGotVector.push_back(new (_file._alloc)
                                 GOTModulePointerAtom<ELFT>(_file));
 }
 
 template <typename ELFT>
-void RelocationPass<ELFT>::perform(std::unique_ptr<MutableFile> &mf) {
+void RelocationPass<ELFT>::perform(std::unique_ptr<SimpleFile> &mf) {
   for (const auto &atom : mf->defined())
     for (const auto &ref : *atom)
       collectReferenceInfo(*cast<MipsELFDefinedAtom<ELFT>>(atom),
                            const_cast<Reference &>(*ref));
 
   // Process all references.
   for (const auto &atom : mf->defined())
     for (const auto &ref : *atom)

lib/ReaderWriter/ELF/OrderPass.h

 #include <limits>
 
 namespace lld {
 namespace elf {
 
 /// \brief This pass sorts atoms by file and atom ordinals.
 class OrderPass : public Pass {
 public:
-  void perform(std::unique_ptr<MutableFile> &file) override {
+  void perform(std::unique_ptr<SimpleFile> &file) override {
     parallel_sort(file->definedAtoms().begin(), file->definedAtoms().end(),
                   DefinedAtom::compareByPosition);
   }
 };
 }
 }
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp

public:
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
   /// to handleReference may modify the reference itself and/or create new
   /// atoms which must be stored in one of the maps below.
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  void perform(std::unique_ptr<MutableFile> &mf) override {
+  void perform(std::unique_ptr<SimpleFile> &mf) override {
     ScopedTask task(getDefaultDomain(), "X86-64 GOT/PLT Pass");
     // Process all references.
     for (const auto &atom : mf->defined())
       for (const auto &ref : *atom)
         handleReference(*atom, *ref);
 
     // Add all created atoms to the link.
     uint64_t ordinal = 0;

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

 class CompactUnwindPass : public Pass {
 public:
   CompactUnwindPass(const MachOLinkingContext &context)
       : _context(context), _archHandler(_context.archHandler()),
         _file("<mach-o Compact Unwind Pass>"),
         _isBig(MachOLinkingContext::isBigEndian(_context.arch())) {}
 
 private:
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override {
+  void perform(std::unique_ptr<SimpleFile> &mergedFile) override {
     DEBUG(llvm::dbgs() << "MachO Compact Unwind pass\n");
 
     std::map<const Atom *, CompactUnwindEntry> unwindLocs;
     std::map<const Atom *, const Atom *> dwarfFrames;
     std::vector<const Atom *> personalities;
     uint32_t numLSDAs = 0;
 
     // First collect all __compact_unwind and __eh_frame entries, addressable by
void perform(std::unique_ptr<SimpleFile> &mergedFile) override {
 
     // Finally, remove all __compact_unwind atoms now that we've processed them.
     mergedFile->removeDefinedAtomsIf([](const DefinedAtom *atom) {
       return atom->contentType() == DefinedAtom::typeCompactUnwindInfo;
     });
   }
 
   void collectCompactUnwindEntries(
-      std::unique_ptr<MutableFile> &mergedFile,
+      std::unique_ptr<SimpleFile> &mergedFile,
       std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       std::vector<const Atom *> &personalities, uint32_t &numLSDAs) {
     DEBUG(llvm::dbgs() << "  Collecting __compact_unwind entries\n");
 
     for (const DefinedAtom *atom : mergedFile->defined()) {
       if (atom->contentType() != DefinedAtom::typeCompactUnwindInfo)
         continue;
 
CompactUnwindEntry extractCompactUnwindEntry(const DefinedAtom *atom) {
     entry.rangeLength =
         read32(atom->rawContent().data() + 2 * sizeof(uint32_t), _isBig);
     entry.encoding =
         read32(atom->rawContent().data() + 3 * sizeof(uint32_t), _isBig);
     return entry;
   }
 
   void
-  collectDwarfFrameEntries(std::unique_ptr<MutableFile> &mergedFile,
+  collectDwarfFrameEntries(std::unique_ptr<SimpleFile> &mergedFile,
                            std::map<const Atom *, const Atom *> &dwarfFrames) {
     for (const DefinedAtom *ehFrameAtom : mergedFile->defined()) {
       if (ehFrameAtom->contentType() != DefinedAtom::typeCFI)
         continue;
       if (ArchHandler::isDwarfCIE(_isBig, ehFrameAtom))
         continue;
 
       if (const Atom *function = _archHandler.fdeTargetFunction(ehFrameAtom))
         dwarfFrames[function] = ehFrameAtom;
     }
   }
 
   /// Every atom defined in __TEXT,__text needs an entry in the final
   /// __unwind_info section (in order). These comes from two sources:
   ///   + Input __compact_unwind sections where possible (after adding the
   ///      personality function offset which is only known now).
   ///   + A synthesised reference to __eh_frame if there's no __compact_unwind
   ///     or too many personality functions to be accommodated.
   std::vector<CompactUnwindEntry> createUnwindInfoEntries(
-      const std::unique_ptr<MutableFile> &mergedFile,
+      const std::unique_ptr<SimpleFile> &mergedFile,
       const std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
       const std::vector<const Atom *> &personalities,
       const std::map<const Atom *, const Atom *> &dwarfFrames) {
     std::vector<CompactUnwindEntry> unwindInfos;
 
     DEBUG(llvm::dbgs() << "  Creating __unwind_info entries\n");
     // The final order in the __unwind_info section must be derived from the
     // order of typeCode atoms, since that's how they'll be put into the object

lib/ReaderWriter/MachO/GOTPass.cpp

 ///
 class GOTPass : public Pass {
 public:
   GOTPass(const MachOLinkingContext &context)
     : _context(context), _archHandler(_context.archHandler()),
       _file("<mach-o GOT Pass>") { }
 
 private:
-
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override {
+  void perform(std::unique_ptr<SimpleFile> &mergedFile) override {
     // Scan all references in all atoms.
     for (const DefinedAtom *atom : mergedFile->defined()) {
       for (const Reference *ref : *atom) {
         // Look at instructions accessing the GOT.
         bool canBypassGOT;
         if (!_archHandler.isGOTAccess(*ref, canBypassGOT))
           continue;
         const Atom *target = ref->target();

lib/ReaderWriter/MachO/LayoutPass.h

 //===------ lib/ReaderWriter/MachO/LayoutPass.h - Handles Layout of atoms -===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_MACHO_LAYOUT_PASS_H
 #define LLD_READER_WRITER_MACHO_LAYOUT_PASS_H
 
 #include "lld/Core/File.h"
 #include "lld/Core/Pass.h"
 #include "lld/Core/Reader.h"
+#include "lld/Core/Simple.h"
 #include "llvm/ADT/DenseMap.h"
 #include <map>
 #include <string>
 #include <vector>
 
 namespace lld {
 class DefinedAtom;
-class MutableFile;
+class SimpleFile;
 
 namespace mach_o {
 
 /// This linker pass does the layout of the atoms. The pass is done after the
 /// order their .o files were found on the command line, then by order of the
 /// atoms (address) in the .o file.  But some atoms have a preferred location
 /// in their section (such as pinned to the start or end of the section), so
 /// the sort must take that into account too.
 class LayoutPass : public Pass {
 public:
   struct SortKey {
     SortKey(const DefinedAtom *atom, const DefinedAtom *root, uint64_t override)
         : _atom(atom), _root(root), _override(override) {}
     const DefinedAtom *_atom;
     const DefinedAtom *_root;
     uint64_t _override;
   };
 
   typedef std::function<bool (const DefinedAtom *left, const DefinedAtom *right,
                               bool &leftBeforeRight)> SortOverride;
 
   LayoutPass(const Registry &registry, SortOverride sorter);
 
   /// Sorts atoms in mergedFile by content type then by command line order.
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override;
+  void perform(std::unique_ptr<SimpleFile> &mergedFile) override;
 
   virtual ~LayoutPass() {}
 
 private:
   // Build the followOn atoms chain as specified by the kindLayoutAfter
   // reference type
-  void buildFollowOnTable(MutableFile::DefinedAtomRange &range);
+  void buildFollowOnTable(SimpleFile::DefinedAtomRange &range);
 
   // Build a map of Atoms to ordinals for sorting the atoms
-  void buildOrdinalOverrideMap(MutableFile::DefinedAtomRange &range);
+  void buildOrdinalOverrideMap(SimpleFile::DefinedAtomRange &range);
 
   const Registry &_registry;
   SortOverride _customSorter;
 
   typedef llvm::DenseMap<const DefinedAtom *, const DefinedAtom *> AtomToAtomT;
   typedef llvm::DenseMap<const DefinedAtom *, uint64_t> AtomToOrdinalT;
 
   // A map to be used to sort atoms. It represents the order of atoms in the
private:
   AtomToOrdinalT _ordinalOverrideMap;
 
   // Helper methods for buildFollowOnTable().
   const DefinedAtom *findAtomFollowedBy(const DefinedAtom *targetAtom);
   bool checkAllPrevAtomsZeroSize(const DefinedAtom *targetAtom);
 
   void setChainRoot(const DefinedAtom *targetAtom, const DefinedAtom *root);
 
-  std::vector<SortKey> decorate(MutableFile::DefinedAtomRange &atomRange) const;
-  void undecorate(MutableFile::DefinedAtomRange &atomRange,
+  std::vector<SortKey> decorate(SimpleFile::DefinedAtomRange &atomRange) const;
+  void undecorate(SimpleFile::DefinedAtomRange &atomRange,
                   std::vector<SortKey> &keys) const;
 
   // Check if the follow-on graph is a correct structure. For debugging only.
-  void checkFollowonChain(MutableFile::DefinedAtomRange &range);
+  void checkFollowonChain(SimpleFile::DefinedAtomRange &range);
 };
 
 } // namespace mach_o
 } // namespace lld
 
 #endif // LLD_READER_WRITER_MACHO_LAYOUT_PASS_H

lib/ReaderWriter/MachO/LayoutPass.cpp

if (!next) {
                            .c_str());
     }
     if (next == ap)
       return;
     ap = next;
   }
 }
 
-static void printDefinedAtoms(const MutableFile::DefinedAtomRange &atomRange) {
+static void printDefinedAtoms(const SimpleFile::DefinedAtomRange &atomRange) {
   for (const DefinedAtom *atom : atomRange) {
     llvm::dbgs() << "  file=" << atom->file().path()
                  << ", name=" << atom->name()
                  << ", size=" << atom->size()
                  << ", type=" << atom->contentType()
                  << ", ordinal=" << atom->ordinal()
                  << "\n";
   }
 }
 
 /// Verify that the followon chain is sane. Should not be called in
 /// release binary.
-void LayoutPass::checkFollowonChain(MutableFile::DefinedAtomRange &range) {
+void LayoutPass::checkFollowonChain(SimpleFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::checkFollowonChain");
 
   // Verify that there's no cycle in follow-on chain.
   std::set<const DefinedAtom *> roots;
   for (const auto &ai : _followOnRoots)
     roots.insert(ai.second);
   for (const DefinedAtom *root : roots)
     checkNoCycleInFollowonChain(_registry, _followOnNexts, root);

 /// b) The targetAtom which this Atom contains, has the root thats set to the
 ///    root of the current atom
 /// c) If the targetAtom is part of a different tree and the root of the
 ///    targetAtom is itself, Chain all the atoms that are contained in the tree
 ///    to the current Tree
 /// d) If the targetAtom is part of a different chain and the root of the
 ///    targetAtom until the targetAtom has all atoms of size 0, then chain the
 ///    targetAtoms and its tree to the current chain
-void LayoutPass::buildFollowOnTable(MutableFile::DefinedAtomRange &range) {
+void LayoutPass::buildFollowOnTable(SimpleFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::buildFollowOnTable");
   // Set the initial size of the followon and the followonNext hash to the
   // number of atoms that we have.
   _followOnRoots.resize(range.size());
   _followOnNexts.resize(range.size());
   for (const DefinedAtom *ai : range) {
     for (const Reference *r : *ai) {
       if (r->kindNamespace() != lld::Reference::KindNamespace::all ||
for (const DefinedAtom *ai : range) {
     }
   }
 }
 
 /// Build an ordinal override map by traversing the followon chain, and
 /// assigning ordinals to each atom, if the atoms have their ordinals
 /// already assigned skip the atom and move to the next. This is the
 /// main map thats used to sort the atoms while comparing two atoms together
-void LayoutPass::buildOrdinalOverrideMap(MutableFile::DefinedAtomRange &range) {
+void LayoutPass::buildOrdinalOverrideMap(SimpleFile::DefinedAtomRange &range) {
   ScopedTask task(getDefaultDomain(), "LayoutPass::buildOrdinalOverrideMap");
   uint64_t index = 0;
   for (const DefinedAtom *ai : range) {
     const DefinedAtom *atom = ai;
     if (_ordinalOverrideMap.find(atom) != _ordinalOverrideMap.end())
       continue;
     AtomToAtomT::iterator start = _followOnRoots.find(atom);
     if (start == _followOnRoots.end())
       continue;
     for (const DefinedAtom *nextAtom = start->second; nextAtom != NULL;
          nextAtom = _followOnNexts[nextAtom]) {
       AtomToOrdinalT::iterator pos = _ordinalOverrideMap.find(nextAtom);
       if (pos == _ordinalOverrideMap.end())
         _ordinalOverrideMap[nextAtom] = index++;
     }
   }
 }
 
 std::vector<LayoutPass::SortKey>
-LayoutPass::decorate(MutableFile::DefinedAtomRange &atomRange) const {
+LayoutPass::decorate(SimpleFile::DefinedAtomRange &atomRange) const {
   std::vector<SortKey> ret;
   for (const DefinedAtom *atom : atomRange) {
     auto ri = _followOnRoots.find(atom);
     auto oi = _ordinalOverrideMap.find(atom);
     const DefinedAtom *root = (ri == _followOnRoots.end()) ? atom : ri->second;
     uint64_t override = (oi == _ordinalOverrideMap.end()) ? 0 : oi->second;
     ret.push_back(SortKey(atom, root, override));
   }
   return ret;
 }
 
-void LayoutPass::undecorate(MutableFile::DefinedAtomRange &atomRange,
+void LayoutPass::undecorate(SimpleFile::DefinedAtomRange &atomRange,
                             std::vector<SortKey> &keys) const {
   size_t i = 0;
   for (SortKey &k : keys)
     atomRange[i++] = k._atom;
 }
 
 /// Perform the actual pass
-void LayoutPass::perform(std::unique_ptr<MutableFile> &mergedFile) {
+void LayoutPass::perform(std::unique_ptr<SimpleFile> &mergedFile) {
   // sort the atoms
   ScopedTask task(getDefaultDomain(), "LayoutPass");
-  MutableFile::DefinedAtomRange atomRange = mergedFile->definedAtoms();
+  SimpleFile::DefinedAtomRange atomRange = mergedFile->definedAtoms();
 
   // Build follow on tables
   buildFollowOnTable(atomRange);
 
   // Check the structure of followon graph if running in debug mode.
   DEBUG(checkFollowonChain(atomRange));
 
   // Build override maps

lib/ReaderWriter/MachO/ShimPass.cpp

 public:
   ShimPass(const MachOLinkingContext &context)
     : _context(context)
     , _archHandler(_context.archHandler())
     , _stubInfo(_archHandler.stubInfo())
     , _file("<mach-o shim pass>") {
   }
 
-
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override {
+  void perform(std::unique_ptr<SimpleFile> &mergedFile) override {
     // Scan all references in all atoms.
     for (const DefinedAtom *atom : mergedFile->defined()) {
       for (const Reference *ref : *atom) {
         // Look at non-call branches.
         if (!_archHandler.isNonCallBranch(*ref))
           continue;
         const Atom *target = ref->target();
         assert(target != nullptr);

lib/ReaderWriter/MachO/StubsPass.cpp

 
 
 class StubsPass : public Pass {
 public:
   StubsPass(const MachOLinkingContext &context)
     : _context(context), _archHandler(_context.archHandler()),
     _stubInfo(_archHandler.stubInfo()), _file("<mach-o Stubs pass>") { }
 
-
-  void perform(std::unique_ptr<MutableFile> &mergedFile) override {
+  void perform(std::unique_ptr<SimpleFile> &mergedFile) override {
     // Skip this pass if output format uses text relocations instead of stubs.
     if (!this->noTextRelocs())
       return;
 
     // Scan all references in all atoms.
     for (const DefinedAtom *atom : mergedFile->defined()) {
       for (const Reference *ref : *atom) {
         // Look at call-sites.

lib/ReaderWriter/PECOFF/EdataPass.h

 
 } // namespace edata
 
 class EdataPass : public lld::Pass {
 public:
   EdataPass(PECOFFLinkingContext &ctx)
       : _ctx(ctx), _file(ctx), _is64(ctx.is64Bit()), _stringOrdinal(1024) {}
 
-  void perform(std::unique_ptr<MutableFile> &file) override;
+  void perform(std::unique_ptr<SimpleFile> &file) override;
 
 private:
   edata::EdataAtom *
   createExportDirectoryTable(const std::vector<edata::TableEntry> &namedEntries,
                              int ordinalBase, int maxOrdinal);
 
   edata::EdataAtom *
   createAddressTable(const std::vector<edata::TableEntry> &entries,
                      int ordinalBase, int maxOrdinal);
 
   edata::EdataAtom *
   createNamePointerTable(const PECOFFLinkingContext &ctx,
                          const std::vector<edata::TableEntry> &entries,
-                         MutableFile *file);
+                         SimpleFile *file);
 
   edata::EdataAtom *
   createOrdinalTable(const std::vector<edata::TableEntry> &entries,
                      int ordinalBase);
 
   PECOFFLinkingContext &_ctx;
   VirtualFile _file;
   bool _is64;
   int _stringOrdinal;
   mutable llvm::BumpPtrAllocator _alloc;
 };
 
 } // namespace pecoff
 } // namespace lld
 
 #endif

lib/ReaderWriter/PECOFF/EdataPass.cpp

static void assignOrdinals(PECOFFLinkingContext &ctx) {
   });
 
   int nextOrdinal = (maxOrdinal == -1) ? 1 : (maxOrdinal + 1);
   for (ExportDesc &desc : exports)
     if (desc.ordinal == -1)
       desc.ordinal = nextOrdinal++;
 }
 
-static bool getExportedAtoms(PECOFFLinkingContext &ctx, MutableFile *file,
+static bool getExportedAtoms(PECOFFLinkingContext &ctx, SimpleFile *file,
                              std::vector<TableEntry> &ret) {
   std::map<StringRef, const DefinedAtom *> definedAtoms;
   for (const DefinedAtom *atom : file->defined())
     definedAtoms[atom->name()] = atom;
 
   for (PECOFFLinkingContext::ExportDesc &desc : ctx.getDllExports()) {
     auto it = definedAtoms.find(desc.getRealName());
     if (it == definedAtoms.end()) {
for (const TableEntry &e : entries) {
     addDir32NBReloc(addressTable, e.atom, _ctx.getMachineType(), offset);
   }
   return addressTable;
 }
 
 edata::EdataAtom *
 EdataPass::createNamePointerTable(const PECOFFLinkingContext &ctx,
                                   const std::vector<TableEntry> &entries,
-                                  MutableFile *file) {
+                                  SimpleFile *file) {
   EdataAtom *table =
       new (_alloc) EdataAtom(_file, sizeof(uint32_t) * entries.size());
 
   size_t offset = 0;
   for (const TableEntry &e : entries) {
     auto *stringAtom = new (_alloc) COFFStringAtom(
         _file, _stringOrdinal++, ".edata", e.exportName);
     file->addAtom(*stringAtom);
EdataAtom *ret =
       new (_alloc) EdataAtom(_file, sizeof(uint16_t) * entries.size());
   uint16_t *data = ret->getContents<uint16_t>();
   int i = 0;
   for (const TableEntry &e : entries)
     data[i++] = e.ordinal - ordinalBase;
   return ret;
 }
 
-void EdataPass::perform(std::unique_ptr<MutableFile> &file) {
+void EdataPass::perform(std::unique_ptr<SimpleFile> &file) {
   dedupExports(_ctx);
   assignOrdinals(_ctx);
 
   std::vector<TableEntry> entries;
   if (!getExportedAtoms(_ctx, file.get(), entries))
     return;
   if (entries.empty())
     return;

lib/ReaderWriter/PECOFF/IdataPass.h

 namespace idata {
 
 class DLLNameAtom;
 class HintNameAtom;
 class ImportTableEntryAtom;
 
 // A state object of this pass.
 struct IdataContext {
-  IdataContext(MutableFile &f, VirtualFile &g, const PECOFFLinkingContext &c)
+  IdataContext(SimpleFile &f, VirtualFile &g, const PECOFFLinkingContext &c)
       : file(f), dummyFile(g), ctx(c) {}
-  MutableFile &file;
+  SimpleFile &file;
   VirtualFile &dummyFile;
   const PECOFFLinkingContext &ctx;
 };
 
 /// The root class of all idata atoms.
 class IdataAtom : public COFFLinkerInternalAtom {
 public:
   SectionChoice sectionChoice() const override { return sectionCustomRequired; }

 };
 
 } // namespace idata
 
 class IdataPass : public lld::Pass {
 public:
   IdataPass(const PECOFFLinkingContext &ctx) : _dummyFile(ctx), _ctx(ctx) {}
 
-  void perform(std::unique_ptr<MutableFile> &file) override;
+  void perform(std::unique_ptr<SimpleFile> &file) override;
 
 private:
   std::map<StringRef, std::vector<COFFSharedLibraryAtom *>>
-  groupByLoadName(MutableFile &file);
+  groupByLoadName(SimpleFile &file);
 
-  void replaceSharedLibraryAtoms(MutableFile &file);
+  void replaceSharedLibraryAtoms(SimpleFile &file);
 
   // A dummy file with which all the atoms created in the pass will be
   // associated. Atoms need to be associated to an input file even if it's not
   // read from a file, so we use this object.
   VirtualFile _dummyFile;
 
   const PECOFFLinkingContext &_ctx;
   llvm::BumpPtrAllocator _alloc;
 };
 
 } // namespace pecoff
 } // namespace lld
 
 #endif

lib/ReaderWriter/PECOFF/IdataPass.cpp

std::vector<uint8_t> DelayImportDirectoryAtom::createContent() {
   auto entry = reinterpret_cast<delay_import_directory_table_entry *>(&r[0]);
   // link.exe seems to set 1 to Attributes field, so do we.
   entry->Attributes = 1;
   return r;
 }
 
 // Find "___delayLoadHelper2@8" (or "__delayLoadHelper2" on x64).
 // This is not efficient but should be OK for now.
-static const Atom *
-findDelayLoadHelper(MutableFile &file, const PECOFFLinkingContext &ctx) {
+static const Atom *findDelayLoadHelper(SimpleFile &file,
+                                       const PECOFFLinkingContext &ctx) {
   StringRef sym = ctx.getDelayLoadHelperName();
   for (const DefinedAtom *atom : file.defined())
     if (atom->name() == sym)
       return atom;
   std::string msg = (sym + " was not found").str();
   llvm_unreachable(msg.c_str());
 }
 
case llvm::COFF::IMAGE_FILE_MACHINE_AMD64:
     return std::vector<uint8_t>(x64, x64 + sizeof(x64));
   default:
     llvm::report_fatal_error("unsupported machine type");
   }
 }
 
 } // namespace idata
 
-void IdataPass::perform(std::unique_ptr<MutableFile> &file) {
+void IdataPass::perform(std::unique_ptr<SimpleFile> &file) {
   if (file->sharedLibrary().empty())
     return;
 
   idata::IdataContext context(*file, _dummyFile, _ctx);
   std::map<StringRef, std::vector<COFFSharedLibraryAtom *>> sharedAtoms =
       groupByLoadName(*file);
   bool hasImports = false;
   bool hasDelayImports = false;
for (auto i : sharedAtoms) {
     new (_alloc) idata::DelayImportDirectoryAtom(context, loadName, atoms);
   }
   if (hasDelayImports)
     new (_alloc) idata::DelayNullImportDirectoryAtom(context);
 
   replaceSharedLibraryAtoms(*file);
 }
 
-std::map<StringRef, std::vector<COFFSharedLibraryAtom *> >
-IdataPass::groupByLoadName(MutableFile &file) {
+std::map<StringRef, std::vector<COFFSharedLibraryAtom *>>
+IdataPass::groupByLoadName(SimpleFile &file) {
   std::map<StringRef, COFFSharedLibraryAtom *> uniqueAtoms;
   for (const SharedLibraryAtom *atom : file.sharedLibrary())
     uniqueAtoms[atom->name()] =
         (COFFSharedLibraryAtom *)const_cast<SharedLibraryAtom *>(atom);
 
   std::map<StringRef, std::vector<COFFSharedLibraryAtom *> > ret;
   for (auto i : uniqueAtoms) {
     COFFSharedLibraryAtom *atom = i.second;
     ret[atom->loadName()].push_back(atom);
   }
   return ret;
 }
 
 /// Transforms a reference to a COFFSharedLibraryAtom to a real reference.
-void IdataPass::replaceSharedLibraryAtoms(MutableFile &file) {
+void IdataPass::replaceSharedLibraryAtoms(SimpleFile &file) {
   for (const DefinedAtom *atom : file.defined()) {
     for (const Reference *ref : *atom) {
       const Atom *target = ref->target();
       auto *sharedAtom = dyn_cast<SharedLibraryAtom>(target);
       if (!sharedAtom)
         continue;
       const auto *coffSharedAtom = (const COFFSharedLibraryAtom *)sharedAtom;
       const DefinedAtom *entry = coffSharedAtom->getImportTableEntry();
       const_cast<Reference *>(ref)->setTarget(entry);
     }
   }
 }
 
 } // namespace pecoff
 } // namespace lld

lib/ReaderWriter/PECOFF/InferSubsystemPass.h

 namespace lld {
 namespace pecoff {
 
 // Infers subsystem from entry point function name.
 class InferSubsystemPass : public lld::Pass {
 public:
   InferSubsystemPass(PECOFFLinkingContext &ctx) : _ctx(ctx) {}
 
-  void perform(std::unique_ptr<MutableFile> &file) override {
+  void perform(std::unique_ptr<SimpleFile> &file) override {
     if (_ctx.getSubsystem() != WindowsSubsystem::IMAGE_SUBSYSTEM_UNKNOWN)
       return;
 
     if (_ctx.isDll()) {
       _ctx.setSubsystem(WindowsSubsystem::IMAGE_SUBSYSTEM_WINDOWS_GUI);
       return;
     }
 

lib/ReaderWriter/PECOFF/LoadConfigPass.h

 };
 
 } // namespace loadcfg
 
 class LoadConfigPass : public lld::Pass {
 public:
   LoadConfigPass(PECOFFLinkingContext &ctx) : _ctx(ctx), _file(ctx) {}
 
-  void perform(std::unique_ptr<MutableFile> &file) override;
+  void perform(std::unique_ptr<SimpleFile> &file) override;
 
 private:
   PECOFFLinkingContext &_ctx;
   VirtualFile _file;
   mutable llvm::BumpPtrAllocator _alloc;
 };
 
 } // namespace pecoff
 } // namespace lld
 
 #endif

lib/ReaderWriter/PECOFF/LoadConfigPass.cpp

addDir32Reloc(
       this, sxdata, llvm::COFF::IMAGE_FILE_MACHINE_I386,
       offsetof(llvm::object::coff_load_configuration32, SEHandlerTable));
   auto *data = getContents<llvm::object::coff_load_configuration32>();
   data->SEHandlerCount = count;
 }
 
 } // namespace loadcfg
 
-void LoadConfigPass::perform(std::unique_ptr<MutableFile> &file) {
+void LoadConfigPass::perform(std::unique_ptr<SimpleFile> &file) {
   if (_ctx.noSEH())
     return;
 
   // Find the first atom in .sxdata section.
   const DefinedAtom *sxdata = nullptr;
   int sectionSize = 0;
   for (const DefinedAtom *atom : file->defined()) {
     if (atom->customSectionName() == ".sxdata") {

lib/ReaderWriter/PECOFF/OrderPass.h

if (lhsCustom && !rhsCustom)
     return true;
   if (!lhsCustom && rhsCustom)
     return false;
   return DefinedAtom::compareByPosition(lhs, rhs);
 }
 
 class OrderPass : public lld::Pass {
 public:
-  void perform(std::unique_ptr<MutableFile> &file) override {
-    MutableFile::DefinedAtomRange defined = file->definedAtoms();
+  void perform(std::unique_ptr<SimpleFile> &file) override {
+    SimpleFile::DefinedAtomRange defined = file->definedAtoms();
     parallel_sort(defined.begin(), defined.end(), compare);
   }
 };
 
 } // namespace pecoff
 } // namespace lld
 
 #endif

lib/ReaderWriter/PECOFF/PDBPass.h

 
 namespace lld {
 namespace pecoff {
 
 class PDBPass : public lld::Pass {
 public:
   PDBPass(PECOFFLinkingContext &ctx) : _ctx(ctx) {}
 
-  void perform(std::unique_ptr<MutableFile> &file) override {
+  void perform(std::unique_ptr<SimpleFile> &file) override {
     if (_ctx.getDebug())
       touch(_ctx.getPDBFilePath());
   }
 
 private:
   void touch(StringRef path) {
     int fd;
     if (llvm::sys::fs::openFileForWrite(path, fd, llvm::sys::fs::F_Append))