[Object] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@301275 91177308-0d34-0410-b5e6-96231b3b80d8

12 files changed, 287 insertions, 189 deletions

diff --git a/include/llvm/Object/ELF.h b/include/llvm/Object/ELF.h
index 7a3155b3953..9c72bd4023d 100644
--- a/include/llvm/Object/ELF.h
+++ b/include/llvm/Object/ELF.h
@@ -14,9 +14,19 @@
 #ifndef LLVM_OBJECT_ELF_H
 #define LLVM_OBJECT_ELF_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELFTypes.h"
-#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Object/Error.h"
+#include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <utility>
 
 namespace llvm {
 namespace object {
@@ -41,27 +51,27 @@ template <class ELFT>
 class ELFFile {
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
-  typedef typename ELFT::uint uintX_t;
-  typedef typename ELFT::Ehdr Elf_Ehdr;
-  typedef typename ELFT::Shdr Elf_Shdr;
-  typedef typename ELFT::Sym Elf_Sym;
-  typedef typename ELFT::Dyn Elf_Dyn;
-  typedef typename ELFT::Phdr Elf_Phdr;
-  typedef typename ELFT::Rel Elf_Rel;
-  typedef typename ELFT::Rela Elf_Rela;
-  typedef typename ELFT::Verdef Elf_Verdef;
-  typedef typename ELFT::Verdaux Elf_Verdaux;
-  typedef typename ELFT::Verneed Elf_Verneed;
-  typedef typename ELFT::Vernaux Elf_Vernaux;
-  typedef typename ELFT::Versym Elf_Versym;
-  typedef typename ELFT::Hash Elf_Hash;
-  typedef typename ELFT::GnuHash Elf_GnuHash;
-  typedef typename ELFT::DynRange Elf_Dyn_Range;
-  typedef typename ELFT::ShdrRange Elf_Shdr_Range;
-  typedef typename ELFT::SymRange Elf_Sym_Range;
-  typedef typename ELFT::RelRange Elf_Rel_Range;
-  typedef typename ELFT::RelaRange Elf_Rela_Range;
-  typedef typename ELFT::PhdrRange Elf_Phdr_Range;
+  using uintX_t = typename ELFT::uint;
+  using Elf_Ehdr = typename ELFT::Ehdr;
+  using Elf_Shdr = typename ELFT::Shdr;
+  using Elf_Sym = typename ELFT::Sym;
+  using Elf_Dyn = typename ELFT::Dyn;
+  using Elf_Phdr = typename ELFT::Phdr;
+  using Elf_Rel = typename ELFT::Rel;
+  using Elf_Rela = typename ELFT::Rela;
+  using Elf_Verdef = typename ELFT::Verdef;
+  using Elf_Verdaux = typename ELFT::Verdaux;
+  using Elf_Verneed = typename ELFT::Verneed;
+  using Elf_Vernaux = typename ELFT::Vernaux;
+  using Elf_Versym = typename ELFT::Versym;
+  using Elf_Hash = typename ELFT::Hash;
+  using Elf_GnuHash = typename ELFT::GnuHash;
+  using Elf_Dyn_Range = typename ELFT::DynRange;
+  using Elf_Shdr_Range = typename ELFT::ShdrRange;
+  using Elf_Sym_Range = typename ELFT::SymRange;
+  using Elf_Rel_Range = typename ELFT::RelRange;
+  using Elf_Rela_Range = typename ELFT::RelaRange;
+  using Elf_Phdr_Range = typename ELFT::PhdrRange;
 
   const uint8_t *base() const {
     return reinterpret_cast<const uint8_t *>(Buf.data());
@@ -70,7 +80,6 @@ public:
   size_t getBufSize() const { return Buf.size(); }
 
 private:
-
   StringRef Buf;
 
 public:
@@ -161,10 +170,10 @@ public:
   Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *Sec) const;
 };
 
-typedef ELFFile<ELFType<support::little, false>> ELF32LEFile;
-typedef ELFFile<ELFType<support::little, true>> ELF64LEFile;
-typedef ELFFile<ELFType<support::big, false>> ELF32BEFile;
-typedef ELFFile<ELFType<support::big, true>> ELF64BEFile;
+using ELF32LEFile = ELFFile<ELFType<support::little, false>>;
+using ELF64LEFile = ELFFile<ELFType<support::little, true>>;
+using ELF32BEFile = ELFFile<ELFType<support::big, false>>;
+using ELF64BEFile = ELFFile<ELFType<support::big, true>>;
 
 template <class ELFT>
 inline Expected<const typename ELFT::Shdr *>
@@ -194,7 +203,7 @@ ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
                                ArrayRef<Elf_Word> ShndxTable) const {
   uint32_t Index = Sym->st_shndx;
   if (Index == ELF::SHN_XINDEX) {
-    auto ErrorOrIndex = object::getExtendedSymbolTableIndex<ELFT>(
+    auto ErrorOrIndex = getExtendedSymbolTableIndex<ELFT>(
         Sym, Syms.begin(), ShndxTable);
     if (!ErrorOrIndex)
       return ErrorOrIndex.takeError();
@@ -519,7 +528,8 @@ inline unsigned hashSysV(StringRef SymbolName) {
   }
   return h;
 }
+
 } // end namespace object
 } // end namespace llvm
 
-#endif
+#endif // LLVM_OBJECT_ELF_H
diff --git a/include/llvm/Object/ELFObjectFile.h b/include/llvm/Object/ELFObjectFile.h
index 9e95f2958aa..d8b58b8079f 100644
--- a/include/llvm/Object/ELFObjectFile.h
+++ b/include/llvm/Object/ELFObjectFile.h
@@ -27,6 +27,7 @@
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/ARMAttributeParser.h"
+#include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
@@ -42,13 +43,11 @@ 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;
+  friend class ELFSectionRef;
+  friend class ELFSymbolRef;
 
 protected:
   ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
@@ -65,7 +64,8 @@ protected:
   virtual ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
 
 public:
-  typedef iterator_range<elf_symbol_iterator> elf_symbol_iterator_range;
+  using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>;
+
   virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
 
   elf_symbol_iterator_range symbols() const;
@@ -201,14 +201,14 @@ template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
 public:
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 
-  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
+  using uintX_t = typename ELFFile<ELFT>::uintX_t;
 
-  typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
-  typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
-  typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
-  typedef typename ELFFile<ELFT>::Elf_Rel Elf_Rel;
-  typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
-  typedef typename ELFFile<ELFT>::Elf_Dyn Elf_Dyn;
+  using Elf_Sym = typename ELFFile<ELFT>::Elf_Sym;
+  using Elf_Shdr = typename ELFFile<ELFT>::Elf_Shdr;
+  using Elf_Ehdr = typename ELFFile<ELFT>::Elf_Ehdr;
+  using Elf_Rel = typename ELFFile<ELFT>::Elf_Rel;
+  using Elf_Rela = typename ELFFile<ELFT>::Elf_Rela;
+  using Elf_Dyn = typename ELFFile<ELFT>::Elf_Dyn;
 
 protected:
   ELFFile<ELFT> EF;
@@ -398,10 +398,10 @@ public:
   bool isRelocatableObject() const override;
 };
 
-typedef ELFObjectFile<ELFType<support::little, false>> ELF32LEObjectFile;
-typedef ELFObjectFile<ELFType<support::little, true>> ELF64LEObjectFile;
-typedef ELFObjectFile<ELFType<support::big, false>> ELF32BEObjectFile;
-typedef ELFObjectFile<ELFType<support::big, true>> ELF64BEObjectFile;
+using ELF32LEObjectFile = ELFObjectFile<ELFType<support::little, false>>;
+using ELF64LEObjectFile = ELFObjectFile<ELFType<support::little, true>>;
+using ELF32BEObjectFile = ELFObjectFile<ELFType<support::big, false>>;
+using ELF64BEObjectFile = ELFObjectFile<ELFType<support::big, true>>;
 
 template <class ELFT>
 void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
diff --git a/include/llvm/Object/ELFTypes.h b/include/llvm/Object/ELFTypes.h
index 3e03fd8b980..99346fe1a88 100644
--- a/include/llvm/Object/ELFTypes.h
+++ b/include/llvm/Object/ELFTypes.h
@@ -11,10 +11,15 @@
 #define LLVM_OBJECT_ELFTYPES_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
-#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/Error.h"
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
 
 namespace llvm {
 namespace object {
@@ -45,58 +50,58 @@ public:
   static const endianness TargetEndianness = E;
   static const bool Is64Bits = Is64;
 
-  typedef typename std::conditional<Is64, uint64_t, uint32_t>::type uint;
-  typedef Elf_Ehdr_Impl<ELFType<E, Is64>> Ehdr;
-  typedef Elf_Shdr_Impl<ELFType<E, Is64>> Shdr;
-  typedef Elf_Sym_Impl<ELFType<E, Is64>> Sym;
-  typedef Elf_Dyn_Impl<ELFType<E, Is64>> Dyn;
-  typedef Elf_Phdr_Impl<ELFType<E, Is64>> Phdr;
-  typedef Elf_Rel_Impl<ELFType<E, Is64>, false> Rel;
-  typedef Elf_Rel_Impl<ELFType<E, Is64>, true> Rela;
-  typedef Elf_Verdef_Impl<ELFType<E, Is64>> Verdef;
-  typedef Elf_Verdaux_Impl<ELFType<E, Is64>> Verdaux;
-  typedef Elf_Verneed_Impl<ELFType<E, Is64>> Verneed;
-  typedef Elf_Vernaux_Impl<ELFType<E, Is64>> Vernaux;
-  typedef Elf_Versym_Impl<ELFType<E, Is64>> Versym;
-  typedef Elf_Hash_Impl<ELFType<E, Is64>> Hash;
-  typedef Elf_GnuHash_Impl<ELFType<E, Is64>> GnuHash;
-  typedef Elf_Chdr_Impl<ELFType<E, Is64>> Chdr;
-  typedef ArrayRef<Dyn> DynRange;
-  typedef ArrayRef<Shdr> ShdrRange;
-  typedef ArrayRef<Sym> SymRange;
-  typedef ArrayRef<Rel> RelRange;
-  typedef ArrayRef<Rela> RelaRange;
-  typedef ArrayRef<Phdr> PhdrRange;
-
-  typedef packed<uint16_t> Half;
-  typedef packed<uint32_t> Word;
-  typedef packed<int32_t> Sword;
-  typedef packed<uint64_t> Xword;
-  typedef packed<int64_t> Sxword;
-  typedef packed<uint> Addr;
-  typedef packed<uint> Off;
-};
-
-typedef ELFType<support::little, false> ELF32LE;
-typedef ELFType<support::big, false> ELF32BE;
-typedef ELFType<support::little, true> ELF64LE;
-typedef ELFType<support::big, true> ELF64BE;
+  using uint = typename std::conditional<Is64, uint64_t, uint32_t>::type;
+  using Ehdr = Elf_Ehdr_Impl<ELFType<E, Is64>>;
+  using Shdr = Elf_Shdr_Impl<ELFType<E, Is64>>;
+  using Sym = Elf_Sym_Impl<ELFType<E, Is64>>;
+  using Dyn = Elf_Dyn_Impl<ELFType<E, Is64>>;
+  using Phdr = Elf_Phdr_Impl<ELFType<E, Is64>>;
+  using Rel = Elf_Rel_Impl<ELFType<E, Is64>, false>;
+  using Rela = Elf_Rel_Impl<ELFType<E, Is64>, true>;
+  using Verdef = Elf_Verdef_Impl<ELFType<E, Is64>>;
+  using Verdaux = Elf_Verdaux_Impl<ELFType<E, Is64>>;
+  using Verneed = Elf_Verneed_Impl<ELFType<E, Is64>>;
+  using Vernaux = Elf_Vernaux_Impl<ELFType<E, Is64>>;
+  using Versym = Elf_Versym_Impl<ELFType<E, Is64>>;
+  using Hash = Elf_Hash_Impl<ELFType<E, Is64>>;
+  using GnuHash = Elf_GnuHash_Impl<ELFType<E, Is64>>;
+  using Chdr = Elf_Chdr_Impl<ELFType<E, Is64>>;
+  using DynRange = ArrayRef<Dyn>;
+  using ShdrRange = ArrayRef<Shdr>;
+  using SymRange = ArrayRef<Sym>;
+  using RelRange = ArrayRef<Rel>;
+  using RelaRange = ArrayRef<Rela>;
+  using PhdrRange = ArrayRef<Phdr>;
+
+  using Half = packed<uint16_t>;
+  using Word = packed<uint32_t>;
+  using Sword = packed<int32_t>;
+  using Xword = packed<uint64_t>;
+  using Sxword = packed<int64_t>;
+  using Addr = packed<uint>;
+  using Off = packed<uint>;
+};
+
+using ELF32LE = ELFType<support::little, false>;
+using ELF32BE = ELFType<support::big, false>;
+using ELF64LE = ELFType<support::little, true>;
+using ELF64BE = ELFType<support::big, true>;
 
 // Use an alignment of 2 for the typedefs since that is the worst case for
 // ELF files in archives.
 
 // Templates to choose Elf_Addr and Elf_Off depending on is64Bits.
 template <endianness target_endianness> struct ELFDataTypeTypedefHelperCommon {
-  typedef support::detail::packed_endian_specific_integral<
-      uint16_t, target_endianness, 2> Elf_Half;
-  typedef support::detail::packed_endian_specific_integral<
-      uint32_t, target_endianness, 2> Elf_Word;
-  typedef support::detail::packed_endian_specific_integral<
-      int32_t, target_endianness, 2> Elf_Sword;
-  typedef support::detail::packed_endian_specific_integral<
-      uint64_t, target_endianness, 2> Elf_Xword;
-  typedef support::detail::packed_endian_specific_integral<
-      int64_t, target_endianness, 2> Elf_Sxword;
+  using Elf_Half = support::detail::packed_endian_specific_integral<
+      uint16_t, target_endianness, 2>;
+  using Elf_Word = support::detail::packed_endian_specific_integral<
+      uint32_t, target_endianness, 2>;
+  using Elf_Sword = support::detail::packed_endian_specific_integral<
+      int32_t, target_endianness, 2>;
+  using Elf_Xword = support::detail::packed_endian_specific_integral<
+      uint64_t, target_endianness, 2>;
+  using Elf_Sxword = support::detail::packed_endian_specific_integral<
+      int64_t, target_endianness, 2>;
 };
 
 template <class ELFT> struct ELFDataTypeTypedefHelper;
@@ -105,34 +110,34 @@ template <class ELFT> struct ELFDataTypeTypedefHelper;
 template <endianness TargetEndianness>
 struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, false>>
     : ELFDataTypeTypedefHelperCommon<TargetEndianness> {
-  typedef uint32_t value_type;
-  typedef support::detail::packed_endian_specific_integral<
-      value_type, TargetEndianness, 2> Elf_Addr;
-  typedef support::detail::packed_endian_specific_integral<
-      value_type, TargetEndianness, 2> Elf_Off;
+  using value_type = uint32_t;
+  using Elf_Addr = support::detail::packed_endian_specific_integral<
+      value_type, TargetEndianness, 2>;
+  using Elf_Off = support::detail::packed_endian_specific_integral<
+      value_type, TargetEndianness, 2>;
 };
 
 /// ELF 64bit types.
 template <endianness TargetEndianness>
 struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, true>>
     : ELFDataTypeTypedefHelperCommon<TargetEndianness> {
-  typedef uint64_t value_type;
-  typedef support::detail::packed_endian_specific_integral<
-      value_type, TargetEndianness, 2> Elf_Addr;
-  typedef support::detail::packed_endian_specific_integral<
-      value_type, TargetEndianness, 2> Elf_Off;
+  using value_type = uint64_t;
+  using Elf_Addr = support::detail::packed_endian_specific_integral<
+      value_type, TargetEndianness, 2>;
+  using Elf_Off = support::detail::packed_endian_specific_integral<
+      value_type, TargetEndianness, 2>;
 };
 
 // I really don't like doing this, but the alternative is copypasta.
 
 #define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)                                       \
-  typedef typename ELFT::Addr Elf_Addr;                                        \
-  typedef typename ELFT::Off Elf_Off;                                          \
-  typedef typename ELFT::Half Elf_Half;                                        \
-  typedef typename ELFT::Word Elf_Word;                                        \
-  typedef typename ELFT::Sword Elf_Sword;                                      \
-  typedef typename ELFT::Xword Elf_Xword;                                      \
-  typedef typename ELFT::Sxword Elf_Sxword;
+  using Elf_Addr = typename ELFT::Addr;                                        \
+  using Elf_Off = typename ELFT::Off;                                          \
+  using Elf_Half = typename ELFT::Half;                                        \
+  using Elf_Word = typename ELFT::Word;                                        \
+  using Elf_Sword = typename ELFT::Sword;                                      \
+  using Elf_Xword = typename ELFT::Xword;                                      \
+  using Elf_Sxword = typename ELFT::Sxword;
 
 #define LLD_ELF_COMMA ,
 #define LLVM_ELF_IMPORT_TYPES(E, W)                                            \
@@ -222,6 +227,7 @@ struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
   uint64_t getValue() const { return st_value; }
   void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
   void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
+
   void setBindingAndType(unsigned char b, unsigned char t) {
     st_info = (b << 4) + (t & 0x0f);
   }
@@ -238,22 +244,29 @@ struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
   }
 
   bool isAbsolute() const { return st_shndx == ELF::SHN_ABS; }
+
   bool isCommon() const {
     return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
   }
+
   bool isDefined() const { return !isUndefined(); }
+
   bool isProcessorSpecific() const {
     return st_shndx >= ELF::SHN_LOPROC && st_shndx <= ELF::SHN_HIPROC;
   }
+
   bool isOSSpecific() const {
     return st_shndx >= ELF::SHN_LOOS && st_shndx <= ELF::SHN_HIOS;
   }
+
   bool isReserved() const {
     // ELF::SHN_HIRESERVE is 0xffff so st_shndx <= ELF::SHN_HIRESERVE is always
     // true and some compilers warn about it.
     return st_shndx >= ELF::SHN_LORESERVE;
   }
+
   bool isUndefined() const { return st_shndx == ELF::SHN_UNDEF; }
+
   bool isExternal() const {
     return getBinding() != ELF::STB_LOCAL;
   }
@@ -277,14 +290,12 @@ struct Elf_Versym_Impl {
   Elf_Half vs_index; // Version index with flags (e.g. VERSYM_HIDDEN)
 };
 
-template <class ELFT> struct Elf_Verdaux_Impl;
-
 /// Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section
 /// (.gnu.version_d). This structure is identical for ELF32 and ELF64.
 template <class ELFT>
 struct Elf_Verdef_Impl {
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
-  typedef Elf_Verdaux_Impl<ELFT> Elf_Verdaux;
+  using Elf_Verdaux = Elf_Verdaux_Impl<ELFT>;
   Elf_Half vd_version; // Version of this structure (e.g. VER_DEF_CURRENT)
   Elf_Half vd_flags;   // Bitwise flags (VER_DEF_*)
   Elf_Half vd_ndx;     // Version index, used in .gnu.version entries
@@ -361,10 +372,10 @@ template <class ELFT>
 struct Elf_Dyn_Impl : Elf_Dyn_Base<ELFT> {
   using Elf_Dyn_Base<ELFT>::d_tag;
   using Elf_Dyn_Base<ELFT>::d_un;
-  typedef typename std::conditional<ELFT::Is64Bits,
-                                    int64_t, int32_t>::type intX_t;
-  typedef typename std::conditional<ELFT::Is64Bits,
-                                    uint64_t, uint32_t>::type uintX_t;
+  using intX_t = typename std::conditional<ELFT::Is64Bits,
+                                           int64_t, int32_t>::type;
+  using uintX_t = typename std::conditional<ELFT::Is64Bits,
+                                            uint64_t, uint32_t>::type;
   intX_t getTag() const { return d_tag; }
   uintX_t getVal() const { return d_un.d_val; }
   uintX_t getPtr() const { return d_un.d_ptr; }
@@ -430,6 +441,7 @@ struct Elf_Rel_Impl<ELFType<TargetEndianness, true>, false> {
     return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) |
            ((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff);
   }
+
   void setRInfo(uint64_t R, bool IsMips64EL) {
     if (IsMips64EL)
       r_info = (R >> 32) | ((R & 0xff000000) << 8) | ((R & 0x00ff0000) << 24) |
@@ -483,15 +495,15 @@ struct Elf_Ehdr_Impl {
   Elf_Half e_shnum;     // Number of entries in the section header table
   Elf_Half e_shstrndx;  // Section header table index of section name
                         // string table
+
   bool checkMagic() const {
     return (memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
   }
+
   unsigned char getFileClass() const { return e_ident[ELF::EI_CLASS]; }
   unsigned char getDataEncoding() const { return e_ident[ELF::EI_DATA]; }
 };
 
-template <class ELFT> struct Elf_Phdr_Impl;
-
 template <endianness TargetEndianness>
 struct Elf_Phdr_Impl<ELFType<TargetEndianness, false>> {
   LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
@@ -582,7 +594,7 @@ struct Elf_Chdr_Impl<ELFType<TargetEndianness, true>> {
 template <class ELFT>
 struct Elf_Mips_RegInfo;
 
-template <llvm::support::endianness TargetEndianness>
+template <support::endianness TargetEndianness>
 struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
   LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
   Elf_Word ri_gprmask;     // bit-mask of used general registers
@@ -590,7 +602,7 @@ struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
   Elf_Addr ri_gp_value;    // gp register value
 };
 
-template <llvm::support::endianness TargetEndianness>
+template <support::endianness TargetEndianness>
 struct Elf_Mips_RegInfo<ELFType<TargetEndianness, true>> {
   LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
   Elf_Word ri_gprmask;     // bit-mask of used general registers
@@ -609,7 +621,7 @@ template <class ELFT> struct Elf_Mips_Options {
   Elf_Word info;    // Kind-specific information
 
   Elf_Mips_RegInfo<ELFT> &getRegInfo() {
-    assert(kind == llvm::ELF::ODK_REGINFO);
+    assert(kind == ELF::ODK_REGINFO);
     return *reinterpret_cast<Elf_Mips_RegInfo<ELFT> *>(
         (uint8_t *)this + sizeof(Elf_Mips_Options));
   }
@@ -637,4 +649,4 @@ template <class ELFT> struct Elf_Mips_ABIFlags {
 } // end namespace object.
 } // end namespace llvm.
 
-#endif
+#endif // LLVM_OBJECT_ELFTYPES_H
diff --git a/include/llvm/Object/IRSymtab.h b/include/llvm/Object/IRSymtab.h
index be0f02aa7f1..b425543bf63 100644
--- a/include/llvm/Object/IRSymtab.h
+++ b/include/llvm/Object/IRSymtab.h
@@ -25,23 +25,31 @@
 #define LLVM_OBJECT_IRSYMTAB_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include <cassert>
+#include <cstdint>
+#include <vector>
 
 namespace llvm {
 namespace irsymtab {
+
 namespace storage {
 
 // The data structures in this namespace define the low-level serialization
 // format. Clients that just want to read a symbol table should use the
 // irsymtab::Reader class.
 
-typedef support::ulittle32_t Word;
+using Word = support::ulittle32_t;
 
 /// A reference to a string in the string table.
 struct Str {
   Word Offset, Size;
+
   StringRef get(StringRef Strtab) const {
     return {Strtab.data() + Offset, Size};
   }
@@ -50,6 +58,7 @@ struct Str {
 /// A reference to a range of objects in the symbol table.
 template <typename T> struct Range {
   Word Offset, Size;
+
   ArrayRef<T> get(StringRef Symtab) const {
     return {reinterpret_cast<const T *>(Symtab.data() + Offset), Size};
   }
@@ -122,7 +131,7 @@ struct Header {
   Str COFFLinkerOpts;
 };
 
-}
+} // end namespace storage
 
 /// Fills in Symtab and Strtab with a valid symbol and string table for Mods.
 Error build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
@@ -152,18 +161,22 @@ struct Symbol {
   int getComdatIndex() const { return ComdatIndex; }
 
   using S = storage::Symbol;
+
   GlobalValue::VisibilityTypes getVisibility() const {
     return GlobalValue::VisibilityTypes((Flags >> S::FB_visibility) & 3);
   }
+
   bool isUndefined() const { return (Flags >> S::FB_undefined) & 1; }
   bool isWeak() const { return (Flags >> S::FB_weak) & 1; }
   bool isCommon() const { return (Flags >> S::FB_common) & 1; }
   bool isIndirect() const { return (Flags >> S::FB_indirect) & 1; }
   bool isUsed() const { return (Flags >> S::FB_used) & 1; }
   bool isTLS() const { return (Flags >> S::FB_tls) & 1; }
+
   bool canBeOmittedFromSymbolTable() const {
     return (Flags >> S::FB_may_omit) & 1;
   }
+
   bool isGlobal() const { return (Flags >> S::FB_global) & 1; }
   bool isFormatSpecific() const { return (Flags >> S::FB_format_specific) & 1; }
   bool isUnnamedAddr() const { return (Flags >> S::FB_unnamed_addr) & 1; }
@@ -173,6 +186,7 @@ struct Symbol {
     assert(isCommon());
     return CommonSize;
   }
+
   uint32_t getCommonAlignment() const {
     assert(isCommon());
     return CommonAlign;
@@ -197,9 +211,11 @@ class Reader {
   ArrayRef<storage::Uncommon> Uncommons;
 
   StringRef str(storage::Str S) const { return S.get(Strtab); }
+
   template <typename T> ArrayRef<T> range(storage::Range<T> R) const {
     return R.get(Symtab);
   }
+
   const storage::Header &header() const {
     return *reinterpret_cast<const storage::Header *>(Symtab.data());
   }
@@ -215,7 +231,7 @@ public:
     Uncommons = range(header().Uncommons);
   }
 
-  typedef iterator_range<object::content_iterator<SymbolRef>> symbol_range;
+  using symbol_range = iterator_range<object::content_iterator<SymbolRef>>;
 
   /// Returns the symbol table for the entire bitcode file.
   /// The symbols enumerated by this method are ephemeral, but they can be
@@ -298,8 +314,7 @@ inline Reader::symbol_range Reader::module_symbols(unsigned I) const {
           SymbolRef(MEnd, MEnd, nullptr, this)};
 }
 
-}
-
-}
+} // end namespace irsymtab
+} // end namespace llvm
 
-#endif
+#endif // LLVM_OBJECT_IRSYMTAB_H
diff --git a/include/llvm/Object/ModuleSymbolTable.h b/include/llvm/Object/ModuleSymbolTable.h
index 333301d5b45..9e932288538 100644
--- a/include/llvm/Object/ModuleSymbolTable.h
+++ b/include/llvm/Object/ModuleSymbolTable.h
@@ -1,4 +1,4 @@
-//===- ModuleSymbolTable.h - symbol table for in-memory IR ----------------===//
+//===- ModuleSymbolTable.h - symbol table for in-memory IR ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -16,22 +16,24 @@
 #ifndef LLVM_OBJECT_MODULESYMBOLTABLE_H
 #define LLVM_OBJECT_MODULESYMBOLTABLE_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerUnion.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Allocator.h"
+#include <cstdint>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace llvm {
 
 class GlobalValue;
-class RecordStreamer;
 
 class ModuleSymbolTable {
 public:
-  typedef std::pair<std::string, uint32_t> AsmSymbol;
-  typedef PointerUnion<GlobalValue *, AsmSymbol *> Symbol;
+  using AsmSymbol = std::pair<std::string, uint32_t>;
+  using Symbol = PointerUnion<GlobalValue *, AsmSymbol *>;
 
 private:
   Module *FirstMod = nullptr;
@@ -57,6 +59,6 @@ public:
       function_ref<void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol);
 };
 
-}
+} // end namespace llvm
 
-#endif
+#endif // LLVM_OBJECT_MODULESYMBOLTABLE_H
diff --git a/include/llvm/Object/StackMapParser.h b/include/llvm/Object/StackMapParser.h
index efea62bb3cb..0c5e1e38cba 100644
--- a/include/llvm/Object/StackMapParser.h
+++ b/include/llvm/Object/StackMapParser.h
@@ -1,4 +1,4 @@
-//===-------- StackMapParser.h - StackMap Parsing Support -------*- C++ -*-===//
+//===- StackMapParser.h - StackMap Parsing Support --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,7 +11,11 @@
 #define LLVM_CODEGEN_STACKMAPPARSER_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Endian.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <vector>
 
 namespace llvm {
@@ -19,12 +23,11 @@ namespace llvm {
 template <support::endianness Endianness>
 class StackMapV2Parser {
 public:
-
   template <typename AccessorT>
   class AccessorIterator {
   public:
-
     AccessorIterator(AccessorT A) : A(A) {}
+
     AccessorIterator& operator++() { A = A.next(); return *this; }
     AccessorIterator operator++(int) {
       auto tmp = *this;
@@ -48,8 +51,8 @@ public:
   /// Accessor for function records.
   class FunctionAccessor {
     friend class StackMapV2Parser;
-  public:
 
+  public:
     /// Get the function address.
     uint64_t getFunctionAddress() const {
       return read<uint64_t>(P);
@@ -80,13 +83,12 @@ public:
   /// Accessor for constants.
   class ConstantAccessor {
     friend class StackMapV2Parser;
-  public:
 
+  public:
     /// Return the value of this constant.
     uint64_t getValue() const { return read<uint64_t>(P); }
 
   private:
-
     ConstantAccessor(const uint8_t *P) : P(P) {}
 
     const static int ConstantAccessorSize = sizeof(uint64_t);
@@ -98,20 +100,16 @@ public:
     const uint8_t *P;
   };
 
-  // Forward-declare RecordAccessor so we can friend it below.
-  class RecordAccessor;
-
   enum class LocationKind : uint8_t {
     Register = 1, Direct = 2, Indirect = 3, Constant = 4, ConstantIndex = 5
   };
 
-
   /// Accessor for location records.
   class LocationAccessor {
     friend class StackMapV2Parser;
     friend class RecordAccessor;
-  public:
 
+  public:
     /// Get the Kind for this location.
     LocationKind getKind() const {
       return LocationKind(P[KindOffset]);
@@ -144,7 +142,6 @@ public:
     }
 
   private:
-
     LocationAccessor(const uint8_t *P) : P(P) {}
 
     LocationAccessor next() const {
@@ -163,8 +160,8 @@ public:
   class LiveOutAccessor {
     friend class StackMapV2Parser;
     friend class RecordAccessor;
-  public:
 
+  public:
     /// Get the Dwarf register number for this live-out.
     uint16_t getDwarfRegNum() const {
       return read<uint16_t>(P + DwarfRegNumOffset);
@@ -176,7 +173,6 @@ public:
     }
 
   private:
-
     LiveOutAccessor(const uint8_t *P) : P(P) {}
 
     LiveOutAccessor next() const {
@@ -194,10 +190,10 @@ public:
   /// Accessor for stackmap records.
   class RecordAccessor {
     friend class StackMapV2Parser;
-  public:
 
-    typedef AccessorIterator<LocationAccessor> location_iterator;
-    typedef AccessorIterator<LiveOutAccessor> liveout_iterator;
+  public:
+    using location_iterator = AccessorIterator<LocationAccessor>;
+    using liveout_iterator = AccessorIterator<LiveOutAccessor>;
 
     /// Get the patchpoint/stackmap ID for this record.
     uint64_t getID() const {
@@ -254,7 +250,6 @@ public:
       return liveout_iterator(getLiveOut(0));
     }
 
-
     /// End iterator for live-outs.
     liveout_iterator liveouts_end() const {
       return liveout_iterator(getLiveOut(getNumLiveOuts()));
@@ -266,7 +261,6 @@ public:
     }
 
   private:
-
     RecordAccessor(const uint8_t *P) : P(P) {}
 
     unsigned getNumLiveOutsOffset() const {
@@ -316,9 +310,9 @@ public:
     }
   }
 
-  typedef AccessorIterator<FunctionAccessor> function_iterator;
-  typedef AccessorIterator<ConstantAccessor> constant_iterator;
-  typedef AccessorIterator<RecordAccessor> record_iterator;
+  using function_iterator = AccessorIterator<FunctionAccessor>;
+  using constant_iterator = AccessorIterator<ConstantAccessor>;
+  using record_iterator = AccessorIterator<RecordAccessor>;
 
   /// Get the version number of this stackmap. (Always returns 2).
   unsigned getVersion() const { return 2; }
@@ -413,7 +407,6 @@ public:
   }
 
 private:
-
   template <typename T>
   static T read(const uint8_t *P) {
     return support::endian::read<T, Endianness, 1>(P);
@@ -441,6 +434,6 @@ private:
   std::vector<unsigned> StackMapRecordOffsets;
 };
 
-}
+} // end namespace llvm
 
-#endif
+#endif // LLVM_CODEGEN_STACKMAPPARSER_H
diff --git a/lib/Object/ELF.cpp b/lib/Object/ELF.cpp
index 23682e1fabf..e89a4a315c4 100644
--- a/lib/Object/ELF.cpp
+++ b/lib/Object/ELF.cpp
@@ -1,4 +1,4 @@
-//===- ELF.cpp - ELF object file implementation -----------------*- C++ -*-===//
+//===- ELF.cpp - ELF object file implementation ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,15 +8,17 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
 
-namespace llvm {
-namespace object {
+using namespace llvm;
+using namespace object;
 
 #define ELF_RELOC(name, value)                                          \
   case ELF::name:                                                       \
     return #name;                                                       \
 
-StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type) {
+StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
+                                                 uint32_t Type) {
   switch (Machine) {
   case ELF::EM_X86_64:
     switch (Type) {
@@ -139,6 +141,3 @@ StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type) {
 }
 
 #undef ELF_RELOC
-
-} // end namespace object
-} // end namespace llvm
diff --git a/lib/Object/ELFObjectFile.cpp b/lib/Object/ELFObjectFile.cpp
index 3f8c81c8e91..86f033bb6cb 100644
--- a/lib/Object/ELFObjectFile.cpp
+++ b/lib/Object/ELFObjectFile.cpp
@@ -1,4 +1,4 @@
-//===- ELFObjectFile.cpp - ELF object file implementation -------*- C++ -*-===//
+//===- ELFObjectFile.cpp - ELF object file implementation -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -11,12 +11,27 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/Triple.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Object/Error.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/ARMAttributeParser.h"
+#include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
 
-namespace llvm {
+using namespace llvm;
 using namespace object;
 
 ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
@@ -299,5 +314,3 @@ void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const {
 
   TheTriple.setArchName(Triple);
 }
-
-} // end namespace llvm
diff --git a/lib/Object/IRSymtab.cpp b/lib/Object/IRSymtab.cpp
index bb3d1b2cf69..367b1e8fb63 100644
--- a/lib/Object/IRSymtab.cpp
+++ b/lib/Object/IRSymtab.cpp
@@ -1,4 +1,4 @@
-//===- IRSymtab.cpp - implementation of IR symbol tables --------*- C++ -*-===//
+//===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,14 +7,34 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Object/IRSymtab.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/ObjectUtils.h"
+#include "llvm/IR/Comdat.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/Mangler.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Object/IRSymtab.h"
 #include "llvm/Object/ModuleSymbolTable.h"
+#include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/StringSaver.h"
+#include <cassert>
+#include <string>
+#include <utility>
+#include <vector>
 
 using namespace llvm;
 using namespace irsymtab;
@@ -25,6 +45,7 @@ namespace {
 struct Builder {
   SmallVector<char, 0> &Symtab;
   SmallVector<char, 0> &Strtab;
+
   Builder(SmallVector<char, 0> &Symtab, SmallVector<char, 0> &Strtab)
       : Symtab(Symtab), Strtab(Strtab) {}
 
@@ -49,6 +70,7 @@ struct Builder {
     S.Offset = StrtabBuilder.add(Value);
     S.Size = Value.size();
   }
+
   template <typename T>
   void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
     R.Offset = Symtab.size();
@@ -228,7 +250,7 @@ Error Builder::build(ArrayRef<Module *> IRMods) {
   return Error::success();
 }
 
-} // anonymous namespace
+} // end anonymous namespace
 
 Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
                       SmallVector<char, 0> &Strtab) {
diff --git a/lib/Object/ModuleSymbolTable.cpp b/lib/Object/ModuleSymbolTable.cpp
index 9a935d8e086..a5b42725d81 100644
--- a/lib/Object/ModuleSymbolTable.cpp
+++ b/lib/Object/ModuleSymbolTable.cpp
@@ -1,4 +1,4 @@
-//===- ModuleSymbolTable.cpp - symbol table for in-memory IR ----*- C++ -*-===//
+//===- ModuleSymbolTable.cpp - symbol table for in-memory IR --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -13,27 +13,45 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Object/IRObjectFile.h"
 #include "RecordStreamer.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Bitcode/BitcodeReader.h"
-#include "llvm/IR/GVMaterializer.h"
-#include "llvm/IR/LLVMContext.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
-#include "llvm/Object/ObjectFile.h"
+#include "llvm/MC/MCSymbol.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/Object/ModuleSymbolTable.h"
+#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
-#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <string>
+
 using namespace llvm;
 using namespace object;
 
diff --git a/lib/Object/RecordStreamer.cpp b/lib/Object/RecordStreamer.cpp
index c9c27451f80..e94e9cfed39 100644
--- a/lib/Object/RecordStreamer.cpp
+++ b/lib/Object/RecordStreamer.cpp
@@ -9,6 +9,7 @@
 
 #include "RecordStreamer.h"
 #include "llvm/MC/MCSymbol.h"
+
 using namespace llvm;
 
 void RecordStreamer::markDefined(const MCSymbol &Symbol) {
@@ -69,14 +70,14 @@ void RecordStreamer::markUsed(const MCSymbol &Symbol) {
 
 void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }
 
+RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
+
 RecordStreamer::const_iterator RecordStreamer::begin() {
   return Symbols.begin();
 }
 
 RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
 
-RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
-
 void RecordStreamer::EmitInstruction(const MCInst &Inst,
                                      const MCSubtargetInfo &STI, bool) {
   MCStreamer::EmitInstruction(Inst, STI);
diff --git a/lib/Object/RecordStreamer.h b/lib/Object/RecordStreamer.h
index a845ecd786a..4d119091a3d 100644
--- a/lib/Object/RecordStreamer.h
+++ b/lib/Object/RecordStreamer.h
@@ -1,4 +1,4 @@
-//===-- RecordStreamer.h - Record asm defined and used symbols ---*- C++ -*===//
+//===- RecordStreamer.h - Record asm defined and used symbols ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -10,9 +10,16 @@
 #ifndef LLVM_LIB_OBJECT_RECORDSTREAMER_H
 #define LLVM_LIB_OBJECT_RECORDSTREAMER_H
 
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/SMLoc.h"
+#include <vector>
 
 namespace llvm {
+
 class RecordStreamer : public MCStreamer {
 public:
   enum State { NeverSeen, Global, Defined, DefinedGlobal, DefinedWeak, Used,
@@ -24,16 +31,19 @@ private:
   // their symbol binding after parsing complete. This maps from each
   // aliasee to its list of aliases.
   DenseMap<const MCSymbol *, std::vector<MCSymbol *>> SymverAliasMap;
+
   void markDefined(const MCSymbol &Symbol);
   void markGlobal(const MCSymbol &Symbol, MCSymbolAttr Attribute);
   void markUsed(const MCSymbol &Symbol);
   void visitUsedSymbol(const MCSymbol &Sym) override;
 
 public:
-  typedef StringMap<State>::const_iterator const_iterator;
+  RecordStreamer(MCContext &Context);
+
+  using const_iterator = StringMap<State>::const_iterator;
+
   const_iterator begin();
   const_iterator end();
-  RecordStreamer(MCContext &Context);
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
                        bool) override;
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
@@ -50,6 +60,7 @@ public:
   DenseMap<const MCSymbol *, std::vector<MCSymbol *>> &symverAliases() {
     return SymverAliasMap;
   }
+
   /// Get the state recorded for the given symbol.
   State getSymbolState(const MCSymbol *Sym) {
     auto SI = Symbols.find(Sym->getName());
@@ -58,5 +69,7 @@ public:
     return SI->second;
   }
 };
-}
-#endif
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_OBJECT_RECORDSTREAMER_H