Revert "Fix Clang-tidy modernize-deprecated-headers warnings in remaining files; other minor fixes."

This reverts commit r265454 since it broke the build.  E.g.:

  http://lab.llvm.org:8080/green/job/clang-stage1-cmake-RA-incremental_build/22413/

llvm-svn: 265459

5 files changed, 105 insertions, 180 deletions

diff --git a/llvm/tools/llvm-c-test/echo.cpp b/llvm/tools/llvm-c-test/echo.cpp
index b0e47d8f544..1922b429eb2 100644
--- a/llvm/tools/llvm-c-test/echo.cpp
+++ b/llvm/tools/llvm-c-test/echo.cpp
@@ -16,18 +16,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c-test.h"
-#include "llvm-c/Core.h"
-#include "llvm-c/ErrorHandling.h"
 #include "llvm-c/Target.h"
-#include "llvm-c/Types.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ErrorHandling.h"
 
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
 
 using namespace llvm;
 
@@ -45,16 +39,13 @@ struct CAPIDenseMap<T*> {
       uintptr_t Val = static_cast<uintptr_t>(-1);
       return reinterpret_cast<T*>(Val);
     }
-
     static inline T* getTombstoneKey() {
       uintptr_t Val = static_cast<uintptr_t>(-2);
       return reinterpret_cast<T*>(Val);
     }
-
     static unsigned getHashValue(const T *PtrVal) {
       return hash_value(PtrVal);
     }
-
     static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   };
 
@@ -163,9 +154,7 @@ struct TypeCloner {
   }
 };
 
-namespace {
-
-ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
+static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
   unsigned Count = LLVMCountParams(Src);
   if (Count != LLVMCountParams(Dst))
     report_fatal_error("Parameter count mismatch");
@@ -223,8 +212,6 @@ ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
   return VMap;
 }
 
-} // end anonymous namespace
-
 LLVMValueRef clone_constant(LLVMValueRef Cst, LLVMModuleRef M) {
   if (!LLVMIsAConstant(Cst))
     report_fatal_error("Expected a constant");
@@ -723,9 +710,7 @@ struct FunCloner {
   }
 };
 
-namespace {
-
-void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
+static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
   LLVMValueRef End = LLVMGetLastGlobal(Src);
 
@@ -789,7 +774,7 @@ FunDecl:
   }
 }
 
-void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
+static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
   LLVMValueRef End = LLVMGetLastGlobal(Src);
 
@@ -876,8 +861,6 @@ FunClone:
   }
 }
 
-} // end anonymous namespace
-
 int llvm_echo(void) {
   LLVMEnablePrettyStackTrace();
 
diff --git a/llvm/tools/llvm-c-test/llvm-c-test.h b/llvm/tools/llvm-c-test/llvm-c-test.h
index fa5a9d04cca..60edc0df4d1 100644
--- a/llvm/tools/llvm-c-test/llvm-c-test.h
+++ b/llvm/tools/llvm-c-test/llvm-c-test.h
@@ -10,15 +10,10 @@
 |* Header file for llvm-c-test                                                *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
-
 #ifndef LLVM_C_TEST_H
 #define LLVM_C_TEST_H
 
-#ifdef __cplusplus
-#include <cstdbool>
-#else
 #include <stdbool.h>
-#endif
 #include "llvm-c/Core.h"
 
 #ifdef __cplusplus
@@ -56,6 +51,6 @@ int llvm_echo(void);
 
 #ifdef __cplusplus
 }
-#endif
+#endif /* !defined(__cplusplus) */
 
-#endif // LLVM_C_TEST_H
+#endif
diff --git a/llvm/tools/llvm-readobj/COFFDumper.cpp b/llvm/tools/llvm-readobj/COFFDumper.cpp
index 9f398d2d04c..781185af849 100644
--- a/llvm/tools/llvm-readobj/COFFDumper.cpp
+++ b/llvm/tools/llvm-readobj/COFFDumper.cpp
@@ -40,14 +40,9 @@
 #include "llvm/Support/Win64EH.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <ctime>
-#include <memory>
-#include <string>
-#include <tuple>
+#include <cstring>
 #include <system_error>
-#include <vector>
+#include <time.h>
 
 using namespace llvm;
 using namespace llvm::object;
@@ -76,7 +71,6 @@ public:
   void printCOFFBaseReloc() override;
   void printCodeViewDebugInfo() override;
   void printStackMap() const override;
-
 private:
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc,
@@ -150,7 +144,8 @@ private:
   StringSet<> TypeNames;
 };
 
-} // end anonymous namespace
+} // namespace
+
 
 namespace llvm {
 
@@ -165,7 +160,7 @@ std::error_code createCOFFDumper(const object::ObjectFile *Obj,
   return readobj_error::success;
 }
 
-} // end namespace llvm
+} // namespace llvm
 
 // Given a a section and an offset into this section the function returns the
 // symbol used for the relocation at the offset.
@@ -248,9 +243,7 @@ void COFFDumper::printBinaryBlockWithRelocs(StringRef Label,
   }
 }
 
-namespace {
-
-const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
+static const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AMD64    ),
@@ -274,7 +267,7 @@ const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2)
 };
 
-const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = {
+static const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_RELOCS_STRIPPED        ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_EXECUTABLE_IMAGE       ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LINE_NUMS_STRIPPED     ),
@@ -292,7 +285,7 @@ const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI      )
 };
 
-const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
+static const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_UNKNOWN                ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_NATIVE                 ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_GUI            ),
@@ -306,7 +299,7 @@ const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX                   ),
 };
 
-const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
+static const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY      ),
@@ -320,7 +313,7 @@ const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE),
 };
 
-const EnumEntry<COFF::SectionCharacteristics>
+static const EnumEntry<COFF::SectionCharacteristics>
 ImageSectionCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD           ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD           ),
@@ -360,7 +353,7 @@ ImageSectionCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE             )
 };
 
-const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
+static const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
   { "Null"  , COFF::IMAGE_SYM_TYPE_NULL   },
   { "Void"  , COFF::IMAGE_SYM_TYPE_VOID   },
   { "Char"  , COFF::IMAGE_SYM_TYPE_CHAR   },
@@ -379,14 +372,14 @@ const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
   { "DWord" , COFF::IMAGE_SYM_TYPE_DWORD  }
 };
 
-const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = {
+static const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = {
   { "Null"    , COFF::IMAGE_SYM_DTYPE_NULL     },
   { "Pointer" , COFF::IMAGE_SYM_DTYPE_POINTER  },
   { "Function", COFF::IMAGE_SYM_DTYPE_FUNCTION },
   { "Array"   , COFF::IMAGE_SYM_DTYPE_ARRAY    }
 };
 
-const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
+static const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
   { "EndOfFunction"  , COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION  },
   { "Null"           , COFF::IMAGE_SYM_CLASS_NULL             },
   { "Automatic"      , COFF::IMAGE_SYM_CLASS_AUTOMATIC        },
@@ -416,7 +409,7 @@ const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
   { "CLRToken"       , COFF::IMAGE_SYM_CLASS_CLR_TOKEN        }
 };
 
-const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
+static const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
   { "NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES },
   { "Any"         , COFF::IMAGE_COMDAT_SELECT_ANY          },
   { "SameSize"    , COFF::IMAGE_COMDAT_SELECT_SAME_SIZE    },
@@ -426,14 +419,14 @@ const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
   { "Newest"      , COFF::IMAGE_COMDAT_SELECT_NEWEST       }
 };
 
-const EnumEntry<COFF::WeakExternalCharacteristics>
+static const EnumEntry<COFF::WeakExternalCharacteristics>
 WeakExternalCharacteristics[] = {
   { "NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY },
   { "Library"  , COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY   },
   { "Alias"    , COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS     }
 };
 
-const EnumEntry<CompileSym3::Flags> CompileSym3Flags[] = {
+static const EnumEntry<CompileSym3::Flags> CompileSym3Flags[] = {
     LLVM_READOBJ_ENUM_ENT(CompileSym3, EC),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, NoDbgInfo),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, LTCG),
@@ -448,7 +441,7 @@ const EnumEntry<CompileSym3::Flags> CompileSym3Flags[] = {
     LLVM_READOBJ_ENUM_ENT(CompileSym3, Exp),
 };
 
-const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
+static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, C),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cpp),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Fortran),
@@ -468,7 +461,7 @@ const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, HLSL),
 };
 
-const EnumEntry<uint32_t> SubSectionTypes[] = {
+static const EnumEntry<uint32_t> SubSectionTypes[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Symbols),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Lines),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, StringTable),
@@ -484,7 +477,7 @@ const EnumEntry<uint32_t> SubSectionTypes[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CoffSymbolRVA),
 };
 
-const EnumEntry<unsigned> CPUTypeNames[] = {
+static const EnumEntry<unsigned> CPUTypeNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel8080),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel8086),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80286),
@@ -546,7 +539,7 @@ const EnumEntry<unsigned> CPUTypeNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, D3D11_Shader),
 };
 
-const EnumEntry<uint8_t> ProcSymFlags[] = {
+static const EnumEntry<uint8_t> ProcSymFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasFP),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasIRET),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasFRET),
@@ -557,7 +550,7 @@ const EnumEntry<uint8_t> ProcSymFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasOptimizedDebugInfo),
 };
 
-const EnumEntry<uint32_t> FrameProcSymFlags[] = {
+static const EnumEntry<uint32_t> FrameProcSymFlags[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasAlloca),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasSetJmp),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasLongJmp),
@@ -583,13 +576,13 @@ const EnumEntry<uint32_t> FrameProcSymFlags[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw),
 };
 
-const EnumEntry<uint32_t> FrameDataFlags[] = {
+static const EnumEntry<uint32_t> FrameDataFlags[] = {
     LLVM_READOBJ_ENUM_ENT(FrameData, HasSEH),
     LLVM_READOBJ_ENUM_ENT(FrameData, HasEH),
     LLVM_READOBJ_ENUM_ENT(FrameData, IsFunctionStart),
 };
 
-const EnumEntry<uint16_t> LocalFlags[] = {
+static const EnumEntry<uint16_t> LocalFlags[] = {
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsParameter),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsAddressTaken),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsCompilerGenerated),
@@ -603,14 +596,14 @@ const EnumEntry<uint16_t> LocalFlags[] = {
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsEnregisteredStatic),
 };
 
-const EnumEntry<uint16_t> FrameCookieKinds[] = {
+static const EnumEntry<uint16_t> FrameCookieKinds[] = {
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, Copy),
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorStackPointer),
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorFramePointer),
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorR13),
 };
 
-const EnumEntry<uint16_t> ClassOptionNames[] = {
+static const EnumEntry<uint16_t> ClassOptionNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Packed),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasConstructorOrDestructor),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasOverloadedOperator),
@@ -625,14 +618,14 @@ const EnumEntry<uint16_t> ClassOptionNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Intrinsic),
 };
 
-const EnumEntry<uint8_t> MemberAccessNames[] = {
+static const EnumEntry<uint8_t> MemberAccessNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, None),
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Private),
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Protected),
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Public),
 };
 
-const EnumEntry<uint16_t> MethodOptionNames[] = {
+static const EnumEntry<uint16_t> MethodOptionNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, Pseudo),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, NoInherit),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, NoConstruct),
@@ -640,7 +633,7 @@ const EnumEntry<uint16_t> MethodOptionNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, Sealed),
 };
 
-const EnumEntry<uint16_t> MemberKindNames[] = {
+static const EnumEntry<uint16_t> MemberKindNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Vanilla),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Virtual),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Static),
@@ -653,7 +646,7 @@ const EnumEntry<uint16_t> MemberKindNames[] = {
 /// The names here all end in "*". If the simple type is a pointer type, we
 /// return the whole name. Otherwise we lop off the last character in our
 /// StringRef.
-const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = {
+static const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = {
     {"void*", SimpleTypeKind::Void},
     {"<not translated>*", SimpleTypeKind::NotTranslated},
     {"HRESULT*", SimpleTypeKind::HResult},
@@ -694,12 +687,12 @@ const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = {
     {"__bool64*", SimpleTypeKind::Boolean64},
 };
 
-const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
+static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
 #define LEAF_TYPE(name, val) LLVM_READOBJ_ENUM_ENT(TypeLeafKind, name),
 #include "llvm/DebugInfo/CodeView/CVLeafTypes.def"
 };
 
-const EnumEntry<uint8_t> PtrKindNames[] = {
+static const EnumEntry<uint8_t> PtrKindNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near16),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Far16),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Huge16),
@@ -715,7 +708,7 @@ const EnumEntry<uint8_t> PtrKindNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near64),
 };
 
-const EnumEntry<uint8_t> PtrModeNames[] = {
+static const EnumEntry<uint8_t> PtrModeNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, Pointer),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, LValueReference),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, PointerToDataMember),
@@ -723,7 +716,7 @@ const EnumEntry<uint8_t> PtrModeNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, RValueReference),
 };
 
-const EnumEntry<uint16_t> PtrMemberRepNames[] = {
+static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, Unknown),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 SingleInheritanceData),
@@ -741,13 +734,13 @@ const EnumEntry<uint16_t> PtrMemberRepNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralFunction),
 };
 
-const EnumEntry<uint16_t> TypeModifierNames[] = {
+static const EnumEntry<uint16_t> TypeModifierNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Const),
     LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Volatile),
     LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Unaligned),
 };
 
-const EnumEntry<uint8_t> CallingConventions[] = {
+static const EnumEntry<uint8_t> CallingConventions[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearC),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarC),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearPascal),
@@ -774,13 +767,13 @@ const EnumEntry<uint8_t> CallingConventions[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearVector),
 };
 
-const EnumEntry<uint8_t> FunctionOptionEnum[] = {
+static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, CxxReturnUdt),
     LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, Constructor),
     LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, ConstructorWithVirtualBases),
 };
 
-const EnumEntry<uint8_t> FileChecksumKindNames[] = {
+static const EnumEntry<uint8_t> FileChecksumKindNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None),
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5),
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1),
@@ -788,7 +781,7 @@ const EnumEntry<uint8_t> FileChecksumKindNames[] = {
 };
 
 template <typename T>
-std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
+static std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
                                         COFFSymbolRef Symbol,
                                         uint8_t AuxSymbolIdx, const T *&Aux) {
   ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol);
@@ -797,8 +790,6 @@ std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
   return readobj_error::success;
 }
 
-} // end anonymous namespace
-
 void COFFDumper::cacheRelocations() {
   if (RelocCached)
     return;
@@ -949,13 +940,11 @@ void COFFDumper::printCodeViewDebugInfo() {
   }
 }
 
-namespace {
-
 /// Consumes sizeof(T) bytes from the given byte sequence. Returns an error if
 /// there are not enough bytes remaining. Reinterprets the consumed bytes as a
 /// T object and points 'Res' at them.
 template <typename T>
-std::error_code consumeObject(StringRef &Data, const T *&Res) {
+static std::error_code consumeObject(StringRef &Data, const T *&Res) {
   if (Data.size() < sizeof(*Res))
     return object_error::parse_failed;
   Res = reinterpret_cast<const T *>(Data.data());
@@ -963,7 +952,7 @@ std::error_code consumeObject(StringRef &Data, const T *&Res) {
   return std::error_code();
 }
 
-std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
+static std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
   const ulittle32_t *IntPtr;
   if (auto EC = consumeObject(Data, IntPtr))
     return EC;
@@ -971,8 +960,6 @@ std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
   return std::error_code();
 }
 
-} // end anonymous namespace
-
 void COFFDumper::initializeFileAndStringTables(StringRef Data) {
   while (!Data.empty() && (CVFileChecksumTable.data() == nullptr ||
                            CVStringTable.data() == nullptr)) {
@@ -1195,9 +1182,7 @@ void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
   }
 }
 
-namespace {
-
-std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
+static std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
   // Used to avoid overload ambiguity on APInt construtor.
   bool FalseVal = false;
   if (Data.size() < 2)
@@ -1263,8 +1248,6 @@ std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
   return object_error::parse_failed;
 }
 
-} // end anonymous namespace
-
 /// Decode an unsigned integer numeric leaf value.
 std::error_code decodeUIntLeaf(StringRef &Data, uint64_t &Num) {
   APSInt N;
@@ -1330,10 +1313,11 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       break;
     }
 
-    case S_PROC_ID_END:
+    case S_PROC_ID_END: {
       W.startLine() << "ProcEnd\n";
       InFunctionScope = false;
       break;
+    }
 
     case S_BLOCK32: {
       DictScope S(W, "BlockStart");
@@ -1353,10 +1337,11 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       break;
     }
 
-    case S_END:
+    case S_END: {
       W.startLine() << "BlockEnd\n";
       InFunctionScope = false;
       break;
+    }
 
     case S_LABEL32: {
       DictScope S(W, "Label");
@@ -1530,7 +1515,6 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       printLocalVariableAddrGap(SymData);
       break;
     }
-
     case S_DEFRANGE_SUBFIELD: {
       DictScope S(W, "DefRangeSubfield");
       const DefRangeSubfieldSym *DefRangeSubfield;
@@ -1545,7 +1529,6 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       printLocalVariableAddrGap(SymData);
       break;
     }
-
     case S_DEFRANGE_REGISTER: {
       DictScope S(W, "DefRangeRegister");
       const DefRangeRegisterSym *DefRangeRegister;
@@ -1557,7 +1540,6 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       printLocalVariableAddrGap(SymData);
       break;
     }
-
     case S_DEFRANGE_SUBFIELD_REGISTER: {
       DictScope S(W, "DefRangeSubfieldRegister");
       const DefRangeSubfieldRegisterSym *DefRangeSubfieldRegisterSym;
@@ -1572,7 +1554,6 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       printLocalVariableAddrGap(SymData);
       break;
     }
-
     case S_DEFRANGE_FRAMEPOINTER_REL: {
       DictScope S(W, "DefRangeFramePointerRel");
       const DefRangeFramePointerRelSym *DefRangeFramePointerRel;
@@ -1583,7 +1564,6 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       printLocalVariableAddrGap(SymData);
       break;
     }
-
     case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: {
       DictScope S(W, "DefRangeFramePointerRelFullScope");
       const DefRangeFramePointerRelFullScopeSym
@@ -1592,7 +1572,6 @@ void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
       W.printNumber("Offset", DefRangeFramePointerRelFullScope->Offset);
       break;
     }
-
     case S_DEFRANGE_REGISTER_REL: {
       DictScope S(W, "DefRangeRegisterRel");
       const DefRangeRegisterRelSym *DefRangeRegisterRel;
@@ -1966,9 +1945,7 @@ void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
   W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
 }
 
-namespace {
-
-StringRef getLeafTypeName(TypeLeafKind LT) {
+static StringRef getLeafTypeName(TypeLeafKind LT) {
   switch (LT) {
   case LF_STRING_ID: return "StringId";
   case LF_FIELDLIST: return "FieldList";
@@ -1997,8 +1974,6 @@ StringRef getLeafTypeName(TypeLeafKind LT) {
   return "UnknownLeaf";
 }
 
-} // end anonymous namespace
-
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");
@@ -2225,7 +2200,7 @@ void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
       break;
     }
 
-    case LF_METHODLIST:
+    case LF_METHODLIST: {
       while (!LeafData.empty()) {
         const MethodListEntry *Method;
         error(consumeObject(LeafData, Method));
@@ -2239,6 +2214,7 @@ void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
         }
       }
       break;
+    }
 
     case LF_FUNC_ID: {
       const FuncId *Func;
@@ -2380,9 +2356,7 @@ void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
   }
 }
 
-namespace {
-
-StringRef skipPadding(StringRef Data) {
+static StringRef skipPadding(StringRef Data) {
   if (Data.empty())
     return Data;
   uint8_t Leaf = Data.front();
@@ -2393,8 +2367,6 @@ StringRef skipPadding(StringRef Data) {
   return Data.drop_front(Leaf & 0x0F);
 }
 
-} // end anonymous namespace
-
 void COFFDumper::printMemberAttributes(MemberAttributes Attrs) {
   W.printEnum("AccessSpecifier", uint8_t(Attrs.getAccess()),
               makeArrayRef(MemberAccessNames));
@@ -2659,9 +2631,7 @@ void COFFDumper::printSymbols() {
 
 void COFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); }
 
-namespace {
-
-ErrorOr<StringRef>
+static ErrorOr<StringRef>
 getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber,
                const coff_section *Section) {
   if (Section) {
@@ -2679,8 +2649,6 @@ getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber,
   return StringRef("");
 }
 
-} // end anonymous namespace
-
 void COFFDumper::printSymbol(const SymbolRef &Sym) {
   DictScope D(W, "Symbol");
 
@@ -2925,9 +2893,7 @@ void COFFDumper::printCOFFDirectives() {
   }
 }
 
-namespace {
-
-StringRef getBaseRelocTypeName(uint8_t Type) {
+static StringRef getBaseRelocTypeName(uint8_t Type) {
   switch (Type) {
   case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE";
   case COFF::IMAGE_REL_BASED_HIGH: return "HIGH";
@@ -2940,8 +2906,6 @@ StringRef getBaseRelocTypeName(uint8_t Type) {
   }
 }
 
-} // end anonymous namespace
-
 void COFFDumper::printCOFFBaseReloc() {
   ListScope D(W, "BaseReloc");
   for (const BaseRelocRef &I : Obj->base_relocs()) {
diff --git a/llvm/tools/sancov/sancov.cc b/llvm/tools/sancov/sancov.cc
index 0d2b48ca868..0baaae16cfe 100644
--- a/llvm/tools/sancov/sancov.cc
+++ b/llvm/tools/sancov/sancov.cc
@@ -1,4 +1,4 @@
-//===-- sancov.cc ---------------------------------------------------------===//
+//===-- sancov.cc --------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -10,13 +10,7 @@
 // This file is a command-line tool for reading and analyzing sanitizer
 // coverage.
 //===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/MC/MCAsmInfo.h"
@@ -53,13 +47,9 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include <algorithm>
-#include <cstdint>
-#include <cstdlib>
-#include <map>
-#include <memory>
 #include <set>
+#include <stdio.h>
 #include <string>
-#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -93,28 +83,28 @@ cl::opt<ActionType> Action(
                           "Print coverage statistics."),
                clEnumValEnd));
 
-cl::list<std::string>
+static cl::list<std::string>
     ClInputFiles(cl::Positional, cl::OneOrMore,
                  cl::desc("(<binary file>|<.sancov file>)..."));
 
-cl::opt<bool> ClDemangle("demangle", cl::init(true),
-                         cl::desc("Print demangled function name."));
+static cl::opt<bool> ClDemangle("demangle", cl::init(true),
+                                cl::desc("Print demangled function name."));
 
-cl::opt<std::string> ClStripPathPrefix(
+static cl::opt<std::string> ClStripPathPrefix(
     "strip_path_prefix", cl::init(""),
     cl::desc("Strip this prefix from file paths in reports."));
 
-cl::opt<std::string>
+static cl::opt<std::string>
     ClBlacklist("blacklist", cl::init(""),
                 cl::desc("Blacklist file (sanitizer blacklist format)."));
 
-cl::opt<bool> ClUseDefaultBlacklist(
+static cl::opt<bool> ClUseDefaultBlacklist(
     "use_default_blacklist", cl::init(true), cl::Hidden,
     cl::desc("Controls if default blacklist should be used."));
 
-const char *const DefaultBlacklistStr = "fun:__sanitizer_.*\n"
-                                        "src:/usr/include/.*\n"
-                                        "src:.*/libc\\+\\+/.*\n";
+static const char *const DefaultBlacklistStr = "fun:__sanitizer_.*\n"
+                                               "src:/usr/include/.*\n"
+                                               "src:.*/libc\\+\\+/.*\n";
 
 // --------- FORMAT SPECIFICATION ---------
 
@@ -123,37 +113,37 @@ struct FileHeader {
   uint32_t Magic;
 };
 
-const uint32_t BinCoverageMagic = 0xC0BFFFFF;
-const uint32_t Bitness32 = 0xFFFFFF32;
-const uint32_t Bitness64 = 0xFFFFFF64;
+static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
+static const uint32_t Bitness32 = 0xFFFFFF32;
+static const uint32_t Bitness64 = 0xFFFFFF64;
 
 // --------- ERROR HANDLING ---------
 
-void Fail(const llvm::Twine &E) {
+static void Fail(const llvm::Twine &E) {
   errs() << "Error: " << E << "\n";
   exit(1);
 }
 
-void FailIfError(std::error_code Error) {
+static void FailIfError(std::error_code Error) {
   if (!Error)
     return;
   errs() << "Error: " << Error.message() << "(" << Error.value() << ")\n";
   exit(1);
 }
 
-template <typename T>
-void FailIfError(const ErrorOr<T> &E) {
+template <typename T> static void FailIfError(const ErrorOr<T> &E) {
   FailIfError(E.getError());
 }
 
-void FailIfNotEmpty(const llvm::Twine &E) {
+static void FailIfNotEmpty(const llvm::Twine &E) {
   if (E.str().empty())
     return;
   Fail(E);
 }
 
 template <typename T>
-void FailIfEmpty(const std::unique_ptr<T> &Ptr, const std::string &Message) {
+static void FailIfEmpty(const std::unique_ptr<T> &Ptr,
+                        const std::string &Message) {
   if (Ptr.get())
     return;
   Fail(Message);
@@ -164,7 +154,7 @@ void FailIfEmpty(const std::unique_ptr<T> &Ptr, const std::string &Message) {
 // Produces std::map<K, std::vector<E>> grouping input
 // elements by FuncTy result.
 template <class RangeTy, class FuncTy>
-inline auto group_by(const RangeTy &R, FuncTy F)
+static inline auto group_by(const RangeTy &R, FuncTy F)
     -> std::map<typename std::decay<decltype(F(*R.begin()))>::type,
                 std::vector<typename std::decay<decltype(*R.begin())>::type>> {
   std::map<typename std::decay<decltype(F(*R.begin()))>::type,
@@ -177,7 +167,8 @@ inline auto group_by(const RangeTy &R, FuncTy F)
 }
 
 template <typename T>
-void readInts(const char *Start, const char *End, std::set<uint64_t> *Ints) {
+static void readInts(const char *Start, const char *End,
+                     std::set<uint64_t> *Ints) {
   const T *S = reinterpret_cast<const T *>(Start);
   const T *E = reinterpret_cast<const T *>(End);
   std::copy(S, E, std::inserter(*Ints, Ints->end()));
@@ -220,7 +211,7 @@ std::string stripPathPrefix(std::string Path) {
   return Path.substr(Pos + ClStripPathPrefix.size());
 }
 
-std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
+static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
@@ -285,9 +276,9 @@ private:
 };
 
 // Collect all debug info for given addresses.
-std::vector<AddrInfo> getAddrInfo(std::string ObjectFile,
-                                  const std::set<uint64_t> &Addrs,
-                                  bool InlinedCode) {
+static std::vector<AddrInfo> getAddrInfo(std::string ObjectFile,
+                                         const std::set<uint64_t> &Addrs,
+                                         bool InlinedCode) {
   std::vector<AddrInfo> Result;
   auto Symbolizer(createSymbolizer());
   Blacklists B;
@@ -315,7 +306,7 @@ std::vector<AddrInfo> getAddrInfo(std::string ObjectFile,
 
 // Locate __sanitizer_cov* function addresses that are used for coverage
 // reporting.
-std::set<uint64_t>
+static std::set<uint64_t>
 findSanitizerCovFunctions(const object::ObjectFile &O) {
   std::set<uint64_t> Result;
 
@@ -340,8 +331,8 @@ findSanitizerCovFunctions(const object::ObjectFile &O) {
 // Locate addresses of all coverage points in a file. Coverage point
 // is defined as the 'address of instruction following __sanitizer_cov
 // call - 1'.
-void getObjectCoveragePoints(const object::ObjectFile &O,
-                             std::set<uint64_t> *Addrs) {
+static void getObjectCoveragePoints(const object::ObjectFile &O,
+                                    std::set<uint64_t> *Addrs) {
   Triple TheTriple("unknown-unknown-unknown");
   TheTriple.setArch(Triple::ArchType(O.getArch()));
   auto TripleName = TheTriple.getTriple();
@@ -413,7 +404,7 @@ void getObjectCoveragePoints(const object::ObjectFile &O,
   }
 }
 
-void
+static void
 visitObjectFiles(const object::Archive &A,
                  std::function<void(const object::ObjectFile &)> Fn) {
   for (auto &ErrorOrChild : A.children()) {
@@ -428,7 +419,7 @@ visitObjectFiles(const object::Archive &A,
   }
 }
 
-void
+static void
 visitObjectFiles(std::string FileName,
                  std::function<void(const object::ObjectFile &)> Fn) {
   ErrorOr<object::OwningBinary<object::Binary>> BinaryOrErr =
@@ -464,7 +455,7 @@ std::set<uint64_t> getCoveragePoints(std::string FileName) {
   return Result;
 }
 
-void printCovPoints(std::string ObjFile, raw_ostream &OS) {
+static void printCovPoints(std::string ObjFile, raw_ostream &OS) {
   for (uint64_t Addr : getCoveragePoints(ObjFile)) {
     OS << "0x";
     OS.write_hex(Addr);
@@ -472,7 +463,7 @@ void printCovPoints(std::string ObjFile, raw_ostream &OS) {
   }
 }
 
-std::string escapeHtml(const std::string &S) {
+static std::string escapeHtml(const std::string &S) {
   std::string Result;
   Result.reserve(S.size());
   for (char Ch : S) {
@@ -502,7 +493,7 @@ std::string escapeHtml(const std::string &S) {
 
 // Adds leading zeroes wrapped in 'lz' style.
 // Leading zeroes help locate 000% coverage.
-std::string formatHtmlPct(size_t Pct) {
+static std::string formatHtmlPct(size_t Pct) {
   Pct = std::max(std::size_t{0}, std::min(std::size_t{100}, Pct));
 
   std::string Num = std::to_string(Pct);
@@ -513,7 +504,7 @@ std::string formatHtmlPct(size_t Pct) {
   return Zeroes + Num;
 }
 
-std::string anchorName(std::string Anchor) {
+static std::string anchorName(std::string Anchor) {
   llvm::MD5 Hasher;
   llvm::MD5::MD5Result Hash;
   Hasher.update(Anchor);
@@ -524,7 +515,7 @@ std::string anchorName(std::string Anchor) {
   return HexString.str().str();
 }
 
-ErrorOr<bool> isCoverageFile(std::string FileName) {
+static ErrorOr<bool> isCoverageFile(std::string FileName) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(FileName);
   if (!BufOrErr) {
@@ -551,7 +542,7 @@ struct CoverageStats {
   size_t CovFns;
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
+static raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
   OS << "all-edges: " << Stats.AllPoints << "\n";
   OS << "cov-edges: " << Stats.CovPoints << "\n";
   OS << "all-functions: " << Stats.AllFns << "\n";
@@ -831,8 +822,8 @@ private:
   std::vector<AddrInfo> CovAddrInfo;
 };
 
-void printFunctionLocs(const SourceCoverageData::FunctionLocs &FnLocs,
-                       raw_ostream &OS) {
+static void printFunctionLocs(const SourceCoverageData::FunctionLocs &FnLocs,
+                              raw_ostream &OS) {
   for (const auto &Fns : FnLocs) {
     for (const auto &Fn : Fns.second) {
       OS << stripPathPrefix(Fns.first.FileName) << ":" << Fns.first.Line << " "
@@ -1191,7 +1182,7 @@ private:
   const std::set<std::string> CoverageFiles;
 };
 
-} // end anonymous namespace
+} // namespace
 
 int main(int argc, char **argv) {
   // Print stack trace if we signal out.
diff --git a/llvm/tools/sanstats/sanstats.cpp b/llvm/tools/sanstats/sanstats.cpp
index 95f5424ba66..3a8cc9aea8c 100644
--- a/llvm/tools/sanstats/sanstats.cpp
+++ b/llvm/tools/sanstats/sanstats.cpp
@@ -12,26 +12,20 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
-#include <cassert>
-#include <cstdint>
-#include <memory>
-#include <string>
+#include <stdint.h>
 
 using namespace llvm;
 
-namespace {
+static cl::opt<std::string> ClInputFile(cl::Positional, cl::Required,
+                                        cl::desc("<filename>"));
 
-cl::opt<std::string> ClInputFile(cl::Positional, cl::Required,
-                                 cl::desc("<filename>"));
-
-cl::opt<bool> ClDemangle("demangle", cl::init(false),
-                         cl::desc("Print demangled function name."));
+static cl::opt<bool> ClDemangle("demangle", cl::init(false),
+                                cl::desc("Print demangled function name."));
 
 inline uint64_t KindFromData(uint64_t Data, char SizeofPtr) {
   return Data >> (SizeofPtr * 8 - kSanitizerStatKindBits);
@@ -69,7 +63,7 @@ const char *ReadModule(char SizeofPtr, const char *Begin, const char *End) {
   SymbolizerOptions.UseSymbolTable = true;
   symbolize::LLVMSymbolizer Symbolizer(SymbolizerOptions);
 
-  while (true) {
+  while (1) {
     uint64_t Addr = ReadLE(SizeofPtr, Begin, End);
     Begin += SizeofPtr;
     uint64_t Data = ReadLE(SizeofPtr, Begin, End);
@@ -115,8 +109,6 @@ const char *ReadModule(char SizeofPtr, const char *Begin, const char *End) {
   }
 }
 
-} // end anonymous namespace
-
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv,
                               "Sanitizer Statistics Processing Tool");