[LLVM] Fix some Clang-tidy modernize-deprecated-headers 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.

[hans]

lgtm

llvm/trunk/include/llvm/DebugInfo/CodeView/TypeStream.h

 //===- TypeStream.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPESTREAM_H
 #define LLVM_DEBUGINFO_CODEVIEW_TYPESTREAM_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/RecordIterator.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/Endian.h"
-
-#include <stdint.h>
+#include <cstdint>
+#include <system_error>
 
 namespace llvm {
+
 class APSInt;
 
 namespace codeview {
 
 /// 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>

 
 inline iterator_range<TypeIterator> makeTypeRange(ArrayRef<uint8_t> Data) {
   return make_range(TypeIterator(Data), TypeIterator());
 }
 
 } // end namespace codeview
 } // end namespace llvm
 
-#endif
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPESTREAM_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/ByteStream.h

 //===- ByteStream.h - Reads stream data from a byte sequence ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_BYTESTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_BYTESTREAM_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/PDB/Raw/StreamInterface.h"
-
-#include <stdint.h>
-
-#include <system_error>
-#include <vector>
+#include "llvm/Support/Error.h"
+#include <cstdint>
+#include <memory>
 
 namespace llvm {
 namespace pdb {
+
 class StreamReader;
+
 class ByteStream : public StreamInterface {
 public:
   ByteStream();
   explicit ByteStream(MutableArrayRef<uint8_t> Bytes);
   explicit ByteStream(uint32_t Length);
   ~ByteStream() override;
 
   void reset();
public:
 
   ArrayRef<uint8_t> data() const { return Data; }
   StringRef str() const;
 
 private:
   MutableArrayRef<uint8_t> Data;
   std::unique_ptr<uint8_t[]> Ownership;
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_BYTESTREAM_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/MappedBlockStream.h

 //===- MappedBlockStream.h - Reads stream data from a PDBFile ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H
 #define LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/DebugInfo/PDB/Raw/StreamInterface.h"
-
-#include <stdint.h>
-
-#include <system_error>
+#include "llvm/Support/Error.h"
+#include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace pdb {
+
 class PDBFile;
 
 class MappedBlockStream : public StreamInterface {
 public:
   MappedBlockStream(uint32_t StreamIdx, const PDBFile &File);
 
   Error readBytes(uint32_t Offset,
                   MutableArrayRef<uint8_t> Buffer) const override;
   Error getArrayRef(uint32_t Offset, ArrayRef<uint8_t> &Buffer,
                     uint32_t Length) const override;
 
   uint32_t getLength() const override { return StreamLength; }
 
 private:
   uint32_t StreamLength;
   std::vector<uint32_t> BlockList;
   const PDBFile &Pdb;
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_MAPPEDBLOCKSTREAM_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/ModInfo.h

 //===- ModInfo.h - PDB module information -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_MODINFO_H
 #define LLVM_DEBUGINFO_PDB_RAW_MODINFO_H
 
 #include "llvm/ADT/StringRef.h"
-
-#include <stdint.h>
+#include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace pdb {
+
 class ModInfo {
 private:
   struct FileLayout;
 
 public:
   ModInfo(const uint8_t *Bytes);
   ~ModInfo();
 
public:
   ModInfoIterator operator++(int);
   bool operator==(const ModInfoIterator &Other);
   bool operator!=(const ModInfoIterator &Other);
   ModInfoIterator &operator=(const ModInfoIterator &Other);
 
 private:
   const uint8_t *Bytes;
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_MODINFO_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/NameHashTable.h

 //===- NameHashTable.h - PDB Name Hash Table --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_NAMEHASHTABLE_H
 #define LLVM_DEBUGINFO_PDB_RAW_NAMEHASHTABLE_H
 
-#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
 #include "llvm/Support/Error.h"
-
-#include <stdint.h>
-#include <utility>
+#include <cstdint>
+#include <vector>
 
 namespace llvm {
 namespace pdb {
+
 class StreamReader;
+
 class NameHashTable {
 public:
   NameHashTable();
 
   Error load(StreamReader &Stream);
 
   uint32_t getNameCount() const { return NameCount; }
   uint32_t getHashVersion() const { return HashVersion; }
   uint32_t getSignature() const { return Signature; }
 
   StringRef getStringForID(uint32_t ID) const;
   uint32_t getIDForString(StringRef Str) const;
 
   ArrayRef<uint32_t> name_ids() const;
 
 private:
   ByteStream NamesBuffer;
   std::vector<uint32_t> IDs;
   uint32_t Signature;
   uint32_t HashVersion;
   uint32_t NameCount;
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_NAMEHASHTABLE_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/NameMap.h

 //===- NameMap.h - PDB Name Map ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBNAMEMAP_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBNAMEMAP_H
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
-
-#include <stdint.h>
-#include <utility>
+#include <cstdint>
 
 namespace llvm {
 namespace pdb {
+
 class StreamReader;
+
 class NameMap {
 public:
   NameMap();
 
   Error load(StreamReader &Stream);
 
   bool tryGetValue(StringRef Name, uint32_t &Value) const;
 
 private:
   StringMap<uint32_t> Mapping;
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_PDBNAMEMAP_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/RawConstants.h

 //===- PDBRawConstants.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 #define LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H
 
-#include <stdint.h>
+#include <cstdint>
 
 namespace llvm {
 namespace pdb {
+
 enum PdbRaw_ImplVer : uint32_t {
   PdbImplVC2 = 19941610,
   PdbImplVC4 = 19950623,
   PdbImplVC41 = 19950814,
   PdbImplVC50 = 19960307,
   PdbImplVC98 = 19970604,
   PdbImplVC70Dep = 19990604, // deprecated
   PdbImplVC70 = 20000404,

 };
 
 enum SpecialStream : uint32_t {
   StreamPDB = 1,
   StreamTPI = 2,
   StreamDBI = 3,
   StreamIPI = 4,
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_PDBRAWCONSTANTS_H

llvm/trunk/include/llvm/DebugInfo/PDB/Raw/StreamInterface.h

 //===- StreamInterface.h - Base interface for a PDB stream ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_PDB_RAW_STREAMINTERFACE_H
 #define LLVM_DEBUGINFO_PDB_RAW_STREAMINTERFACE_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/DebugInfo/PDB/Raw/RawError.h"
-
-#include <stdint.h>
+#include "llvm/Support/Error.h"
+#include <cstdint>
 
 namespace llvm {
 namespace pdb {
+
 class StreamInterface {
 public:
   virtual ~StreamInterface() {}
 
   virtual Error readBytes(uint32_t Offset,
                           MutableArrayRef<uint8_t> Buffer) const = 0;
   virtual Error getArrayRef(uint32_t Offset, ArrayRef<uint8_t> &Buffer,
                             uint32_t Length) const = 0;
 
   virtual uint32_t getLength() const = 0;
 };
-}
-}
 
-#endif
+} // end namespace pdb
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_PDB_RAW_STREAMINTERFACE_H

llvm/trunk/include/llvm/Object/ELFObjectFile.h

 //===- ELFObjectFile.h - ELF object file implementation ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the ELFObjectFile template class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_ELFOBJECTFILE_H
 #define LLVM_OBJECT_ELFOBJECTFILE_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Object/Binary.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include <algorithm>
-#include <cctype>
-#include <utility>
+#include <cassert>
+#include <cstdint>
+#include <system_error>
 
 namespace llvm {
 namespace object {
 
 class elf_symbol_iterator;
 class ELFSymbolRef;
 class ELFRelocationRef;
 
 class ELFObjectFileBase : public ObjectFile {
   friend class ELFSymbolRef;
   friend class ELFSectionRef;
   friend class ELFRelocationRef;
 
 protected:
   ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
 
   virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0;
   virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
   virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
 
   virtual uint32_t getSectionType(DataRefImpl Sec) const = 0;
   virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0;
 
   virtual ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
-public:
 
+public:
   typedef iterator_range<elf_symbol_iterator> elf_symbol_iterator_range;
   virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
 
   elf_symbol_iterator_range symbols() const;
 
   static inline bool classof(const Binary *v) { return v->isELF(); }
 };
 
protected:
 
   bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
     unsigned char Binding = ESym->getBinding();
     unsigned char Visibility = ESym->getVisibility();
 
     // A symbol is exported if its binding is either GLOBAL or WEAK, and its
     // visibility is either DEFAULT or PROTECTED. All other symbols are not
     // exported.
-    if ((Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK) &&
-        (Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_PROTECTED))
-      return true;
-
-    return false;
+    return ((Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK) &&
+            (Visibility == ELF::STV_DEFAULT ||
+             Visibility == ELF::STV_PROTECTED));
   }
 
   // This flag is used for classof, to distinguish ELFObjectFile from
   // its subclass. If more subclasses will be created, this flag will
   // have to become an enum.
   bool isDyldELFObject;
 
 public:

 ELFObjectFile<ELFT>::getDynamicSymbolIterators() const {
   return make_range(dynamic_symbol_begin(), dynamic_symbol_end());
 }
 
 template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
   return EF.getHeader()->e_type == ELF::ET_REL;
 }
 
-}
-}
+} // end namespace object
+} // end namespace llvm
 
-#endif
+#endif // LLVM_OBJECT_ELFOBJECTFILE_H

llvm/trunk/include/llvm/Support/AtomicOrdering.h

 /// These values are used by LLVM to represent atomic ordering for C++11's
 /// memory model and more, as detailed in docs/Atomics.rst.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ATOMICORDERING_H
 #define LLVM_SUPPORT_ATOMICORDERING_H
 
-#include <stddef.h>
+#include <cstddef>
 
 namespace llvm {
 
 /// Atomic ordering for C11 / C++11's memody models.
 ///
 /// These values cannot change because they are shared with standard library
 /// implementations as well as with other compilers.
 enum class AtomicOrderingCABI {
static const AtomicOrderingCABI lookup[8] = {
       /* acquire   */ AtomicOrderingCABI::acquire,
       /* release   */ AtomicOrderingCABI::release,
       /* acq_rel   */ AtomicOrderingCABI::acq_rel,
       /* seq_cst   */ AtomicOrderingCABI::seq_cst,
   };
   return lookup[(size_t)ao];
 }
 
-} // End namespace llvm
+} // end namespace llvm
 
-#endif
+#endif // LLVM_SUPPORT_ATOMICORDERING_H

llvm/trunk/include/llvm/Target/TargetRecip.h

 // generation will default to using supported operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_TARGETRECIP_H
 #define LLVM_TARGET_TARGETRECIP_H
 
 #include "llvm/ADT/StringRef.h"
+#include <cstdint>
 #include <map>
-#include <stdint.h>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
 struct TargetRecip {
 public:
   TargetRecip();
private:
   std::map<StringRef, RecipParams> RecipMap;
   typedef std::map<StringRef, RecipParams>::iterator RecipIter;
   typedef std::map<StringRef, RecipParams>::const_iterator ConstRecipIter;
 
   bool parseGlobalParams(const std::string &Arg);
   void parseIndividualParams(const std::vector<std::string> &Args);
 };
 
-} // End llvm namespace
+} // end namespace llvm
 
-#endif
+#endif // LLVM_TARGET_TARGETRECIP_H

llvm/trunk/lib/DebugInfo/PDB/Raw/ByteStream.cpp

 //===- ByteStream.cpp - Reads stream data from a byte sequence ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Raw/ByteStream.h"
+#include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/DebugInfo/PDB/Raw/StreamReader.h"
+#include <cstring>
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 ByteStream::ByteStream() {}
 
 ByteStream::ByteStream(MutableArrayRef<uint8_t> Bytes) { initialize(Bytes); }
 

llvm/trunk/lib/DebugInfo/Symbolize/DIPrinter.cpp

 //===- lib/DebugInfo/Symbolize/DIPrinter.cpp ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the DIPrinter class, which is responsible for printing
 // structures defined in DebugInfo/DIContext.h
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/Symbolize/DIPrinter.h"
-
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/LineIterator.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
 
 namespace llvm {
 namespace symbolize {
 
 // By default, DILineInfo contains "<invalid>" for function/filename it
 // cannot fetch. We replace it to "??" to make our output closer to addr2line.
 static const char kDILineInfoBadString[] = "<invalid>";
 static const char kBadString[] = "??";

 }
 
 void DIPrinter::print(const DILineInfo &Info, bool Inlined) {
   if (PrintFunctionNames) {
     std::string FunctionName = Info.FunctionName;
     if (FunctionName == kDILineInfoBadString)
       FunctionName = kBadString;
 
-    StringRef Delimiter = (PrintPretty == true) ? " at " : "\n";
+    StringRef Delimiter = PrintPretty ? " at " : "\n";
     StringRef Prefix = (PrintPretty && Inlined) ? " (inlined by) " : "";
     OS << Prefix << FunctionName << Delimiter;
   }
   std::string Filename = Info.FileName;
   if (Filename == kDILineInfoBadString)
     Filename = kBadString;
   OS << Filename << ":" << Info.Line << ":" << Info.Column << "\n";
   printContext(Filename, Info.Line);
DIPrinter &DIPrinter::operator<<(const DIGlobal &Global) {
   std::string Name = Global.Name;
   if (Name == kDILineInfoBadString)
     Name = kBadString;
   OS << Name << "\n";
   OS << Global.Start << " " << Global.Size << "\n";
   return *this;
 }
 
-}
-}
+} // end namespace symbolize
+} // end namespace llvm