[LLD] Fix some Clang-tidy modernize-use-default and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[ruiu]

LGTM

lld/trunk/include/lld/Core/Atom.h

-//===- Core/Atom.h - A node in linking graph ------------------------------===//
+//===- Core/Atom.h - A node in linking graph --------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_ATOM_H
 #define LLD_CORE_ATOM_H
 
 #include "lld/Core/LLVM.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace lld {
 
 class File;
 
 template<typename T>
 class OwningAtomPtr;
 
 ///
 /// The linker has a Graph Theory model of linking. An object file is seen
 /// as a set of Atoms with References to other Atoms.  Each Atom is a node
 /// and each Reference is an edge. An Atom can be a DefinedAtom which has
 /// content or a UndefinedAtom which is a placeholder and represents an
 /// undefined symbol (extern declaration).
 ///
 class Atom {
   template<typename T> friend class OwningAtomPtr;
+
 public:
   /// Whether this atom is defined or a proxy for an undefined symbol
   enum Definition {
     definitionRegular,      ///< Normal C/C++ function or global variable.
     definitionAbsolute,     ///< Asm-only (foo = 10). Not tied to any content.
     definitionUndefined,    ///< Only in .o files to model reference to undef.
     definitionSharedLibrary ///< Only in shared libraries to model export.
   };
 
   /// The scope in which this atom is acessible to other atoms.
   enum Scope {
     scopeTranslationUnit,  ///< Accessible only to atoms in the same translation
                            ///  unit (e.g. a C static).
     scopeLinkageUnit,      ///< Accessible to atoms being linked but not visible
                            ///  to runtime loader (e.g. visibility=hidden).
     scopeGlobal            ///< Accessible to all atoms and visible to runtime
                            ///  loader (e.g. visibility=default).
   };
 
-
   /// file - returns the File that produced/owns this Atom
   virtual const File& file() const = 0;
 
   /// name - The name of the atom. For a function atom, it is the (mangled)
   /// name of the function.
   virtual StringRef name() const = 0;
 
   /// definition - Whether this atom is a definition or represents an undefined
   /// symbol.
   Definition definition() const { return _definition; }
 
   static bool classof(const Atom *a) { return true; }
 
 protected:
   /// Atom is an abstract base class.  Only subclasses can access constructor.
   explicit Atom(Definition def) : _definition(def) {}
 
   /// The memory for Atom objects is always managed by the owning File
   /// object.  Therefore, no one but the owning File object should call
   /// delete on an Atom.  In fact, some File objects may bulk allocate
   /// an array of Atoms, so they cannot be individually deleted by anyone.
-  virtual ~Atom() {}
+  virtual ~Atom() = default;
 
 private:
   Definition _definition;
 };
 
 /// Class which owns an atom pointer and runs the atom destructor when the
 /// owning pointer goes out of scope.
 template<typename T>
 class OwningAtomPtr {
 private:
   OwningAtomPtr(const OwningAtomPtr &) = delete;
-  void operator=(const OwningAtomPtr&) = delete;
+  void operator=(const OwningAtomPtr &) = delete;
+
 public:
-  OwningAtomPtr() : atom(nullptr) { }
+  OwningAtomPtr() = default;
   OwningAtomPtr(T *atom) : atom(atom) { }
 
   ~OwningAtomPtr() {
     if (atom)
       runDestructor(atom);
   }
 
   void runDestructor(Atom *atom) {
public:
 
   T *release() {
     auto *v = atom;
     atom = nullptr;
     return v;
   }
 
 private:
-  T *atom;
+  T *atom = nullptr;
 };
 
-} // namespace lld
+} // end namespace lld
 
 #endif // LLD_CORE_ATOM_H

lld/trunk/include/lld/Core/LinkingContext.h

-//===- lld/Core/LinkingContext.h - Linker Target Info Interface -----------===//
+//===- lld/Core/LinkingContext.h - Linker Target Info Interface -*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_LINKING_CONTEXT_H
 #define LLD_CORE_LINKING_CONTEXT_H
 
-#include "lld/Core/Error.h"
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Node.h"
-#include "lld/Core/Reference.h"
 #include "lld/Core/Reader.h"
-#include "llvm/Support/ErrorOr.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
 namespace lld {
+
 class PassManager;
 class File;
 class Writer;
 class Node;
 class SharedLibraryFile;
 
 /// \brief The LinkingContext class encapsulates "what and how" to link.
 ///
public:
   // the symbol if your platform supports dead-stripping, so that the symbol
   // will not be removed from the output.
   void setEntrySymbolName(StringRef name) {
     _entrySymbolName = name;
   }
 
   void setDeadStripping(bool enable) { _deadStrip = enable; }
   void setGlobalsAreDeadStripRoots(bool v) { _globalsAreDeadStripRoots = v; }
+
   void setPrintRemainingUndefines(bool print) {
     _printRemainingUndefines = print;
   }
+
   void setAllowRemainingUndefines(bool allow) {
     _allowRemainingUndefines = allow;
   }
+
   void setAllowShlibUndefines(bool allow) { _allowShlibUndefines = allow; }
   void setLogInputFiles(bool log) { _logInputFiles = log; }
 
   void appendLLVMOption(const char *opt) { _llvmOptions.push_back(opt); }
 
   std::vector<std::unique_ptr<Node>> &getNodes() { return _nodes; }
   const std::vector<std::unique_ptr<Node>> &getNodes() const { return _nodes; }
 
public:
   typedef std::vector<StringRef> StringRefVector;
   typedef StringRefVector::iterator StringRefVectorIter;
   typedef StringRefVector::const_iterator StringRefVectorConstIter;
 
   /// Create linker internal files containing atoms for the linker to include
   /// during link. Flavors can override this function in their LinkingContext
   /// to add more internal files. These internal files are positioned before
   /// the actual input files.
-  virtual void createInternalFiles(std::vector<std::unique_ptr<File> > &) const;
+  virtual void createInternalFiles(std::vector<std::unique_ptr<File>> &) const;
 
   /// Return the list of undefined symbols that are specified in the
   /// linker command line, using the -u option.
   ArrayRef<StringRef> initialUndefinedSymbols() const {
     return _initialUndefinedSymbols;
   }
 
   /// After all set* methods are called, the Driver calls this method

 
 private:
   /// Validate the subclass bits. Only called by validate.
   virtual bool validateImpl(raw_ostream &diagnostics) = 0;
 };
 
 } // end namespace lld
 
-#endif
+#endif // LLD_CORE_LINKING_CONTEXT_H

lld/trunk/include/lld/Core/Node.h

-//===- lld/Core/Node.h - Input file class ---------------------------------===//
+//===- lld/Core/Node.h - Input file class -----------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// The classes in this file represents inputs to the linker.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_NODE_H
 #define LLD_CORE_NODE_H
 
 #include "lld/Core/File.h"
-#include "llvm/Option/ArgList.h"
+#include <algorithm>
 #include <memory>
-#include <vector>
 
 namespace lld {
 
 // A Node represents a FileNode or other type of Node. In the latter case,
 // the node contains meta information about the input file list.
 // Currently only GroupEnd node is defined as a meta node.
 class Node {
 public:
   enum class Kind { File, GroupEnd };
+
   explicit Node(Kind type) : _kind(type) {}
-  virtual ~Node() {}
+  virtual ~Node() = default;
+
   virtual Kind kind() const { return _kind; }
 
 private:
   Kind _kind;
 };
 
 // This is a marker for --end-group. getSize() returns the number of
 // files between the corresponding --start-group and this marker.
public:
   }
 
   File *getFile() { return _file.get(); }
 
 protected:
   std::unique_ptr<File> _file;
 };
 
-} // namespace lld
+} // end namespace lld
 
 #endif // LLD_CORE_NODE_H

lld/trunk/include/lld/Core/Reader.h

 //===- lld/Core/Reader.h - Abstract File Format Reading Interface ---------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_READER_H
 #define LLD_CORE_READER_H
 
-#include "lld/Core/LLVM.h"
 #include "lld/Core/Reference.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/YAMLTraits.h"
-#include <functional>
+#include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 #include <vector>
 
 using llvm::sys::fs::file_magic;
 
 namespace llvm {
 namespace yaml {
 class IO;
-}
-}
+} // end namespace yaml
+} // end namespace llvm
 
 namespace lld {
+
 class File;
 class LinkingContext;
 class MachOLinkingContext;
 
 /// \brief An abstract class for reading object files, library files, and
 /// executable files.
 ///
 /// Each file format (e.g. mach-o, etc) has a concrete subclass of Reader.
 class Reader {
 public:
-  virtual ~Reader() {}
+  virtual ~Reader() = default;
 
   /// Sniffs the file to determine if this Reader can parse it.
   /// The method is called with:
   /// 1) the file_magic enumeration returned by identify_magic()
   /// 2) the whole file content buffer if the above is not enough.
   virtual bool canParse(file_magic magic, MemoryBufferRef mb) const = 0;
 
   /// \brief Parse a supplied buffer (already filled with the contents of a
   /// file) and create a File object.
   /// The resulting File object takes ownership of the MemoryBuffer.
   virtual ErrorOr<std::unique_ptr<File>>
   loadFile(std::unique_ptr<MemoryBuffer> mb, const class Registry &) const = 0;
 };
 
-
 /// \brief An abstract class for handling alternate yaml representations
 /// of object files.
 ///
 /// The YAML syntax allows "tags" which are used to specify the type of
 /// the YAML node.  In lld, top level YAML documents can be in many YAML
 /// representations (e.g mach-o encoded as yaml, etc).  A tag is used to
 /// specify which representation is used in the following YAML document.
 /// To work, there must be a YamlIOTaggedDocumentHandler registered that
 /// handles each tag type.
 class YamlIOTaggedDocumentHandler {
 public:
   virtual ~YamlIOTaggedDocumentHandler();
 
   /// This method is called on each registered YamlIOTaggedDocumentHandler
   /// until one returns true.  If the subclass handles tag type !xyz, then
   /// this method should call io.mapTag("!xzy") to see if that is the current
   /// document type, and if so, process the rest of the document using
   /// YAML I/O, then convert the result into an lld::File* and return it.
   virtual bool handledDocTag(llvm::yaml::IO &io, const lld::File *&f) const = 0;
 };
 
-
 /// A registry to hold the list of currently registered Readers and
 /// tables which map Reference kind values to strings.
 /// The linker does not directly invoke Readers.  Instead, it registers
 /// Readers based on it configuration and command line options, then calls
 /// the Registry object to parse files.
 class Registry {
 public:
   Registry();
public:
   };
 
   /// A Reference Kind value is a tuple of <namespace, arch, value>.  All
   /// entries in a conversion table have the same <namespace, arch>.  The
   /// array then contains the value/name pairs.
   void addKindTable(Reference::KindNamespace ns, Reference::KindArch arch,
                     const KindStrings array[]);
 
-
 private:
   struct KindEntry {
     Reference::KindNamespace  ns;
     Reference::KindArch       arch;
     const KindStrings        *array;
   };
 
   void add(std::unique_ptr<Reader>);

 //      LLD_KIND_STRING_ENTRY(R_VAX_DATA16),
 //      LLD_KIND_STRING_END
 //   };
 #define LLD_KIND_STRING_ENTRY(name) { name, #name }
 #define LLD_KIND_STRING_END         { 0,    "" }
 
 } // end namespace lld
 
-#endif
+#endif // LLD_CORE_READER_H

lld/trunk/lib/Core/LinkingContext.cpp

 //===- lib/Core/LinkingContext.cpp - Linker Context Object Interface ------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Core/LinkingContext.h"
-#include "lld/Core/Resolver.h"
+#include "lld/Core/File.h"
+#include "lld/Core/Node.h"
 #include "lld/Core/Simple.h"
 #include "lld/Core/Writer.h"
-#include "llvm/ADT/Triple.h"
+#include <algorithm>
 
 namespace lld {
 
-LinkingContext::LinkingContext() {}
+LinkingContext::LinkingContext() = default;
 
-LinkingContext::~LinkingContext() {}
+LinkingContext::~LinkingContext() = default;
 
 bool LinkingContext::validate(raw_ostream &diagnostics) {
   return validateImpl(diagnostics);
 }
 
 llvm::Error LinkingContext::writeFile(const File &linkedFile) const {
   return this->writer().writeFile(linkedFile, _outputPath);
 }
std::unique_ptr<SimpleFile> undefinedSymFile(
     new SimpleFile(filename, File::kindUndefinedSymsObject));
   for (StringRef undefSym : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) SimpleUndefinedAtom(
                                    *undefinedSymFile, undefSym)));
   return std::move(undefinedSymFile);
 }
 
 void LinkingContext::createInternalFiles(
-    std::vector<std::unique_ptr<File> > &result) const {
+    std::vector<std::unique_ptr<File>> &result) const {
   if (std::unique_ptr<File> file = createEntrySymbolFile())
     result.push_back(std::move(file));
   if (std::unique_ptr<File> file = createUndefinedSymbolFile())
     result.push_back(std::move(file));
 }
 
 } // end namespace lld

lld/trunk/lib/Driver/DarwinLdDriver.cpp

 //===- lib/Driver/DarwinLdDriver.cpp --------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// Concrete instance of the Driver for darwin's ld.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Instrumentation.h"
+#include "lld/Core/LLVM.h"
+#include "lld/Core/Node.h"
 #include "lld/Core/PassManager.h"
 #include "lld/Core/Resolver.h"
 #include "lld/Core/SharedLibraryFile.h"
-#include "lld/Driver/Driver.h"
+#include "lld/Core/Simple.h"
+#include "lld/Core/LinkingContext.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Option/OptTable.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/MachO.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <vector>
 
 using namespace lld;
 
 namespace {
 
 // Create enum with OPT_xxx values for each option in DarwinLdOptions.td
 enum {
   OPT_INVALID = 0,
loadFile(MachOLinkingContext &ctx, StringRef path,
   }
   if (wholeArchive)
     return parseMemberFiles(std::move(file));
   std::vector<std::unique_ptr<File>> files;
   files.push_back(std::move(file));
   return files;
 }
 
-} // anonymous namespace
+} // end anonymous namespace
 
 // Test may be running on Windows. Canonicalize the path
 // separator to '/' to get consistent outputs for tests.
 static std::string canonicalizePath(StringRef path) {
   char sep = llvm::sys::path::get_separator().front();
   if (sep != '/') {
     std::string fixedPath = path;
     std::replace(fixedPath.begin(), fixedPath.end(), sep, '/');
while (!buffer.empty()) {
     StringRef sym = symAndComment.first.trim();
     if (!sym.empty())
       ctx.addExportSymbol(sym);
     buffer = lineAndRest.second;
   }
   return std::error_code();
 }
 
-
-
 /// Order files are one symbol per line. Blank lines are ignored.
 /// Trailing comments start with #. Symbol names can be prefixed with an
 /// architecture name and/or .o leaf name.  Examples:
 ///     _foo
 ///     bar.o:_bar
 ///     libfrob.a(bar.o):_bar
 ///     x86_64:_foo64
 static std::error_code parseOrderFile(StringRef orderFilePath,
if (auto ec = ctx.writeFile(*merged)) {
     // to be passed a Twine instead of a string.
     diagnostics << "Failed to write file '" << ctx.outputPath() << "': ";
     logAllUnhandledErrors(std::move(ec), diagnostics, std::string());
     return false;
   }
 
   return true;
 }
-} // namespace mach_o
-} // namespace lld
+
+} // end namespace mach_o
+} // end namespace lld