[LLD] Fix Clang-tidy readability-static-definition-in-anonymous-namespace warnings; other minor fixes.

[Eugene.Zelenko]

Summary

Some Include What You Use suggestions were used too.

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

[ruiu]

I think as a policy we should use static for functions instead of anonymous namespaces in LLVM. Can you narrow the scopes of anonymous namespaces instead of removing static?

COFF/DLL.cpp

 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Path.h"
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::object;

 
 // Import table
 
-static int ptrSize() { return Config->is64() ? 8 : 4; }
+int ptrSize() { return Config->is64() ? 8 : 4; }
 
 // A chunk for the import descriptor table.
 class HintNameChunk : public Chunk {

   size_t Size;
 };
 
-static std::vector<std::vector<DefinedImportData *>>
+std::vector<std::vector<DefinedImportData *>>
 binImports(const std::vector<DefinedImportData *> &Imports) {
   // Group DLL-imported symbols by DLL name because that's how
   // symbols are layed out in the import descriptor table.

 // This code calls __delayLoadHelper2 function to resolve a symbol
 // and then overwrites its jump table slot with the result
 // for subsequent function calls.
-static const uint8_t ThunkX64[] = {
+const uint8_t ThunkX64[] = {
     0x51,                               // push    rcx
     0x52,                               // push    rdx
     0x41, 0x50,                         // push    r8

     0xFF, 0xE0,                         // jmp     rax
 };
 
-static const uint8_t ThunkX86[] = {
+const uint8_t ThunkX86[] = {
     0x51,              // push  ecx
     0x52,              // push  edx
     0x68, 0, 0, 0, 0,  // push  offset ___imp__<FUNCNAME>

COFF/ModuleDef.cpp

 #include "Error.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cstddef>
+#include <cstdint>
+#include <string>
 #include <system_error>
+#include <tuple>
+#include <vector>
 
 using namespace llvm;
 

   StringRef Value;
 };
 
-static bool isDecorated(StringRef Sym) {
+bool isDecorated(StringRef Sym) {
   return Sym.startswith("_") || Sym.startswith("@") || Sym.startswith("?");
 }
 

lib/Driver/DarwinLdDriver.cpp

 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"

 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
 
 using namespace lld;
 

 #undef PREFIX
 
 // Create table mapping all options defined in DarwinLdOptions.td
-static const llvm::opt::OptTable::Info infoTable[] = {
+const llvm::opt::OptTable::Info infoTable[] = {
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
                HELPTEXT, METAVAR)   \
   { PREFIX, NAME, HELPTEXT, METAVAR, OPT_##ID, llvm::opt::Option::KIND##Class, \

   DarwinLdOptTable() : OptTable(infoTable) {}
 };
 
-static std::vector<std::unique_ptr<File>>
+std::vector<std::unique_ptr<File>>
 makeErrorFile(StringRef path, std::error_code ec) {
   std::vector<std::unique_ptr<File>> result;
   result.push_back(llvm::make_unique<ErrorFile>(path, ec));
   return result;
 }
 
-static std::vector<std::unique_ptr<File>>
+std::vector<std::unique_ptr<File>>
 parseMemberFiles(std::unique_ptr<File> file) {
   std::vector<std::unique_ptr<File>> members;
   if (auto *archive = dyn_cast<ArchiveLibraryFile>(file.get())) {

   return files;
 }
 
-} // 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) {
+std::string canonicalizePath(StringRef path) {
   char sep = llvm::sys::path::get_separator().front();
   if (sep != '/') {
     std::string fixedPath = path;

   }
 }
 
-static void addFile(StringRef path, MachOLinkingContext &ctx,
-                    bool loadWholeArchive,
-                    bool upwardDylib, raw_ostream &diag) {
+void addFile(StringRef path, MachOLinkingContext &ctx, bool loadWholeArchive,
+             bool upwardDylib, raw_ostream &diag) {
   std::vector<std::unique_ptr<File>> files =
       loadFile(ctx, path, diag, loadWholeArchive, upwardDylib);
   for (std::unique_ptr<File> &file : files)

 
 // Export lists are one symbol per line.  Blank lines are ignored.
 // Trailing comments start with #.
-static std::error_code parseExportsList(StringRef exportFilePath,
-                                        MachOLinkingContext &ctx,
-                                        raw_ostream &diagnostics) {
+std::error_code parseExportsList(StringRef exportFilePath,
   // Map in export list file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                    MemoryBuffer::getFileOrSTDIN(exportFilePath);

   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:

 ///     bar.o:_bar
 ///     libfrob.a(bar.o):_bar
 ///     x86_64:_foo64
-static std::error_code parseOrderFile(StringRef orderFilePath,
-                                      MachOLinkingContext &ctx,
-                                      raw_ostream &diagnostics) {
+std::error_code parseOrderFile(StringRef orderFilePath,
   // Map in order file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                    MemoryBuffer::getFileOrSTDIN(orderFilePath);

 // In this variant, the path is to a text file which contains a partial path
 // per line. The <dir> prefix is prepended to each partial path.
 //
-static llvm::Error loadFileList(StringRef fileListPath,
-                                MachOLinkingContext &ctx, bool forceLoad,
-                                raw_ostream &diagnostics) {
+llvm::Error loadFileList(StringRef fileListPath, MachOLinkingContext &ctx,
+                         bool forceLoad, raw_ostream &diagnostics) {
   // If there is a comma, split off <dir>.
   std::pair<StringRef, StringRef> opt = fileListPath.split(',');
   StringRef filePath = opt.first;

 }
 
 /// Parse number assuming it is base 16, but allow 0x prefix.
-static bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
+bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
   if (numStr.startswith_lower("0x"))
     numStr = numStr.drop_front(2);
   return numStr.getAsInteger(16, baseAddress);
 }
 
-static void parseLLVMOptions(const LinkingContext &ctx) {
+void parseLLVMOptions(const LinkingContext &ctx) {
   // Honor -mllvm
   if (!ctx.llvmOptions().empty()) {
     unsigned numArgs = ctx.llvmOptions().size();

   }
 }
 
+} // anonymous namespace
+
 namespace lld {
 namespace mach_o {
 

 
   return true;
 }
+
 } // namespace mach_o
 } // namespace lld

lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

 #include "MachONormalizedFileBinaryUtils.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MachO.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
 
 using namespace llvm::MachO;
 using namespace lld::mach_o::normalized;

 namespace lld {
 namespace mach_o {
 
+namespace {
 
-namespace { // anonymous
-
-
 #define ENTRY(seg, sect, type, atomType) \
   {seg, sect, type, DefinedAtom::atomType }
 

   atomizeModel = atomizeAtSymbols;
 }
 
-
 Atom::Scope atomScope(uint8_t scope) {
   switch (scope) {
   case N_EXT:

   return section.segmentName.equals("__DWARF");
 }
 
-static int64_t readSPtr(bool is64, bool isBig, const uint8_t *addr) {
+int64_t readSPtr(bool is64, bool isBig, const uint8_t *addr) {
   if (is64)
     return read64(addr, isBig);
 

 
 typedef llvm::DenseMap<const MachODefinedAtom*, CIEInfo> CIEInfoMap;
 
-static llvm::Error processAugmentationString(const uint8_t *augStr,
-                                             CIEInfo &cieInfo,
-                                             unsigned &len) {
+llvm::Error processAugmentationString(const uint8_t *augStr, CIEInfo &cieInfo,
+                                      unsigned &len) {
 
   if (augStr[0] == '\0') {
     len = 1;

   return llvm::Error();
 }
 
-static llvm::Error processCIE(const NormalizedFile &normalizedFile,
-                              MachOFile &file,
-                              mach_o::ArchHandler &handler,
-                              const Section *ehFrameSection,
-                              MachODefinedAtom *atom,
-                              uint64_t offset,
-                              CIEInfoMap &cieInfos) {
+llvm::Error processCIE(const NormalizedFile &normalizedFile, MachOFile &file,
+                       mach_o::ArchHandler &handler,
+                       const Section *ehFrameSection, MachODefinedAtom *atom,
+                       uint64_t offset, CIEInfoMap &cieInfos) {
   const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   const uint8_t *frameData = atom->rawContent().data();
 

   return llvm::Error();
 }
 
-static llvm::Error processFDE(const NormalizedFile &normalizedFile,
-                              MachOFile &file,
-                              mach_o::ArchHandler &handler,
-                              const Section *ehFrameSection,
-                              MachODefinedAtom *atom,
-                              uint64_t offset,
-                              const CIEInfoMap &cieInfos) {
-
+llvm::Error processFDE(const NormalizedFile &normalizedFile, MachOFile &file,
+                       mach_o::ArchHandler &handler,
+                       const Section *ehFrameSection,  MachODefinedAtom *atom,
+                       uint64_t offset, const CIEInfoMap &cieInfos) {
   const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   const bool is64 = MachOLinkingContext::is64Bit(normalizedFile.arch);
 

   return llvm::Error();
 }
 
-
 /// Converts normalized mach-o file into an lld::File and lld::Atoms.
 llvm::Expected<std::unique_ptr<lld::File>>
 objectToAtoms(const NormalizedFile &normalizedFile, StringRef path,

 
 namespace normalized {
 
-static bool isObjCImageInfo(const Section &sect) {
+namespace {
+
+bool isObjCImageInfo(const Section &sect) {
   return (sect.segmentName == "__OBJC" && sect.sectionName == "__image_info") ||
     (sect.segmentName == "__DATA" && sect.sectionName == "__objc_imageinfo");
 }
 
+} // anonymous namespace
+
 llvm::Error
 normalizedObjectToAtoms(MachOFile *file,
                         const NormalizedFile &normalizedFile,

     if (isDebugInfoSection(sect))
       continue;
 
-
     // If the file contains an objc_image_info struct, then we should parse the
     // ObjC flags and Swift version.
     if (isObjCImageInfo(sect)) {

                                           SectionType &sectionType,
                                           SectionAttr &sectionAttrs,
                                           bool &relocsToDefinedCanBeImplicit) {
-
   for (const MachORelocatableSectionToAtomType *p = sectsToAtomType ;
                                  p->atomType != DefinedAtom::typeUnknown; ++p) {
     if (p->atomType != atomType)