Simplify Pass::perform to take a SimpleFile& instead of unique_ptr<SimpleFile>&

None of the implementations replace the SimpleFile with some other file,
they just modify the SimpleFile in-place, so a direct reference to the
file is sufficient.

llvm-svn: 240167

8 files changed, 66 insertions, 66 deletions

diff --git a/lld/lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp b/lld/lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp
index 787d11c1303..bf8d6c4e0b8 100644
--- a/lld/lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp
+++ b/lld/lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp
@@ -256,32 +256,32 @@ public:
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  std::error_code perform(std::unique_ptr<SimpleFile> &mf) override {
+  std::error_code perform(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()) {
+             : mf.undefined()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         } llvm::dbgs()
             << "Shared Library Atoms"
             << "\n";
         for (const auto &atom
-             : mf->sharedLibrary()) {
+             : mf.sharedLibrary()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         } llvm::dbgs()
             << "Absolute Atoms"
             << "\n";
         for (const auto &atom
-             : mf->absolute()) {
+             : mf.absolute()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         }
             // Process all references.
             llvm::dbgs()
             << "Defined Atoms"
             << "\n");
-    for (const auto &atom : mf->defined()) {
+    for (const auto &atom : mf.defined()) {
       for (const auto &ref : *atom) {
         handleReference(*atom, *ref);
       }
@@ -291,29 +291,29 @@ public:
     uint64_t ordinal = 0;
     if (_plt0) {
       _plt0->setOrdinal(ordinal++);
-      mf->addAtom(*_plt0);
+      mf.addAtom(*_plt0);
     }
     for (auto &plt : _pltVector) {
       plt->setOrdinal(ordinal++);
-      mf->addAtom(*plt);
+      mf.addAtom(*plt);
     }
     if (_null) {
       _null->setOrdinal(ordinal++);
-      mf->addAtom(*_null);
+      mf.addAtom(*_null);
     }
     if (_plt0) {
       _got0->setOrdinal(ordinal++);
       _got1->setOrdinal(ordinal++);
-      mf->addAtom(*_got0);
-      mf->addAtom(*_got1);
+      mf.addAtom(*_got0);
+      mf.addAtom(*_got1);
     }
     for (auto &got : _gotVector) {
       got->setOrdinal(ordinal++);
-      mf->addAtom(*got);
+      mf.addAtom(*got);
     }
     for (auto obj : _objectVector) {
       obj->setOrdinal(ordinal++);
-      mf->addAtom(*obj);
+      mf.addAtom(*obj);
     }
 
     return std::error_code();
diff --git a/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp b/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp
index 4ba02d809f9..fc2ae75cd7a 100644
--- a/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp
+++ b/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp
@@ -673,35 +673,35 @@ public:
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  std::error_code perform(std::unique_ptr<SimpleFile> &mf) override {
+  std::error_code perform(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()) {
+             : mf.undefined()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         }
 
         llvm::dbgs() << "Shared Library Atoms" << "\n";
         for (const auto &atom
-             : mf->sharedLibrary()) {
+             : mf.sharedLibrary()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         }
 
         llvm::dbgs() << "Absolute Atoms" << "\n";
         for (const auto &atom
-             : mf->absolute()) {
+             : mf.absolute()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         }
 
         llvm::dbgs() << "Defined Atoms" << "\n";
         for (const auto &atom
-             : mf->defined()) {
+             : mf.defined()) {
           llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
         });
 
     // Process all references.
-    for (const auto &atom : mf->defined()) {
+    for (const auto &atom : mf.defined()) {
       for (const auto &ref : *atom) {
         handleReference(*atom, *ref);
       }
@@ -711,53 +711,53 @@ public:
     uint64_t ordinal = 0;
     if (_plt0) {
       _plt0->setOrdinal(ordinal++);
-      mf->addAtom(*_plt0);
+      mf.addAtom(*_plt0);
       _plt0_d->setOrdinal(ordinal++);
-      mf->addAtom(*_plt0_d);
+      mf.addAtom(*_plt0_d);
     }
     for (auto &pltKV : _pltAtoms) {
       auto &plt = pltKV.second;
       if (auto *v = plt._veneer) {
         v->setOrdinal(ordinal++);
-        mf->addAtom(*v);
+        mf.addAtom(*v);
       }
       auto *p = plt._plt;
       p->setOrdinal(ordinal++);
-      mf->addAtom(*p);
+      mf.addAtom(*p);
     }
     if (_null) {
       _null->setOrdinal(ordinal++);
-      mf->addAtom(*_null);
+      mf.addAtom(*_null);
     }
     if (_plt0) {
       _got0->setOrdinal(ordinal++);
-      mf->addAtom(*_got0);
+      mf.addAtom(*_got0);
       _got1->setOrdinal(ordinal++);
-      mf->addAtom(*_got1);
+      mf.addAtom(*_got1);
     }
     for (auto &gotKV : _gotAtoms) {
       auto &got = gotKV.second;
       got->setOrdinal(ordinal++);
-      mf->addAtom(*got);
+      mf.addAtom(*got);
     }
     for (auto &gotKV : _gotpltAtoms) {
       auto &got = gotKV.second;
       got->setOrdinal(ordinal++);
-      mf->addAtom(*got);
+      mf.addAtom(*got);
     }
     for (auto &objectKV : _objectAtoms) {
       auto &obj = objectKV.second;
       obj->setOrdinal(ordinal++);
-      mf->addAtom(*obj);
+      mf.addAtom(*obj);
     }
     for (auto &veneerKV : _veneerAtoms) {
       auto &veneer = veneerKV.second;
       auto *m = veneer._mapping;
       m->setOrdinal(ordinal++);
-      mf->addAtom(*m);
+      mf.addAtom(*m);
       auto *v = veneer._veneer;
       v->setOrdinal(ordinal++);
-      mf->addAtom(*v);
+      mf.addAtom(*v);
     }
 
     return std::error_code();
diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
index f835eb6683d..6c0360c310f 100644
--- a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
+++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
@@ -169,9 +169,9 @@ public:
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  std::error_code perform(std::unique_ptr<SimpleFile> &mf) override {
+  std::error_code perform(SimpleFile &mf) override {
     // Process all references.
-    for (const auto &atom : mf->defined())
+    for (const auto &atom : mf.defined())
       for (const auto &ref : *atom)
         handleReference(*atom, *ref);
 
@@ -179,23 +179,23 @@ public:
     uint64_t ordinal = 0;
     if (_plt0) {
       _plt0->setOrdinal(ordinal++);
-      mf->addAtom(*_plt0);
+      mf.addAtom(*_plt0);
     }
     for (auto &plt : _pltVector) {
       plt->setOrdinal(ordinal++);
-      mf->addAtom(*plt);
+      mf.addAtom(*plt);
     }
     if (_null) {
       _null->setOrdinal(ordinal++);
-      mf->addAtom(*_null);
+      mf.addAtom(*_null);
     }
     if (_got0) {
       _got0->setOrdinal(ordinal++);
-      mf->addAtom(*_got0);
+      mf.addAtom(*_got0);
     }
     for (auto &got : _gotVector) {
       got->setOrdinal(ordinal++);
-      mf->addAtom(*got);
+      mf.addAtom(*got);
     }
 
     return std::error_code();
diff --git a/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.cpp b/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.cpp
index 276d87dc193..a7062813df4 100644
--- a/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.cpp
+++ b/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.cpp
@@ -49,8 +49,8 @@ static int32_t getSectionPriority(StringRef path, StringRef sectionName) {
   return priority;
 }
 
-std::error_code MipsCtorsOrderPass::perform(std::unique_ptr<SimpleFile> &f) {
-  auto definedAtoms = f->definedAtoms();
+std::error_code MipsCtorsOrderPass::perform(SimpleFile &f) {
+  auto definedAtoms = f.definedAtoms();
 
   auto last = std::stable_partition(definedAtoms.begin(), definedAtoms.end(),
                                     [](const DefinedAtom *atom) {
diff --git a/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.h b/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.h
index 65c9d9b90d5..5b12b7de0fa 100644
--- a/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.h
+++ b/lld/lib/ReaderWriter/ELF/Mips/MipsCtorsOrderPass.h
@@ -17,7 +17,7 @@ namespace elf {
 /// \brief This pass sorts atoms in .{ctors,dtors}.<priority> sections.
 class MipsCtorsOrderPass : public Pass {
 public:
-  std::error_code perform(std::unique_ptr<SimpleFile> &mergedFile) override;
+  std::error_code perform(SimpleFile &mergedFile) override;
 };
 }
 }
diff --git a/lld/lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp b/lld/lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp
index f4f0a8acd93..493b41abee1 100644
--- a/lld/lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp
+++ b/lld/lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp
@@ -302,7 +302,7 @@ template <typename ELFT> class RelocationPass : public Pass {
 public:
   RelocationPass(MipsLinkingContext &ctx);
 
-  std::error_code perform(std::unique_ptr<SimpleFile> &mf) override;
+  std::error_code perform(SimpleFile &mf) override;
 
 private:
   /// \brief Reference to the linking context.
@@ -428,14 +428,14 @@ RelocationPass<ELFT>::RelocationPass(MipsLinkingContext &ctx)
 }
 
 template <typename ELFT>
-std::error_code RelocationPass<ELFT>::perform(std::unique_ptr<SimpleFile> &mf) {
-  for (const auto &atom : mf->defined())
+std::error_code RelocationPass<ELFT>::perform(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 &atom : mf.defined())
     for (const auto &ref : *atom)
       handleReference(*cast<MipsELFDefinedAtom<ELFT>>(atom),
                       const_cast<Reference &>(*ref));
@@ -457,22 +457,22 @@ std::error_code RelocationPass<ELFT>::perform(std::unique_ptr<SimpleFile> &mf) {
       !_tlsGotVector.empty()) {
     SimpleDefinedAtom *ga = new (_file._alloc) MipsGlobalOffsetTableAtom(_file);
     ga->setOrdinal(ordinal++);
-    mf->addAtom(*ga);
+    mf.addAtom(*ga);
   }
 
   for (auto &got : _localGotVector) {
     got->setOrdinal(ordinal++);
-    mf->addAtom(*got);
+    mf.addAtom(*got);
   }
 
   for (auto &got : _globalGotVector) {
     got->setOrdinal(ordinal++);
-    mf->addAtom(*got);
+    mf.addAtom(*got);
   }
 
   for (auto &got : _tlsGotVector) {
     got->setOrdinal(ordinal++);
-    mf->addAtom(*got);
+    mf.addAtom(*got);
   }
 
   // Create and emit PLT0 entry.
@@ -484,19 +484,19 @@ std::error_code RelocationPass<ELFT>::perform(std::unique_ptr<SimpleFile> &mf) {
 
   if (plt0Atom) {
     plt0Atom->setOrdinal(ordinal++);
-    mf->addAtom(*plt0Atom);
+    mf.addAtom(*plt0Atom);
   }
 
   // Emit regular PLT entries firts.
   for (auto &plt : _pltRegVector) {
     plt->setOrdinal(ordinal++);
-    mf->addAtom(*plt);
+    mf.addAtom(*plt);
   }
 
   // microMIPS PLT entries come after regular ones.
   for (auto &plt : _pltMicroVector) {
     plt->setOrdinal(ordinal++);
-    mf->addAtom(*plt);
+    mf.addAtom(*plt);
   }
 
   // Assign PLT0 to GOTPLT entries.
@@ -506,17 +506,17 @@ std::error_code RelocationPass<ELFT>::perform(std::unique_ptr<SimpleFile> &mf) {
 
   for (auto &gotplt : _gotpltVector) {
     gotplt->setOrdinal(ordinal++);
-    mf->addAtom(*gotplt);
+    mf.addAtom(*gotplt);
   }
 
   for (auto obj : _objectVector) {
     obj->setOrdinal(ordinal++);
-    mf->addAtom(*obj);
+    mf.addAtom(*obj);
   }
 
   for (auto la25 : _la25Vector) {
     la25->setOrdinal(ordinal++);
-    mf->addAtom(*la25);
+    mf.addAtom(*la25);
   }
 
   return std::error_code();
diff --git a/lld/lib/ReaderWriter/ELF/OrderPass.h b/lld/lib/ReaderWriter/ELF/OrderPass.h
index 4b4e2b16af5..11f88056c8c 100644
--- a/lld/lib/ReaderWriter/ELF/OrderPass.h
+++ b/lld/lib/ReaderWriter/ELF/OrderPass.h
@@ -19,8 +19,8 @@ namespace elf {
 /// \brief This pass sorts atoms by file and atom ordinals.
 class OrderPass : public Pass {
 public:
-  std::error_code perform(std::unique_ptr<SimpleFile> &file) override {
-    parallel_sort(file->definedAtoms().begin(), file->definedAtoms().end(),
+  std::error_code perform(SimpleFile &file) override {
+    parallel_sort(file.definedAtoms().begin(), file.definedAtoms().end(),
                   DefinedAtom::compareByPosition);
     return std::error_code();
   }
diff --git a/lld/lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp b/lld/lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp
index 10b6d4c15f1..a2f10dc08a4 100644
--- a/lld/lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp
+++ b/lld/lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp
@@ -254,10 +254,10 @@ public:
   ///
   /// After all references are handled, the atoms created during that are all
   /// added to mf.
-  std::error_code perform(std::unique_ptr<SimpleFile> &mf) override {
+  std::error_code perform(SimpleFile &mf) override {
     ScopedTask task(getDefaultDomain(), "X86-64 GOT/PLT Pass");
     // Process all references.
-    for (const auto &atom : mf->defined())
+    for (const auto &atom : mf.defined())
       for (const auto &ref : *atom)
         handleReference(*atom, *ref);
 
@@ -265,33 +265,33 @@ public:
     uint64_t ordinal = 0;
     if (_plt0) {
       _plt0->setOrdinal(ordinal++);
-      mf->addAtom(*_plt0);
+      mf.addAtom(*_plt0);
     }
     for (auto &plt : _pltVector) {
       plt->setOrdinal(ordinal++);
-      mf->addAtom(*plt);
+      mf.addAtom(*plt);
     }
     if (_null) {
       _null->setOrdinal(ordinal++);
-      mf->addAtom(*_null);
+      mf.addAtom(*_null);
     }
     if (_plt0) {
       _got0->setOrdinal(ordinal++);
       _got1->setOrdinal(ordinal++);
-      mf->addAtom(*_got0);
-      mf->addAtom(*_got1);
+      mf.addAtom(*_got0);
+      mf.addAtom(*_got1);
     }
     for (auto &got : _gotVector) {
       got->setOrdinal(ordinal++);
-      mf->addAtom(*got);
+      mf.addAtom(*got);
     }
     for (auto &got : _tlsGotVector) {
       got->setOrdinal(ordinal++);
-      mf->addAtom(*got);
+      mf.addAtom(*got);
     }
     for (auto obj : _objectVector) {
       obj->setOrdinal(ordinal++);
-      mf->addAtom(*obj);
+      mf.addAtom(*obj);
     }
     return std::error_code();
   }