[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.

[• rafael]

ELF/Target.cpp

35

I am not sure how to properly manage this include list if we are going the Include What You Use way. How do we make sure we are not including unnecessary headers?

[Eugene.Zelenko]

ELF/Target.cpp

35

Sure, Include What You Use may have false positives and it is not supporting libc++ well. But I manually checked that all added headers are used explicitly.

See D26320 as example where manual headers maintenance was less then adequate.

Please try Include What You Use. It prints used declarations in comments after each include directive.

COFF/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/LTO/legacy/LTOModule.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/COFF.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/StringSaver.h"
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <map>
 #include <memory>
 #include <mutex>
 #include <set>
+#include <string>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
 using llvm::LTOModule;
 using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 using llvm::COFF::MachineTypes;

 class Lazy;
 class SymbolBody;
 class Undefined;
 
 // The root class of input files.
 class InputFile {
 public:
   enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
+
+  virtual ~InputFile() = default;
+
   Kind kind() const { return FileKind; }
-  virtual ~InputFile() {}
 
   // Returns the filename.
   StringRef getName() { return MB.getBufferIdentifier(); }
 
   // Returns symbols defined by this file.
   virtual std::vector<SymbolBody *> &getSymbols() = 0;
 
   // Reads a file (the constructor doesn't do that).
private:
   const Kind FileKind;
   StringRef ParentName;
 };
 
 // .lib or .a file.
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef M);
+
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
+
   void parse() override;
 
   // Returns a memory buffer for a given symbol. An empty memory buffer
   // is returned if we have already returned the same memory buffer.
   // (So that we don't instantiate same members more than once.)
   MemoryBufferRef getMember(const Archive::Symbol *Sym);
 
   llvm::MutableArrayRef<Lazy> getLazySymbols();
private:
   std::vector<Lazy> LazySymbols;
   std::map<uint64_t, std::atomic_flag> Seen;
 };
 
 // .obj or .o file. This may be a member of an archive file.
 class ObjectFile : public InputFile {
 public:
   explicit ObjectFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
+
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
+
   void parse() override;
   MachineTypes getMachineType() override;
   std::vector<Chunk *> &getChunks() { return Chunks; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
   // Returns a SymbolBody object for the SymbolIndex'th symbol in the
   // underlying object file.
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) {

 
 // This type represents import library members that contain DLL names
 // and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
 // for details about the format.
 class ImportFile : public InputFile {
 public:
   explicit ImportFile(MemoryBufferRef M)
       : InputFile(ImportKind, M), StringAlloc(StringAllocAux) {}
+
   static bool classof(const InputFile *F) { return F->kind() == ImportKind; }
+
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
   DefinedImportData *ImpSym = nullptr;
   DefinedImportThunk *ThunkSym = nullptr;
   std::string DLLName;
 
 private:
   void parse() override;
 
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   llvm::BumpPtrAllocator StringAllocAux;
   llvm::StringSaver StringAlloc;
 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
+
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
+
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
   MachineTypes getMachineType() override;
   std::unique_ptr<LTOModule> takeModule() { return std::move(M); }
 
   static llvm::LLVMContext Context;
 
 private:
   void parse() override;
 
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   std::unique_ptr<LTOModule> M;
   static std::mutex Mu;
 };
 
-} // namespace coff
-} // namespace lld
+} // end namespace coff
+} // end namespace lld
 
-#endif
+#endif // LLD_COFF_INPUT_FILES_H

ELF/Target.cpp

 // See the following paper for the details.
 //
 //   Ulrich Drepper, ELF Handling For Thread-Local Storage
 //   http://www.akkadia.org/drepper/tls.pdf
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
+#include "Config.h"
 #include "Error.h"
-#include "InputFiles.h"
 #include "OutputSections.h"
 #include "Symbols.h"
-#include "Thunks.h"
-#include "Writer.h"
-
-#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Object/ELF.h"
-#include "llvm/Support/Endian.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
+#include <cstring>
+#include <cstdint>
+#include <tuple>
+#include <utility>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 namespace lld {
 namespace elf {

 }
 
 static void errorDynRel(uint32_t Type) {
   error("relocation " + getRelName(Type) +
         " cannot be used against shared object; recompile with -fPIC.");
 }
 
 namespace {
+
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
+
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   bool isTlsLocalDynamicRel(uint32_t Type) const override;
   bool isTlsGlobalDynamicRel(uint32_t Type) const override;
   bool isTlsInitialExecRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 
   RelExpr adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                           RelExpr Expr) const override;
   void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 template <class ELFT> class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
+
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   bool isTlsLocalDynamicRel(uint32_t Type) const override;
   bool isTlsGlobalDynamicRel(uint32_t Type) const override;
   bool isTlsInitialExecRel(uint32_t Type) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;

 private:
   void relaxGotNoPic(uint8_t *Loc, uint64_t Val, uint8_t Op,
                      uint8_t ModRm) const;
 };
 
 class PPCTargetInfo final : public TargetInfo {
 public:
   PPCTargetInfo();
+
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
+
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
+
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   bool isTlsInitialExecRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool usesOnlyLowPageBits(uint32_t Type) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                           RelExpr Expr) const override;
   void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 class AMDGPUTargetInfo final : public TargetInfo {
 public:
   AMDGPUTargetInfo();
+
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
 };
 
 class ARMTargetInfo final : public TargetInfo {
 public:
   ARMTargetInfo();
+
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   uint64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   bool isTlsLocalDynamicRel(uint32_t Type) const override;
   bool isTlsGlobalDynamicRel(uint32_t Type) const override;
   bool isTlsInitialExecRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   RelExpr getThunkExpr(RelExpr Expr, uint32_t RelocType, const InputFile &File,
                        const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
+
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   bool isTlsLocalDynamicRel(uint32_t Type) const override;
   bool isTlsGlobalDynamicRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   RelExpr getThunkExpr(RelExpr Expr, uint32_t RelocType, const InputFile &File,
                        const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   bool usesOnlyLowPageBits(uint32_t Type) const override;
 };
-} // anonymous namespace
+
+} // end anonymous namespace
 
 TargetInfo *createTarget() {
   switch (Config->EMachine) {
   case EM_386:
   case EM_IAMCU:
     return new X86TargetInfo();
   case EM_AARCH64:
     return new AArch64TargetInfo();
TargetInfo *createTarget() {
   case EM_X86_64:
     if (Config->EKind == ELF32LEKind)
       return new X86_64TargetInfo<ELF32LE>();
     return new X86_64TargetInfo<ELF64LE>();
   }
   fatal("unknown target machine");
 }
 
-TargetInfo::~TargetInfo() {}
+TargetInfo::~TargetInfo() = default;
 
 uint64_t TargetInfo::getImplicitAddend(const uint8_t *Buf,
                                        uint32_t Type) const {
   return 0;
 }
 
 bool TargetInfo::usesOnlyLowPageBits(uint32_t Type) const { return false; }
 

 static uint16_t applyPPCLo(uint64_t V) { return V; }
 static uint16_t applyPPCHi(uint64_t V) { return V >> 16; }
 static uint16_t applyPPCHa(uint64_t V) { return (V + 0x8000) >> 16; }
 static uint16_t applyPPCHigher(uint64_t V) { return V >> 32; }
 static uint16_t applyPPCHighera(uint64_t V) { return (V + 0x8000) >> 32; }
 static uint16_t applyPPCHighest(uint64_t V) { return V >> 48; }
 static uint16_t applyPPCHighesta(uint64_t V) { return (V + 0x8000) >> 48; }
 
-PPCTargetInfo::PPCTargetInfo() {}
+PPCTargetInfo::PPCTargetInfo() = default;
 
 void PPCTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
                                 uint64_t Val) const {
   switch (Type) {
   case R_PPC_ADDR16_HA:
     write16be(Loc, applyPPCHa(Val));
     break;
   case R_PPC_ADDR16_LO:
default:
     fatal("unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::usesOnlyLowPageBits(uint32_t Type) const {
   return Type == R_MIPS_LO16 || Type == R_MIPS_GOT_OFST;
 }
-}
-}
+
+} // end namespace elf
+} // end namespace lld

lib/ReaderWriter/MachO/ArchHandler.cpp

 //===- lib/FileFormat/MachO/ArchHandler.cpp -------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "ArchHandler.h"
 #include "Atoms.h"
 #include "MachONormalizedFileBinaryUtils.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MachO.h"
+#include <cassert>
 
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;
 
 namespace lld {
 namespace mach_o {
 
+ArchHandler::ArchHandler() = default;
 
-ArchHandler::ArchHandler() {
-}
-
-ArchHandler::~ArchHandler() {
-}
+ArchHandler::~ArchHandler() = default;
 
 std::unique_ptr<mach_o::ArchHandler> ArchHandler::create(
                                                MachOLinkingContext::Arch arch) {
   switch (arch) {
   case MachOLinkingContext::arch_x86_64:
     return create_x86_64();
   case MachOLinkingContext::arch_x86:
     return create_x86();
   case MachOLinkingContext::arch_armv6:
   case MachOLinkingContext::arch_armv7:
   case MachOLinkingContext::arch_armv7s:
     return create_arm();
   case MachOLinkingContext::arch_arm64:
     return create_arm64();
   default:
     llvm_unreachable("Unknown arch");
   }
 }
 
-
 bool ArchHandler::isLazyPointer(const Reference &ref) {
   // A lazy bind entry is needed for a lazy pointer.
   const StubInfo &info = stubInfo();
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return false;
   if (ref.kindArch() != info.lazyPointerReferenceToFinal.arch)
     return false;
   return (ref.kindValue() == info.lazyPointerReferenceToFinal.kind);
 }
 
-
 ArchHandler::RelocPattern ArchHandler::relocPattern(const Relocation &reloc) {
   assert((reloc.type & 0xFFF0) == 0);
   uint16_t result = reloc.type;
   if (reloc.scattered)
     result |= rScattered;
   if (reloc.pcRel)
     result |= rPcRel;
   if (reloc.isExtern)

 int32_t ArchHandler::readS32(const uint8_t *addr, bool isBig) {
   return read32(addr, isBig);
 }
 
 uint32_t ArchHandler::readU32(const uint8_t *addr, bool isBig) {
   return read32(addr, isBig);
 }
 
-  int64_t ArchHandler::readS64(const uint8_t *addr, bool isBig) {
   return read64(addr, isBig);
 }
 
 bool ArchHandler::isDwarfCIE(bool isBig, const DefinedAtom *atom) {
   assert(atom->contentType() == DefinedAtom::typeCFI);
   if (atom->rawContent().size() < sizeof(uint32_t))
     return false;
   uint32_t size = read32(atom->rawContent().data(), isBig);
if (ref->kindNamespace() == Reference::KindNamespace::mach_o &&
       assert(ref->kindArch() == kindArch() && "unexpected Reference arch");
       return ref->target();
     }
   }
 
   return nullptr;
 }
 
-} // namespace mach_o
-} // namespace lld
-
-
-
+} // end namespace mach_o
+} // end namespace lld

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "ArchHandler.h"
 #include "File.h"
 #include "FlatNamespaceFile.h"
 #include "MachONormalizedFile.h"
 #include "MachOPasses.h"
 #include "SectCreateFile.h"
 #include "lld/Core/ArchiveLibraryFile.h"
-#include "lld/Core/PassManager.h"
+#include "lld/Core/DefinedAtom.h"
+#include "lld/Core/Error.h"
+#include "lld/Core/File.h"
+#include "lld/Core/LLVM.h"
+#include "lld/Core/Node.h"
 #include "lld/Core/Reader.h"
+#include "lld/Core/SharedLibraryFile.h"
 #include "lld/Core/Writer.h"
-#include "lld/Driver/Driver.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.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/Config/config.h"
 #include "llvm/Demangle/Demangle.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/Errc.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MachO.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <vector>
 
 using lld::mach_o::ArchHandler;
 using lld::mach_o::MachOFile;
 using lld::mach_o::MachODylibFile;
 using namespace llvm::MachO;
 
 namespace lld {
 
bool MachOLinkingContext::isThinObjectFile(StringRef path, Arch &arch) {
   return mach_o::normalized::isThinObjectFile(path, arch);
 }
 
 bool MachOLinkingContext::sliceFromFatFile(MemoryBufferRef mb, uint32_t &offset,
                                            uint32_t &size) {
   return mach_o::normalized::sliceFromFatFile(mb, _arch, offset, size);
 }
 
-MachOLinkingContext::MachOLinkingContext() {}
+MachOLinkingContext::MachOLinkingContext() = default;
 
 MachOLinkingContext::~MachOLinkingContext() {
   // Atoms are allocated on BumpPtrAllocator's on File's.
   // As we transfer atoms from one file to another, we need to clear all of the
   // atoms before we remove any of the BumpPtrAllocator's.
   auto &nodes = getNodes();
   for (unsigned i = 0, e = nodes.size(); i != e; ++i) {
     FileNode *node = dyn_cast<FileNode>(nodes[i].get());
void MachOLinkingContext::addSectionAlignment(StringRef seg, StringRef sect,
                                               uint16_t align) {
   SectionAlign entry = { seg, sect, align };
   _sectAligns.push_back(entry);
 }
 
 void MachOLinkingContext::addSectCreateSection(
                                         StringRef seg, StringRef sect,
                                         std::unique_ptr<MemoryBuffer> content) {
-
   if (!_sectCreateFile) {
     auto sectCreateFile = llvm::make_unique<mach_o::SectCreateFile>();
     _sectCreateFile = sectCreateFile.get();
     getNodes().push_back(llvm::make_unique<FileNode>(std::move(sectCreateFile)));
   }
 
   assert(_sectCreateFile && "sectcreate file does not exist.");
   _sectCreateFile->addSection(seg, sect, std::move(content));

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

NormalizedFile(IO &io, const lld::File *file)
         : File(file->path(), kindNormalizedObject), _io(io),
           _rnb(new RefNameBuilder(*file)), _path(file->path()),
         _definedAtomsRef(file->defined()),
         _undefinedAtomsRef(file->undefined()),
         _sharedLibraryAtomsRef(file->sharedLibrary()),
         _absoluteAtomsRef(file->absolute()) {
     }
 
-    ~NormalizedFile() override {
-    }
+    ~NormalizedFile() override = default;
 
     const lld::File *denormalize(IO &io);
 
     const AtomRange<lld::DefinedAtom> defined() const override {
       return _definedAtomsRef;
     }
 
     const AtomRange<lld::UndefinedAtom> undefined() const override {