Replace the `createImplicitFiles` method return type with `void`

[atanasyan]

Summary

All instances of the createImplicitFiles always return true and this return value is used nowhere. The patch changes return type from bool to void.

[ruiu]

LGTM. Nice!

[atanasyan]

Thanks for review.

Closed by commit rL234205.

include/lld/Core/LinkingContext.h

public:
 
   /// Accessor for Register object embedded in LinkingContext.
   const Registry &registry() const { return _registry; }
   Registry &registry() { return _registry; }
 
   /// This method is called by core linking to give the Writer a chance
   /// to add file format specific "files" to set of files to be linked. This is
   /// how file format specific atoms can be added to the link.
-  virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
+  virtual void createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   /// This method is called by core linking to build the list of Passes to be
   /// run on the merged/linked graph of all input files.
   virtual void addPasses(PassManager &pm);
 
   /// Calls through to the writeFile() method on the specified Writer.
   ///
   /// \param linkedFile This is the merged/linked graph of all input file Atoms.

include/lld/Core/Writer.h

public:
   virtual ~Writer();
 
   /// \brief Write a file from the supplied File object
   virtual std::error_code writeFile(const File &linkedFile, StringRef path) = 0;
 
   /// \brief This method is called by Core Linking to give the Writer a chance
   /// to add file format specific "files" to set of files to be linked. This is
   /// how file format specific atoms can be added to the link.
-  virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
+  virtual void createImplicitFiles(std::vector<std::unique_ptr<File>> &) {}
 
 protected:
   // only concrete subclasses can be instantiated
   Writer();
 };
 
 std::unique_ptr<Writer> createWriterELF(const ELFLinkingContext &);
 std::unique_ptr<Writer> createWriterMachO(const MachOLinkingContext &);
 std::unique_ptr<Writer> createWriterPECOFF(const PECOFFLinkingContext &);
 std::unique_ptr<Writer> createWriterNative();
 std::unique_ptr<Writer> createWriterYAML(const LinkingContext &);
 } // end namespace lld
 
 #endif

include/lld/ReaderWriter/MachOLinkingContext.h

public:
   /// file type, arch, os, and minimum os version.  This should be called before
   /// other setXXX() methods.
   void configure(HeaderFileType type, Arch arch, OS os, uint32_t minOSVersion);
 
   void addPasses(PassManager &pm) override;
   bool validateImpl(raw_ostream &diagnostics) override;
   std::string demangle(StringRef symbolName) const override;
 
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   uint32_t getCPUType() const;
   uint32_t getCPUSubType() const;
 
   bool addEntryPointLoadCommand() const;
   bool addUnixThreadLoadCommand() const;
   bool outputTypeHasEntry() const;
   bool is64Bit() const;

include/lld/ReaderWriter/PECOFFLinkingContext.h

public:
   /// \brief Casting support
   static bool classof(const LinkingContext *info) { return true; }
 
   Writer &writer() const override;
   bool validateImpl(raw_ostream &diagnostics) override;
 
   void addPasses(PassManager &pm) override;
 
-  bool createImplicitFiles(
-      std::vector<std::unique_ptr<File> > &result) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &result) override;
 
   bool is64Bit() const {
     return _machineType == llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
   }
 
   // Returns a set of all defined symbols in input files.
   const std::set<std::string> &definedSymbols();
 

lib/Core/LinkingContext.cpp

 bool LinkingContext::validate(raw_ostream &diagnostics) {
   return validateImpl(diagnostics);
 }
 
 std::error_code LinkingContext::writeFile(const File &linkedFile) const {
   return this->writer().writeFile(linkedFile, _outputPath);
 }
 
-bool LinkingContext::createImplicitFiles(
-    std::vector<std::unique_ptr<File> > &result) {
-  return this->writer().createImplicitFiles(result);
+void LinkingContext::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  this->writer().createImplicitFiles(result);
 }
 
 std::unique_ptr<File> LinkingContext::createEntrySymbolFile() const {
   return createEntrySymbolFile("<command line option -e>");
 }
 
 std::unique_ptr<File>
 LinkingContext::createEntrySymbolFile(StringRef filename) const {

lib/Core/Writer.cpp

 #include "lld/Core/Writer.h"
 
 namespace lld {
 Writer::Writer() {
 }
 
 Writer::~Writer() {
 }
-
-bool Writer::createImplicitFiles(std::vector<std::unique_ptr<File> > &) {
-  return true;
-}
 } // end namespace lld

lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h

 template <class ELFT>
 class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
   AArch64DynamicLibraryWriter(AArch64LinkingContext &ctx,
                               TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     return DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override {
     return DynamicLibraryWriter<ELFT>::addDefaultAtoms();
   }

 
 template <class ELFT>
 AArch64DynamicLibraryWriter<ELFT>::AArch64DynamicLibraryWriter(
     AArch64LinkingContext &ctx, TargetLayout<ELFT> &layout)
     : DynamicLibraryWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)),
       _ctx(ctx), _layout(layout) {}
 
 template <class ELFT>
-bool AArch64DynamicLibraryWriter<ELFT>::createImplicitFiles(
+void AArch64DynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
-  return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h

 template <class ELFT>
 class AArch64ExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   AArch64ExecutableWriter(AArch64LinkingContext &ctx,
                           TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     return ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override{
     return ExecutableWriter<ELFT>::addDefaultAtoms();
   }

 
 template <class ELFT>
 AArch64ExecutableWriter<ELFT>::AArch64ExecutableWriter(
     AArch64LinkingContext &ctx, TargetLayout<ELFT> &layout)
     : ExecutableWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)),
       _ctx(ctx), _layout(layout) {}
 
 template <class ELFT>
-bool AArch64ExecutableWriter<ELFT>::createImplicitFiles(
+void AArch64ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
   if (_ctx.isDynamic())
     _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
-  return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

 
 template <class ELFT>
 class ARMExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   ARMExecutableWriter(ARMLinkingContext &ctx, ARMTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
 
   void addDefaultAtoms() override {
     ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
   /// \brief Create symbol table.

 };
 
 template <class ELFT>
 ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &ctx,
                                                ARMTargetLayout<ELFT> &layout)
     : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _armLayout(layout) {}
 
 template <class ELFT>
-bool ARMExecutableWriter<ELFT>::createImplicitFiles(
+void ARMExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
-  return true;
 }
 
 template <class ELFT>
 void ARMExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   AtomLayout *gotAtom = _armLayout.findAbsoluteAtom(gotSymbol);
   if (gotAtom) {

lib/ReaderWriter/ELF/DynamicLibraryWriter.h

 public:
   DynamicLibraryWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
       : OutputELFWriter<ELFT>(ctx, layout),
         _runtimeFile(new RuntimeFile<ELFT>(ctx, "C runtime")) {}
 
 protected:
   void buildDynamicSymbolTable(const File &file) override;
   void addDefaultAtoms() override;
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
   void finalizeDefaultAtomValues() override;
 
 protected:
   std::unique_ptr<RuntimeFile<ELFT> > _runtimeFile;
 };
 
 //===----------------------------------------------------------------------===//
 //  DynamicLibraryWriter

 
 template <class ELFT> void DynamicLibraryWriter<ELFT>::addDefaultAtoms() {
   OutputELFWriter<ELFT>::addDefaultAtoms();
   _runtimeFile->addAbsoluteAtom("_end");
 }
 
 /// \brief Hook in lld to add CRuntime file
 template <class ELFT>
-bool DynamicLibraryWriter<ELFT>::createImplicitFiles(
+void DynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &result) {
   // Add the default atoms as defined by executables
   DynamicLibraryWriter<ELFT>::addDefaultAtoms();
   OutputELFWriter<ELFT>::createImplicitFiles(result);
   result.push_back(std::move(_runtimeFile));
-  return true;
 }
 
 template <class ELFT>
 void DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
   lld::AtomLayout *underScoreEndAtom = this->_layout.findAbsoluteAtom("_end");
   assert(underScoreEndAtom);
 

lib/ReaderWriter/ELF/ExecutableWriter.h

 public:
   ExecutableWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
       : OutputELFWriter<ELFT>(ctx, layout),
         _runtimeFile(new RuntimeFile<ELFT>(ctx, "C runtime")) {}
 
 protected:
   void buildDynamicSymbolTable(const File &file) override;
   void addDefaultAtoms() override;
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
   void finalizeDefaultAtomValues() override;
   void createDefaultSections() override;
 
   bool isNeededTagRequired(const SharedLibraryAtom *sla) const override {
     return this->_layout.isCopied(sla);
   }
 
   unique_bump_ptr<InterpSection<ELFT>> _interpSection;
if (this->_ctx.isRelaOutputFormat()) {
     _runtimeFile->addAbsoluteAtom("__rel_iplt_end");
   }
   _runtimeFile->addAbsoluteAtom("__fini_array_start");
   _runtimeFile->addAbsoluteAtom("__fini_array_end");
 }
 
 /// \brief Hook in lld to add CRuntime file
 template <class ELFT>
-bool ExecutableWriter<ELFT>::createImplicitFiles(
+void ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &result) {
   // Add the default atoms as defined by executables
   ExecutableWriter<ELFT>::addDefaultAtoms();
   OutputELFWriter<ELFT>::createImplicitFiles(result);
   result.push_back(std::move(_runtimeFile));
-  return true;
 }
 
 template <class ELFT> void ExecutableWriter<ELFT>::createDefaultSections() {
   OutputELFWriter<ELFT>::createDefaultSections();
   if (this->_ctx.isDynamic()) {
     _interpSection.reset(new (this->_alloc) InterpSection<ELFT>(
         this->_ctx, ".interp", TargetLayout<ELFT>::ORDER_INTERP,
         this->_ctx.getInterpreter()));

lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h

 template <class ELFT>
 class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
   HexagonDynamicLibraryWriter(HexagonLinkingContext &ctx,
                               HexagonTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
     DynamicLibraryWriter<ELFT>::setELFHeader();
     setHexagonELFHeader(*this->_elfHeader);
     return std::error_code();
   }

 
 template <class ELFT>
 HexagonDynamicLibraryWriter<ELFT>::HexagonDynamicLibraryWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
     : DynamicLibraryWriter<ELFT>(ctx, layout), _ctx(ctx), _targetLayout(layout),
       _runtimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
 
 template <class ELFT>
-bool HexagonDynamicLibraryWriter<ELFT>::createImplicitFiles(
+void HexagonDynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
   result.push_back(std::move(_runtimeFile));
-  return true;
 }
 
 template <class ELFT>
 void HexagonDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   if (_ctx.isDynamic())
     finalizeHexagonRuntimeAtomValues(_targetLayout);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_DYNAMIC_LIBRARY_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h

 template <class ELFT>
 class HexagonExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   HexagonExecutableWriter(HexagonLinkingContext &ctx,
                           HexagonTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
     ExecutableWriter<ELFT>::setELFHeader();
     setHexagonELFHeader(*this->_elfHeader);
     return std::error_code();
   }

 
 template <class ELFT>
 HexagonExecutableWriter<ELFT>::HexagonExecutableWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
     : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _targetLayout(layout),
       _runtimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
 
 template <class ELFT>
-bool HexagonExecutableWriter<ELFT>::createImplicitFiles(
+void HexagonExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
   result.push_back(std::move(_runtimeFile));
-  return true;
 }
 
 template <class ELFT>
 void HexagonExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   AtomLayout *sdabaseAtom = _targetLayout.findAbsoluteAtom("_SDA_BASE_");
   sdabaseAtom->_virtualAddr = _targetLayout.getSDataSection()->virtualAddr();
   if (_ctx.isDynamic())
     finalizeHexagonRuntimeAtomValues(_targetLayout);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

 template <class ELFT>
 class MipsDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
   MipsDynamicLibraryWriter(MipsLinkingContext &ctx,
                            MipsTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
   void createDefaultSections() override;
 
   std::error_code setELFHeader() override {
     DynamicLibraryWriter<ELFT>::setELFHeader();
     _writeHelper.setELFHeader(*this->_elfHeader);
     return std::error_code();

 
 template <class ELFT>
 MipsDynamicLibraryWriter<ELFT>::MipsDynamicLibraryWriter(
     MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout)
     : DynamicLibraryWriter<ELFT>(ctx, layout), _writeHelper(ctx, layout),
       _targetLayout(layout) {}
 
 template <class ELFT>
-bool MipsDynamicLibraryWriter<ELFT>::createImplicitFiles(
+void MipsDynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   result.push_back(std::move(_writeHelper.createRuntimeFile()));
-  return true;
 }
 
 template <class ELFT>
 void MipsDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   _writeHelper.finalizeMipsRuntimeAtomValues();
 }

lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h

 class MipsExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   MipsExecutableWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout);
 
 protected:
   void buildDynamicSymbolTable(const File &file) override;
 
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
   void createDefaultSections() override;
   std::error_code setELFHeader() override;
 
   unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override;
   unique_bump_ptr<DynamicTable<ELFT>> createDynamicTable() override;
   unique_bump_ptr<DynamicSymbolTable<ELFT>> createDynamicSymbolTable() override;
void MipsExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
 
   // Skip our immediate parent class method
   // ExecutableWriter<ELFT>::buildDynamicSymbolTable because we replaced it
   // with our own version. Call OutputELFWriter directly.
   OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
 }
 
 template <class ELFT>
-bool MipsExecutableWriter<ELFT>::createImplicitFiles(
+void MipsExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   result.push_back(std::move(_writeHelper.createRuntimeFile()));
-  return true;
 }
 
 template <class ELFT>
 void MipsExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   _writeHelper.finalizeMipsRuntimeAtomValues();
 }

lib/ReaderWriter/ELF/OutputELFWriter.h

protected:
   // Assign sections that have no segments such as the symbol table,
   // section header table, string table etc
   virtual void assignSectionsWithNoSegments();
 
   // Add default atoms that need to be present in the output file
   virtual void addDefaultAtoms();
 
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   // Finalize the default atom values
   virtual void finalizeDefaultAtomValues();
 
   // This is called by the write section to apply relocations
   uint64_t addressOfAtom(const Atom *atom) override {
     auto addr = _atomToAddressMap.find(atom);
     return addr == _atomToAddressMap.end() ? 0 : addr->second;

 template <class ELFT> void OutputELFWriter<ELFT>::addDefaultAtoms() {
   const llvm::StringSet<> &symbols =
       _ctx.linkerScriptSema().getScriptDefinedSymbols();
   for (auto &sym : symbols)
     _scriptFile->addAbsoluteAtom(sym.getKey());
 }
 
 template <class ELFT>
-bool OutputELFWriter<ELFT>::createImplicitFiles(
+void OutputELFWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   // Add the virtual archive to resolve undefined symbols.
   // The file will be added later in the linking context.
   auto callback = [this](StringRef sym, RuntimeFile<ELFT> &file) {
     processUndefinedSymbol(sym, file);
   };
   auto &ctx = const_cast<ELFLinkingContext &>(_ctx);
   ctx.setUndefinesResolver(
       llvm::make_unique<DynamicSymbolFile<ELFT>>(ctx, std::move(callback)));
   // Add script defined symbols
   result.push_back(std::move(_scriptFile));
-  return true;
 }
 
 template <class ELFT>
 void OutputELFWriter<ELFT>::finalizeDefaultAtomValues() {
   const llvm::StringSet<> &symbols =
       _ctx.linkerScriptSema().getScriptDefinedSymbols();
   for (auto &sym : symbols) {
     uint64_t res =

lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h

 
 template <class ELFT>
 class X86DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
   X86DynamicLibraryWriter(X86LinkingContext &ctx, TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     return DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override {
     return DynamicLibraryWriter<ELFT>::addDefaultAtoms();
   }

 
 template <class ELFT>
 X86DynamicLibraryWriter<ELFT>::X86DynamicLibraryWriter(
     X86LinkingContext &ctx, TargetLayout<ELFT> &layout)
     : DynamicLibraryWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)),
       _ctx(ctx), _layout(layout) {}
 
 template <class ELFT>
-bool X86DynamicLibraryWriter<ELFT>::createImplicitFiles(
+void X86DynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
-  return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h

 
 template <class ELFT>
 class X86ExecutableWriter : public ExecutableWriter<ELFT> {
 public:
   X86ExecutableWriter(X86LinkingContext &ctx, TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     return ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override {
     return ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
 private:
   X86LinkingContext &_ctx;
   TargetLayout<ELFT> &_layout;
 };
 
 template <class ELFT>
 X86ExecutableWriter<ELFT>::X86ExecutableWriter(X86LinkingContext &ctx,
                                                TargetLayout<ELFT> &layout)
     : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _layout(layout) {}
 
 template <class ELFT>
-bool X86ExecutableWriter<ELFT>::createImplicitFiles(
+void X86ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
-  return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

 
 class X86_64DynamicLibraryWriter : public DynamicLibraryWriter<X86_64ELFType> {
 public:
   X86_64DynamicLibraryWriter(X86_64LinkingContext &ctx,
                              X86_64TargetLayout &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     return DynamicLibraryWriter::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override {
     return DynamicLibraryWriter::addDefaultAtoms();
   }
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
   std::unique_ptr<GOTFile> _gotFile;
 };
 
 X86_64DynamicLibraryWriter::X86_64DynamicLibraryWriter(
     X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
     : DynamicLibraryWriter(ctx, layout), _gotFile(new GOTFile(ctx)) {}
 
-bool X86_64DynamicLibraryWriter::createImplicitFiles(
+void X86_64DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
-  return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h

 
 class X86_64ExecutableWriter : public ExecutableWriter<X86_64ELFType> {
 public:
   X86_64ExecutableWriter(X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
       : ExecutableWriter(ctx, layout), _gotFile(new GOTFile(ctx)), _ctx(ctx) {}
 
 protected:
   // Add any runtime files and their atoms to the output
-  bool
+  void
   createImplicitFiles(std::vector<std::unique_ptr<File>> &result) override {
     ExecutableWriter::createImplicitFiles(result);
     _gotFile->addAtom(*new (_gotFile->_alloc)
                       GlobalOffsetTableAtom(*_gotFile));
     if (_ctx.isDynamic())
       _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
     result.push_back(std::move(_gotFile));
-    return true;
   }
 
   void finalizeDefaultAtomValues() override {
     return ExecutableWriter::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override {
     return ExecutableWriter::addDefaultAtoms();

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 uint32_t MachOLinkingContext::dylibCompatVersion(StringRef installName) const {
   auto pos = _pathToDylibMap.find(installName);
   if (pos != _pathToDylibMap.end())
     return pos->second->compatVersion();
   else
     return 0x1000; // 1.0
 }
 
-bool MachOLinkingContext::createImplicitFiles(
+void MachOLinkingContext::createImplicitFiles(
                             std::vector<std::unique_ptr<File> > &result) {
   // Add indirect dylibs by asking each linked dylib to add its indirects.
   // Iterate until no more dylibs get loaded.
   size_t dylibCount = 0;
   while (dylibCount != _allDylibs.size()) {
     dylibCount = _allDylibs.size();
     for (MachODylibFile *dylib : _allDylibs) {
       dylib->loadReExportedDylibs([this] (StringRef path) -> MachODylibFile* {
                                   return findIndirectDylib(path); });
     }
   }
 
   // Let writer add output type specific extras.
-  return writer().createImplicitFiles(result);
+  writer().createImplicitFiles(result);
 }
 
 
 void MachOLinkingContext::registerDylib(MachODylibFile *dylib,
                                         bool upward) const {
   _allDylibs.insert(dylib);
   _pathToDylibMap[dylib->installName()] = dylib;
   // If path is different than install name, register path too.

lib/ReaderWriter/MachO/WriterMachO.cpp

if (_context.printAtoms()) {
       std::unique_ptr<Writer> yamlWriter = createWriterYAML(_context);
       yamlWriter->writeFile(file, "-");
     }
 
     // Write normalized file as mach-o binary.
     return writeBinary(*nFile->get(), path);
   }
 
-  bool createImplicitFiles(std::vector<std::unique_ptr<File> > &r) override {
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &r) override {
     // When building main executables, add _main as required entry point.
     if (_context.outputTypeHasEntry())
       r.emplace_back(new CEntryFile(_context));
     // If this can link with dylibs, need helper function (dyld_stub_binder).
     if (_context.needsStubsPass())
       r.emplace_back(new StubHelperFile(_context));
     // Final linked images can access a symbol for their mach_header.
     if (_context.outputMachOType() != llvm::MachO::MH_OBJECT)
       r.emplace_back(new MachHeaderAliasFile(_context));
-
-    return true;
   }
 private:
    const MachOLinkingContext  &_context;
  };
 
 
 } // namespace mach_o
 
 std::unique_ptr<Writer> createWriterMachO(const MachOLinkingContext &context) {
   return std::unique_ptr<Writer>(new lld::mach_o::MachOWriter(context));
 }
 
 } // namespace lld

lib/ReaderWriter/PECOFF/PECOFFLinkingContext.cpp

for (int i = 0, e = elements.size(); i < e; ++i) {
     }
   }
   assert(pos >= 0);
   elements.insert(elements.begin() + pos, std::move(file));
   elements[pos + 1] = llvm::make_unique<GroupEnd>(
       currentGroupEnd->getSize() + 1);
 }
 
-bool PECOFFLinkingContext::createImplicitFiles(
+void PECOFFLinkingContext::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &) {
   std::vector<std::unique_ptr<Node>> &members = getNodes();
 
   // Create a file for the entry point function.
   std::unique_ptr<FileNode> entry(new FileNode(
       llvm::make_unique<pecoff::EntryPointFile>(*this)));
   members.insert(members.begin() + getGroupStartPos(members), std::move(entry));
 
   // Create a file for __ImageBase.
   std::unique_ptr<FileNode> fileNode(new FileNode(
       llvm::make_unique<pecoff::LinkerGeneratedSymbolFile>(*this)));
   members.push_back(std::move(fileNode));
 
   // Create a file for _imp_ symbols.
   std::unique_ptr<FileNode> impFileNode(new FileNode(
       llvm::make_unique<pecoff::LocallyImportedSymbolFile>(*this)));
   members.push_back(std::move(impFileNode));
 
   // Create a file for dllexported symbols.
   std::unique_ptr<FileNode> exportNode(new FileNode(
       llvm::make_unique<pecoff::ExportedSymbolRenameFile>(*this)));
   addLibraryFile(std::move(exportNode));
-
-  return true;
 }
 
 /// Returns the section name in the resulting executable.
 ///
 /// Sections in object files are usually output to the executable with the same
 /// name, but you can rename by command line option. /merge:from=to makes the
 /// linker to combine "from" section contents to "to" section in the
 /// executable. We have a mapping for the renaming. This method looks up the