[LLD] Fix Clang-tidy modernize-deprecated-headers warnings; other minor fixes

[Eugene.Zelenko]

Summary

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

[ruiu]

I'm sorry that I missed this one. LGTM.

lld/trunk/unittests/MachOTests/MachONormalizedFileBinaryReaderTests.cpp

 //===- lld/unittest/MachOTests/MachONormalizedFileBinaryReaderTests.cpp ---===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include "../../lib/ReaderWriter/MachO/MachONormalizedFile.h"
 #include "llvm/Support/MachO.h"
-#include <assert.h>
-#include <vector>
 
 using llvm::StringRef;
 using llvm::MemoryBuffer;
 using llvm::ErrorOr;
 
 using namespace lld::mach_o::normalized;
 using namespace llvm::MachO;
 
TEST(BinaryReaderTest, empty_obj_x86_64) {
   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86_64);
   EXPECT_EQ((int)(f->fileType), MH_OBJECT);
   EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
   EXPECT_TRUE(f->localSymbols.empty());
   EXPECT_TRUE(f->globalSymbols.empty());
   EXPECT_TRUE(f->undefinedSymbols.empty());
 }
 
-
 TEST(BinaryReaderTest, empty_obj_x86) {
   FILEBYTES = {
       0xce, 0xfa, 0xed, 0xfe, 0x07, 0x00, 0x00, 0x00,
       0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
       0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00,
       0x00, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
       0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
TEST(BinaryReaderTest, empty_obj_x86) {
   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_x86);
   EXPECT_EQ((int)(f->fileType), MH_OBJECT);
   EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
   EXPECT_TRUE(f->localSymbols.empty());
   EXPECT_TRUE(f->globalSymbols.empty());
   EXPECT_TRUE(f->undefinedSymbols.empty());
 }
 
-
 TEST(BinaryReaderTest, empty_obj_ppc) {
   FILEBYTES = {
       0xfe, 0xed, 0xfa, 0xce, 0x00, 0x00, 0x00, 0x12,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7c,
       0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
TEST(BinaryReaderTest, empty_obj_ppc) {
   EXPECT_EQ(f->arch, lld::MachOLinkingContext::arch_ppc);
   EXPECT_EQ((int)(f->fileType), MH_OBJECT);
   EXPECT_EQ((int)(f->flags), MH_SUBSECTIONS_VIA_SYMBOLS);
   EXPECT_TRUE(f->localSymbols.empty());
   EXPECT_TRUE(f->globalSymbols.empty());
   EXPECT_TRUE(f->undefinedSymbols.empty());
 }
 
-
 TEST(BinaryReaderTest, empty_obj_armv7) {
   FILEBYTES = {
       0xce, 0xfa, 0xed, 0xfe, 0x0c, 0x00, 0x00, 0x00,
       0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
       0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00,
       0x00, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
       0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
TEST(BinaryReaderTest, hello_obj_x86_64) {
   EXPECT_EQ(mainLabel.value, Hex64(0x0));
   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
   const Symbol& printfLabel = f->undefinedSymbols[0];
   EXPECT_TRUE(printfLabel.name.equals("_printf"));
   EXPECT_EQ(printfLabel.type, N_UNDF);
   EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
 }
 
-
 TEST(BinaryReaderTest, hello_obj_x86) {
   FILEBYTES = {
     0xCE, 0xFA, 0xED, 0xFE, 0x07, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00,
     0x00, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
TEST(BinaryReaderTest, hello_obj_x86) {
   EXPECT_EQ(mainLabel.value, Hex64(0x0));
   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
   const Symbol& printfLabel = f->undefinedSymbols[0];
   EXPECT_TRUE(printfLabel.name.equals("_printf"));
   EXPECT_EQ(printfLabel.type, N_UNDF);
   EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
 }
 
-
 TEST(BinaryReaderTest, hello_obj_armv7) {
   FILEBYTES = {
     0xCE, 0xFA, 0xED, 0xFE, 0x0C, 0x00, 0x00, 0x00,
     0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00,
     0x00, 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
TEST(BinaryReaderTest, hello_obj_armv7) {
   EXPECT_EQ(mainLabel.value, Hex64(0x0));
   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
   const Symbol& printfLabel = f->undefinedSymbols[0];
   EXPECT_TRUE(printfLabel.name.equals("_printf"));
   EXPECT_EQ(printfLabel.type, N_UNDF);
   EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
 }
 
-
 TEST(BinaryReaderTest, hello_obj_ppc) {
   FILEBYTES = {
     0xFE, 0xED, 0xFA, 0xCE, 0x00, 0x00, 0x00, 0x12,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x28,
     0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
TEST(BinaryReaderTest, hello_obj_ppc) {
   EXPECT_EQ(mainLabel.value, Hex64(0x0));
   EXPECT_EQ(f->undefinedSymbols.size(), 1UL);
   const Symbol& printfLabel = f->undefinedSymbols[0];
   EXPECT_TRUE(printfLabel.name.equals("_printf"));
   EXPECT_EQ(printfLabel.type, N_UNDF);
   EXPECT_EQ(printfLabel.scope, SymbolScope(N_EXT));
 
   writeBinary(*f, "/tmp/foo.o");
-
 }

lld/trunk/unittests/MachOTests/MachONormalizedFileToAtomsTests.cpp

 //===- lld/unittest/MachOTests/MachONormalizedFileToAtomsTests.cpp --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include "../../lib/ReaderWriter/MachO/MachONormalizedFile.h"
 #include "llvm/Support/MachO.h"
-#include <assert.h>
-#include <vector>
 
 using llvm::ErrorOr;
 
 using namespace lld::mach_o::normalized;
 using namespace llvm::MachO;
 
 TEST(ToAtomsTest, empty_obj_x86_64) {
   NormalizedFile f;

lld/trunk/unittests/MachOTests/MachONormalizedFileYAMLTests.cpp

 //===- lld/unittest/MachOTests/MachONormalizedFileYAMLTests.cpp -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include "../../lib/ReaderWriter/MachO/MachONormalizedFile.h"
 #include "llvm/Support/MachO.h"
-#include <assert.h>
-#include <vector>
 
 using llvm::StringRef;
 using llvm::MemoryBuffer;
 using llvm::ErrorOr;
 using lld::mach_o::normalized::NormalizedFile;
 using lld::mach_o::normalized::Symbol;
 using lld::mach_o::normalized::Section;
 using lld::mach_o::normalized::Relocation;
 
-
 static std::unique_ptr<NormalizedFile> fromYAML(StringRef str) {
   std::unique_ptr<MemoryBuffer> mb(MemoryBuffer::getMemBuffer(str));
   ErrorOr<std::unique_ptr<NormalizedFile>> r
                                     = lld::mach_o::normalized::readYaml(mb);
   EXPECT_FALSE(!r);
   return std::move(*r);
 }
 
 static void toYAML(const NormalizedFile &f, std::string &out) {
   llvm::raw_string_ostream ostr(out);
   std::error_code ec = lld::mach_o::normalized::writeYaml(f, ostr);
   EXPECT_TRUE(!ec);
 }
 
-
 // ppc is no longer supported, but it is here to test endianness handling.
 TEST(ObjectFileYAML, empty_ppc) {
   std::unique_ptr<NormalizedFile> f = fromYAML(
     "---\n"
     "arch:      ppc\n"
     "file-type: MH_OBJECT\n"
     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
     "...\n");
TEST(ObjectFileYAML, empty_armv7s) {
   EXPECT_EQ(f->fileType, llvm::MachO::MH_OBJECT);
   EXPECT_EQ((int)(f->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
   EXPECT_TRUE(f->sections.empty());
   EXPECT_TRUE(f->localSymbols.empty());
   EXPECT_TRUE(f->globalSymbols.empty());
   EXPECT_TRUE(f->undefinedSymbols.empty());
 }
 
-
 TEST(ObjectFileYAML, roundTrip) {
   std::string intermediate;
   {
     NormalizedFile f;
     f.arch = lld::MachOLinkingContext::arch_x86_64;
     f.fileType = llvm::MachO::MH_OBJECT;
     f.flags = llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
     f.os = lld::MachOLinkingContext::OS::macOSX;
     toYAML(f, intermediate);
   }
   {
     std::unique_ptr<NormalizedFile> f2 = fromYAML(intermediate);
     EXPECT_EQ(f2->arch, lld::MachOLinkingContext::arch_x86_64);
     EXPECT_EQ((int)(f2->fileType), llvm::MachO::MH_OBJECT);
     EXPECT_EQ((int)(f2->flags), llvm::MachO::MH_SUBSECTIONS_VIA_SYMBOLS);
     EXPECT_TRUE(f2->sections.empty());
     EXPECT_TRUE(f2->localSymbols.empty());
     EXPECT_TRUE(f2->globalSymbols.empty());
     EXPECT_TRUE(f2->undefinedSymbols.empty());
   }
 }
 
-
 TEST(ObjectFileYAML, oneSymbol) {
   std::unique_ptr<NormalizedFile> f = fromYAML(
     "---\n"
     "arch:      x86_64\n"
     "file-type: MH_OBJECT\n"
     "global-symbols:\n"
     "  - name:   _main\n"
     "    type:   N_SECT\n"
TEST(ObjectFileYAML, oneSymbol) {
   EXPECT_TRUE(sym.name.equals("_main"));
   EXPECT_EQ((int)(sym.type), llvm::MachO::N_SECT);
   EXPECT_EQ((int)(sym.scope), llvm::MachO::N_EXT);
   EXPECT_EQ(sym.sect, 1);
   EXPECT_EQ((int)(sym.desc), 0);
   EXPECT_EQ((uint64_t)sym.value, 0x100ULL);
 }
 
-
 TEST(ObjectFileYAML, oneSection) {
   std::unique_ptr<NormalizedFile> f = fromYAML(
     "---\n"
     "arch:      x86_64\n"
     "file-type: MH_OBJECT\n"
     "sections:\n"
     "  - segment:     __TEXT\n"
     "    section:     __text\n"
EXPECT_EQ((uint32_t)(sect.attributes),
                             (uint32_t)(llvm::MachO::S_ATTR_PURE_INSTRUCTIONS));
   EXPECT_EQ((uint16_t)sect.alignment, 2U);
   EXPECT_EQ((uint64_t)sect.address, 0x12345678ULL);
   EXPECT_EQ(sect.content.size(), 2UL);
   EXPECT_EQ((int)(sect.content[0]), 0x90);
   EXPECT_EQ((int)(sect.content[1]), 0x90);
 }
 
-
 TEST(ObjectFileYAML, hello_x86_64) {
   std::unique_ptr<NormalizedFile> f = fromYAML(
     "---\n"
     "arch:      x86_64\n"
     "file-type: MH_OBJECT\n"
     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
     "sections:\n"
     "  - segment:     __TEXT\n"
TEST(ObjectFileYAML, hello_x86_64) {
   EXPECT_TRUE(sym3.name.equals("_printf"));
   EXPECT_EQ((int)(sym3.type), llvm::MachO::N_UNDF);
   EXPECT_EQ((int)(sym3.scope), 0);
   EXPECT_EQ(sym3.sect, 0);
   EXPECT_EQ((int)(sym3.desc), 0);
   EXPECT_EQ((uint64_t)sym3.value, 0x0ULL);
 }
 
-
 TEST(ObjectFileYAML, hello_x86) {
   std::unique_ptr<NormalizedFile> f = fromYAML(
     "---\n"
     "arch:      x86\n"
     "file-type: MH_OBJECT\n"
     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
     "sections:\n"
     "  - segment:     __TEXT\n"
TEST(ObjectFileYAML, hello_armv6) {
   EXPECT_TRUE(sym2.name.equals("_printf"));
   EXPECT_EQ((int)(sym2.type), llvm::MachO::N_UNDF);
   EXPECT_EQ((int)(sym2.scope), 0);
   EXPECT_EQ(sym2.sect, 0);
   EXPECT_EQ((int)(sym2.desc), 0);
   EXPECT_EQ((uint64_t)sym2.value, 0x0ULL);
 }
 
-
-
 TEST(ObjectFileYAML, hello_armv7) {
   std::unique_ptr<NormalizedFile> f = fromYAML(
     "---\n"
     "arch:      armv7\n"
     "file-type: MH_OBJECT\n"
     "flags:     [ MH_SUBSECTIONS_VIA_SYMBOLS ]\n"
     "sections:\n"
     "  - segment:     __TEXT\n"