[LLD] Fix some 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/Simple.h

 /// \file
 /// \brief Provide simple implementations for Atoms and File.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_SIMPLE_H
 #define LLD_CORE_SIMPLE_H
 
+#include "lld/Core/AbsoluteAtom.h"
+#include "lld/Core/Atom.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LinkingContext.h"
 #include "lld/Core/Reference.h"
+#include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/UndefinedAtom.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist.h"
-#include "llvm/ADT/ilist_node.h"
-#include <atomic>
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <functional>
 
 namespace lld {
 
 class SimpleFile : public File {
 public:
   SimpleFile(StringRef path, File::Kind kind)
     : File(path, kind) {}
 

 private:
   const Atom *_target;
   uint64_t _offsetInAtom;
   Addend _addend;
   SimpleReference *_next;
   SimpleReference *_prev;
 };
 
-}
+} // end namespace lld
 
 // ilist will lazily create a sentinal (so end() can return a node past the
 // end of the list). We need this trait so that the sentinal is allocated
 // via the BumpPtrAllocator.
 namespace llvm {
+
 template<>
 struct ilist_sentinel_traits<lld::SimpleReference> {
 
   ilist_sentinel_traits() : _allocator(nullptr) { }
 
   void setAllocator(llvm::BumpPtrAllocator *alloc) {
     _allocator = alloc;
   }
struct ilist_sentinel_traits<lld::SimpleReference> {
   void noteHead(lld::SimpleReference *newHead,
                 lld::SimpleReference *sentinel) const {
     ilist_traits<lld::SimpleReference>::setPrev(newHead, sentinel);
   }
 
 private:
   mutable llvm::BumpPtrAllocator *_allocator;
 };
-}
+
+} // end namespace llvm
 
 namespace lld {
 
 class SimpleDefinedAtom : public DefinedAtom {
 public:
   explicit SimpleDefinedAtom(const File &f)
     : _file(f), _ordinal(f.getNextAtomOrdinalAndIncrement()) {
     _references.setAllocator(&f.allocator());
   }
 
-  ~SimpleDefinedAtom() {
+  ~SimpleDefinedAtom() override {
     _references.clearAndLeakNodesUnsafely();
   }
 
   const File &file() const override { return _file; }
 
   StringRef name() const override { return StringRef(); }
 
   uint64_t ordinal() const override { return _ordinal; }
std::sort(elements.begin(), elements.end(),
             return (lhs->kindArch() < rhs->kindArch());
           return (lhs->kindValue() < rhs->kindValue());
         });
     _references.clearAndLeakNodesUnsafely();
     for (SimpleReference *node : elements) {
       _references.push_back(node);
     }
   }
+
   void setOrdinal(uint64_t ord) { _ordinal = ord; }
 
 private:
   typedef llvm::ilist<SimpleReference> RefList;
 
   const File &_file;
   uint64_t _ordinal;
   mutable RefList _references;

 
 private:
   const File &_file;
   StringRef _name;
 };
 
 } // end namespace lld
 
-#endif
+#endif // LLD_CORE_SIMPLE_H

lld/trunk/lib/ReaderWriter/MachO/Atoms.h

-//===- lib/ReaderWriter/MachO/Atoms.h -------------------------------------===//
+//===- lib/ReaderWriter/MachO/Atoms.h ---------------------------*- C++ -*-===//
 //
 //                             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_ATOMS_H
 #define LLD_READER_WRITER_MACHO_ATOMS_H
 
+#include "lld/Core/Atom.h"
+#include "lld/Core/DefinedAtom.h"
+#include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/Simple.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include <cstdint>
+#include <string>
 
 namespace lld {
+
+class File;
+
 namespace mach_o {
+
 class MachODefinedAtom : public SimpleDefinedAtom {
 public:
   MachODefinedAtom(const File &f, const StringRef name, Scope scope,
                    ContentType type, Merge merge, bool thumb, bool noDeadStrip,
                    const ArrayRef<uint8_t> content, Alignment align)
       : SimpleDefinedAtom(f), _name(name), _content(content),
         _align(align), _contentType(type), _scope(scope), _merge(merge),
         _thumb(thumb), _noDeadStrip(noDeadStrip) {}
public:
   }
 
 private:
   const File &_file;
   StringRef _name;
   StringRef _dylibInstallName;
 };
 
-} // namespace mach_o
-} // namespace lld
+} // end namespace mach_o
+} // end namespace lld
 
 #endif // LLD_READER_WRITER_MACHO_ATOMS_H

lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 //===- lib/ReaderWriter/YAML/ReaderWriterYAML.cpp -------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "lld/Core/AbsoluteAtom.h"
 #include "lld/Core/ArchiveLibraryFile.h"
+#include "lld/Core/Atom.h"
 #include "lld/Core/DefinedAtom.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
-#include "lld/Core/LLVM.h"
+#include "lld/Core/LinkingContext.h"
 #include "lld/Core/Reader.h"
 #include "lld/Core/Reference.h"
+#include "lld/Core/SharedLibraryAtom.h"
 #include "lld/Core/Simple.h"
+#include "lld/Core/UndefinedAtom.h"
 #include "lld/Core/Writer.h"
 #include "lld/ReaderWriter/YamlContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <cstdint>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <system_error>
+#include <vector>
 
 using llvm::yaml::MappingTraits;
 using llvm::yaml::ScalarEnumerationTraits;
 using llvm::yaml::ScalarTraits;
 using llvm::yaml::IO;
 using llvm::yaml::SequenceTraits;
 using llvm::yaml::DocumentListTraits;
 

 // lld::Reference::Kind is a tuple of <namespace, arch, value>.
 // For yaml, we just want one string that encapsulates the tuple.
 struct RefKind {
   Reference::KindNamespace  ns;
   Reference::KindArch       arch;
   Reference::KindValue      value;
 };
 
-} // anonymous namespace
+} // end anonymous namespace
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(ArchMember)
 LLVM_YAML_IS_SEQUENCE_VECTOR(const lld::Reference *)
 // Always write DefinedAtoms content bytes as a flow sequence.
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(ImplicitHex8)
 // for compatibility with gcc-4.7 in C++11 mode, add extra namespace
 namespace llvm {
 namespace yaml {
const lld::DefinedAtom *denormalize(IO &io) {
       if (!_sectionName.empty())
         _sectionName = f->copyString(_sectionName);
       DEBUG_WITH_TYPE("WriterYAML",
                       llvm::dbgs() << "created DefinedAtom named: '" << _name
                                    << "' (" << (const void *)_name.data()
                                    << ", " << _name.size() << ")\n");
       return this;
     }
+
     void bind(const RefNameResolver &);
+
     // Extract current File object from YAML I/O parsing context
     const lld::File &fileFromContext(IO &io) {
       YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
       assert(info != nullptr);
       assert(info->_file != nullptr);
       return *info->_file;
     }
 
static void mapping(IO &io, lld::UndefinedAtom *&atom) {
     const lld::UndefinedAtom *atomPtr = atom;
     MappingTraits<const lld::UndefinedAtom *>::mapping(io, atomPtr);
     atom = const_cast<lld::UndefinedAtom *>(atomPtr);
   }
 };
 
 // YAML conversion for const lld::SharedLibraryAtom*
 template <> struct MappingTraits<const lld::SharedLibraryAtom *> {
-
   class NormalizedAtom : public lld::SharedLibraryAtom {
   public:
     NormalizedAtom(IO &io)
         : _file(fileFromContext(io)), _name(), _loadName(), _canBeNull(false),
           _type(Type::Unknown), _size(0) {}
     NormalizedAtom(IO &io, const lld::SharedLibraryAtom *atom)
         : _file(fileFromContext(io)), _name(atom->name()),
           _loadName(atom->loadName()), _canBeNull(atom->canBeNullAtRuntime()),

 template <> struct MappingTraits<lld::AbsoluteAtom *> {
   static void mapping(IO &io, lld::AbsoluteAtom *&atom) {
     const lld::AbsoluteAtom *atomPtr = atom;
     MappingTraits<const lld::AbsoluteAtom *>::mapping(io, atomPtr);
     atom = const_cast<lld::AbsoluteAtom *>(atomPtr);
   }
 };
 
-} // namespace llvm
-} // namespace yaml
+} // end namespace llvm
+} // end namespace yaml
 
 RefNameResolver::RefNameResolver(const lld::File *file, IO &io) : _io(io) {
   typedef MappingTraits<const lld::DefinedAtom *>::NormalizedAtom
   NormalizedAtom;
   for (const lld::DefinedAtom *a : file->defined()) {
     const auto *na = (const NormalizedAtom *)a;
     if (!na->_refName.empty())
       add(na->_refName, a);
loadFile(std::unique_ptr<MemoryBuffer> mb,
     f->setSharedMemoryBuffer(smb);
     return std::unique_ptr<File>(f);
   }
 
 private:
   const Registry &_registry;
 };
 
-} // anonymous namespace
+} // end anonymous namespace
 
 void Registry::addSupportYamlFiles() {
   add(std::unique_ptr<Reader>(new YAMLReader(*this)));
   add(std::unique_ptr<YamlIOTaggedDocumentHandler>(
                                     new NativeYamlIOTaggedDocumentHandler()));
   add(std::unique_ptr<YamlIOTaggedDocumentHandler>(
                                     new ArchiveYamlIOTaggedDocumentHandler()));
 }
 
 std::unique_ptr<Writer> createWriterYAML(const LinkingContext &context) {
   return std::unique_ptr<Writer>(new lld::yaml::Writer(context));
 }
 
 } // end namespace lld