[llvm-readobj][nfc] Run clang-format on the directory's .cpp and .h files

[oontvoo]

Summary

Motivation: Prevent unrelated formatting changes on lines that are current il-formatted.

Diff was generated with:

clang-format -i --style=llvm llvm/tools/llvm-readobj/*.h
clang-format -i --style=llvm llvm/tools/llvm-readobj/*.cpp

(With the exception of 'ARMEHABIPrinter.h', which had a 81'th char
on the first line, hence needed manual edit).

If there is any part that should not have been formatted, please let me know - can put clang-format off around it.

[jhenderson]

llvm/tools/llvm-readobj/ARMEHABIPrinter.h

1

Perhaps while you're at it put the C++ marker here.

llvm/tools/llvm-readobj/COFFDumper.cpp

365

Not that I'm suggesting you change what clang-format has done here, but I find it odd that the closing brace is on the same line as an entry, but the opening one isn't. Perhaps worth asking a clang-format person about,

1765–1772

There's an active discussion on discourse about whether this style should be allowed. I'm not sure we should change it at this time, although preventing clang-format doing anything to it seems wrong too.

https://discourse.llvm.org/t/enable-single-line-case-statements-in-llvm-clang-format-style/61062

I've asked there for thoughts.

llvm/tools/llvm-readobj/ELFDumper.cpp

83

Looks like clang-format doesn't agree with itself?

988–990

Here and throughout these tables, I think the existing style is more readable, so possibly decorate them (though do remove the extra space in this column for example).

If this style isn't available as a clang-format option, please make a feature request. If it is, I'd start a Discourse thread on enabling it, citing this code as an example.

2088

Another linter complaint.

llvm/tools/llvm-readobj/WasmDumper.cpp

25

And more here.

llvm/tools/llvm-readobj/XCOFFDumper.cpp

141

And more (multiple times in this file).

llvm/tools/llvm-readobj/llvm-readobj.h

47

Ditto.

[mehdi_amini]

llvm/tools/llvm-readobj/ELFDumper.cpp

83

The check is supposed to be using the most recent release of clang-format (not HEAD)

llvm/tools/llvm-readobj/ARMEHABIPrinter.h

-//===--- ARMEHABIPrinter.h - ARM EHABI Unwind Information Printer ----------===//
+//===--- ARMEHABIPrinter.h - ARM EHABI Unwind Information Printer ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H
SW.startLine() << format("0x%02X      ; vsp = vsp - %u\n", Opcode,
                            ((Opcode & 0x3f) << 2) + 4);
 }
 inline void OpcodeDecoder::Decode_1000iiii_iiiiiiii(const uint8_t *Opcodes,
                                                     unsigned &OI) {
   uint8_t Opcode0 = Opcodes[OI++ ^ 3];
   uint8_t Opcode1 = Opcodes[OI++ ^ 3];
 
   uint16_t GPRMask = (Opcode1 << 4) | ((Opcode0 & 0x0f) << 12);
-  SW.startLine()
-    << format("0x%02X 0x%02X ; %s",
-              Opcode0, Opcode1, GPRMask ? "pop " : "refuse to unwind");
+  SW.startLine() << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1,
+                           GPRMask ? "pop " : "refuse to unwind");
   if (GPRMask)
     PrintGPR(GPRMask);
   OS << '\n';
 }
 inline void OpcodeDecoder::Decode_10011101(const uint8_t *Opcodes,
                                            unsigned &OI) {
   uint8_t Opcode = Opcodes[OI++ ^ 3];
   SW.startLine() << format("0x%02X      ; reserved (ARM MOVrr)\n", Opcode);
 }
 inline void OpcodeDecoder::Decode_10011111(const uint8_t *Opcodes,
                                            unsigned &OI) {
   uint8_t Opcode = Opcodes[OI++ ^ 3];
   SW.startLine() << format("0x%02X      ; reserved (WiMMX MOVrr)\n", Opcode);
 }
 inline void OpcodeDecoder::Decode_1001nnnn(const uint8_t *Opcodes,
                                            unsigned &OI) {
   uint8_t Opcode = Opcodes[OI++ ^ 3];
-  SW.startLine() << format("0x%02X      ; vsp = r%u\n", Opcode, (Opcode & 0x0f));
+  SW.startLine() << format("0x%02X      ; vsp = r%u\n", Opcode,
+                           (Opcode & 0x0f));
 }
 inline void OpcodeDecoder::Decode_10100nnn(const uint8_t *Opcodes,
                                            unsigned &OI) {
   uint8_t Opcode = Opcodes[OI++ ^ 3];
   SW.startLine() << format("0x%02X      ; pop ", Opcode);
   PrintGPR((((1 << ((Opcode & 0x7) + 1)) - 1) << 4));
   OS << '\n';
 }
inline void OpcodeDecoder::Decode_10110001_0000iiii(const uint8_t *Opcodes,
   OS << '\n';
 }
 inline void OpcodeDecoder::Decode_10110010_uleb128(const uint8_t *Opcodes,
                                                    unsigned &OI) {
   uint8_t Opcode = Opcodes[OI++ ^ 3];
   SW.startLine() << format("0x%02X ", Opcode);
 
   SmallVector<uint8_t, 4> ULEB;
-  do { ULEB.push_back(Opcodes[OI ^ 3]); } while (Opcodes[OI++ ^ 3] & 0x80);
+  do {
+    ULEB.push_back(Opcodes[OI ^ 3]);
+  } while (Opcodes[OI++ ^ 3] & 0x80);
 
   for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI)
     OS << format("0x%02X ", ULEB[BI]);
 
   uint64_t Value = 0;
   for (unsigned BI = 0, BE = ULEB.size(); BI != BE; ++BI)
     Value = Value | ((ULEB[BI] & 0x7f) << (7 * BI));
 
inline void OpcodeDecoder::Decode_11000110_sssscccc(const uint8_t *Opcodes,
   uint8_t Count = ((Opcode1 & 0x0f) >> 0);
   PrintRegisters((((1 << (Count + 1)) - 1) << Start), "wR");
   OS << '\n';
 }
 inline void OpcodeDecoder::Decode_11000111_0000iiii(const uint8_t *Opcodes,
                                                     unsigned &OI) {
   uint8_t Opcode0 = Opcodes[OI++ ^ 3];
   uint8_t Opcode1 = Opcodes[OI++ ^ 3];
-  SW.startLine()
-    << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1,
-              ((Opcode1 & 0xf0) || Opcode1 == 0x00) ? "spare" : "pop ");
+  SW.startLine() << format("0x%02X 0x%02X ; %s", Opcode0, Opcode1,
+                           ((Opcode1 & 0xf0) || Opcode1 == 0x00) ? "spare"
+                                                                 : "pop ");
   if ((Opcode1 & 0xf0) == 0x00 && Opcode1)
-      PrintRegisters(Opcode1 & 0x0f, "wCGR");
   OS << '\n';
 }
 inline void OpcodeDecoder::Decode_11001000_sssscccc(const uint8_t *Opcodes,
                                                     unsigned &OI) {
   uint8_t Opcode0 = Opcodes[OI++ ^ 3];
   uint8_t Opcode1 = Opcodes[OI++ ^ 3];
   SW.startLine() << format("0x%02X 0x%02X ; pop ", Opcode0, Opcode1);
   uint8_t Start = 16 + ((Opcode1 & 0xf0) >> 4);

 inline void OpcodeDecoder::Decode_11xxxyyy(const uint8_t *Opcodes,
                                            unsigned &OI) {
   uint8_t Opcode = Opcodes[OI++ ^ 3];
   SW.startLine() << format("0x%02X      ; spare\n", Opcode);
 }
 
 inline void OpcodeDecoder::PrintGPR(uint16_t GPRMask) {
   static const char *GPRRegisterNames[16] = {
-    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
-    "fp", "ip", "sp", "lr", "pc"
-  };
+      "r0", "r1", "r2",  "r3", "r4", "r5", "r6", "r7",
+      "r8", "r9", "r10", "fp", "ip", "sp", "lr", "pc"};
 
   OS << '{';
   bool Comma = false;
   for (unsigned RI = 0, RE = 17; RI < RE; ++RI) {
     if (GPRMask & (1 << RI)) {
       if (Comma)
         OS << ", ";
       OS << GPRRegisterNames[RI];
if (VFPMask & (1 << RI)) {
       Comma = true;
     }
   }
   OS << '}';
 }
 
 inline void OpcodeDecoder::Decode(const uint8_t *Opcodes, off_t Offset,
                                   size_t Length) {
-  for (unsigned OCI = Offset; OCI < Length + Offset; ) {
+  for (unsigned OCI = Offset; OCI < Length + Offset;) {
     bool Decoded = false;
     for (const auto &RE : ring()) {
       if ((Opcodes[OCI ^ 3] & RE.Mask) == RE.Value) {
         (this->*RE.Routine)(Opcodes, OCI);
         Decoded = true;
         break;
       }
     }
     if (!Decoded)
       SW.startLine() << format("0x%02X      ; reserved\n", Opcodes[OCI++ ^ 3]);
   }
 }
 
-template <typename ET>
-class PrinterContext {
+template <typename ET> class PrinterContext {
   typedef typename ET::Sym Elf_Sym;
   typedef typename ET::Shdr Elf_Shdr;
   typedef typename ET::Rel Elf_Rel;
   typedef typename ET::Word Elf_Word;
 
   ScopedPrinter &SW;
   const object::ELFFile<ET> &ELF;
   StringRef FileName;
   const Elf_Shdr *Symtab;
   ArrayRef<Elf_Word> ShndxTable;
 
   static const size_t IndexTableEntrySize;
 
   static uint64_t PREL31(uint32_t Address, uint32_t Place) {
     uint64_t Location = Address & 0x7fffffff;
     if (Location & 0x40000000)
-      Location |= (uint64_t) ~0x7fffffff;
+      Location |= (uint64_t)~0x7fffffff;
     return Location + Place;
   }
 
   ErrorOr<StringRef> FunctionAtAddress(uint64_t Address,
                                        Optional<unsigned> SectionIndex) const;
   const Elf_Shdr *FindExceptionTable(unsigned IndexTableIndex,
                                      off_t IndexTableOffset) const;
 
   void PrintIndexTable(unsigned SectionIndex, const Elf_Shdr *IT) const;
   void PrintExceptionTable(const Elf_Shdr &EHT,
                            uint64_t TableEntryOffset) const;
   void PrintOpcodes(const uint8_t *Entry, size_t Length, off_t Offset) const;
 
 public:
   PrinterContext(ScopedPrinter &SW, const object::ELFFile<ET> &ELF,
                  StringRef FileName, const Elf_Shdr *Symtab)
       : SW(SW), ELF(ELF), FileName(FileName), Symtab(Symtab) {}
 
   void PrintUnwindInformation() const;
 };
 
-template <typename ET>
-const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
+template <typename ET> const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
 
 template <typename ET>
 ErrorOr<StringRef>
 PrinterContext<ET>::FunctionAtAddress(uint64_t Address,
                                       Optional<unsigned> SectionIndex) const {
   if (!Symtab)
     return inconvertibleErrorCode();
   auto StrTableOrErr = ELF.getStringTableForSymtab(*Symtab);
void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr &EHT,
   ///  3 3 2 2  2 2
   ///  1 0 8 7  4 3                     0
   /// +-+---+----+-----------------------+
   /// |1| 0 | Ix | data for pers routine |
   /// +-+---+----+-----------------------+
   /// |  more personality routine data   |
 
   const support::ulittle32_t Word =
-    *reinterpret_cast<const support::ulittle32_t *>(Contents->data() + TableEntryOffset);
+      *reinterpret_cast<const support::ulittle32_t *>(Contents->data() +
+                                                      TableEntryOffset);
 
   if (Word & 0x80000000) {
     SW.printString("Model", StringRef("Compact"));
 
     unsigned PersonalityIndex = (Word & 0x0f000000) >> 24;
     SW.printNumber("PersonalityIndex", PersonalityIndex);
 
     switch (PersonalityIndex) {
if (Word & 0x80000000) {
     Optional<unsigned> SecIndex =
         IsRelocatable ? Optional<unsigned>(EHT.sh_link) : None;
     if (ErrorOr<StringRef> Name = FunctionAtAddress(Address, SecIndex))
       SW.printString("PersonalityRoutineName", *Name);
   }
 }
 
 template <typename ET>
-void PrinterContext<ET>::PrintOpcodes(const uint8_t *Entry,
-                                      size_t Length, off_t Offset) const {
+void PrinterContext<ET>::PrintOpcodes(const uint8_t *Entry, size_t Length,
+                                      off_t Offset) const {
   ListScope OCC(SW, "Opcodes");
   OpcodeDecoder(SW).Decode(Entry, Offset, Length);
 }
 
 template <typename ET>
 void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
                                          const Elf_Shdr *IT) const {
   // TODO: handle failure.
   Expected<ArrayRef<uint8_t>> Contents = ELF.getSectionContents(*IT);
   if (!Contents)
     return;
 
   /// ARM EHABI Section 5 - Index Table Entries
   /// * The first word contains a PREL31 offset to the start of a function with
   ///   bit 31 clear
   /// * The second word contains one of:
   ///   - The PREL31 offset of the start of the table entry for the function,
   ///     with bit 31 clear
   ///   - The exception-handling table entry itself with bit 31 set
   ///   - The special bit pattern EXIDX_CANTUNWIND, indicating that associated
   ///     frames cannot be unwound
 
   const support::ulittle32_t *Data =
       reinterpret_cast<const support::ulittle32_t *>(Contents->data());
   const unsigned Entries = IT->sh_size / IndexTableEntrySize;
   const bool IsRelocatable = ELF.getHeader().e_type == ELF::ET_REL;
 
   ListScope E(SW, "Entries");
   for (unsigned Entry = 0; Entry < Entries; ++Entry) {
     DictScope E(SW, "Entry");
 
     const support::ulittle32_t Word0 =
         Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 0];
     const support::ulittle32_t Word1 =
         Data[Entry * (IndexTableEntrySize / sizeof(*Data)) + 1];
 
     if (Word0 & 0x80000000) {
       errs() << "corrupt unwind data in section " << SectionIndex << "\n";
       continue;
     }
 
     // FIXME: For a relocatable object ideally we might want to:
     // 1) Find a relocation for the offset of Word0.
if (Word1 & 0x80000000) {
           PrintExceptionTable(*EHT, TableEntryAddress);
         else
           PrintExceptionTable(*EHT, TableEntryAddress - EHT->sh_addr);
       }
     }
   }
 }
 
-template <typename ET>
-void PrinterContext<ET>::PrintUnwindInformation() const {
+template <typename ET> void PrinterContext<ET>::PrintUnwindInformation() const {
   DictScope UI(SW, "UnwindInformation");
 
   int SectionIndex = 0;
   for (const Elf_Shdr &Sec : unwrapOrError(FileName, ELF.sections())) {
     if (Sec.sh_type == ELF::SHT_ARM_EXIDX) {
       DictScope UIT(SW, "UnwindIndexTable");
 
       SW.printNumber("SectionIndex", SectionIndex);
       // TODO: handle failure.
       if (Expected<StringRef> SectionName = ELF.getSectionName(Sec))
         SW.printString("SectionName", *SectionName);
       SW.printHex("SectionOffset", Sec.sh_offset);
 
       PrintIndexTable(SectionIndex, &Sec);
     }
     ++SectionIndex;
   }
 }
-}
-}
-}
+} // namespace EHABI
+} // namespace ARM
+} // namespace llvm
 
 #endif

llvm/tools/llvm-readobj/ARMWinEHPrinter.h

bool opcode_trap_frame(const uint8_t *Opcodes, unsigned &Offset,
                          unsigned Length, bool Prologue);
   bool opcode_machine_frame(const uint8_t *Opcodes, unsigned &Offset,
                             unsigned Length, bool Prologue);
   bool opcode_context(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
                       bool Prologue);
   bool opcode_clear_unwound_to_call(const uint8_t *Opcodes, unsigned &Offset,
                                     unsigned Length, bool Prologue);
 
-  void decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
-                     bool Prologue);
+  void decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset, bool Prologue);
 
   void printRegisters(const std::pair<uint16_t, uint32_t> &RegisterMask);
 
   ErrorOr<object::SectionRef>
   getSectionContaining(const object::COFFObjectFile &COFF, uint64_t Address);
 
-  ErrorOr<object::SymbolRef>
-  getSymbol(const object::COFFObjectFile &COFF, uint64_t Address,
+  ErrorOr<object::SymbolRef> getSymbol(const object::COFFObjectFile &COFF,
+                                       uint64_t Address,
                                        bool FunctionOnly = false);
 
   ErrorOr<object::SymbolRef>
   getRelocatedSymbol(const object::COFFObjectFile &COFF,
                      const object::SectionRef &Section, uint64_t Offset);
 
   ErrorOr<object::SymbolRef>
   getSymbolForLocation(const object::COFFObjectFile &COFF,
                        const object::SectionRef &Section,
bool dumpPackedARM64Entry(const object::COFFObjectFile &COFF,
                             unsigned Index, const RuntimeFunctionARM64 &Entry);
   bool dumpProcedureDataEntry(const object::COFFObjectFile &COFF,
                               const object::SectionRef Section, unsigned Entry,
                               ArrayRef<uint8_t> Contents);
   void dumpProcedureData(const object::COFFObjectFile &COFF,
                          const object::SectionRef Section);
 
 public:
-  Decoder(ScopedPrinter &SW, bool isAArch64) : SW(SW),
-                                               OS(SW.getOStream()),
-                                               isAArch64(isAArch64) {}
+  Decoder(ScopedPrinter &SW, bool isAArch64)
+      : SW(SW), OS(SW.getOStream()), isAArch64(isAArch64) {}
   Error dumpProcedureData(const object::COFFObjectFile &COFF);
 };
-}
-}
-}
+} // namespace WinEH
+} // namespace ARM
+} // namespace llvm
 
 #endif

llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp

case ARM::WinEH::ReturnType::RT_BW:
     OS << "b.w target";
     break;
   case ARM::WinEH::ReturnType::RT_NoEpilogue:
     OS << "(no epilogue)";
     break;
   }
   return OS;
 }
-}
+} // namespace llvm
 
 static std::string formatSymbol(StringRef Name, uint64_t Address,
                                 uint64_t Offset = 0) {
   std::string Buffer;
   raw_string_ostream OS(Buffer);
 
   if (!Name.empty())
     OS << Name << " ";

 
 namespace llvm {
 namespace ARM {
 namespace WinEH {
 const size_t Decoder::PDataEntrySize = sizeof(RuntimeFunction);
 
 // TODO name the uops more appropriately
 const Decoder::RingEntry Decoder::Ring[] = {
-  { 0x80, 0x00, 1, &Decoder::opcode_0xxxxxxx },  // UOP_STACK_FREE (16-bit)
-  { 0xc0, 0x80, 2, &Decoder::opcode_10Lxxxxx },  // UOP_POP (32-bit)
-  { 0xf0, 0xc0, 1, &Decoder::opcode_1100xxxx },  // UOP_STACK_SAVE (16-bit)
-  { 0xf8, 0xd0, 1, &Decoder::opcode_11010Lxx },  // UOP_POP (16-bit)
-  { 0xf8, 0xd8, 1, &Decoder::opcode_11011Lxx },  // UOP_POP (32-bit)
-  { 0xf8, 0xe0, 1, &Decoder::opcode_11100xxx },  // UOP_VPOP (32-bit)
-  { 0xfc, 0xe8, 2, &Decoder::opcode_111010xx },  // UOP_STACK_FREE (32-bit)
-  { 0xfe, 0xec, 2, &Decoder::opcode_1110110L },  // UOP_POP (16-bit)
-  { 0xff, 0xee, 2, &Decoder::opcode_11101110 },  // UOP_MICROSOFT_SPECIFIC (16-bit)
-                                              // UOP_PUSH_MACHINE_FRAME
-                                              // UOP_PUSH_CONTEXT
-                                              // UOP_PUSH_TRAP_FRAME
-                                              // UOP_REDZONE_RESTORE_LR
-  { 0xff, 0xef, 2, &Decoder::opcode_11101111 },  // UOP_LDRPC_POSTINC (32-bit)
-  { 0xff, 0xf5, 2, &Decoder::opcode_11110101 },  // UOP_VPOP (32-bit)
-  { 0xff, 0xf6, 2, &Decoder::opcode_11110110 },  // UOP_VPOP (32-bit)
-  { 0xff, 0xf7, 3, &Decoder::opcode_11110111 },  // UOP_STACK_RESTORE (16-bit)
-  { 0xff, 0xf8, 4, &Decoder::opcode_11111000 },  // UOP_STACK_RESTORE (16-bit)
-  { 0xff, 0xf9, 3, &Decoder::opcode_11111001 },  // UOP_STACK_RESTORE (32-bit)
-  { 0xff, 0xfa, 4, &Decoder::opcode_11111010 },  // UOP_STACK_RESTORE (32-bit)
-  { 0xff, 0xfb, 1, &Decoder::opcode_11111011 },  // UOP_NOP (16-bit)
-  { 0xff, 0xfc, 1, &Decoder::opcode_11111100 },  // UOP_NOP (32-bit)
-  { 0xff, 0xfd, 1, &Decoder::opcode_11111101 },  // UOP_NOP (16-bit) / END
-  { 0xff, 0xfe, 1, &Decoder::opcode_11111110 },  // UOP_NOP (32-bit) / END
-  { 0xff, 0xff, 1, &Decoder::opcode_11111111 },  // UOP_END
+    {0x80, 0x00, 1, &Decoder::opcode_0xxxxxxx}, // UOP_STACK_FREE (16-bit)
+    {0xc0, 0x80, 2, &Decoder::opcode_10Lxxxxx}, // UOP_POP (32-bit)
+    {0xf0, 0xc0, 1, &Decoder::opcode_1100xxxx}, // UOP_STACK_SAVE (16-bit)
+    {0xf8, 0xd0, 1, &Decoder::opcode_11010Lxx}, // UOP_POP (16-bit)
+    {0xf8, 0xd8, 1, &Decoder::opcode_11011Lxx}, // UOP_POP (32-bit)
+    {0xf8, 0xe0, 1, &Decoder::opcode_11100xxx}, // UOP_VPOP (32-bit)
+    {0xfc, 0xe8, 2, &Decoder::opcode_111010xx}, // UOP_STACK_FREE (32-bit)
+    {0xfe, 0xec, 2, &Decoder::opcode_1110110L}, // UOP_POP (16-bit)
+    {0xff, 0xee, 2,
+     &Decoder::opcode_11101110}, // UOP_MICROSOFT_SPECIFIC (16-bit)
+    {0xff, 0xef, 2, &Decoder::opcode_11101111}, // UOP_LDRPC_POSTINC (32-bit)
+    {0xff, 0xf5, 2, &Decoder::opcode_11110101}, // UOP_VPOP (32-bit)
+    {0xff, 0xf6, 2, &Decoder::opcode_11110110}, // UOP_VPOP (32-bit)
+    {0xff, 0xf7, 3, &Decoder::opcode_11110111}, // UOP_STACK_RESTORE (16-bit)
+    {0xff, 0xf8, 4, &Decoder::opcode_11111000}, // UOP_STACK_RESTORE (16-bit)
+    {0xff, 0xf9, 3, &Decoder::opcode_11111001}, // UOP_STACK_RESTORE (32-bit)
+    {0xff, 0xfa, 4, &Decoder::opcode_11111010}, // UOP_STACK_RESTORE (32-bit)
+    {0xff, 0xfb, 1, &Decoder::opcode_11111011}, // UOP_NOP (16-bit)
+    {0xff, 0xfc, 1, &Decoder::opcode_11111100}, // UOP_NOP (32-bit)
+    {0xff, 0xfd, 1, &Decoder::opcode_11111101}, // UOP_NOP (16-bit) / END
+    {0xff, 0xfe, 1, &Decoder::opcode_11111110}, // UOP_NOP (32-bit) / END
+    {0xff, 0xff, 1, &Decoder::opcode_11111111}, // UOP_END
 };
 
-
 // Unwind opcodes for ARM64.
 // https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
 const Decoder::RingEntry Decoder::Ring64[] = {
-  { 0xe0, 0x00, 1, &Decoder::opcode_alloc_s },
-  { 0xe0, 0x20, 1, &Decoder::opcode_save_r19r20_x },
-  { 0xc0, 0x40, 1, &Decoder::opcode_save_fplr },
-  { 0xc0, 0x80, 1, &Decoder::opcode_save_fplr_x },
-  { 0xf8, 0xc0, 2, &Decoder::opcode_alloc_m },
-  { 0xfc, 0xc8, 2, &Decoder::opcode_save_regp },
-  { 0xfc, 0xcc, 2, &Decoder::opcode_save_regp_x },
-  { 0xfc, 0xd0, 2, &Decoder::opcode_save_reg },
-  { 0xfe, 0xd4, 2, &Decoder::opcode_save_reg_x },
-  { 0xfe, 0xd6, 2, &Decoder::opcode_save_lrpair },
-  { 0xfe, 0xd8, 2, &Decoder::opcode_save_fregp },
-  { 0xfe, 0xda, 2, &Decoder::opcode_save_fregp_x },
-  { 0xfe, 0xdc, 2, &Decoder::opcode_save_freg },
-  { 0xff, 0xde, 2, &Decoder::opcode_save_freg_x },
-  { 0xff, 0xe0, 4, &Decoder::opcode_alloc_l },
-  { 0xff, 0xe1, 1, &Decoder::opcode_setfp },
-  { 0xff, 0xe2, 2, &Decoder::opcode_addfp },
-  { 0xff, 0xe3, 1, &Decoder::opcode_nop },
-  { 0xff, 0xe4, 1, &Decoder::opcode_end },
-  { 0xff, 0xe5, 1, &Decoder::opcode_end_c },
-  { 0xff, 0xe6, 1, &Decoder::opcode_save_next },
-  { 0xff, 0xe8, 1, &Decoder::opcode_trap_frame },
-  { 0xff, 0xe9, 1, &Decoder::opcode_machine_frame },
-  { 0xff, 0xea, 1, &Decoder::opcode_context },
-  { 0xff, 0xec, 1, &Decoder::opcode_clear_unwound_to_call },
+    {0xe0, 0x00, 1, &Decoder::opcode_alloc_s},
+    {0xe0, 0x20, 1, &Decoder::opcode_save_r19r20_x},
+    {0xc0, 0x40, 1, &Decoder::opcode_save_fplr},
+    {0xc0, 0x80, 1, &Decoder::opcode_save_fplr_x},
+    {0xf8, 0xc0, 2, &Decoder::opcode_alloc_m},
+    {0xfc, 0xc8, 2, &Decoder::opcode_save_regp},
+    {0xfc, 0xcc, 2, &Decoder::opcode_save_regp_x},
+    {0xfc, 0xd0, 2, &Decoder::opcode_save_reg},
+    {0xfe, 0xd4, 2, &Decoder::opcode_save_reg_x},
+    {0xfe, 0xd6, 2, &Decoder::opcode_save_lrpair},
+    {0xfe, 0xd8, 2, &Decoder::opcode_save_fregp},
+    {0xfe, 0xda, 2, &Decoder::opcode_save_fregp_x},
+    {0xfe, 0xdc, 2, &Decoder::opcode_save_freg},
+    {0xff, 0xde, 2, &Decoder::opcode_save_freg_x},
+    {0xff, 0xe0, 4, &Decoder::opcode_alloc_l},
+    {0xff, 0xe1, 1, &Decoder::opcode_setfp},
+    {0xff, 0xe2, 2, &Decoder::opcode_addfp},
+    {0xff, 0xe3, 1, &Decoder::opcode_nop},
+    {0xff, 0xe4, 1, &Decoder::opcode_end},
+    {0xff, 0xe5, 1, &Decoder::opcode_end_c},
+    {0xff, 0xe6, 1, &Decoder::opcode_save_next},
+    {0xff, 0xe8, 1, &Decoder::opcode_trap_frame},
+    {0xff, 0xe9, 1, &Decoder::opcode_machine_frame},
+    {0xff, 0xea, 1, &Decoder::opcode_context},
+    {0xff, 0xec, 1, &Decoder::opcode_clear_unwound_to_call},
 };
 
-void Decoder::printRegisters(const std::pair<uint16_t, uint32_t> &RegisterMask) {
-  static const char * const GPRRegisterNames[16] = {
-    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
-    "r11", "ip", "sp", "lr", "pc",
+void Decoder::printRegisters(
+    const std::pair<uint16_t, uint32_t> &RegisterMask) {
+  static const char *const GPRRegisterNames[16] = {
+      "r0", "r1", "r2",  "r3",  "r4", "r5", "r6", "r7",
+      "r8", "r9", "r10", "r11", "ip", "sp", "lr", "pc",
   };
 
   const uint16_t GPRMask = std::get<0>(RegisterMask);
   const uint16_t VFPMask = std::get<1>(RegisterMask);
 
   OS << '{';
   ListSeparator LS;
   for (unsigned RI = 0, RE = 11; RI < RE; ++RI)
if (SymOrErr) {
     SymOrErr = getSymbol(COFF, SymbolAddress, FunctionOnly);
   }
   return SymOrErr;
 }
 
 bool Decoder::opcode_0xxxxxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint8_t Imm = OC[Offset] & 0x7f;
-  SW.startLine() << format("0x%02x                ; %s sp, #(%u * 4)\n",
-                           OC[Offset],
-                           static_cast<const char *>(Prologue ? "sub" : "add"),
-                           Imm);
+  SW.startLine() << format(
+      "0x%02x                ; %s sp, #(%u * 4)\n", OC[Offset],
+      static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
   ++Offset;
   return false;
 }
 
 bool Decoder::opcode_10Lxxxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Link = (OC[Offset] & 0x20) >> 5;
-  uint16_t RegisterMask = (Link << (Prologue ? 14 : 15))
-                        | ((OC[Offset + 0] & 0x1f) << 8)
-                        | ((OC[Offset + 1] & 0xff) << 0);
+  uint16_t RegisterMask = (Link << (Prologue ? 14 : 15)) |
+                          ((OC[Offset + 0] & 0x1f) << 8) |
+                          ((OC[Offset + 1] & 0xff) << 0);
   assert((~RegisterMask & (1 << 13)) && "sp must not be set");
   assert((~RegisterMask & (1 << (Prologue ? 15 : 14))) && "pc must not be set");
 
-  SW.startLine() << format("0x%02x 0x%02x           ; %s.w ",
-                           OC[Offset + 0], OC[Offset + 1],
-                           Prologue ? "push" : "pop");
+  SW.startLine() << format("0x%02x 0x%02x           ; %s.w ", OC[Offset + 0],
+                           OC[Offset + 1], Prologue ? "push" : "pop");
   printRegisters(std::make_pair(RegisterMask, 0));
   OS << '\n';
 
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_1100xxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   if (Prologue)
     SW.startLine() << format("0x%02x                ; mov r%u, sp\n",
                              OC[Offset], OC[Offset] & 0xf);
   else
     SW.startLine() << format("0x%02x                ; mov sp, r%u\n",
                              OC[Offset], OC[Offset] & 0xf);
   ++Offset;
   return false;
 }
 
 bool Decoder::opcode_11010Lxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Link = (OC[Offset] & 0x4) >> 3;
   unsigned Count = (OC[Offset] & 0x3);
 
-  uint16_t GPRMask = (Link << (Prologue ? 14 : 15))
-                   | (((1 << (Count + 1)) - 1) << 4);
+  uint16_t GPRMask =
+      (Link << (Prologue ? 14 : 15)) | (((1 << (Count + 1)) - 1) << 4);
 
   SW.startLine() << format("0x%02x                ; %s ", OC[Offset],
                            Prologue ? "push" : "pop");
   printRegisters(std::make_pair(GPRMask, 0));
   OS << '\n';
 
   ++Offset;
   return false;
 }
 
 bool Decoder::opcode_11011Lxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Link = (OC[Offset] & 0x4) >> 2;
   unsigned Count = (OC[Offset] & 0x3) + 4;
 
-  uint16_t GPRMask = (Link << (Prologue ? 14 : 15))
-                   | (((1 << (Count + 1)) - 1) << 4);
+  uint16_t GPRMask =
+      (Link << (Prologue ? 14 : 15)) | (((1 << (Count + 1)) - 1) << 4);
 
   SW.startLine() << format("0x%02x                ; %s.w ", OC[Offset],
                            Prologue ? "push" : "pop");
   printRegisters(std::make_pair(GPRMask, 0));
   OS << '\n';
 
   ++Offset;
   return false;
bool Decoder::opcode_11100xxx(const uint8_t *OC, unsigned &Offset,
   OS << '\n';
 
   ++Offset;
   return false;
 }
 
 bool Decoder::opcode_111010xx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
-  uint16_t Imm = ((OC[Offset + 0] & 0x03) << 8) | ((OC[Offset + 1] & 0xff) << 0);
+  uint16_t Imm =
+      ((OC[Offset + 0] & 0x03) << 8) | ((OC[Offset + 1] & 0xff) << 0);
 
-  SW.startLine() << format("0x%02x 0x%02x           ; %s.w sp, #(%u * 4)\n",
-                           OC[Offset + 0], OC[Offset + 1],
-                           static_cast<const char *>(Prologue ? "sub" : "add"),
-                           Imm);
+  SW.startLine() << format(
+      "0x%02x 0x%02x           ; %s.w sp, #(%u * 4)\n", OC[Offset + 0],
+      OC[Offset + 1], static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
 
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_1110110L(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
-  uint8_t GPRMask = ((OC[Offset + 0] & 0x01) << (Prologue ? 14 : 15))
-                  | ((OC[Offset + 1] & 0xff) << 0);
+  uint8_t GPRMask = ((OC[Offset + 0] & 0x01) << (Prologue ? 14 : 15)) |
+                    ((OC[Offset + 1] & 0xff) << 0);
 
   SW.startLine() << format("0x%02x 0x%02x           ; %s ", OC[Offset + 0],
                            OC[Offset + 1], Prologue ? "push" : "pop");
   printRegisters(std::make_pair(GPRMask, 0));
   OS << '\n';
 
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_11101110(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   assert(!Prologue && "may not be used in prologue");
 
   if (OC[Offset + 1] & 0xf0)
     SW.startLine() << format("0x%02x 0x%02x           ; reserved\n",
-                             OC[Offset + 0], OC[Offset +  1]);
+                             OC[Offset + 0], OC[Offset + 1]);
   else
-    SW.startLine()
-      << format("0x%02x 0x%02x           ; microsoft-specific (type: %u)\n",
-                OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] & 0x0f);
+    SW.startLine() << format(
+        "0x%02x 0x%02x           ; microsoft-specific (type: %u)\n",
 
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_11101111(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   assert(!Prologue && "may not be used in prologue");
 
   if (OC[Offset + 1] & 0xf0)
     SW.startLine() << format("0x%02x 0x%02x           ; reserved\n",
-                             OC[Offset + 0], OC[Offset +  1]);
+                             OC[Offset + 0], OC[Offset + 1]);
   else
-    SW.startLine()
-      << format("0x%02x 0x%02x           ; ldr.w lr, [sp], #%u\n",
-                OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] << 2);
+    SW.startLine() << format("0x%02x 0x%02x           ; ldr.w lr, [sp], #%u\n",
+                             OC[Offset + 0], OC[Offset + 1],
+                             OC[Offset + 1] << 2);
 
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_11110101(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   unsigned Start = (OC[Offset + 1] & 0xf0) >> 4;
SW.startLine() << format("0x%02x 0x%02x 0x%02x      ; %s sp, sp, #(%u * 4)\n",
                            Imm);
 
   Offset += 3;
   return false;
 }
 
 bool Decoder::opcode_11111000(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
-  uint32_t Imm = (OC[Offset + 1] << 16)
-               | (OC[Offset + 2] << 8)
-               | (OC[Offset + 3] << 0);
-
-  SW.startLine()
-    << format("0x%02x 0x%02x 0x%02x 0x%02x ; %s sp, sp, #(%u * 4)\n",
-              OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
-              static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
+  uint32_t Imm =
+      (OC[Offset + 1] << 16) | (OC[Offset + 2] << 8) | (OC[Offset + 3] << 0);
+
+  SW.startLine() << format(
+      "0x%02x 0x%02x 0x%02x 0x%02x ; %s sp, sp, #(%u * 4)\n", OC[Offset + 0],
+      OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
 
   Offset += 4;
   return false;
 }
 
 bool Decoder::opcode_11111001(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint32_t Imm = (OC[Offset + 1] << 8) | (OC[Offset + 2] << 0);
 
-  SW.startLine()
-    << format("0x%02x 0x%02x 0x%02x      ; %s.w sp, sp, #(%u * 4)\n",
-              OC[Offset + 0], OC[Offset + 1], OC[Offset + 2],
-              static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
+  SW.startLine() << format(
+      "0x%02x 0x%02x 0x%02x      ; %s.w sp, sp, #(%u * 4)\n", OC[Offset + 0],
+      OC[Offset + 1], OC[Offset + 2],
 
   Offset += 3;
   return false;
 }
 
 bool Decoder::opcode_11111010(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
-  uint32_t Imm = (OC[Offset + 1] << 16)
-               | (OC[Offset + 2] << 8)
-               | (OC[Offset + 3] << 0);
-
-  SW.startLine()
-    << format("0x%02x 0x%02x 0x%02x 0x%02x ; %s.w sp, sp, #(%u * 4)\n",
-              OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
-              static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
+  uint32_t Imm =
+      (OC[Offset + 1] << 16) | (OC[Offset + 2] << 8) | (OC[Offset + 3] << 0);
+
+  SW.startLine() << format(
+      "0x%02x 0x%02x 0x%02x 0x%02x ; %s.w sp, sp, #(%u * 4)\n", OC[Offset + 0],
+      OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
 
   Offset += 4;
   return false;
 }
 
 bool Decoder::opcode_11111011(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   SW.startLine() << format("0x%02x                ; nop\n", OC[Offset]);
bool Decoder::opcode_save_fplr_x(const uint8_t *OC, unsigned &Offset,
   return false;
 }
 
 bool Decoder::opcode_alloc_m(const uint8_t *OC, unsigned &Offset,
                              unsigned Length, bool Prologue) {
   uint32_t NumBytes = ((OC[Offset] & 0x07) << 8);
   NumBytes |= (OC[Offset + 1] & 0xFF);
   NumBytes <<= 4;
-  SW.startLine() << format("0x%02x%02x              ; %s sp, #%u\n",
-                           OC[Offset], OC[Offset + 1],
-                           static_cast<const char *>(Prologue ? "sub" : "add"),
-                           NumBytes);
+  SW.startLine() << format(
+      "0x%02x%02x              ; %s sp, #%u\n", OC[Offset], OC[Offset + 1],
+      static_cast<const char *>(Prologue ? "sub" : "add"), NumBytes);
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_save_regp(const uint8_t *OC, unsigned &Offset,
                                unsigned Length, bool Prologue) {
   uint32_t Reg = ((OC[Offset] & 0x03) << 8);
   Reg |= (OC[Offset + 1] & 0xC0);
   Reg >>= 6;
   Reg += 19;
   uint32_t Off = (OC[Offset + 1] & 0x3F) << 3;
-  SW.startLine() << format(
-      "0x%02x%02x              ; %s x%u, x%u, [sp, #%u]\n",
+  SW.startLine() << format("0x%02x%02x              ; %s x%u, x%u, [sp, #%u]\n",
                            OC[Offset], OC[Offset + 1],
-      static_cast<const char *>(Prologue ? "stp" : "ldp"), Reg, Reg + 1, Off);
+                           static_cast<const char *>(Prologue ? "stp" : "ldp"),
+                           Reg, Reg + 1, Off);
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_save_regp_x(const uint8_t *OC, unsigned &Offset,
                                  unsigned Length, bool Prologue) {
   uint32_t Reg = ((OC[Offset] & 0x03) << 8);
   Reg |= (OC[Offset + 1] & 0xC0);
   Reg >>= 6;
   Reg += 19;
   uint32_t Off = ((OC[Offset + 1] & 0x3F) + 1) << 3;
   if (Prologue)
     SW.startLine() << format(
-        "0x%02x%02x              ; stp x%u, x%u, [sp, #-%u]!\n",
-        OC[Offset], OC[Offset + 1], Reg,
-        Reg + 1, Off);
+        "0x%02x%02x              ; stp x%u, x%u, [sp, #-%u]!\n", OC[Offset],
+        OC[Offset + 1], Reg, Reg + 1, Off);
   else
     SW.startLine() << format(
-        "0x%02x%02x              ; ldp x%u, x%u, [sp], #%u\n",
-        OC[Offset], OC[Offset + 1], Reg,
-        Reg + 1, Off);
+        "0x%02x%02x              ; ldp x%u, x%u, [sp], #%u\n", OC[Offset],
+        OC[Offset + 1], Reg, Reg + 1, Off);
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_save_reg(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint32_t Reg = (OC[Offset] & 0x03) << 8;
   Reg |= (OC[Offset + 1] & 0xC0);
bool Decoder::opcode_save_freg(const uint8_t *OC, unsigned &Offset,
   return false;
 }
 
 bool Decoder::opcode_save_freg_x(const uint8_t *OC, unsigned &Offset,
                                  unsigned Length, bool Prologue) {
   uint32_t Reg = ((OC[Offset + 1] & 0xE0) >> 5) + 8;
   uint32_t Off = ((OC[Offset + 1] & 0x1F) + 1) << 3;
   if (Prologue)
-    SW.startLine() << format(
-        "0x%02x%02x              ; str d%u, [sp, #-%u]!\n", OC[Offset],
-        OC[Offset + 1], Reg, Off);
+    SW.startLine() << format("0x%02x%02x              ; str d%u, [sp, #-%u]!\n",
+                             OC[Offset], OC[Offset + 1], Reg, Off);
   else
-    SW.startLine() << format(
-        "0x%02x%02x              ; ldr d%u, [sp], #%u\n", OC[Offset],
-        OC[Offset + 1], Reg, Off);
+    SW.startLine() << format("0x%02x%02x              ; ldr d%u, [sp], #%u\n",
+                             OC[Offset], OC[Offset + 1], Reg, Off);
   Offset += 2;
   return false;
 }
 
 bool Decoder::opcode_alloc_l(const uint8_t *OC, unsigned &Offset,
                              unsigned Length, bool Prologue) {
   unsigned Off =
       (OC[Offset + 1] << 16) | (OC[Offset + 2] << 8) | (OC[Offset + 3] << 0);
SW.startLine() << format("0x%02x                ; clear unwound to call\n",
                            OC[Offset]);
   ++Offset;
   return false;
 }
 
 void Decoder::decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
                             bool Prologue) {
   assert((!Prologue || Offset == 0) && "prologue should always use offset 0");
-  const RingEntry* DecodeRing = isAArch64 ? Ring64 : Ring;
+  const RingEntry *DecodeRing = isAArch64 ? Ring64 : Ring;
   bool Terminated = false;
-  for (unsigned OI = Offset, OE = Opcodes.size(); !Terminated && OI < OE; ) {
+  for (unsigned OI = Offset, OE = Opcodes.size(); !Terminated && OI < OE;) {
     for (unsigned DI = 0;; ++DI) {
       if ((isAArch64 && (DI >= array_lengthof(Ring64))) ||
           (!isAArch64 && (DI >= array_lengthof(Ring)))) {
         SW.startLine() << format("0x%02x                ; Bad opcode!\n",
                                  Opcodes.data()[OI]);
         ++OI;
         break;
       }
 
       if ((Opcodes[OI] & DecodeRing[DI].Mask) == DecodeRing[DI].Value) {
         if (OI + DecodeRing[DI].Length > OE) {
           SW.startLine() << format("Opcode 0x%02x goes past the unwind data\n",
-                                    Opcodes[OI]);
           OI += DecodeRing[DI].Length;
           break;
         }
         Terminated =
             (this->*DecodeRing[DI].Routine)(Opcodes.data(), OI, 0, Prologue);
         break;
       }
     }
   }
 }
 
 bool Decoder::dumpXDataRecord(const COFFObjectFile &COFF,
                               const SectionRef &Section,
                               uint64_t FunctionAddress, uint64_t VA) {
   ArrayRef<uint8_t> Contents;
   if (COFF.getSectionContents(COFF.getCOFFSection(Section), Contents))
     return false;
 
   uint64_t SectionVA = Section.getAddress();
   uint64_t Offset = VA - SectionVA;
   const ulittle32_t *Data =
       reinterpret_cast<const ulittle32_t *>(Contents.data() + Offset);
 
   // Sanity check to ensure that the .xdata header is present.
   // A header is one or two words, followed by at least one word to describe
   // the unwind codes. Applicable to both ARM and AArch64.
   if (Contents.size() - Offset < 8)
     report_fatal_error(".xdata must be at least 8 bytes in size");
 
   const ExceptionDataRecord XData(Data, isAArch64);
   DictScope XRS(SW, "ExceptionData");
-  SW.printNumber("FunctionLength",
-                 isAArch64 ? XData.FunctionLengthInBytesAArch64() :
-                 XData.FunctionLengthInBytesARM());
+  SW.printNumber("FunctionLength", isAArch64
+                                       ? XData.FunctionLengthInBytesAArch64()
+                                       : XData.FunctionLengthInBytesARM());
   SW.printNumber("Version", XData.Vers());
   SW.printBoolean("ExceptionData", XData.X());
   SW.printBoolean("EpiloguePacked", XData.E());
   if (!isAArch64)
     SW.printBoolean("Fragment", XData.F());
   SW.printNumber(XData.E() ? "EpilogueOffset" : "EpilogueScopes",
                  XData.EpilogueCount());
   uint64_t ByteCodeLength = XData.CodeWords() * sizeof(uint32_t);
if (XData.E()) {
     }
     ArrayRef<ulittle32_t> EpilogueScopes = XData.EpilogueScopes();
     ListScope ESS(SW, "EpilogueScopes");
     for (const EpilogueScope ES : EpilogueScopes) {
       DictScope ESES(SW, "EpilogueScope");
       SW.printNumber("StartOffset", ES.EpilogueStartOffset());
       if (!isAArch64)
         SW.printNumber("Condition", ES.Condition());
-      SW.printNumber("EpilogueStartIndex",
-                     isAArch64 ? ES.EpilogueStartIndexAArch64()
+      SW.printNumber("EpilogueStartIndex", isAArch64
+                                               ? ES.EpilogueStartIndexAArch64()
                                                : ES.EpilogueStartIndexARM());
       if (ES.ES & ~0xffc3ffff)
         SW.printNumber("ReservedBits", (ES.ES >> 18) & 0xF);
 
       ListScope Opcodes(SW, "Opcodes");
       decodeOpcodes(XData.UnwindByteCode(),
                     isAArch64 ? ES.EpilogueStartIndexAArch64()
                               : ES.EpilogueStartIndexARM(),
                     /*Prologue=*/false);
SW.printString("Function",
                  formatSymbol(FunctionName, FunctionAddress, FunctionOffset));
   if (!isAArch64)
     SW.printBoolean("Fragment",
                     RF.Flag() == RuntimeFunctionFlag::RFF_PackedFragment);
   SW.printNumber("FunctionLength", RF.FunctionLength());
   SW.startLine() << "ReturnType: " << RF.Ret() << '\n';
   SW.printBoolean("HomedParameters", RF.H());
   SW.startLine() << "SavedRegisters: ";
-                 printRegisters(SavedRegisterMask(RF));
   OS << '\n';
   SW.printNumber("StackAdjustment", StackAdjustment(RF) << 2);
 
   return true;
 }
 
 bool Decoder::dumpPackedARM64Entry(const object::COFFObjectFile &COFF,
                                    const SectionRef Section, uint64_t Offset,
bool Decoder::dumpPackedARM64Entry(const object::COFFObjectFile &COFF,
   return true;
 }
 
 bool Decoder::dumpProcedureDataEntry(const COFFObjectFile &COFF,
                                      const SectionRef Section, unsigned Index,
                                      ArrayRef<uint8_t> Contents) {
   uint64_t Offset = PDataEntrySize * Index;
   const ulittle32_t *Data =
       reinterpret_cast<const ulittle32_t *>(Contents.data() + Offset);
 
   const RuntimeFunction Entry(Data);
   DictScope RFS(SW, "RuntimeFunction");
   if (Entry.Flag() == RuntimeFunctionFlag::RFF_Unpacked)
     return dumpUnpackedEntry(COFF, Section, Offset, Index, Entry);
   if (isAArch64) {
     const RuntimeFunctionARM64 EntryARM64(Data);
     return dumpPackedARM64Entry(COFF, Section, Offset, Index, EntryARM64);
for (const auto &Section : COFF.sections()) {
     if (!NameOrErr)
       return NameOrErr.takeError();
 
     if (NameOrErr->startswith(".pdata"))
       dumpProcedureData(COFF, Section);
   }
   return Error::success();
 }
-}
-}
-}
+} // namespace WinEH
+} // namespace ARM
+} // namespace llvm

llvm/tools/llvm-readobj/COFFDumper.cpp

private:
   template <typename T>
   void printCOFFLoadConfig(const T *Conf, LoadConfigTables &Tables);
   template <typename IntTy>
   void printCOFFTLSDirectory(const coff_tls_directory<IntTy> *TlsTable);
   typedef void (*PrintExtraCB)(raw_ostream &, const uint8_t *);
   void printRVATable(uint64_t TableVA, uint64_t Count, uint64_t EntrySize,
                      PrintExtraCB PrintExtra = nullptr);
 
-  void printCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section);
-  void printCodeViewTypeSection(StringRef SectionName, const SectionRef &Section);
+  void printCodeViewSymbolSection(StringRef SectionName,
+                                  const SectionRef &Section);
+  void printCodeViewTypeSection(StringRef SectionName,
+                                const SectionRef &Section);
   StringRef getFileNameForFileOffset(uint32_t FileOffset);
   void printFileNameForOffset(StringRef Label, uint32_t FileOffset);
   void printTypeIndex(StringRef FieldName, TypeIndex TI) {
     // Forward to CVTypeDumper for simplicity.
     codeview::printTypeIndex(Writer, FieldName, TI, Types);
   }
 
   void printCodeViewSymbolsSubsection(StringRef Subsection,
private:
   std::error_code resolveSymbol(const coff_section *Section, uint64_t Offset,
                                 SymbolRef &Sym);
   std::error_code resolveSymbolName(const coff_section *Section,
                                     uint64_t Offset, StringRef &Name);
   std::error_code resolveSymbolName(const coff_section *Section,
                                     StringRef SectionContents,
                                     const void *RelocPtr, StringRef &Name);
   void printImportedSymbols(iterator_range<imported_symbol_iterator> Range);
-  void printDelayImportedSymbols(
-      const DelayImportDirectoryEntryRef &I,
+  void
+  printDelayImportedSymbols(const DelayImportDirectoryEntryRef &I,
                             iterator_range<imported_symbol_iterator> Range);
 
-  typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;
+  typedef DenseMap<const coff_section *, std::vector<RelocationRef>> RelocMapTy;
 
   const llvm::object::COFFObjectFile *Obj;
   bool RelocCached = false;
   RelocMapTy RelocMap;
 
   DebugChecksumsSubsectionRef CVFileChecksumTable;
 
   DebugStringTableSubsectionRef CVStringTable;
void COFFDumper::printBinaryBlockWithRelocs(StringRef Label,
   for (const auto &Relocation : Relocations) {
     uint64_t RelocationOffset = Relocation.getOffset();
     if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd)
       printRelocation(Sec, Relocation, OffsetStart);
   }
 }
 
 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    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386     ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64     ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R     ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16   ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU  ),
+    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),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU),
     LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU16),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPC  ),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPC),
     LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPCFP),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_R4000    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3DSP   ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH4      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH5      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_THUMB    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2)
-};
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_R4000),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3DSP),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH4),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH5),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_THUMB),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2)};
 
 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     ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LOCAL_SYMS_STRIPPED    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_AGGRESSIVE_WS_TRIM     ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LARGE_ADDRESS_AWARE    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_LO      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_32BIT_MACHINE          ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DEBUG_STRIPPED         ),
+    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),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LOCAL_SYMS_STRIPPED),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_AGGRESSIVE_WS_TRIM),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LARGE_ADDRESS_AWARE),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_LO),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_32BIT_MACHINE),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DEBUG_STRIPPED),
     LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_NET_RUN_FROM_SWAP      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_SYSTEM                 ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DLL                    ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_UP_SYSTEM_ONLY         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI      )
-};
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_NET_RUN_FROM_SWAP),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_SYSTEM),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DLL),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_UP_SYSTEM_ONLY),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI)};
 
 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            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CUI            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_POSIX_CUI              ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_APPLICATION        ),
+    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),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CUI),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_POSIX_CUI),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_APPLICATION),
     LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER     ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_ROM                ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX                   ),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_ROM),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX),
 };
 
 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      ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_SEH               ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_BIND              ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER           ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF             ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE),
+    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),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_SEH),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_BIND),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER),
+    LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF),
+    LLVM_READOBJ_ENUM_ENT(COFF,
+                          IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE),
 };
 
 static const EnumEntry<COFF::ExtendedDLLCharacteristics>
     PEExtendedDLLCharacteristics[] = {
         LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT),
 };
 
 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           ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE              ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA  ),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA),
         LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER             ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO              ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_GPREL                 ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT             ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD           ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES          ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES          ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES          ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES          ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES        ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES        ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES        ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES       ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES       ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES       ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES       ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL       ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE       ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED        ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED         ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED            ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE           ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ              ),
-  LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE             )
-};
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_GPREL),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ),
+        LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE)};
 
 const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
-  { "Null"  , COFF::IMAGE_SYM_TYPE_NULL   },
-  { "Void"  , COFF::IMAGE_SYM_TYPE_VOID   },
-  { "Char"  , COFF::IMAGE_SYM_TYPE_CHAR   },
-  { "Short" , COFF::IMAGE_SYM_TYPE_SHORT  },
-  { "Int"   , COFF::IMAGE_SYM_TYPE_INT    },
-  { "Long"  , COFF::IMAGE_SYM_TYPE_LONG   },
-  { "Float" , COFF::IMAGE_SYM_TYPE_FLOAT  },
-  { "Double", COFF::IMAGE_SYM_TYPE_DOUBLE },
-  { "Struct", COFF::IMAGE_SYM_TYPE_STRUCT },
-  { "Union" , COFF::IMAGE_SYM_TYPE_UNION  },
-  { "Enum"  , COFF::IMAGE_SYM_TYPE_ENUM   },
-  { "MOE"   , COFF::IMAGE_SYM_TYPE_MOE    },
-  { "Byte"  , COFF::IMAGE_SYM_TYPE_BYTE   },
-  { "Word"  , COFF::IMAGE_SYM_TYPE_WORD   },
-  { "UInt"  , COFF::IMAGE_SYM_TYPE_UINT   },
-  { "DWord" , COFF::IMAGE_SYM_TYPE_DWORD  }
-};
+    {"Null", COFF::IMAGE_SYM_TYPE_NULL},
+    {"Void", COFF::IMAGE_SYM_TYPE_VOID},
+    {"Char", COFF::IMAGE_SYM_TYPE_CHAR},
+    {"Short", COFF::IMAGE_SYM_TYPE_SHORT},
+    {"Int", COFF::IMAGE_SYM_TYPE_INT},
+    {"Long", COFF::IMAGE_SYM_TYPE_LONG},
+    {"Float", COFF::IMAGE_SYM_TYPE_FLOAT},
+    {"Double", COFF::IMAGE_SYM_TYPE_DOUBLE},
+    {"Struct", COFF::IMAGE_SYM_TYPE_STRUCT},
+    {"Union", COFF::IMAGE_SYM_TYPE_UNION},
+    {"Enum", COFF::IMAGE_SYM_TYPE_ENUM},
+    {"MOE", COFF::IMAGE_SYM_TYPE_MOE},
+    {"Byte", COFF::IMAGE_SYM_TYPE_BYTE},
+    {"Word", COFF::IMAGE_SYM_TYPE_WORD},
+    {"UInt", COFF::IMAGE_SYM_TYPE_UINT},
+    {"DWord", COFF::IMAGE_SYM_TYPE_DWORD}};
 
 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    }
-};
+    {"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[] = {
-  { "EndOfFunction"  , COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION  },
-  { "Null"           , COFF::IMAGE_SYM_CLASS_NULL             },
-  { "Automatic"      , COFF::IMAGE_SYM_CLASS_AUTOMATIC        },
-  { "External"       , COFF::IMAGE_SYM_CLASS_EXTERNAL         },
-  { "Static"         , COFF::IMAGE_SYM_CLASS_STATIC           },
-  { "Register"       , COFF::IMAGE_SYM_CLASS_REGISTER         },
-  { "ExternalDef"    , COFF::IMAGE_SYM_CLASS_EXTERNAL_DEF     },
-  { "Label"          , COFF::IMAGE_SYM_CLASS_LABEL            },
-  { "UndefinedLabel" , COFF::IMAGE_SYM_CLASS_UNDEFINED_LABEL  },
-  { "MemberOfStruct" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_STRUCT },
-  { "Argument"       , COFF::IMAGE_SYM_CLASS_ARGUMENT         },
-  { "StructTag"      , COFF::IMAGE_SYM_CLASS_STRUCT_TAG       },
-  { "MemberOfUnion"  , COFF::IMAGE_SYM_CLASS_MEMBER_OF_UNION  },
-  { "UnionTag"       , COFF::IMAGE_SYM_CLASS_UNION_TAG        },
-  { "TypeDefinition" , COFF::IMAGE_SYM_CLASS_TYPE_DEFINITION  },
-  { "UndefinedStatic", COFF::IMAGE_SYM_CLASS_UNDEFINED_STATIC },
-  { "EnumTag"        , COFF::IMAGE_SYM_CLASS_ENUM_TAG         },
-  { "MemberOfEnum"   , COFF::IMAGE_SYM_CLASS_MEMBER_OF_ENUM   },
-  { "RegisterParam"  , COFF::IMAGE_SYM_CLASS_REGISTER_PARAM   },
-  { "BitField"       , COFF::IMAGE_SYM_CLASS_BIT_FIELD        },
-  { "Block"          , COFF::IMAGE_SYM_CLASS_BLOCK            },
-  { "Function"       , COFF::IMAGE_SYM_CLASS_FUNCTION         },
-  { "EndOfStruct"    , COFF::IMAGE_SYM_CLASS_END_OF_STRUCT    },
-  { "File"           , COFF::IMAGE_SYM_CLASS_FILE             },
-  { "Section"        , COFF::IMAGE_SYM_CLASS_SECTION          },
-  { "WeakExternal"   , COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL    },
-  { "CLRToken"       , COFF::IMAGE_SYM_CLASS_CLR_TOKEN        }
-};
+    {"EndOfFunction", COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION},
+    {"Null", COFF::IMAGE_SYM_CLASS_NULL},
+    {"Automatic", COFF::IMAGE_SYM_CLASS_AUTOMATIC},
+    {"External", COFF::IMAGE_SYM_CLASS_EXTERNAL},
+    {"Static", COFF::IMAGE_SYM_CLASS_STATIC},
+    {"Register", COFF::IMAGE_SYM_CLASS_REGISTER},
+    {"ExternalDef", COFF::IMAGE_SYM_CLASS_EXTERNAL_DEF},
+    {"Label", COFF::IMAGE_SYM_CLASS_LABEL},
+    {"UndefinedLabel", COFF::IMAGE_SYM_CLASS_UNDEFINED_LABEL},
+    {"MemberOfStruct", COFF::IMAGE_SYM_CLASS_MEMBER_OF_STRUCT},
+    {"Argument", COFF::IMAGE_SYM_CLASS_ARGUMENT},
+    {"StructTag", COFF::IMAGE_SYM_CLASS_STRUCT_TAG},
+    {"MemberOfUnion", COFF::IMAGE_SYM_CLASS_MEMBER_OF_UNION},
+    {"UnionTag", COFF::IMAGE_SYM_CLASS_UNION_TAG},
+    {"TypeDefinition", COFF::IMAGE_SYM_CLASS_TYPE_DEFINITION},
+    {"UndefinedStatic", COFF::IMAGE_SYM_CLASS_UNDEFINED_STATIC},
+    {"EnumTag", COFF::IMAGE_SYM_CLASS_ENUM_TAG},
+    {"MemberOfEnum", COFF::IMAGE_SYM_CLASS_MEMBER_OF_ENUM},
+    {"RegisterParam", COFF::IMAGE_SYM_CLASS_REGISTER_PARAM},
+    {"BitField", COFF::IMAGE_SYM_CLASS_BIT_FIELD},
+    {"Block", COFF::IMAGE_SYM_CLASS_BLOCK},
+    {"Function", COFF::IMAGE_SYM_CLASS_FUNCTION},
+    {"EndOfStruct", COFF::IMAGE_SYM_CLASS_END_OF_STRUCT},
+    {"File", COFF::IMAGE_SYM_CLASS_FILE},
+    {"Section", COFF::IMAGE_SYM_CLASS_SECTION},
+    {"WeakExternal", COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL},
+    {"CLRToken", COFF::IMAGE_SYM_CLASS_CLR_TOKEN}};
 
 const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
-  { "NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES },
-  { "Any"         , COFF::IMAGE_COMDAT_SELECT_ANY          },
-  { "SameSize"    , COFF::IMAGE_COMDAT_SELECT_SAME_SIZE    },
-  { "ExactMatch"  , COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH  },
-  { "Associative" , COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE  },
-  { "Largest"     , COFF::IMAGE_COMDAT_SELECT_LARGEST      },
-  { "Newest"      , COFF::IMAGE_COMDAT_SELECT_NEWEST       }
-};
+    {"NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES},
+    {"Any", COFF::IMAGE_COMDAT_SELECT_ANY},
+    {"SameSize", COFF::IMAGE_COMDAT_SELECT_SAME_SIZE},
+    {"ExactMatch", COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH},
+    {"Associative", COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE},
+    {"Largest", COFF::IMAGE_COMDAT_SELECT_LARGEST},
+    {"Newest", COFF::IMAGE_COMDAT_SELECT_NEWEST}};
 
 const EnumEntry<COFF::DebugType> ImageDebugType[] = {
     {"Unknown", COFF::IMAGE_DEBUG_TYPE_UNKNOWN},
     {"COFF", COFF::IMAGE_DEBUG_TYPE_COFF},
     {"CodeView", COFF::IMAGE_DEBUG_TYPE_CODEVIEW},
     {"FPO", COFF::IMAGE_DEBUG_TYPE_FPO},
     {"Misc", COFF::IMAGE_DEBUG_TYPE_MISC},
     {"Exception", COFF::IMAGE_DEBUG_TYPE_EXCEPTION},
     {"Fixup", COFF::IMAGE_DEBUG_TYPE_FIXUP},
     {"OmapToSrc", COFF::IMAGE_DEBUG_TYPE_OMAP_TO_SRC},
     {"OmapFromSrc", COFF::IMAGE_DEBUG_TYPE_OMAP_FROM_SRC},
     {"Borland", COFF::IMAGE_DEBUG_TYPE_BORLAND},
     {"Reserved10", COFF::IMAGE_DEBUG_TYPE_RESERVED10},
     {"CLSID", COFF::IMAGE_DEBUG_TYPE_CLSID},
     {"VCFeature", COFF::IMAGE_DEBUG_TYPE_VC_FEATURE},
     {"POGO", COFF::IMAGE_DEBUG_TYPE_POGO},
     {"ILTCG", COFF::IMAGE_DEBUG_TYPE_ILTCG},
     {"MPX", COFF::IMAGE_DEBUG_TYPE_MPX},
     {"Repro", COFF::IMAGE_DEBUG_TYPE_REPRO},
     {"ExtendedDLLCharacteristics",
      COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS},
 };
 
 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     }
-};
+        {"NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY},
+        {"Library", COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY},
+        {"Alias", COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS}};
 
 const EnumEntry<uint32_t> SubSectionTypes[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, Symbols),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, Lines),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, StringTable),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, FileChecksums),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, FrameData),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, InlineeLines),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, CrossScopeImports),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, CrossScopeExports),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, ILLines),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, FuncMDTokenMap),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, TypeMDTokenMap),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, MergedAssemblyInput),
     LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, CoffSymbolRVA),
 };
 
 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<uint8_t> FileChecksumKindNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None),
     LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5),
     LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1),
     LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA256),
 };
 
 template <typename T>
 static std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
                                         COFFSymbolRef Symbol,
                                         uint8_t AuxSymbolIdx, const T *&Aux) {
   ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol);
   AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize());
-  Aux = reinterpret_cast<const T*>(AuxData.data());
+  Aux = reinterpret_cast<const T *>(AuxData.data());
   return std::error_code();
 }
 
 void COFFDumper::cacheRelocations() {
   if (RelocCached)
     return;
   RelocCached = true;
 
void COFFDumper::printDataDirectory(uint32_t Index,
   if (!Data)
     return;
   W.printHex(FieldName + "RVA", Data->RelativeVirtualAddress);
   W.printHex(FieldName + "Size", Data->Size);
 }
 
 void COFFDumper::printFileHeaders() {
   time_t TDS = Obj->getTimeDateStamp();
-  char FormattedTime[20] = { };
+  char FormattedTime[20] = {};
   strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
 
   {
     DictScope D(W, "ImageFileHeader");
-    W.printEnum  ("Machine", Obj->getMachine(),
-                    makeArrayRef(ImageFileMachineType));
+    W.printEnum("Machine", Obj->getMachine(),
     W.printNumber("SectionCount", Obj->getNumberOfSections());
-    W.printHex   ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp());
-    W.printHex   ("PointerToSymbolTable", Obj->getPointerToSymbolTable());
+    W.printHex("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp());
+    W.printHex("PointerToSymbolTable", Obj->getPointerToSymbolTable());
     W.printNumber("SymbolCount", Obj->getNumberOfSymbols());
     W.printNumber("StringTableSize", Obj->getStringTableSize());
     W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader());
-    W.printFlags ("Characteristics", Obj->getCharacteristics(),
-                    makeArrayRef(ImageFileCharacteristics));
+    W.printFlags("Characteristics", Obj->getCharacteristics(),
   }
 
   // Print PE header. This header does not exist if this is an object file and
   // not an executable.
   if (const pe32_header *PEHeader = Obj->getPE32Header())
     printPEHeader<pe32_header>(PEHeader);
 
   if (const pe32plus_header *PEPlusHeader = Obj->getPE32PlusHeader())
void COFFDumper::printDOSHeader(const dos_header *DH) {
   W.printNumber("InitialRelativeCS", DH->InitialRelativeCS);
   W.printNumber("AddressOfRelocationTable", DH->AddressOfRelocationTable);
   W.printNumber("OverlayNumber", DH->OverlayNumber);
   W.printNumber("OEMid", DH->OEMid);
   W.printNumber("OEMinfo", DH->OEMinfo);
   W.printNumber("AddressOfNewExeHeader", DH->AddressOfNewExeHeader);
 }
 
-template <class PEHeader>
-void COFFDumper::printPEHeader(const PEHeader *Hdr) {
+template <class PEHeader> void COFFDumper::printPEHeader(const PEHeader *Hdr) {
   DictScope D(W, "ImageOptionalHeader");
-  W.printHex   ("Magic", Hdr->Magic);
+  W.printHex("Magic", Hdr->Magic);
   W.printNumber("MajorLinkerVersion", Hdr->MajorLinkerVersion);
   W.printNumber("MinorLinkerVersion", Hdr->MinorLinkerVersion);
   W.printNumber("SizeOfCode", Hdr->SizeOfCode);
   W.printNumber("SizeOfInitializedData", Hdr->SizeOfInitializedData);
   W.printNumber("SizeOfUninitializedData", Hdr->SizeOfUninitializedData);
-  W.printHex   ("AddressOfEntryPoint", Hdr->AddressOfEntryPoint);
-  W.printHex   ("BaseOfCode", Hdr->BaseOfCode);
+  W.printHex("AddressOfEntryPoint", Hdr->AddressOfEntryPoint);
+  W.printHex("BaseOfCode", Hdr->BaseOfCode);
   printBaseOfDataField(Hdr);
-  W.printHex   ("ImageBase", Hdr->ImageBase);
+  W.printHex("ImageBase", Hdr->ImageBase);
   W.printNumber("SectionAlignment", Hdr->SectionAlignment);
   W.printNumber("FileAlignment", Hdr->FileAlignment);
   W.printNumber("MajorOperatingSystemVersion",
                 Hdr->MajorOperatingSystemVersion);
   W.printNumber("MinorOperatingSystemVersion",
                 Hdr->MinorOperatingSystemVersion);
   W.printNumber("MajorImageVersion", Hdr->MajorImageVersion);
   W.printNumber("MinorImageVersion", Hdr->MinorImageVersion);
   W.printNumber("MajorSubsystemVersion", Hdr->MajorSubsystemVersion);
   W.printNumber("MinorSubsystemVersion", Hdr->MinorSubsystemVersion);
   W.printNumber("SizeOfImage", Hdr->SizeOfImage);
   W.printNumber("SizeOfHeaders", Hdr->SizeOfHeaders);
-  W.printEnum  ("Subsystem", Hdr->Subsystem, makeArrayRef(PEWindowsSubsystem));
-  W.printFlags ("Characteristics", Hdr->DLLCharacteristics,
-                makeArrayRef(PEDLLCharacteristics));
+  W.printEnum("Subsystem", Hdr->Subsystem, makeArrayRef(PEWindowsSubsystem));
+  W.printFlags("Characteristics", Hdr->DLLCharacteristics,
   W.printNumber("SizeOfStackReserve", Hdr->SizeOfStackReserve);
   W.printNumber("SizeOfStackCommit", Hdr->SizeOfStackCommit);
   W.printNumber("SizeOfHeapReserve", Hdr->SizeOfHeapReserve);
   W.printNumber("SizeOfHeapCommit", Hdr->SizeOfHeapCommit);
   W.printNumber("NumberOfRvaAndSize", Hdr->NumberOfRvaAndSize);
 
   if (Hdr->NumberOfRvaAndSize > 0) {
     DictScope D(W, "DataDirectory");
-    static const char * const directory[] = {
-      "ExportTable", "ImportTable", "ResourceTable", "ExceptionTable",
-      "CertificateTable", "BaseRelocationTable", "Debug", "Architecture",
-      "GlobalPtr", "TLSTable", "LoadConfigTable", "BoundImport", "IAT",
-      "DelayImportDescriptor", "CLRRuntimeHeader", "Reserved"
-    };
+    static const char *const directory[] = {"ExportTable",
+                                            "ImportTable",
+                                            "ResourceTable",
+                                            "ExceptionTable",
+                                            "CertificateTable",
+                                            "BaseRelocationTable",
+                                            "Debug",
+                                            "Architecture",
+                                            "GlobalPtr",
+                                            "TLSTable",
+                                            "LoadConfigTable",
+                                            "BoundImport",
+                                            "IAT",
+                                            "DelayImportDescriptor",
+                                            "CLRRuntimeHeader",
+                                            "Reserved"};
 
     for (uint32_t i = 0; i < Hdr->NumberOfRvaAndSize; ++i)
       if (i < sizeof(directory) / sizeof(char *))
         printDataDirectory(i, directory[i]);
       else
         printDataDirectory(i, "Unknown");
   }
 }
if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW) {
         W.printBinary("PDBGUID", makeArrayRef(DebugInfo->PDB70.Signature));
         W.printNumber("PDBAge", DebugInfo->PDB70.Age);
         W.printString("PDBFileName", PDBFileName);
       }
     } else if (D.SizeOfData != 0) {
       // FIXME: Data visualization for IMAGE_DEBUG_TYPE_VC_FEATURE and
       // IMAGE_DEBUG_TYPE_POGO?
       ArrayRef<uint8_t> RawData;
-      if (Error E = Obj->getRvaAndSizeAsBytes(D.AddressOfRawData,
-                                                         D.SizeOfData, RawData))
+      if (Error E = Obj->getRvaAndSizeAsBytes(D.AddressOfRawData, D.SizeOfData,
+                                              RawData))
         reportError(std::move(E), Obj->getFileName());
       if (D.Type == COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS) {
         // FIXME right now the only possible value would fit in 8 bits,
         // but that might change in the future
         uint16_t Characteristics = RawData[0];
         W.printFlags("ExtendedCharacteristics", Characteristics,
                      makeArrayRef(PEExtendedDLLCharacteristics));
       }
       W.printBinaryBlock("RawData", RawData);
     }
   }
 }
 
 void COFFDumper::printRVATable(uint64_t TableVA, uint64_t Count,
                                uint64_t EntrySize, PrintExtraCB PrintExtra) {
   uintptr_t TableStart, TableEnd;
   if (Error E = Obj->getVaPtr(TableVA, TableStart))
     reportError(std::move(E), Obj->getFileName());
-  if (Error E =
-          Obj->getVaPtr(TableVA + Count * EntrySize - 1, TableEnd))
+  if (Error E = Obj->getVaPtr(TableVA + Count * EntrySize - 1, TableEnd))
     reportError(std::move(E), Obj->getFileName());
   TableEnd++;
   for (uintptr_t I = TableStart; I < TableEnd; I += EntrySize) {
     uint32_t RVA = *reinterpret_cast<const ulittle32_t *>(I);
     raw_ostream &OS = W.startLine();
     OS << W.hex(Obj->getImageBase() + RVA);
     if (PrintExtra)
       PrintExtra(OS, reinterpret_cast<const uint8_t *>(I));

 }
 
 void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
                                                 const SectionRef &Section,
                                                 StringRef SectionContents) {
   ArrayRef<uint8_t> BinaryData(Subsection.bytes_begin(),
                                Subsection.bytes_end());
   auto CODD = std::make_unique<COFFObjectDumpDelegate>(*this, Section, Obj,
-                                                        SectionContents);
   CVSymbolDumper CVSD(W, Types, CodeViewContainer::ObjectFile, std::move(CODD),
                       CompilationCPUType, opts::CodeViewSubsectionBytes);
   CVSymbolArray Symbols;
   BinaryStreamReader Reader(BinaryData, llvm::support::little);
   if (Error E = Reader.readArray(Symbols, Reader.getLength())) {
     W.flush();
     reportError(std::move(E), Obj->getFileName());
   }
for (const SectionRef &Sec : Obj->sections()) {
     ++SectionNumber;
     const coff_section *Section = Obj->getCOFFSection(Sec);
 
     StringRef Name = unwrapOrError(Obj->getFileName(), Sec.getName());
 
     DictScope D(W, "Section");
     W.printNumber("Number", SectionNumber);
     W.printBinary("Name", Name, Section->Name);
-    W.printHex   ("VirtualSize", Section->VirtualSize);
-    W.printHex   ("VirtualAddress", Section->VirtualAddress);
+    W.printHex("VirtualSize", Section->VirtualSize);
+    W.printHex("VirtualAddress", Section->VirtualAddress);
     W.printNumber("RawDataSize", Section->SizeOfRawData);
-    W.printHex   ("PointerToRawData", Section->PointerToRawData);
-    W.printHex   ("PointerToRelocations", Section->PointerToRelocations);
-    W.printHex   ("PointerToLineNumbers", Section->PointerToLinenumbers);
+    W.printHex("PointerToRawData", Section->PointerToRawData);
+    W.printHex("PointerToRelocations", Section->PointerToRelocations);
+    W.printHex("PointerToLineNumbers", Section->PointerToLinenumbers);
     W.printNumber("RelocationCount", Section->NumberOfRelocations);
     W.printNumber("LineNumberCount", Section->NumberOfLinenumbers);
-    W.printFlags ("Characteristics", Section->Characteristics,
-                    makeArrayRef(ImageSectionCharacteristics),
-                    COFF::SectionCharacteristics(0x00F00000));
+    W.printFlags("Characteristics", Section->Characteristics,
 
     if (opts::SectionRelocations) {
       ListScope D(W, "Relocations");
       for (const RelocationRef &Reloc : Sec.relocations())
         printRelocation(Sec, Reloc);
     }
 
     if (opts::SectionSymbols) {
void COFFDumper::printRelocation(const SectionRef &Section,
 
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Offset);
     W.printNumber("Type", RelocName, RelocType);
     W.printString("Symbol", SymbolName.empty() ? "-" : SymbolName);
     W.printNumber("SymbolIndex", SymbolIndex);
   } else {
-    raw_ostream& OS = W.startLine();
-    OS << W.hex(Offset)
-       << " " << RelocName
-       << " " << (SymbolName.empty() ? "-" : SymbolName)
-       << " (" << SymbolIndex << ")"
+    raw_ostream &OS = W.startLine();
+    OS << W.hex(Offset) << " " << RelocName << " "
+       << (SymbolName.empty() ? "-" : SymbolName) << " (" << SymbolIndex << ")"
        << "\n";
   }
 }
 
 void COFFDumper::printSymbols() {
   ListScope Group(W, "Symbols");
 
   for (const SymbolRef &Symbol : Obj->symbols())
void COFFDumper::printSymbol(const SymbolRef &Sym) {
   StringRef SectionName;
   if (Expected<StringRef> SecNameOrErr =
           getSectionName(Obj, Symbol.getSectionNumber(), Section))
     SectionName = *SecNameOrErr;
 
   W.printString("Name", SymbolName);
   W.printNumber("Value", Symbol.getValue());
   W.printNumber("Section", SectionName, Symbol.getSectionNumber());
-  W.printEnum  ("BaseType", Symbol.getBaseType(), makeArrayRef(ImageSymType));
-  W.printEnum  ("ComplexType", Symbol.getComplexType(),
-                                                   makeArrayRef(ImageSymDType));
-  W.printEnum  ("StorageClass", Symbol.getStorageClass(),
-                                                   makeArrayRef(ImageSymClass));
+  W.printEnum("BaseType", Symbol.getBaseType(), makeArrayRef(ImageSymType));
+  W.printEnum("ComplexType", Symbol.getComplexType(),
+  W.printEnum("StorageClass", Symbol.getStorageClass(),
   W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols());
 
   for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) {
     if (Symbol.isFunctionDefinition()) {
       const coff_aux_function_definition *Aux;
       if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, Aux))
         reportError(errorCodeToError(EC), Obj->getFileName());
 
       DictScope AS(W, "AuxFunctionDef");
       W.printNumber("TagIndex", Aux->TagIndex);
       W.printNumber("TotalSize", Aux->TotalSize);
       W.printHex("PointerToLineNumber", Aux->PointerToLinenumber);
       W.printHex("PointerToNextFunction", Aux->PointerToNextFunction);
 
     } else if (Symbol.isAnyUndefined()) {
       const coff_aux_weak_external *Aux;
       if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, Aux))
         reportError(errorCodeToError(EC), Obj->getFileName());
 
       DictScope AS(W, "AuxWeakExternal");
       W.printNumber("Linked", getSymbolName(Aux->TagIndex), Aux->TagIndex);
-      W.printEnum  ("Search", Aux->Characteristics,
-                    makeArrayRef(WeakExternalCharacteristics));
+      W.printEnum("Search", Aux->Characteristics,
 
     } else if (Symbol.isFileRecord()) {
       const char *FileName;
       if (std::error_code EC = getSymbolAuxData(Obj, Symbol, I, FileName))
         reportError(errorCodeToError(EC), Obj->getFileName());
       DictScope AS(W, "AuxFileRecord");
 
       StringRef Name(FileName, Symbol.getNumberOfAuxSymbols() *
if (Symbol.isFunctionDefinition()) {
       DictScope AS(W, "AuxSectionDef");
       W.printNumber("Length", Aux->Length);
       W.printNumber("RelocationCount", Aux->NumberOfRelocations);
       W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers);
       W.printHex("Checksum", Aux->CheckSum);
       W.printNumber("Number", AuxNumber);
       W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect));
 
-      if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
-          && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
+      if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT &&
+          Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
         Expected<const coff_section *> Assoc = Obj->getSection(AuxNumber);
         if (!Assoc)
           reportError(Assoc.takeError(), Obj->getFileName());
         Expected<StringRef> AssocName = getSectionName(Obj, AuxNumber, *Assoc);
         if (!AssocName)
           reportError(AssocName.takeError(), Obj->getFileName());
 
         W.printNumber("AssocSection", *AssocName, AuxNumber);
void COFFDumper::printSymbol(const SymbolRef &Sym) {
   }
 }
 
 void COFFDumper::printUnwindInfo() {
   ListScope D(W, "UnwindInformation");
   switch (Obj->getMachine()) {
   case COFF::IMAGE_FILE_MACHINE_AMD64: {
     Win64EH::Dumper Dumper(W);
-    Win64EH::Dumper::SymbolResolver
-    Resolver = [](const object::coff_section *Section, uint64_t Offset,
-                  SymbolRef &Symbol, void *user_data) -> std::error_code {
+    Win64EH::Dumper::SymbolResolver Resolver =
+        [](const object::coff_section *Section, uint64_t Offset,
       COFFDumper *Dumper = reinterpret_cast<COFFDumper *>(user_data);
       return Dumper->resolveSymbol(Section, Offset, Symbol);
     };
     Win64EH::Dumper::Context Ctx(*Obj, Resolver, this);
     Dumper.printData(Ctx);
     break;
   }
   case COFF::IMAGE_FILE_MACHINE_ARM64:
for (const ImportDirectoryEntryRef &I : Obj->import_directories()) {
     // fall back to the import address table in that case.
     if (ILTAddr)
       printImportedSymbols(I.lookup_table_symbols());
     else
       printImportedSymbols(I.imported_symbols());
   }
 
   // Delay imports
-  for (const DelayImportDirectoryEntryRef &I : Obj->delay_import_directories()) {
+  for (const DelayImportDirectoryEntryRef &I :
+       Obj->delay_import_directories()) {
     DictScope Import(W, "DelayImport");
     StringRef Name;
     if (Error E = I.getName(Name))
       reportError(std::move(E), Obj->getFileName());
     W.printString("Name", Name);
     const delay_import_directory_table_entry *Table;
     if (Error E = I.getDelayImportTable(Table))
       reportError(std::move(E), Obj->getFileName());
for (const SectionRef &Section : Obj->sections()) {
     StringRef Contents =
         unwrapOrError(Obj->getFileName(), Section.getContents());
     W.printString("Directive(s)", Contents);
   }
 }
 
 static std::string getBaseRelocTypeName(uint8_t Type) {
   switch (Type) {
-  case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE";
-  case COFF::IMAGE_REL_BASED_HIGH: return "HIGH";
-  case COFF::IMAGE_REL_BASED_LOW: return "LOW";
-  case COFF::IMAGE_REL_BASED_HIGHLOW: return "HIGHLOW";
-  case COFF::IMAGE_REL_BASED_HIGHADJ: return "HIGHADJ";
-  case COFF::IMAGE_REL_BASED_ARM_MOV32T: return "ARM_MOV32(T)";
-  case COFF::IMAGE_REL_BASED_DIR64: return "DIR64";
-  default: return "unknown (" + llvm::utostr(Type) + ")";
+  case COFF::IMAGE_REL_BASED_ABSOLUTE:
+    return "ABSOLUTE";
+  case COFF::IMAGE_REL_BASED_HIGH:
+    return "HIGH";
+  case COFF::IMAGE_REL_BASED_LOW:
+    return "LOW";
+  case COFF::IMAGE_REL_BASED_HIGHLOW:
+    return "HIGHLOW";
+  case COFF::IMAGE_REL_BASED_HIGHADJ:
+    return "HIGHADJ";
+  case COFF::IMAGE_REL_BASED_ARM_MOV32T:
+    return "ARM_MOV32(T)";
+  case COFF::IMAGE_REL_BASED_DIR64:
+    return "DIR64";
+  default:
+    return "unknown (" + llvm::utostr(Type) + ")";
   }
 }
 
 void COFFDumper::printCOFFBaseReloc() {
   ListScope D(W, "BaseReloc");
   for (const BaseRelocRef &I : Obj->base_relocs()) {
     uint8_t Type;
     uint32_t RVA;
if (StackMapSection == SectionRef())
     return;
 
   StringRef StackMapContents =
       unwrapOrError(Obj->getFileName(), StackMapSection.getContents());
   ArrayRef<uint8_t> StackMapContentsArray =
       arrayRefFromStringRef(StackMapContents);
 
   if (Obj->isLittleEndian())
-    prettyPrintStackMap(
-        W, StackMapParser<support::little>(StackMapContentsArray));
+    prettyPrintStackMap(W,
+                        StackMapParser<support::little>(StackMapContentsArray));
   else
-    prettyPrintStackMap(
-        W, StackMapParser<support::big>(StackMapContentsArray));
+    prettyPrintStackMap(W, StackMapParser<support::big>(StackMapContentsArray));
 }
 
 void COFFDumper::printAddrsig() {
   SectionRef AddrsigSection;
   for (auto Sec : Obj->sections()) {
     StringRef Name;
     if (Expected<StringRef> NameOrErr = Sec.getName())
       Name = *NameOrErr;

llvm/tools/llvm-readobj/COFFImportDumper.cpp

 
 void dumpCOFFImportFile(const COFFImportFile *File, ScopedPrinter &Writer) {
   Writer.startLine() << '\n';
   Writer.printString("File", File->getFileName());
   Writer.printString("Format", "COFF-import-file");
 
   const coff_import_header *H = File->getCOFFImportHeader();
   switch (H->getType()) {
-  case COFF::IMPORT_CODE:  Writer.printString("Type", "code"); break;
-  case COFF::IMPORT_DATA:  Writer.printString("Type", "data"); break;
-  case COFF::IMPORT_CONST: Writer.printString("Type", "const"); break;
+  case COFF::IMPORT_CODE:
+    Writer.printString("Type", "code");
+    break;
+  case COFF::IMPORT_DATA:
+    Writer.printString("Type", "data");
+    break;
+  case COFF::IMPORT_CONST:
+    Writer.printString("Type", "const");
+    break;
   }
 
   switch (H->getNameType()) {
   case COFF::IMPORT_ORDINAL:
     Writer.printString("Name type", "ordinal");
     break;
   case COFF::IMPORT_NAME:
     Writer.printString("Name type", "name");

llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h

void PrinterContext<ELFT>::printUnwindInformation() const {
   }
 }
 
 template <typename ELFT>
 void PrinterContext<ELFT>::printEHFrameHdr(const Elf_Phdr *EHFramePHdr) const {
   DictScope L(W, "EHFrameHeader");
   uint64_t EHFrameHdrAddress = EHFramePHdr->p_vaddr;
   W.startLine() << format("Address: 0x%" PRIx64 "\n", EHFrameHdrAddress);
-  W.startLine() << format("Offset: 0x%" PRIx64 "\n", (uint64_t)EHFramePHdr->p_offset);
-  W.startLine() << format("Size: 0x%" PRIx64 "\n", (uint64_t)EHFramePHdr->p_memsz);
+  W.startLine() << format("Offset: 0x%" PRIx64 "\n",
+                          (uint64_t)EHFramePHdr->p_offset);
+  W.startLine() << format("Size: 0x%" PRIx64 "\n",
+                          (uint64_t)EHFramePHdr->p_memsz);
 
   const object::ELFFile<ELFT> &Obj = ObjF.getELFFile();
   if (const Elf_Shdr *EHFrameHdr =
           findSectionByAddress(ObjF, EHFramePHdr->p_vaddr)) {
     Expected<StringRef> NameOrErr = Obj.getSectionName(*EHFrameHdr);
     if (!NameOrErr)
       reportError(NameOrErr.takeError(), ObjF.getFileName());
     W.printString("Corresponding Section", *NameOrErr);

llvm/tools/llvm-readobj/ELFDumper.cpp

 using namespace llvm::object;
 using namespace ELF;
 
 #define LLVM_READOBJ_ENUM_CASE(ns, enum)                                       \
   case ns::enum:                                                               \
     return #enum;
 
 #define ENUM_ENT(enum, altName)                                                \
-  { #enum, altName, ELF::enum }
+  {                                                                            \
+#enum, altName, ELF::enum                                                  \
+  }
 
 #define ENUM_ENT_1(enum)                                                       \
-  { #enum, #enum, ELF::enum }
+  {                                                                            \
+#enum, #enum, ELF::enum                                                    \
+  }
 
 namespace {
 
 template <class ELFT> struct RelSymbol {
-  RelSymbol(const typename ELFT::Sym *S, StringRef N)
-      : Sym(S), Name(N.str()) {}
+  RelSymbol(const typename ELFT::Sym *S, StringRef N) : Sym(S), Name(N.str()) {}
   const typename ELFT::Sym *Sym;
   std::string Name;
 };
 
 /// Represents a contiguous uniform range in the file. We cannot just create a
 /// range directly because when creating one of these from the .dynamic table
 /// the size, entity size and virtual address are different entries in arbitrary
 /// order (DT_REL, DT_RELSZ, DT_RELENT for example).
protected:
   const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotSymtabSec = nullptr;
   const Elf_Shdr *DotDynsymSec = nullptr;
   const Elf_Shdr *DotAddrsigSec = nullptr;
   DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables;
   Optional<uint64_t> SONameOffset;
   Optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap;
 
-  const Elf_Shdr *SymbolVersionSection = nullptr;   // .gnu.version
+  const Elf_Shdr *SymbolVersionSection = nullptr;     // .gnu.version
   const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r
-  const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d
+  const Elf_Shdr *SymbolVersionDefSection = nullptr;  // .gnu.version_d
 
   std::string getFullSymbolName(const Elf_Sym &Symbol, unsigned SymIndex,
                                 DataRegion<Elf_Word> ShndxTable,
                                 Optional<StringRef> StrTable,
                                 bool IsDynamic) const;
   Expected<unsigned>
   getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex,
                         DataRegion<Elf_Word> ShndxTable) const;
if (!EntryOrErr)
     return EntryOrErr.takeError();
 
   unsigned Version = (*EntryOrErr)->vs_index;
   if (Version == VER_NDX_LOCAL || Version == VER_NDX_GLOBAL) {
     IsDefault = false;
     return "";
   }
 
-  Expected<SmallVector<Optional<VersionEntry>, 0> *> MapOrErr =
-      getVersionMap();
+  Expected<SmallVector<Optional<VersionEntry>, 0> *> MapOrErr = getVersionMap();
   if (!MapOrErr)
     return MapOrErr.takeError();
 
   return Obj.getSymbolVersionByIndex(Version, IsDefault, **MapOrErr,
                                      Sym.st_shndx == ELF::SHN_UNDEF);
 }
 
 template <typename ELFT>
findNotEmptySectionByAddress(const ELFO &Obj, StringRef FileName,
                              uint64_t Addr) {
   for (const typename ELFO::Elf_Shdr &Shdr : cantFail(Obj.sections()))
     if (Shdr.sh_addr == Addr && Shdr.sh_size > 0)
       return &Shdr;
   return nullptr;
 }
 
 const EnumEntry<unsigned> ElfClass[] = {
-  {"None",   "none",   ELF::ELFCLASSNONE},
-  {"32-bit", "ELF32",  ELF::ELFCLASS32},
-  {"64-bit", "ELF64",  ELF::ELFCLASS64},
+    {"None", "none", ELF::ELFCLASSNONE},
+    {"32-bit", "ELF32", ELF::ELFCLASS32},
+    {"64-bit", "ELF64", ELF::ELFCLASS64},
 };
 
 const EnumEntry<unsigned> ElfDataEncoding[] = {
-  {"None",         "none",                          ELF::ELFDATANONE},
+    {"None", "none", ELF::ELFDATANONE},
     {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB},
-  {"BigEndian",    "2's complement, big endian",    ELF::ELFDATA2MSB},
+    {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB},
 };
 
 const EnumEntry<unsigned> ElfObjectFileType[] = {
-  {"None",         "NONE (none)",              ELF::ET_NONE},
-  {"Relocatable",  "REL (Relocatable file)",   ELF::ET_REL},
-  {"Executable",   "EXEC (Executable file)",   ELF::ET_EXEC},
+    {"None", "NONE (none)", ELF::ET_NONE},
+    {"Relocatable", "REL (Relocatable file)", ELF::ET_REL},
+    {"Executable", "EXEC (Executable file)", ELF::ET_EXEC},
     {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN},
-  {"Core",         "CORE (Core file)",         ELF::ET_CORE},
+    {"Core", "CORE (Core file)", ELF::ET_CORE},
 };
 
 const EnumEntry<unsigned> ElfOSABI[] = {
-  {"SystemV",      "UNIX - System V",      ELF::ELFOSABI_NONE},
-  {"HPUX",         "UNIX - HP-UX",         ELF::ELFOSABI_HPUX},
-  {"NetBSD",       "UNIX - NetBSD",        ELF::ELFOSABI_NETBSD},
-  {"GNU/Linux",    "UNIX - GNU",           ELF::ELFOSABI_LINUX},
-  {"GNU/Hurd",     "GNU/Hurd",             ELF::ELFOSABI_HURD},
-  {"Solaris",      "UNIX - Solaris",       ELF::ELFOSABI_SOLARIS},
-  {"AIX",          "UNIX - AIX",           ELF::ELFOSABI_AIX},
-  {"IRIX",         "UNIX - IRIX",          ELF::ELFOSABI_IRIX},
-  {"FreeBSD",      "UNIX - FreeBSD",       ELF::ELFOSABI_FREEBSD},
-  {"TRU64",        "UNIX - TRU64",         ELF::ELFOSABI_TRU64},
-  {"Modesto",      "Novell - Modesto",     ELF::ELFOSABI_MODESTO},
-  {"OpenBSD",      "UNIX - OpenBSD",       ELF::ELFOSABI_OPENBSD},
-  {"OpenVMS",      "VMS - OpenVMS",        ELF::ELFOSABI_OPENVMS},
-  {"NSK",          "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK},
-  {"AROS",         "AROS",                 ELF::ELFOSABI_AROS},
-  {"FenixOS",      "FenixOS",              ELF::ELFOSABI_FENIXOS},
-  {"CloudABI",     "CloudABI",             ELF::ELFOSABI_CLOUDABI},
-  {"Standalone",   "Standalone App",       ELF::ELFOSABI_STANDALONE}
-};
+    {"SystemV", "UNIX - System V", ELF::ELFOSABI_NONE},
+    {"HPUX", "UNIX - HP-UX", ELF::ELFOSABI_HPUX},
+    {"NetBSD", "UNIX - NetBSD", ELF::ELFOSABI_NETBSD},
+    {"GNU/Linux", "UNIX - GNU", ELF::ELFOSABI_LINUX},
+    {"GNU/Hurd", "GNU/Hurd", ELF::ELFOSABI_HURD},
+    {"Solaris", "UNIX - Solaris", ELF::ELFOSABI_SOLARIS},
+    {"AIX", "UNIX - AIX", ELF::ELFOSABI_AIX},
+    {"IRIX", "UNIX - IRIX", ELF::ELFOSABI_IRIX},
+    {"FreeBSD", "UNIX - FreeBSD", ELF::ELFOSABI_FREEBSD},
+    {"TRU64", "UNIX - TRU64", ELF::ELFOSABI_TRU64},
+    {"Modesto", "Novell - Modesto", ELF::ELFOSABI_MODESTO},
+    {"OpenBSD", "UNIX - OpenBSD", ELF::ELFOSABI_OPENBSD},
+    {"OpenVMS", "VMS - OpenVMS", ELF::ELFOSABI_OPENVMS},
+    {"NSK", "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK},
+    {"AROS", "AROS", ELF::ELFOSABI_AROS},
+    {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS},
+    {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI},
+    {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE}};
 
 const EnumEntry<unsigned> AMDGPUElfOSABI[] = {
-  {"AMDGPU_HSA",    "AMDGPU - HSA",    ELF::ELFOSABI_AMDGPU_HSA},
-  {"AMDGPU_PAL",    "AMDGPU - PAL",    ELF::ELFOSABI_AMDGPU_PAL},
-  {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D}
-};
+    {"AMDGPU_HSA", "AMDGPU - HSA", ELF::ELFOSABI_AMDGPU_HSA},
+    {"AMDGPU_PAL", "AMDGPU - PAL", ELF::ELFOSABI_AMDGPU_PAL},
+    {"AMDGPU_MESA3D", "AMDGPU - MESA3D", ELF::ELFOSABI_AMDGPU_MESA3D}};
 
-const EnumEntry<unsigned> ARMElfOSABI[] = {
-  {"ARM", "ARM", ELF::ELFOSABI_ARM}
-};
+const EnumEntry<unsigned> ARMElfOSABI[] = {{"ARM", "ARM", ELF::ELFOSABI_ARM}};
 
 const EnumEntry<unsigned> C6000ElfOSABI[] = {
     {"C6000_ELFABI", "Bare-metal C6000", ELF::ELFOSABI_C6000_ELFABI},
-  {"C6000_LINUX",  "Linux C6000",      ELF::ELFOSABI_C6000_LINUX}
-};
+    {"C6000_LINUX", "Linux C6000", ELF::ELFOSABI_C6000_LINUX}};
 
 const EnumEntry<unsigned> ElfMachineType[] = {
-  ENUM_ENT(EM_NONE,          "None"),
-  ENUM_ENT(EM_M32,           "WE32100"),
-  ENUM_ENT(EM_SPARC,         "Sparc"),
-  ENUM_ENT(EM_386,           "Intel 80386"),
-  ENUM_ENT(EM_68K,           "MC68000"),
-  ENUM_ENT(EM_88K,           "MC88000"),
-  ENUM_ENT(EM_IAMCU,         "EM_IAMCU"),
-  ENUM_ENT(EM_860,           "Intel 80860"),
-  ENUM_ENT(EM_MIPS,          "MIPS R3000"),
-  ENUM_ENT(EM_S370,          "IBM System/370"),
-  ENUM_ENT(EM_MIPS_RS3_LE,   "MIPS R3000 little-endian"),
-  ENUM_ENT(EM_PARISC,        "HPPA"),
-  ENUM_ENT(EM_VPP500,        "Fujitsu VPP500"),
-  ENUM_ENT(EM_SPARC32PLUS,   "Sparc v8+"),
-  ENUM_ENT(EM_960,           "Intel 80960"),
-  ENUM_ENT(EM_PPC,           "PowerPC"),
-  ENUM_ENT(EM_PPC64,         "PowerPC64"),
-  ENUM_ENT(EM_S390,          "IBM S/390"),
-  ENUM_ENT(EM_SPU,           "SPU"),
-  ENUM_ENT(EM_V800,          "NEC V800 series"),
-  ENUM_ENT(EM_FR20,          "Fujistsu FR20"),
-  ENUM_ENT(EM_RH32,          "TRW RH-32"),
-  ENUM_ENT(EM_RCE,           "Motorola RCE"),
-  ENUM_ENT(EM_ARM,           "ARM"),
-  ENUM_ENT(EM_ALPHA,         "EM_ALPHA"),
-  ENUM_ENT(EM_SH,            "Hitachi SH"),
-  ENUM_ENT(EM_SPARCV9,       "Sparc v9"),
-  ENUM_ENT(EM_TRICORE,       "Siemens Tricore"),
-  ENUM_ENT(EM_ARC,           "ARC"),
-  ENUM_ENT(EM_H8_300,        "Hitachi H8/300"),
-  ENUM_ENT(EM_H8_300H,       "Hitachi H8/300H"),
-  ENUM_ENT(EM_H8S,           "Hitachi H8S"),
-  ENUM_ENT(EM_H8_500,        "Hitachi H8/500"),
-  ENUM_ENT(EM_IA_64,         "Intel IA-64"),
-  ENUM_ENT(EM_MIPS_X,        "Stanford MIPS-X"),
-  ENUM_ENT(EM_COLDFIRE,      "Motorola Coldfire"),
-  ENUM_ENT(EM_68HC12,        "Motorola MC68HC12 Microcontroller"),
-  ENUM_ENT(EM_MMA,           "Fujitsu Multimedia Accelerator"),
-  ENUM_ENT(EM_PCP,           "Siemens PCP"),
-  ENUM_ENT(EM_NCPU,          "Sony nCPU embedded RISC processor"),
-  ENUM_ENT(EM_NDR1,          "Denso NDR1 microprocesspr"),
-  ENUM_ENT(EM_STARCORE,      "Motorola Star*Core processor"),
-  ENUM_ENT(EM_ME16,          "Toyota ME16 processor"),
-  ENUM_ENT(EM_ST100,         "STMicroelectronics ST100 processor"),
-  ENUM_ENT(EM_TINYJ,         "Advanced Logic Corp. TinyJ embedded processor"),
-  ENUM_ENT(EM_X86_64,        "Advanced Micro Devices X86-64"),
-  ENUM_ENT(EM_PDSP,          "Sony DSP processor"),
-  ENUM_ENT(EM_PDP10,         "Digital Equipment Corp. PDP-10"),
-  ENUM_ENT(EM_PDP11,         "Digital Equipment Corp. PDP-11"),
-  ENUM_ENT(EM_FX66,          "Siemens FX66 microcontroller"),
-  ENUM_ENT(EM_ST9PLUS,       "STMicroelectronics ST9+ 8/16 bit microcontroller"),
-  ENUM_ENT(EM_ST7,           "STMicroelectronics ST7 8-bit microcontroller"),
-  ENUM_ENT(EM_68HC16,        "Motorola MC68HC16 Microcontroller"),
-  ENUM_ENT(EM_68HC11,        "Motorola MC68HC11 Microcontroller"),
-  ENUM_ENT(EM_68HC08,        "Motorola MC68HC08 Microcontroller"),
-  ENUM_ENT(EM_68HC05,        "Motorola MC68HC05 Microcontroller"),
-  ENUM_ENT(EM_SVX,           "Silicon Graphics SVx"),
-  ENUM_ENT(EM_ST19,          "STMicroelectronics ST19 8-bit microcontroller"),
-  ENUM_ENT(EM_VAX,           "Digital VAX"),
-  ENUM_ENT(EM_CRIS,          "Axis Communications 32-bit embedded processor"),
-  ENUM_ENT(EM_JAVELIN,       "Infineon Technologies 32-bit embedded cpu"),
-  ENUM_ENT(EM_FIREPATH,      "Element 14 64-bit DSP processor"),
-  ENUM_ENT(EM_ZSP,           "LSI Logic's 16-bit DSP processor"),
-  ENUM_ENT(EM_MMIX,          "Donald Knuth's educational 64-bit processor"),
-  ENUM_ENT(EM_HUANY,         "Harvard Universitys's machine-independent object format"),
-  ENUM_ENT(EM_PRISM,         "Vitesse Prism"),
-  ENUM_ENT(EM_AVR,           "Atmel AVR 8-bit microcontroller"),
-  ENUM_ENT(EM_FR30,          "Fujitsu FR30"),
-  ENUM_ENT(EM_D10V,          "Mitsubishi D10V"),
-  ENUM_ENT(EM_D30V,          "Mitsubishi D30V"),
-  ENUM_ENT(EM_V850,          "NEC v850"),
-  ENUM_ENT(EM_M32R,          "Renesas M32R (formerly Mitsubishi M32r)"),
-  ENUM_ENT(EM_MN10300,       "Matsushita MN10300"),
-  ENUM_ENT(EM_MN10200,       "Matsushita MN10200"),
-  ENUM_ENT(EM_PJ,            "picoJava"),
-  ENUM_ENT(EM_OPENRISC,      "OpenRISC 32-bit embedded processor"),
-  ENUM_ENT(EM_ARC_COMPACT,   "EM_ARC_COMPACT"),
-  ENUM_ENT(EM_XTENSA,        "Tensilica Xtensa Processor"),
-  ENUM_ENT(EM_VIDEOCORE,     "Alphamosaic VideoCore processor"),
-  ENUM_ENT(EM_TMM_GPP,       "Thompson Multimedia General Purpose Processor"),
-  ENUM_ENT(EM_NS32K,         "National Semiconductor 32000 series"),
-  ENUM_ENT(EM_TPC,           "Tenor Network TPC processor"),
-  ENUM_ENT(EM_SNP1K,         "EM_SNP1K"),
-  ENUM_ENT(EM_ST200,         "STMicroelectronics ST200 microcontroller"),
-  ENUM_ENT(EM_IP2K,          "Ubicom IP2xxx 8-bit microcontrollers"),
-  ENUM_ENT(EM_MAX,           "MAX Processor"),
-  ENUM_ENT(EM_CR,            "National Semiconductor CompactRISC"),
-  ENUM_ENT(EM_F2MC16,        "Fujitsu F2MC16"),
-  ENUM_ENT(EM_MSP430,        "Texas Instruments msp430 microcontroller"),
-  ENUM_ENT(EM_BLACKFIN,      "Analog Devices Blackfin"),
-  ENUM_ENT(EM_SE_C33,        "S1C33 Family of Seiko Epson processors"),
-  ENUM_ENT(EM_SEP,           "Sharp embedded microprocessor"),
-  ENUM_ENT(EM_ARCA,          "Arca RISC microprocessor"),
-  ENUM_ENT(EM_UNICORE,       "Unicore"),
-  ENUM_ENT(EM_EXCESS,        "eXcess 16/32/64-bit configurable embedded CPU"),
-  ENUM_ENT(EM_DXP,           "Icera Semiconductor Inc. Deep Execution Processor"),
-  ENUM_ENT(EM_ALTERA_NIOS2,  "Altera Nios"),
-  ENUM_ENT(EM_CRX,           "National Semiconductor CRX microprocessor"),
-  ENUM_ENT(EM_XGATE,         "Motorola XGATE embedded processor"),
-  ENUM_ENT(EM_C166,          "Infineon Technologies xc16x"),
-  ENUM_ENT(EM_M16C,          "Renesas M16C"),
-  ENUM_ENT(EM_DSPIC30F,      "Microchip Technology dsPIC30F Digital Signal Controller"),
-  ENUM_ENT(EM_CE,            "Freescale Communication Engine RISC core"),
-  ENUM_ENT(EM_M32C,          "Renesas M32C"),
-  ENUM_ENT(EM_TSK3000,       "Altium TSK3000 core"),
-  ENUM_ENT(EM_RS08,          "Freescale RS08 embedded processor"),
-  ENUM_ENT(EM_SHARC,         "EM_SHARC"),
-  ENUM_ENT(EM_ECOG2,         "Cyan Technology eCOG2 microprocessor"),
-  ENUM_ENT(EM_SCORE7,        "SUNPLUS S+Core"),
-  ENUM_ENT(EM_DSP24,         "New Japan Radio (NJR) 24-bit DSP Processor"),
-  ENUM_ENT(EM_VIDEOCORE3,    "Broadcom VideoCore III processor"),
+    ENUM_ENT(EM_NONE, "None"),
+    ENUM_ENT(EM_M32, "WE32100"),
+    ENUM_ENT(EM_SPARC, "Sparc"),
+    ENUM_ENT(EM_386, "Intel 80386"),
+    ENUM_ENT(EM_68K, "MC68000"),
+    ENUM_ENT(EM_88K, "MC88000"),
+    ENUM_ENT(EM_IAMCU, "EM_IAMCU"),
+    ENUM_ENT(EM_860, "Intel 80860"),
+    ENUM_ENT(EM_MIPS, "MIPS R3000"),
+    ENUM_ENT(EM_S370, "IBM System/370"),
+    ENUM_ENT(EM_MIPS_RS3_LE, "MIPS R3000 little-endian"),
+    ENUM_ENT(EM_PARISC, "HPPA"),
+    ENUM_ENT(EM_VPP500, "Fujitsu VPP500"),
+    ENUM_ENT(EM_SPARC32PLUS, "Sparc v8+"),
+    ENUM_ENT(EM_960, "Intel 80960"),
+    ENUM_ENT(EM_PPC, "PowerPC"),
+    ENUM_ENT(EM_PPC64, "PowerPC64"),
+    ENUM_ENT(EM_S390, "IBM S/390"),
+    ENUM_ENT(EM_SPU, "SPU"),
+    ENUM_ENT(EM_V800, "NEC V800 series"),
+    ENUM_ENT(EM_FR20, "Fujistsu FR20"),
+    ENUM_ENT(EM_RH32, "TRW RH-32"),
+    ENUM_ENT(EM_RCE, "Motorola RCE"),
+    ENUM_ENT(EM_ARM, "ARM"),
+    ENUM_ENT(EM_ALPHA, "EM_ALPHA"),
+    ENUM_ENT(EM_SH, "Hitachi SH"),
+    ENUM_ENT(EM_SPARCV9, "Sparc v9"),
+    ENUM_ENT(EM_TRICORE, "Siemens Tricore"),
+    ENUM_ENT(EM_ARC, "ARC"),
+    ENUM_ENT(EM_H8_300, "Hitachi H8/300"),
+    ENUM_ENT(EM_H8_300H, "Hitachi H8/300H"),
+    ENUM_ENT(EM_H8S, "Hitachi H8S"),
+    ENUM_ENT(EM_H8_500, "Hitachi H8/500"),
+    ENUM_ENT(EM_IA_64, "Intel IA-64"),
+    ENUM_ENT(EM_MIPS_X, "Stanford MIPS-X"),
+    ENUM_ENT(EM_COLDFIRE, "Motorola Coldfire"),
+    ENUM_ENT(EM_68HC12, "Motorola MC68HC12 Microcontroller"),
+    ENUM_ENT(EM_MMA, "Fujitsu Multimedia Accelerator"),
+    ENUM_ENT(EM_PCP, "Siemens PCP"),
+    ENUM_ENT(EM_NCPU, "Sony nCPU embedded RISC processor"),
+    ENUM_ENT(EM_NDR1, "Denso NDR1 microprocesspr"),
+    ENUM_ENT(EM_STARCORE, "Motorola Star*Core processor"),
+    ENUM_ENT(EM_ME16, "Toyota ME16 processor"),
+    ENUM_ENT(EM_ST100, "STMicroelectronics ST100 processor"),
+    ENUM_ENT(EM_TINYJ, "Advanced Logic Corp. TinyJ embedded processor"),
+    ENUM_ENT(EM_X86_64, "Advanced Micro Devices X86-64"),
+    ENUM_ENT(EM_PDSP, "Sony DSP processor"),
+    ENUM_ENT(EM_PDP10, "Digital Equipment Corp. PDP-10"),
+    ENUM_ENT(EM_PDP11, "Digital Equipment Corp. PDP-11"),
+    ENUM_ENT(EM_FX66, "Siemens FX66 microcontroller"),
+    ENUM_ENT(EM_ST9PLUS, "STMicroelectronics ST9+ 8/16 bit microcontroller"),
+    ENUM_ENT(EM_ST7, "STMicroelectronics ST7 8-bit microcontroller"),
+    ENUM_ENT(EM_68HC16, "Motorola MC68HC16 Microcontroller"),
+    ENUM_ENT(EM_68HC11, "Motorola MC68HC11 Microcontroller"),
+    ENUM_ENT(EM_68HC08, "Motorola MC68HC08 Microcontroller"),
+    ENUM_ENT(EM_68HC05, "Motorola MC68HC05 Microcontroller"),
+    ENUM_ENT(EM_SVX, "Silicon Graphics SVx"),
+    ENUM_ENT(EM_ST19, "STMicroelectronics ST19 8-bit microcontroller"),
+    ENUM_ENT(EM_VAX, "Digital VAX"),
+    ENUM_ENT(EM_CRIS, "Axis Communications 32-bit embedded processor"),
+    ENUM_ENT(EM_JAVELIN, "Infineon Technologies 32-bit embedded cpu"),
+    ENUM_ENT(EM_FIREPATH, "Element 14 64-bit DSP processor"),
+    ENUM_ENT(EM_ZSP, "LSI Logic's 16-bit DSP processor"),
+    ENUM_ENT(EM_MMIX, "Donald Knuth's educational 64-bit processor"),
+    ENUM_ENT(EM_HUANY,
+             "Harvard Universitys's machine-independent object format"),
+    ENUM_ENT(EM_PRISM, "Vitesse Prism"),
+    ENUM_ENT(EM_AVR, "Atmel AVR 8-bit microcontroller"),
+    ENUM_ENT(EM_FR30, "Fujitsu FR30"),
+    ENUM_ENT(EM_D10V, "Mitsubishi D10V"),
+    ENUM_ENT(EM_D30V, "Mitsubishi D30V"),
+    ENUM_ENT(EM_V850, "NEC v850"),
+    ENUM_ENT(EM_M32R, "Renesas M32R (formerly Mitsubishi M32r)"),
+    ENUM_ENT(EM_MN10300, "Matsushita MN10300"),
+    ENUM_ENT(EM_MN10200, "Matsushita MN10200"),
+    ENUM_ENT(EM_PJ, "picoJava"),
+    ENUM_ENT(EM_OPENRISC, "OpenRISC 32-bit embedded processor"),
+    ENUM_ENT(EM_ARC_COMPACT, "EM_ARC_COMPACT"),
+    ENUM_ENT(EM_XTENSA, "Tensilica Xtensa Processor"),
+    ENUM_ENT(EM_VIDEOCORE, "Alphamosaic VideoCore processor"),
+    ENUM_ENT(EM_TMM_GPP, "Thompson Multimedia General Purpose Processor"),
+    ENUM_ENT(EM_NS32K, "National Semiconductor 32000 series"),
+    ENUM_ENT(EM_TPC, "Tenor Network TPC processor"),
+    ENUM_ENT(EM_SNP1K, "EM_SNP1K"),
+    ENUM_ENT(EM_ST200, "STMicroelectronics ST200 microcontroller"),
+    ENUM_ENT(EM_IP2K, "Ubicom IP2xxx 8-bit microcontrollers"),
+    ENUM_ENT(EM_MAX, "MAX Processor"),
+    ENUM_ENT(EM_CR, "National Semiconductor CompactRISC"),
+    ENUM_ENT(EM_F2MC16, "Fujitsu F2MC16"),
+    ENUM_ENT(EM_MSP430, "Texas Instruments msp430 microcontroller"),
+    ENUM_ENT(EM_BLACKFIN, "Analog Devices Blackfin"),
+    ENUM_ENT(EM_SE_C33, "S1C33 Family of Seiko Epson processors"),
+    ENUM_ENT(EM_SEP, "Sharp embedded microprocessor"),
+    ENUM_ENT(EM_ARCA, "Arca RISC microprocessor"),
+    ENUM_ENT(EM_UNICORE, "Unicore"),
+    ENUM_ENT(EM_EXCESS, "eXcess 16/32/64-bit configurable embedded CPU"),
+    ENUM_ENT(EM_DXP, "Icera Semiconductor Inc. Deep Execution Processor"),
+    ENUM_ENT(EM_ALTERA_NIOS2, "Altera Nios"),
+    ENUM_ENT(EM_CRX, "National Semiconductor CRX microprocessor"),
+    ENUM_ENT(EM_XGATE, "Motorola XGATE embedded processor"),
+    ENUM_ENT(EM_C166, "Infineon Technologies xc16x"),
+    ENUM_ENT(EM_M16C, "Renesas M16C"),
+    ENUM_ENT(EM_DSPIC30F,
+             "Microchip Technology dsPIC30F Digital Signal Controller"),
+    ENUM_ENT(EM_CE, "Freescale Communication Engine RISC core"),
+    ENUM_ENT(EM_M32C, "Renesas M32C"),
+    ENUM_ENT(EM_TSK3000, "Altium TSK3000 core"),
+    ENUM_ENT(EM_RS08, "Freescale RS08 embedded processor"),
+    ENUM_ENT(EM_SHARC, "EM_SHARC"),
+    ENUM_ENT(EM_ECOG2, "Cyan Technology eCOG2 microprocessor"),
+    ENUM_ENT(EM_SCORE7, "SUNPLUS S+Core"),
+    ENUM_ENT(EM_DSP24, "New Japan Radio (NJR) 24-bit DSP Processor"),
+    ENUM_ENT(EM_VIDEOCORE3, "Broadcom VideoCore III processor"),
     ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"),
-  ENUM_ENT(EM_SE_C17,        "Seiko Epson C17 family"),
-  ENUM_ENT(EM_TI_C6000,      "Texas Instruments TMS320C6000 DSP family"),
-  ENUM_ENT(EM_TI_C2000,      "Texas Instruments TMS320C2000 DSP family"),
-  ENUM_ENT(EM_TI_C5500,      "Texas Instruments TMS320C55x DSP family"),
-  ENUM_ENT(EM_MMDSP_PLUS,    "STMicroelectronics 64bit VLIW Data Signal Processor"),
-  ENUM_ENT(EM_CYPRESS_M8C,   "Cypress M8C microprocessor"),
-  ENUM_ENT(EM_R32C,          "Renesas R32C series microprocessors"),
-  ENUM_ENT(EM_TRIMEDIA,      "NXP Semiconductors TriMedia architecture family"),
-  ENUM_ENT(EM_HEXAGON,       "Qualcomm Hexagon"),
-  ENUM_ENT(EM_8051,          "Intel 8051 and variants"),
-  ENUM_ENT(EM_STXP7X,        "STMicroelectronics STxP7x family"),
-  ENUM_ENT(EM_NDS32,         "Andes Technology compact code size embedded RISC processor family"),
-  ENUM_ENT(EM_ECOG1,         "Cyan Technology eCOG1 microprocessor"),
+    ENUM_ENT(EM_SE_C17, "Seiko Epson C17 family"),
+    ENUM_ENT(EM_TI_C6000, "Texas Instruments TMS320C6000 DSP family"),
+    ENUM_ENT(EM_TI_C2000, "Texas Instruments TMS320C2000 DSP family"),
+    ENUM_ENT(EM_TI_C5500, "Texas Instruments TMS320C55x DSP family"),
+    ENUM_ENT(EM_MMDSP_PLUS,
+             "STMicroelectronics 64bit VLIW Data Signal Processor"),
+    ENUM_ENT(EM_CYPRESS_M8C, "Cypress M8C microprocessor"),
+    ENUM_ENT(EM_R32C, "Renesas R32C series microprocessors"),
+    ENUM_ENT(EM_TRIMEDIA, "NXP Semiconductors TriMedia architecture family"),
+    ENUM_ENT(EM_HEXAGON, "Qualcomm Hexagon"),
+    ENUM_ENT(EM_8051, "Intel 8051 and variants"),
+    ENUM_ENT(EM_STXP7X, "STMicroelectronics STxP7x family"),
+    ENUM_ENT(
+        EM_NDS32,
+        "Andes Technology compact code size embedded RISC processor family"),
+    ENUM_ENT(EM_ECOG1, "Cyan Technology eCOG1 microprocessor"),
     // FIXME: Following EM_ECOG1X definitions is dead code since EM_ECOG1X has
     //        an identical number to EM_ECOG1.
-  ENUM_ENT(EM_ECOG1X,        "Cyan Technology eCOG1X family"),
-  ENUM_ENT(EM_MAXQ30,        "Dallas Semiconductor MAXQ30 Core microcontrollers"),
-  ENUM_ENT(EM_XIMO16,        "New Japan Radio (NJR) 16-bit DSP Processor"),
-  ENUM_ENT(EM_MANIK,         "M2000 Reconfigurable RISC Microprocessor"),
-  ENUM_ENT(EM_CRAYNV2,       "Cray Inc. NV2 vector architecture"),
-  ENUM_ENT(EM_RX,            "Renesas RX"),
-  ENUM_ENT(EM_METAG,         "Imagination Technologies Meta processor architecture"),
-  ENUM_ENT(EM_MCST_ELBRUS,   "MCST Elbrus general purpose hardware architecture"),
-  ENUM_ENT(EM_ECOG16,        "Cyan Technology eCOG16 family"),
-  ENUM_ENT(EM_CR16,          "National Semiconductor CompactRISC 16-bit processor"),
-  ENUM_ENT(EM_ETPU,          "Freescale Extended Time Processing Unit"),
-  ENUM_ENT(EM_SLE9X,         "Infineon Technologies SLE9X core"),
-  ENUM_ENT(EM_L10M,          "EM_L10M"),
-  ENUM_ENT(EM_K10M,          "EM_K10M"),
-  ENUM_ENT(EM_AARCH64,       "AArch64"),
-  ENUM_ENT(EM_AVR32,         "Atmel Corporation 32-bit microprocessor family"),
-  ENUM_ENT(EM_STM8,          "STMicroeletronics STM8 8-bit microcontroller"),
-  ENUM_ENT(EM_TILE64,        "Tilera TILE64 multicore architecture family"),
-  ENUM_ENT(EM_TILEPRO,       "Tilera TILEPro multicore architecture family"),
-  ENUM_ENT(EM_MICROBLAZE,    "Xilinx MicroBlaze 32-bit RISC soft processor core"),
-  ENUM_ENT(EM_CUDA,          "NVIDIA CUDA architecture"),
-  ENUM_ENT(EM_TILEGX,        "Tilera TILE-Gx multicore architecture family"),
-  ENUM_ENT(EM_CLOUDSHIELD,   "EM_CLOUDSHIELD"),
-  ENUM_ENT(EM_COREA_1ST,     "EM_COREA_1ST"),
-  ENUM_ENT(EM_COREA_2ND,     "EM_COREA_2ND"),
-  ENUM_ENT(EM_ARC_COMPACT2,  "EM_ARC_COMPACT2"),
-  ENUM_ENT(EM_OPEN8,         "EM_OPEN8"),
-  ENUM_ENT(EM_RL78,          "Renesas RL78"),
-  ENUM_ENT(EM_VIDEOCORE5,    "Broadcom VideoCore V processor"),
-  ENUM_ENT(EM_78KOR,         "EM_78KOR"),
-  ENUM_ENT(EM_56800EX,       "EM_56800EX"),
-  ENUM_ENT(EM_AMDGPU,        "EM_AMDGPU"),
-  ENUM_ENT(EM_RISCV,         "RISC-V"),
-  ENUM_ENT(EM_LANAI,         "EM_LANAI"),
-  ENUM_ENT(EM_BPF,           "EM_BPF"),
-  ENUM_ENT(EM_VE,            "NEC SX-Aurora Vector Engine"),
-  ENUM_ENT(EM_LOONGARCH,     "LoongArch"),
+    ENUM_ENT(EM_ECOG1X, "Cyan Technology eCOG1X family"),
+    ENUM_ENT(EM_MAXQ30, "Dallas Semiconductor MAXQ30 Core microcontrollers"),
+    ENUM_ENT(EM_XIMO16, "New Japan Radio (NJR) 16-bit DSP Processor"),
+    ENUM_ENT(EM_MANIK, "M2000 Reconfigurable RISC Microprocessor"),
+    ENUM_ENT(EM_CRAYNV2, "Cray Inc. NV2 vector architecture"),
+    ENUM_ENT(EM_RX, "Renesas RX"),
+    ENUM_ENT(EM_METAG, "Imagination Technologies Meta processor architecture"),
+    ENUM_ENT(EM_MCST_ELBRUS,
+             "MCST Elbrus general purpose hardware architecture"),
+    ENUM_ENT(EM_ECOG16, "Cyan Technology eCOG16 family"),
+    ENUM_ENT(EM_CR16, "National Semiconductor CompactRISC 16-bit processor"),
+    ENUM_ENT(EM_ETPU, "Freescale Extended Time Processing Unit"),
+    ENUM_ENT(EM_SLE9X, "Infineon Technologies SLE9X core"),
+    ENUM_ENT(EM_L10M, "EM_L10M"),
+    ENUM_ENT(EM_K10M, "EM_K10M"),
+    ENUM_ENT(EM_AARCH64, "AArch64"),
+    ENUM_ENT(EM_AVR32, "Atmel Corporation 32-bit microprocessor family"),
+    ENUM_ENT(EM_STM8, "STMicroeletronics STM8 8-bit microcontroller"),
+    ENUM_ENT(EM_TILE64, "Tilera TILE64 multicore architecture family"),
+    ENUM_ENT(EM_TILEPRO, "Tilera TILEPro multicore architecture family"),
+    ENUM_ENT(EM_MICROBLAZE,
+             "Xilinx MicroBlaze 32-bit RISC soft processor core"),
+    ENUM_ENT(EM_CUDA, "NVIDIA CUDA architecture"),
+    ENUM_ENT(EM_TILEGX, "Tilera TILE-Gx multicore architecture family"),
+    ENUM_ENT(EM_CLOUDSHIELD, "EM_CLOUDSHIELD"),
+    ENUM_ENT(EM_COREA_1ST, "EM_COREA_1ST"),
+    ENUM_ENT(EM_COREA_2ND, "EM_COREA_2ND"),
+    ENUM_ENT(EM_ARC_COMPACT2, "EM_ARC_COMPACT2"),
+    ENUM_ENT(EM_OPEN8, "EM_OPEN8"),
+    ENUM_ENT(EM_RL78, "Renesas RL78"),
+    ENUM_ENT(EM_VIDEOCORE5, "Broadcom VideoCore V processor"),
+    ENUM_ENT(EM_78KOR, "EM_78KOR"),
+    ENUM_ENT(EM_56800EX, "EM_56800EX"),
+    ENUM_ENT(EM_AMDGPU, "EM_AMDGPU"),
+    ENUM_ENT(EM_RISCV, "RISC-V"),
+    ENUM_ENT(EM_LANAI, "EM_LANAI"),
+    ENUM_ENT(EM_BPF, "EM_BPF"),
+    ENUM_ENT(EM_VE, "NEC SX-Aurora Vector Engine"),
+    ENUM_ENT(EM_LOONGARCH, "LoongArch"),
 };
 
 const EnumEntry<unsigned> ElfSymbolBindings[] = {
-    {"Local",  "LOCAL",  ELF::STB_LOCAL},
+    {"Local", "LOCAL", ELF::STB_LOCAL},
     {"Global", "GLOBAL", ELF::STB_GLOBAL},
-    {"Weak",   "WEAK",   ELF::STB_WEAK},
+    {"Weak", "WEAK", ELF::STB_WEAK},
     {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};
 
 const EnumEntry<unsigned> ElfSymbolVisibilities[] = {
-    {"DEFAULT",   "DEFAULT",   ELF::STV_DEFAULT},
-    {"INTERNAL",  "INTERNAL",  ELF::STV_INTERNAL},
-    {"HIDDEN",    "HIDDEN",    ELF::STV_HIDDEN},
+    {"DEFAULT", "DEFAULT", ELF::STV_DEFAULT},
+    {"INTERNAL", "INTERNAL", ELF::STV_INTERNAL},
+    {"HIDDEN", "HIDDEN", ELF::STV_HIDDEN},
     {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}};
 
 const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
-  { "AMDGPU_HSA_KERNEL",            ELF::STT_AMDGPU_HSA_KERNEL }
-};
+    {"AMDGPU_HSA_KERNEL", ELF::STT_AMDGPU_HSA_KERNEL}};
 
 static const char *getGroupType(uint32_t Flag) {
   if (Flag & ELF::GRP_COMDAT)
     return "COMDAT";
   else
     return "(unknown)";
 }
 
 const EnumEntry<unsigned> ElfSectionFlags[] = {
-  ENUM_ENT(SHF_WRITE,            "W"),
-  ENUM_ENT(SHF_ALLOC,            "A"),
-  ENUM_ENT(SHF_EXECINSTR,        "X"),
-  ENUM_ENT(SHF_MERGE,            "M"),
-  ENUM_ENT(SHF_STRINGS,          "S"),
-  ENUM_ENT(SHF_INFO_LINK,        "I"),
-  ENUM_ENT(SHF_LINK_ORDER,       "L"),
-  ENUM_ENT(SHF_OS_NONCONFORMING, "O"),
-  ENUM_ENT(SHF_GROUP,            "G"),
-  ENUM_ENT(SHF_TLS,              "T"),
-  ENUM_ENT(SHF_COMPRESSED,       "C"),
-  ENUM_ENT(SHF_EXCLUDE,          "E"),
+    ENUM_ENT(SHF_WRITE, "W"),      ENUM_ENT(SHF_ALLOC, "A"),
+    ENUM_ENT(SHF_EXECINSTR, "X"),  ENUM_ENT(SHF_MERGE, "M"),
+    ENUM_ENT(SHF_STRINGS, "S"),    ENUM_ENT(SHF_INFO_LINK, "I"),
+    ENUM_ENT(SHF_LINK_ORDER, "L"), ENUM_ENT(SHF_OS_NONCONFORMING, "O"),
+    ENUM_ENT(SHF_GROUP, "G"),      ENUM_ENT(SHF_TLS, "T"),
+    ENUM_ENT(SHF_COMPRESSED, "C"), ENUM_ENT(SHF_EXCLUDE, "E"),
 };
 
 const EnumEntry<unsigned> ElfGNUSectionFlags[] = {
-  ENUM_ENT(SHF_GNU_RETAIN, "R")
-};
+    ENUM_ENT(SHF_GNU_RETAIN, "R")};
 
 const EnumEntry<unsigned> ElfSolarisSectionFlags[] = {
-  ENUM_ENT(SHF_SUNW_NODISCARD, "R")
-};
+    ENUM_ENT(SHF_SUNW_NODISCARD, "R")};
 
 const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
-  ENUM_ENT(XCORE_SHF_CP_SECTION, ""),
-  ENUM_ENT(XCORE_SHF_DP_SECTION, "")
-};
+    ENUM_ENT(XCORE_SHF_CP_SECTION, ""), ENUM_ENT(XCORE_SHF_DP_SECTION, "")};
 
 const EnumEntry<unsigned> ElfARMSectionFlags[] = {
-  ENUM_ENT(SHF_ARM_PURECODE, "y")
-};
+    ENUM_ENT(SHF_ARM_PURECODE, "y")};
 
 const EnumEntry<unsigned> ElfHexagonSectionFlags[] = {
-  ENUM_ENT(SHF_HEX_GPREL, "")
-};
+    ENUM_ENT(SHF_HEX_GPREL, "")};
 
 const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
-  ENUM_ENT(SHF_MIPS_NODUPES, ""),
-  ENUM_ENT(SHF_MIPS_NAMES,   ""),
-  ENUM_ENT(SHF_MIPS_LOCAL,   ""),
-  ENUM_ENT(SHF_MIPS_NOSTRIP, ""),
-  ENUM_ENT(SHF_MIPS_GPREL,   ""),
-  ENUM_ENT(SHF_MIPS_MERGE,   ""),
-  ENUM_ENT(SHF_MIPS_ADDR,    ""),
-  ENUM_ENT(SHF_MIPS_STRING,  "")
-};
+    ENUM_ENT(SHF_MIPS_NODUPES, ""), ENUM_ENT(SHF_MIPS_NAMES, ""),
+    ENUM_ENT(SHF_MIPS_LOCAL, ""),   ENUM_ENT(SHF_MIPS_NOSTRIP, ""),
+    ENUM_ENT(SHF_MIPS_GPREL, ""),   ENUM_ENT(SHF_MIPS_MERGE, ""),
+    ENUM_ENT(SHF_MIPS_ADDR, ""),    ENUM_ENT(SHF_MIPS_STRING, "")};
 
 const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
-  ENUM_ENT(SHF_X86_64_LARGE, "l")
-};
+    ENUM_ENT(SHF_X86_64_LARGE, "l")};
 
 static std::vector<EnumEntry<unsigned>>
 getSectionFlagsForTarget(unsigned EOSAbi, unsigned EMachine) {
   std::vector<EnumEntry<unsigned>> Ret(std::begin(ElfSectionFlags),
                                        std::end(ElfSectionFlags));
   switch (EOSAbi) {
   case ELFOSABI_SOLARIS:
     Ret.insert(Ret.end(), std::begin(ElfSolarisSectionFlags),
if (Seg.startswith("PT_MIPS_"))
     return Seg.drop_front(8).str();
 
   // E.g. "PT_LOAD" -> "LOAD".
   assert(Seg.startswith("PT_"));
   return Seg.drop_front(3).str();
 }
 
 const EnumEntry<unsigned> ElfSegmentFlags[] = {
-  LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
-  LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
-  LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, PF_X), LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
+    LLVM_READOBJ_ENUM_ENT(ELF, PF_R)};
 
 const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
     ENUM_ENT(EF_MIPS_NOREORDER, "noreorder"),
     ENUM_ENT(EF_MIPS_PIC, "pic"),
     ENUM_ENT(EF_MIPS_CPIC, "cpic"),
     ENUM_ENT(EF_MIPS_ABI2, "abi2"),
     ENUM_ENT(EF_MIPS_32BITMODE, "32bitmode"),
     ENUM_ENT(EF_MIPS_FP64, "fp64"),
     ENUM_ENT(EF_MIPS_NAN2008, "nan2008"),
     ENUM_ENT(EF_MIPS_ABI_O32, "o32"),
     ENUM_ENT(EF_MIPS_ABI_O64, "o64"),
     ENUM_ENT(EF_MIPS_ABI_EABI32, "eabi32"),
     ENUM_ENT(EF_MIPS_ABI_EABI64, "eabi64"),
     ENUM_ENT(EF_MIPS_MACH_3900, "3900"),
     ENUM_ENT(EF_MIPS_MACH_4010, "4010"),
     ENUM_ENT(EF_MIPS_MACH_4100, "4100"),
     ENUM_ENT(EF_MIPS_MACH_4650, "4650"),
     ENUM_ENT(EF_MIPS_MACH_4120, "4120"),
     ENUM_ENT(EF_MIPS_MACH_4111, "4111"),
     ENUM_ENT(EF_MIPS_MACH_SB1, "sb1"),
     ENUM_ENT(EF_MIPS_MACH_OCTEON, "octeon"),
     ENUM_ENT(EF_MIPS_MACH_XLR, "xlr"),
     ENUM_ENT(EF_MIPS_MACH_OCTEON2, "octeon2"),
     ENUM_ENT(EF_MIPS_MACH_OCTEON3, "octeon3"),
     ENUM_ENT(EF_MIPS_MACH_5400, "5400"),
     ENUM_ENT(EF_MIPS_MACH_5900, "5900"),
     ENUM_ENT(EF_MIPS_MACH_5500, "5500"),
     ENUM_ENT(EF_MIPS_MACH_9000, "9000"),
     ENUM_ENT(EF_MIPS_MACH_LS2E, "loongson-2e"),
     ENUM_ENT(EF_MIPS_MACH_LS2F, "loongson-2f"),
     ENUM_ENT(EF_MIPS_MACH_LS3A, "loongson-3a"),
     ENUM_ENT(EF_MIPS_MICROMIPS, "micromips"),
     ENUM_ENT(EF_MIPS_ARCH_ASE_M16, "mips16"),
     ENUM_ENT(EF_MIPS_ARCH_ASE_MDMX, "mdmx"),
     ENUM_ENT(EF_MIPS_ARCH_1, "mips1"),
     ENUM_ENT(EF_MIPS_ARCH_2, "mips2"),
     ENUM_ENT(EF_MIPS_ARCH_3, "mips3"),
     ENUM_ENT(EF_MIPS_ARCH_4, "mips4"),
     ENUM_ENT(EF_MIPS_ARCH_5, "mips5"),
     ENUM_ENT(EF_MIPS_ARCH_32, "mips32"),
     ENUM_ENT(EF_MIPS_ARCH_64, "mips64"),
     ENUM_ENT(EF_MIPS_ARCH_32R2, "mips32r2"),
     ENUM_ENT(EF_MIPS_ARCH_64R2, "mips64r2"),
     ENUM_ENT(EF_MIPS_ARCH_32R6, "mips32r6"),
-  ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6")
-};
+    ENUM_ENT(EF_MIPS_ARCH_64R6, "mips64r6")};
 
 const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion3[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_V3),
-  LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_V3)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_V3)};
 
 const EnumEntry<unsigned> ElfHeaderAMDGPUFlagsABIVersion4[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_NONE),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R600),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_R630),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RS880),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV670),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV710),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV730),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_RV770),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CEDAR),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CYPRESS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_JUNIPER),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_REDWOOD),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_SUMO),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_BARTS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAICOS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_CAYMAN),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_R600_TURKS),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX600),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX601),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX602),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX700),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX701),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX702),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX703),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX704),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX705),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX801),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX802),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX803),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX805),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX810),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX900),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX902),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX904),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX906),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX908),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX909),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90A),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX90C),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX940),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1010),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1011),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1012),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1013),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1030),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1031),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1032),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1033),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1034),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1035),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_MACH_AMDGCN_GFX1036),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ANY_V4),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_OFF_V4),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_XNACK_ON_V4),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ANY_V4),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_OFF_V4),
-  LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ON_V4)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, EF_AMDGPU_FEATURE_SRAMECC_ON_V4)};
 
 const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = {
     ENUM_ENT(EF_RISCV_RVC, "RVC"),
     ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"),
     ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"),
     ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"),
     ENUM_ENT(EF_RISCV_RVE, "RVE"),
     ENUM_ENT(EF_RISCV_TSO, "TSO"),
 };
 
 const EnumEntry<unsigned> ElfHeaderAVRFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR1),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR2),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR25),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR3),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR31),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR35),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR4),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR5),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR51),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR6),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVRTINY),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA1),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA2),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA3),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA4),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA5),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA6),
     LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA7),
     ENUM_ENT(EF_AVR_LINKRELAX_PREPARED, "relaxable"),
 };
 
-
 const EnumEntry<unsigned> ElfSymOtherFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL),
     LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN),
-  LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED)};
 
 const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
     LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT),
     LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC),
-  LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS)};
 
 const EnumEntry<unsigned> ElfAArch64SymOtherFlags[] = {
-  LLVM_READOBJ_ENUM_ENT(ELF, STO_AARCH64_VARIANT_PCS)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, STO_AARCH64_VARIANT_PCS)};
 
 const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
     LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT),
-  LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16)
-};
+    LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16)};
 
 const EnumEntry<unsigned> ElfRISCVSymOtherFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ELF, STO_RISCV_VARIANT_CC)};
 
 static const char *getElfMipsOptionsOdkType(unsigned Odk) {
   switch (Odk) {
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT);
     LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE);
   default:
     return "Unknown";
   }
 }
 
 template <typename ELFT>
 std::pair<const typename ELFT::Phdr *, const typename ELFT::Shdr *>
 ELFDumper<ELFT>::findDynamic() {
if (DynamicPhdr && DynamicSec) {
     if (DynamicSec->sh_addr != DynamicPhdr->p_vaddr)
       reportUniqueWarning(describe(*DynamicSec) + " is not at the start of "
                                                   "PT_DYNAMIC segment");
   }
 
   return std::make_pair(DynamicPhdr, DynamicSec);
 }
 
-template <typename ELFT>
-void ELFDumper<ELFT>::loadDynamicTable() {
+template <typename ELFT> void ELFDumper<ELFT>::loadDynamicTable() {
   const Elf_Phdr *DynamicPhdr;
   const Elf_Shdr *DynamicSec;
   std::tie(DynamicPhdr, DynamicSec) = findDynamic();
   if (!DynamicPhdr && !DynamicSec)
     return;
 
   DynRegionInfo FromPhdr(ObjF, *this);
   bool IsPhdrTableValid = false;
template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() {
   // Dump version definition section.
   printVersionDefinitionSection(SymbolVersionDefSection);
 
   // Dump version dependency section.
   printVersionDependencySection(SymbolVersionNeedSection);
 }
 
 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum)                                 \
-  { #enum, prefix##_##enum }
+  {                                                                            \
+#enum, prefix##_##enum                                                     \
+  }
 
 const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
     LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
     LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
     LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
     LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
-  LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
-};
+    LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)};
 
 const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELPND),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON),
     LLVM_READOBJ_DT_FLAG_ENT(DF_1, PIE),
 };
 
 const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
     LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
     LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
     LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
-  LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
-};
+    LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)};
 
 #undef LLVM_READOBJ_DT_FLAG_ENT
 
 template <typename T, typename TFlag>
 void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
   SmallVector<EnumEntry<TFlag>, 10> SetFlags;
   for (const EnumEntry<TFlag> &Flag : Flags)
     if (Flag.Value != 0 && (Value & Flag.Value) == Flag.Value)
return createError(
         "the first hashed symbol index (" + Twine(GnuHashTable->symndx) +
         ") is greater than or equal to the number of dynamic symbols (" +
         Twine(NumSyms) + ")");
   // There is no way to represent an array of (dynamic symbols count - symndx)
   // length.
   return ArrayRef<typename ELFT::Word>();
 }
 
-template <typename ELFT>
-void ELFDumper<ELFT>::printGnuHashTable() {
+template <typename ELFT> void ELFDumper<ELFT>::printGnuHashTable() {
   DictScope D(W, "GnuHashTable");
   if (!GnuHashTable)
     return;
 
   bool IsHeaderValid;
   Error Err = checkGNUHashTable<ELFT>(Obj, GnuHashTable, &IsHeaderValid);
   if (IsHeaderValid) {
     W.printNumber("Num Buckets", GnuHashTable->nbuckets);
public:
   const Entry *getPltLazyResolver() const;
   const Entry *getPltModulePointer() const;
 
   Entries getLocalEntries() const;
   Entries getGlobalEntries() const;
   Entries getOtherEntries() const;
   Entries getPltEntries() const;
 
-  uint64_t getGotAddress(const Entry * E) const;
-  int64_t getGotOffset(const Entry * E) const;
+  uint64_t getGotAddress(const Entry *E) const;
+  int64_t getGotOffset(const Entry *E) const;
   const Elf_Sym *getGotSym(const Entry *E) const;
 
-  uint64_t getPltAddress(const Entry * E) const;
+  uint64_t getPltAddress(const Entry *E) const;
   const Elf_Sym *getPltSym(const Entry *E) const;
 
   StringRef getPltStrTable() const { return PltStrTable; }
   const Elf_Shdr *getPltSymTable() const { return PltSymTable; }
 
 private:
   const Elf_Shdr *GotSec;
   size_t LocalNum;
MipsGOTParser<ELFT>::getPltSym(const Entry *E) const {
   } else {
     Elf_Rela_Range Rels = unwrapOrError(FileName, Obj.relas(*PltRelSec));
     return unwrapOrError(FileName,
                          Obj.getRelocationSymbol(Rels[Offset], PltSymTable));
   }
 }
 
 const EnumEntry<unsigned> ElfMipsISAExtType[] = {
-  {"None",                    Mips::AFL_EXT_NONE},
-  {"Broadcom SB-1",           Mips::AFL_EXT_SB1},
-  {"Cavium Networks Octeon",  Mips::AFL_EXT_OCTEON},
+    {"None", Mips::AFL_EXT_NONE},
+    {"Broadcom SB-1", Mips::AFL_EXT_SB1},
+    {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON},
     {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
     {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
     {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
-  {"LSI R4010",               Mips::AFL_EXT_4010},
-  {"Loongson 2E",             Mips::AFL_EXT_LOONGSON_2E},
-  {"Loongson 2F",             Mips::AFL_EXT_LOONGSON_2F},
-  {"Loongson 3A",             Mips::AFL_EXT_LOONGSON_3A},
-  {"MIPS R4650",              Mips::AFL_EXT_4650},
-  {"MIPS R5900",              Mips::AFL_EXT_5900},
-  {"MIPS R10000",             Mips::AFL_EXT_10000},
-  {"NEC VR4100",              Mips::AFL_EXT_4100},
-  {"NEC VR4111/VR4181",       Mips::AFL_EXT_4111},
-  {"NEC VR4120",              Mips::AFL_EXT_4120},
-  {"NEC VR5400",              Mips::AFL_EXT_5400},
-  {"NEC VR5500",              Mips::AFL_EXT_5500},
-  {"RMI Xlr",                 Mips::AFL_EXT_XLR},
-  {"Toshiba R3900",           Mips::AFL_EXT_3900}
-};
+    {"LSI R4010", Mips::AFL_EXT_4010},
+    {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E},
+    {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F},
+    {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A},
+    {"MIPS R4650", Mips::AFL_EXT_4650},
+    {"MIPS R5900", Mips::AFL_EXT_5900},
+    {"MIPS R10000", Mips::AFL_EXT_10000},
+    {"NEC VR4100", Mips::AFL_EXT_4100},
+    {"NEC VR4111/VR4181", Mips::AFL_EXT_4111},
+    {"NEC VR4120", Mips::AFL_EXT_4120},
+    {"NEC VR5400", Mips::AFL_EXT_5400},
+    {"NEC VR5500", Mips::AFL_EXT_5500},
+    {"RMI Xlr", Mips::AFL_EXT_XLR},
+    {"Toshiba R3900", Mips::AFL_EXT_3900}};
 
 const EnumEntry<unsigned> ElfMipsASEFlags[] = {
-  {"DSP",                Mips::AFL_ASE_DSP},
-  {"DSPR2",              Mips::AFL_ASE_DSPR2},
+    {"DSP", Mips::AFL_ASE_DSP},
+    {"DSPR2", Mips::AFL_ASE_DSPR2},
     {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
-  {"MCU",                Mips::AFL_ASE_MCU},
-  {"MDMX",               Mips::AFL_ASE_MDMX},
-  {"MIPS-3D",            Mips::AFL_ASE_MIPS3D},
-  {"MT",                 Mips::AFL_ASE_MT},
-  {"SmartMIPS",          Mips::AFL_ASE_SMARTMIPS},
-  {"VZ",                 Mips::AFL_ASE_VIRT},
-  {"MSA",                Mips::AFL_ASE_MSA},
-  {"MIPS16",             Mips::AFL_ASE_MIPS16},
-  {"microMIPS",          Mips::AFL_ASE_MICROMIPS},
-  {"XPA",                Mips::AFL_ASE_XPA},
-  {"CRC",                Mips::AFL_ASE_CRC},
-  {"GINV",               Mips::AFL_ASE_GINV},
+    {"MCU", Mips::AFL_ASE_MCU},
+    {"MDMX", Mips::AFL_ASE_MDMX},
+    {"MIPS-3D", Mips::AFL_ASE_MIPS3D},
+    {"MT", Mips::AFL_ASE_MT},
+    {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS},
+    {"VZ", Mips::AFL_ASE_VIRT},
+    {"MSA", Mips::AFL_ASE_MSA},
+    {"MIPS16", Mips::AFL_ASE_MIPS16},
+    {"microMIPS", Mips::AFL_ASE_MICROMIPS},
+    {"XPA", Mips::AFL_ASE_XPA},
+    {"CRC", Mips::AFL_ASE_CRC},
+    {"GINV", Mips::AFL_ASE_GINV},
 };
 
 const EnumEntry<unsigned> ElfMipsFpABIType[] = {
-  {"Hard or soft float",                  Mips::Val_GNU_MIPS_ABI_FP_ANY},
-  {"Hard float (double precision)",       Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
-  {"Hard float (single precision)",       Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
-  {"Soft float",                          Mips::Val_GNU_MIPS_ABI_FP_SOFT},
+    {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY},
+    {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
+    {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
+    {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT},
     {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
      Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
-  {"Hard float (32-bit CPU, Any FPU)",    Mips::Val_GNU_MIPS_ABI_FP_XX},
+    {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX},
     {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
     {"Hard float compat (32-bit CPU, 64-bit FPU)",
-   Mips::Val_GNU_MIPS_ABI_FP_64A}
-};
+     Mips::Val_GNU_MIPS_ABI_FP_64A}};
 
-static const EnumEntry<unsigned> ElfMipsFlags1[] {
+static const EnumEntry<unsigned> ElfMipsFlags1[]{
     {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
 };
 
 static int getMipsRegisterSize(uint8_t Flag) {
   switch (Flag) {
   case Mips::AFL_REG_NONE:
     return 0;
   case Mips::AFL_REG_32:
     return 32;
readMipsOptions(const uint8_t *SecBegin, ArrayRef<uint8_t> &SecData,
   }
 
   IsSupported = O->kind == ODK_REGINFO;
   const size_t ExpectedSize =
       sizeof(Elf_Mips_Options<ELFT>) + sizeof(Elf_Mips_RegInfo<ELFT>);
 
   if (IsSupported)
     if (Size < ExpectedSize)
-      return createError(
-          "a .MIPS.options entry of kind " +
+      return createError("a .MIPS.options entry of kind " +
                          Twine(getElfMipsOptionsOdkType(O->kind)) +
                          " has an invalid size (0x" + Twine::utohexstr(Size) +
-          "), the expected size is 0x" + Twine::utohexstr(ExpectedSize));
+                         "), the expected size is 0x" +
+                         Twine::utohexstr(ExpectedSize));
 
   SecData = SecData.drop_front(Size);
   return O;
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
   const Elf_Shdr *MipsOpts = findSectionByName(".MIPS.options");
   if (!MipsOpts) {
while (true) {
         this->reportUniqueWarning(
             "unable to read the hash value for symbol with index " +
             Twine(SymIndex) +
             ", which is less than the index of the first hashed symbol (" +
             Twine(GnuHash.symndx) + ")");
         break;
       }
 
-       // Chain ends at symbol with stopper bit.
       if ((Values[SymIndex - GnuHash.symndx] & 1) == 1)
         break;
     }
   }
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printHashSymbols() {
   if (this->HashTable) {
struct IsaVersion {
       uint16_t ArchitectureNameSize;
       uint32_t Major;
       uint32_t Minor;
       uint32_t Stepping;
     };
     if (Desc.size() < sizeof(IsaVersion))
       return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"};
     auto Isa = reinterpret_cast<const IsaVersion *>(Desc.data());
-    if (Desc.size() < sizeof(IsaVersion) +
-                          Isa->VendorNameSize + Isa->ArchitectureNameSize ||
+    if (Desc.size() < sizeof(IsaVersion) + Isa->VendorNameSize +
+                          Isa->ArchitectureNameSize ||
         Isa->VendorNameSize == 0 || Isa->ArchitectureNameSize == 0)
       return {"AMD HSA ISA Version", "Invalid AMD HSA ISA Version"};
     std::string IsaString;
     raw_string_ostream StrOS(IsaString);
     StrOS << "[Vendor: "
-          << StringRef((const char*)Desc.data() + sizeof(IsaVersion), Isa->VendorNameSize - 1)
+          << StringRef((const char *)Desc.data() + sizeof(IsaVersion),
+                       Isa->VendorNameSize - 1)
           << ", Architecture: "
-          << StringRef((const char*)Desc.data() + sizeof(IsaVersion) + Isa->VendorNameSize,
+          << StringRef((const char *)Desc.data() + sizeof(IsaVersion) +
+                           Isa->VendorNameSize,
                        Isa->ArchitectureNameSize - 1)
           << ", Major: " << Isa->Major << ", Minor: " << Isa->Minor
           << ", Stepping: " << Isa->Stepping << "]";
     return {"AMD HSA ISA Version", IsaString};
   }
   case ELF::NT_AMD_HSA_METADATA: {
     if (Desc.size() == 0)
       return {"AMD HSA Metadata", ""};
-    return {
-        "AMD HSA Metadata",
-        std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size() - 1)};
+    return {"AMD HSA Metadata",
+            std::string(reinterpret_cast<const char *>(Desc.data()),
+                        Desc.size() - 1)};
   }
   case ELF::NT_AMD_HSA_ISA_NAME: {
     if (Desc.size() == 0)
       return {"AMD HSA ISA Name", ""};
     return {
         "AMD HSA ISA Name",
         std::string(reinterpret_cast<const char *>(Desc.data()), Desc.size())};
   }
const NoteType OpenBSDCoreNoteTypes[] = {
     {ELF::NT_OPENBSD_FPREGS, "NT_OPENBSD_FPREGS (floating point registers)"},
     {ELF::NT_OPENBSD_WCOOKIE, "NT_OPENBSD_WCOOKIE (window cookie)"},
 };
 
 const NoteType AMDNoteTypes[] = {
     {ELF::NT_AMD_HSA_CODE_OBJECT_VERSION,
      "NT_AMD_HSA_CODE_OBJECT_VERSION (AMD HSA Code Object Version)"},
     {ELF::NT_AMD_HSA_HSAIL, "NT_AMD_HSA_HSAIL (AMD HSA HSAIL Properties)"},
-    {ELF::NT_AMD_HSA_ISA_VERSION, "NT_AMD_HSA_ISA_VERSION (AMD HSA ISA Version)"},
+    {ELF::NT_AMD_HSA_ISA_VERSION,
+     "NT_AMD_HSA_ISA_VERSION (AMD HSA ISA Version)"},
     {ELF::NT_AMD_HSA_METADATA, "NT_AMD_HSA_METADATA (AMD HSA Metadata)"},
     {ELF::NT_AMD_HSA_ISA_NAME, "NT_AMD_HSA_ISA_NAME (AMD HSA ISA Name)"},
     {ELF::NT_AMD_PAL_METADATA, "NT_AMD_PAL_METADATA (AMD PAL Metadata)"},
 };
 
 const NoteType AMDGPUNoteTypes[] = {
     {ELF::NT_AMDGPU_METADATA, "NT_AMDGPU_METADATA (AMDGPU Metadata)"},
 };
for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
     // to the section that contains the functions whose stack sizes are
     // described in it.
     const Elf_Shdr *FunctionSec = unwrapOrError(
         this->FileName, Obj.getSection(StackSizesELFSec->sh_link));
 
     SupportsRelocation IsSupportedFn;
     RelocationResolver Resolver;
     std::tie(IsSupportedFn, Resolver) = getRelocationResolver(this->ObjF);
-    ArrayRef<uint8_t> Contents =
-        unwrapOrError(this->FileName, Obj.getSectionContents(*StackSizesELFSec));
+    ArrayRef<uint8_t> Contents = unwrapOrError(
+        this->FileName, Obj.getSectionContents(*StackSizesELFSec));
     DataExtractor Data(Contents, Obj.isLE(), sizeof(Elf_Addr));
 
     forEachRelocationDo(
         *RelocSec, /*RawRelr=*/false,
         [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec,
             const Elf_Shdr *SymTab) {
           if (!IsSupportedFn || !IsSupportedFn(R.Type)) {
             reportUniqueWarning(
                 describe(*RelocSec) +
                 " contains an unsupported relocation with index " + Twine(Ndx) +
                 ": " + Obj.getRelocationTypeName(R.Type));
             return;
           }
 
           this->printStackSize(R, *RelocSec, Ndx, SymTab, FunctionSec,
                                *StackSizesELFSec, Resolver, Data);
         },
         [](const Elf_Relr &) {
           llvm_unreachable("can't get here, because we only support "
                            "SHT_REL/SHT_RELA sections");
         });
   }
 }
 
-template <class ELFT>
-void GNUELFDumper<ELFT>::printStackSizes() {
+template <class ELFT> void GNUELFDumper<ELFT>::printStackSizes() {
   bool HeaderHasBeenPrinted = false;
   auto PrintHeader = [&]() {
     if (HeaderHasBeenPrinted)
       return;
     OS << "\nStack Sizes:\n";
     OS.PadToColumn(9);
     OS << "Size";
     OS.PadToColumn(18);
getMipsAbiFlagsSection(const ELFDumper<ELFT> &Dumper) {
   constexpr StringRef ErrPrefix = "unable to read the .MIPS.abiflags section: ";
   Expected<ArrayRef<uint8_t>> DataOrErr =
       Dumper.getElfObject().getELFFile().getSectionContents(*Sec);
   if (!DataOrErr)
     return createError(ErrPrefix + toString(DataOrErr.takeError()));
 
   if (DataOrErr->size() != sizeof(Elf_Mips_ABIFlags<ELFT>))
     return createError(ErrPrefix + "it has a wrong size (" +
                        Twine(DataOrErr->size()) + ")");
   return reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(DataOrErr->data());
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printMipsABIFlags() {
   const Elf_Mips_ABIFlags<ELFT> *Flags = nullptr;
   if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr =
           getMipsAbiFlagsSection(*this))
     Flags = *SecOrErr;
for (size_t I = 0, E = Syms.size(); I < E; ++I) {
     DictScope S(W, "Symbol");
     W.printNumber("Version", (*VerTableOrErr)[I].vs_index & VERSYM_VERSION);
     W.printString("Name",
                   this->getFullSymbolName(Syms[I], I, ShNdxTable, StrTable,
                                           /*IsDynamic=*/true));
   }
 }
 
-const EnumEntry<unsigned> SymVersionFlags[] = {
-    {"Base", "BASE", VER_FLG_BASE},
+const EnumEntry<unsigned> SymVersionFlags[] = {{"Base", "BASE", VER_FLG_BASE},
                                                {"Weak", "WEAK", VER_FLG_WEAK},
                                                {"Info", "INFO", VER_FLG_INFO}};
 
 template <class ELFT>
 void LLVMELFDumper<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) {
   ListScope SD(W, "VersionDefinitions");
   if (!Sec)
     return;
 
   Expected<std::vector<VerDef>> V = this->Obj.getVersionDefinitions(*Sec);

llvm/tools/llvm-readobj/MachODumper.cpp

public:
   void printNeededLibraries() override;
 
   // MachO-specific.
   void printMachODataInCode() override;
   void printMachOVersionMin() override;
   void printMachODysymtab() override;
   void printMachOSegment() override;
   void printMachOIndirectSymbols() override;
-  void printMachOLinkerOptions () override;
+  void printMachOLinkerOptions() override;
 
 private:
-  template<class MachHeader>
-  void printFileHeaders(const MachHeader &Header);
+  template <class MachHeader> void printFileHeaders(const MachHeader &Header);
 
   StringRef getSymbolName(const SymbolRef &Symbol);
 
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
 
   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
 
   void printSectionHeaders(const MachOObjectFile *Obj);
 
   const MachOObjectFile *Obj;
 };
 
 } // namespace
 
-
 namespace llvm {
 
 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
                                              ScopedPrinter &Writer) {
   return std::make_unique<MachODumper>(&Obj, Writer);
 }
 
 } // namespace llvm
 
 const EnumEntry<uint32_t> MachOMagics[] = {
-  { "Magic",      MachO::MH_MAGIC    },
-  { "Cigam",      MachO::MH_CIGAM    },
-  { "Magic64",    MachO::MH_MAGIC_64 },
-  { "Cigam64",    MachO::MH_CIGAM_64 },
-  { "FatMagic",   MachO::FAT_MAGIC   },
-  { "FatCigam",   MachO::FAT_CIGAM   },
+    {"Magic", MachO::MH_MAGIC},      {"Cigam", MachO::MH_CIGAM},
+    {"Magic64", MachO::MH_MAGIC_64}, {"Cigam64", MachO::MH_CIGAM_64},
+    {"FatMagic", MachO::FAT_MAGIC},  {"FatCigam", MachO::FAT_CIGAM},
 };
 
 const EnumEntry<uint32_t> MachOHeaderFileTypes[] = {
-  { "Relocatable",          MachO::MH_OBJECT      },
-  { "Executable",           MachO::MH_EXECUTE     },
-  { "FixedVMLibrary",       MachO::MH_FVMLIB      },
-  { "Core",                 MachO::MH_CORE        },
-  { "PreloadedExecutable",  MachO::MH_PRELOAD     },
-  { "DynamicLibrary",       MachO::MH_DYLIB       },
-  { "DynamicLinker",        MachO::MH_DYLINKER    },
-  { "Bundle",               MachO::MH_BUNDLE      },
-  { "DynamicLibraryStub",   MachO::MH_DYLIB_STUB  },
-  { "DWARFSymbol",          MachO::MH_DSYM        },
-  { "KextBundle",           MachO::MH_KEXT_BUNDLE },
+    {"Relocatable", MachO::MH_OBJECT},
+    {"Executable", MachO::MH_EXECUTE},
+    {"FixedVMLibrary", MachO::MH_FVMLIB},
+    {"Core", MachO::MH_CORE},
+    {"PreloadedExecutable", MachO::MH_PRELOAD},
+    {"DynamicLibrary", MachO::MH_DYLIB},
+    {"DynamicLinker", MachO::MH_DYLINKER},
+    {"Bundle", MachO::MH_BUNDLE},
+    {"DynamicLibraryStub", MachO::MH_DYLIB_STUB},
+    {"DWARFSymbol", MachO::MH_DSYM},
+    {"KextBundle", MachO::MH_KEXT_BUNDLE},
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuTypes[] = {
-  { "Any"       , static_cast<uint32_t>(MachO::CPU_TYPE_ANY) },
-  { "X86"       , MachO::CPU_TYPE_X86       },
-  { "X86-64"    , MachO::CPU_TYPE_X86_64    },
-  { "Mc98000"   , MachO::CPU_TYPE_MC98000   },
-  { "Arm"       , MachO::CPU_TYPE_ARM       },
-  { "Arm64"     , MachO::CPU_TYPE_ARM64     },
-  { "Sparc"     , MachO::CPU_TYPE_SPARC     },
-  { "PowerPC"   , MachO::CPU_TYPE_POWERPC   },
-  { "PowerPC64" , MachO::CPU_TYPE_POWERPC64 },
+    {"Any", static_cast<uint32_t>(MachO::CPU_TYPE_ANY)},
+    {"X86", MachO::CPU_TYPE_X86},
+    {"X86-64", MachO::CPU_TYPE_X86_64},
+    {"Mc98000", MachO::CPU_TYPE_MC98000},
+    {"Arm", MachO::CPU_TYPE_ARM},
+    {"Arm64", MachO::CPU_TYPE_ARM64},
+    {"Sparc", MachO::CPU_TYPE_SPARC},
+    {"PowerPC", MachO::CPU_TYPE_POWERPC},
+    {"PowerPC64", MachO::CPU_TYPE_POWERPC64},
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuSubtypesX86[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_I386_ALL),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_386),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486SX),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_586),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTPRO),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M3),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M5),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON_MOBILE),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_M),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_XEON),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_M),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4_M),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM_2),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON_MP),
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuSubtypesX64[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_ALL),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_ARCH1),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_H),
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_ALL),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V4T),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5TEJ),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_XSCALE),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7S),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7K),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6M),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7M),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7EM),
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM64[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_ALL),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_V8),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64E),
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuSubtypesSPARC[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_SPARC_ALL),
 };
 
 const EnumEntry<uint32_t> MachOHeaderCpuSubtypesPPC[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_ALL),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_601),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_602),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603e),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603ev),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604e),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_620),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_750),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7400),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7450),
     LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_970),
 };
 
 const EnumEntry<uint32_t> MachOHeaderFlags[] = {
     LLVM_READOBJ_ENUM_ENT(MachO, MH_NOUNDEFS),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_INCRLINK),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_DYLDLINK),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDATLOAD),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBOUND),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_SPLIT_SEGS),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_LAZY_INIT),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_TWOLEVEL),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_FORCE_FLAT),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_NOMULTIDEFS),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_NOFIXPREBINDING),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBINDABLE),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLMODSBOUND),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_SUBSECTIONS_VIA_SYMBOLS),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_CANONICAL),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_WEAK_DEFINES),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDS_TO_WEAK),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLOW_STACK_EXECUTION),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_ROOT_SAFE),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_SETUID_SAFE),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_REEXPORTED_DYLIBS),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_PIE),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_DEAD_STRIPPABLE_DYLIB),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_HAS_TLV_DESCRIPTORS),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_HEAP_EXECUTION),
     LLVM_READOBJ_ENUM_ENT(MachO, MH_APP_EXTENSION_SAFE),
 };
 
 const EnumEntry<unsigned> MachOSectionTypes[] = {
-  { "Regular"                        , MachO::S_REGULAR },
-  { "ZeroFill"                       , MachO::S_ZEROFILL },
-  { "CStringLiterals"                , MachO::S_CSTRING_LITERALS },
-  { "4ByteLiterals"                  , MachO::S_4BYTE_LITERALS },
-  { "8ByteLiterals"                  , MachO::S_8BYTE_LITERALS },
-  { "LiteralPointers"                , MachO::S_LITERAL_POINTERS },
-  { "NonLazySymbolPointers"          , MachO::S_NON_LAZY_SYMBOL_POINTERS },
-  { "LazySymbolPointers"             , MachO::S_LAZY_SYMBOL_POINTERS },
-  { "SymbolStubs"                    , MachO::S_SYMBOL_STUBS },
-  { "ModInitFuncPointers"            , MachO::S_MOD_INIT_FUNC_POINTERS },
-  { "ModTermFuncPointers"            , MachO::S_MOD_TERM_FUNC_POINTERS },
-  { "Coalesced"                      , MachO::S_COALESCED },
-  { "GBZeroFill"                     , MachO::S_GB_ZEROFILL },
-  { "Interposing"                    , MachO::S_INTERPOSING },
-  { "16ByteLiterals"                 , MachO::S_16BYTE_LITERALS },
-  { "DTraceDOF"                      , MachO::S_DTRACE_DOF },
-  { "LazyDylibSymbolPointers"        , MachO::S_LAZY_DYLIB_SYMBOL_POINTERS },
-  { "ThreadLocalRegular"             , MachO::S_THREAD_LOCAL_REGULAR },
-  { "ThreadLocalZerofill"            , MachO::S_THREAD_LOCAL_ZEROFILL },
-  { "ThreadLocalVariables"           , MachO::S_THREAD_LOCAL_VARIABLES },
-  { "ThreadLocalVariablePointers"    , MachO::S_THREAD_LOCAL_VARIABLE_POINTERS },
-  { "ThreadLocalInitFunctionPointers", MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS }
-};
+    {"Regular", MachO::S_REGULAR},
+    {"ZeroFill", MachO::S_ZEROFILL},
+    {"CStringLiterals", MachO::S_CSTRING_LITERALS},
+    {"4ByteLiterals", MachO::S_4BYTE_LITERALS},
+    {"8ByteLiterals", MachO::S_8BYTE_LITERALS},
+    {"LiteralPointers", MachO::S_LITERAL_POINTERS},
+    {"NonLazySymbolPointers", MachO::S_NON_LAZY_SYMBOL_POINTERS},
+    {"LazySymbolPointers", MachO::S_LAZY_SYMBOL_POINTERS},
+    {"SymbolStubs", MachO::S_SYMBOL_STUBS},
+    {"ModInitFuncPointers", MachO::S_MOD_INIT_FUNC_POINTERS},
+    {"ModTermFuncPointers", MachO::S_MOD_TERM_FUNC_POINTERS},
+    {"Coalesced", MachO::S_COALESCED},
+    {"GBZeroFill", MachO::S_GB_ZEROFILL},
+    {"Interposing", MachO::S_INTERPOSING},
+    {"16ByteLiterals", MachO::S_16BYTE_LITERALS},
+    {"DTraceDOF", MachO::S_DTRACE_DOF},
+    {"LazyDylibSymbolPointers", MachO::S_LAZY_DYLIB_SYMBOL_POINTERS},
+    {"ThreadLocalRegular", MachO::S_THREAD_LOCAL_REGULAR},
+    {"ThreadLocalZerofill", MachO::S_THREAD_LOCAL_ZEROFILL},
+    {"ThreadLocalVariables", MachO::S_THREAD_LOCAL_VARIABLES},
+    {"ThreadLocalVariablePointers", MachO::S_THREAD_LOCAL_VARIABLE_POINTERS},
+    {"ThreadLocalInitFunctionPointers",
+     MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS}};
 
 const EnumEntry<unsigned> MachOSectionAttributes[] = {
-  { "LocReloc"         , 1 <<  0 /*S_ATTR_LOC_RELOC          */ },
-  { "ExtReloc"         , 1 <<  1 /*S_ATTR_EXT_RELOC          */ },
-  { "SomeInstructions" , 1 <<  2 /*S_ATTR_SOME_INSTRUCTIONS  */ },
-  { "Debug"            , 1 << 17 /*S_ATTR_DEBUG              */ },
-  { "SelfModifyingCode", 1 << 18 /*S_ATTR_SELF_MODIFYING_CODE*/ },
-  { "LiveSupport"      , 1 << 19 /*S_ATTR_LIVE_SUPPORT       */ },
-  { "NoDeadStrip"      , 1 << 20 /*S_ATTR_NO_DEAD_STRIP      */ },
-  { "StripStaticSyms"  , 1 << 21 /*S_ATTR_STRIP_STATIC_SYMS  */ },
-  { "NoTOC"            , 1 << 22 /*S_ATTR_NO_TOC             */ },
-  { "PureInstructions" , 1 << 23 /*S_ATTR_PURE_INSTRUCTIONS  */ },
+    {"LocReloc", 1 << 0 /*S_ATTR_LOC_RELOC          */},
+    {"ExtReloc", 1 << 1 /*S_ATTR_EXT_RELOC          */},
+    {"SomeInstructions", 1 << 2 /*S_ATTR_SOME_INSTRUCTIONS  */},
+    {"Debug", 1 << 17 /*S_ATTR_DEBUG              */},
+    {"SelfModifyingCode", 1 << 18 /*S_ATTR_SELF_MODIFYING_CODE*/},
+    {"LiveSupport", 1 << 19 /*S_ATTR_LIVE_SUPPORT       */},
+    {"NoDeadStrip", 1 << 20 /*S_ATTR_NO_DEAD_STRIP      */},
+    {"StripStaticSyms", 1 << 21 /*S_ATTR_STRIP_STATIC_SYMS  */},
+    {"NoTOC", 1 << 22 /*S_ATTR_NO_TOC             */},
+    {"PureInstructions", 1 << 23 /*S_ATTR_PURE_INSTRUCTIONS  */},
 };
 
 const EnumEntry<unsigned> MachOSymbolRefTypes[] = {
-  { "UndefinedNonLazy",                     0 },
-  { "ReferenceFlagUndefinedLazy",           1 },
-  { "ReferenceFlagDefined",                 2 },
-  { "ReferenceFlagPrivateDefined",          3 },
-  { "ReferenceFlagPrivateUndefinedNonLazy", 4 },
-  { "ReferenceFlagPrivateUndefinedLazy",    5 }
-};
+    {"UndefinedNonLazy", 0},
+    {"ReferenceFlagUndefinedLazy", 1},
+    {"ReferenceFlagDefined", 2},
+    {"ReferenceFlagPrivateDefined", 3},
+    {"ReferenceFlagPrivateUndefinedNonLazy", 4},
+    {"ReferenceFlagPrivateUndefinedLazy", 5}};
 
 const EnumEntry<unsigned> MachOSymbolFlags[] = {
-  { "ThumbDef",               0x8 },
-  { "ReferencedDynamically", 0x10 },
-  { "NoDeadStrip",           0x20 },
-  { "WeakRef",               0x40 },
-  { "WeakDef",               0x80 },
-  { "SymbolResolver",       0x100 },
-  { "AltEntry",             0x200 },
-  { "ColdFunc",             0x400 },
+    {"ThumbDef", 0x8},     {"ReferencedDynamically", 0x10},
+    {"NoDeadStrip", 0x20}, {"WeakRef", 0x40},
+    {"WeakDef", 0x80},     {"SymbolResolver", 0x100},
+    {"AltEntry", 0x200},   {"ColdFunc", 0x400},
 };
 
-const EnumEntry<unsigned> MachOSymbolTypes[] = {
-  { "Undef",           0x0 },
-  { "Abs",             0x2 },
-  { "Indirect",        0xA },
-  { "PreboundUndef",   0xC },
-  { "Section",         0xE }
-};
+const EnumEntry<unsigned> MachOSymbolTypes[] = {{"Undef", 0x0},
+                                                {"Abs", 0x2},
+                                                {"Indirect", 0xA},
+                                                {"PreboundUndef", 0xC},
+                                                {"Section", 0xE}};
 
 namespace {
-  struct MachOSection {
-    ArrayRef<char> Name;
-    ArrayRef<char> SegmentName;
-    uint64_t Address;
-    uint64_t Size;
-    uint32_t Offset;
-    uint32_t Alignment;
-    uint32_t RelocationTableOffset;
-    uint32_t NumRelocationTableEntries;
-    uint32_t Flags;
-    uint32_t Reserved1;
-    uint32_t Reserved2;
-    uint32_t Reserved3;
-  };
 
-  struct MachOSegment {
-    std::string CmdName;
-    std::string SegName;
-    uint64_t cmdsize;
-    uint64_t vmaddr;
-    uint64_t vmsize;
-    uint64_t fileoff;
-    uint64_t filesize;
-    uint32_t maxprot;
-    uint32_t initprot;
-    uint32_t nsects;
-    uint32_t flags;
-  };
 
-  struct MachOSymbol {
-    uint32_t StringIndex;
-    uint8_t Type;
-    uint8_t SectionIndex;
-    uint16_t Flags;
-    uint64_t Value;
-  };
-}
+} // namespace
 
-static std::string getMask(uint32_t prot)
-{
+static std::string getMask(uint32_t prot) {
   // TODO (davide): This always assumes prot is valid.
   // Catch mistakes and report if needed.
   std::string Prot;
   Prot = "";
   Prot += (prot & MachO::VM_PROT_READ) ? "r" : "-";
   Prot += (prot & MachO::VM_PROT_WRITE) ? "w" : "-";
   Prot += (prot & MachO::VM_PROT_EXECUTE) ? "x" : "-";
   return Prot;
 }
 
-static void getSection(const MachOObjectFile *Obj,
-                       DataRefImpl Sec,
+static void getSection(const MachOObjectFile *Obj, DataRefImpl Sec,
                        MachOSection &Section) {
   if (!Obj->is64Bit()) {
     MachO::section Sect = Obj->getSection(Sec);
-    Section.Address     = Sect.addr;
-    Section.Size        = Sect.size;
-    Section.Offset      = Sect.offset;
-    Section.Alignment   = Sect.align;
+    Section.Address = Sect.addr;
+    Section.Size = Sect.size;
+    Section.Offset = Sect.offset;
+    Section.Alignment = Sect.align;
     Section.RelocationTableOffset = Sect.reloff;
     Section.NumRelocationTableEntries = Sect.nreloc;
-    Section.Flags       = Sect.flags;
-    Section.Reserved1   = Sect.reserved1;
-    Section.Reserved2   = Sect.reserved2;
+    Section.Flags = Sect.flags;
+    Section.Reserved1 = Sect.reserved1;
+    Section.Reserved2 = Sect.reserved2;
     return;
   }
   MachO::section_64 Sect = Obj->getSection64(Sec);
-  Section.Address     = Sect.addr;
-  Section.Size        = Sect.size;
-  Section.Offset      = Sect.offset;
-  Section.Alignment   = Sect.align;
+  Section.Address = Sect.addr;
+  Section.Size = Sect.size;
+  Section.Offset = Sect.offset;
+  Section.Alignment = Sect.align;
   Section.RelocationTableOffset = Sect.reloff;
   Section.NumRelocationTableEntries = Sect.nreloc;
-  Section.Flags       = Sect.flags;
-  Section.Reserved1   = Sect.reserved1;
-  Section.Reserved2   = Sect.reserved2;
-  Section.Reserved3   = Sect.reserved3;
+  Section.Flags = Sect.flags;
+  Section.Reserved1 = Sect.reserved1;
+  Section.Reserved2 = Sect.reserved2;
+  Section.Reserved3 = Sect.reserved3;
 }
 
 static void getSegment(const MachOObjectFile *Obj,
                        const MachOObjectFile::LoadCommandInfo &L,
                        MachOSegment &Segment) {
   if (!Obj->is64Bit()) {
     MachO::segment_command SC = Obj->getSegmentLoadCommand(L);
     Segment.CmdName = "LC_SEGMENT";
static void getSegment(const MachOObjectFile *Obj,
   Segment.fileoff = SC.fileoff;
   Segment.filesize = SC.filesize;
   Segment.maxprot = SC.maxprot;
   Segment.initprot = SC.initprot;
   Segment.nsects = SC.nsects;
   Segment.flags = SC.flags;
 }
 
-static void getSymbol(const MachOObjectFile *Obj,
-                      DataRefImpl DRI,
+static void getSymbol(const MachOObjectFile *Obj, DataRefImpl DRI,
                       MachOSymbol &Symbol) {
   if (!Obj->is64Bit()) {
     MachO::nlist Entry = Obj->getSymbolTableEntry(DRI);
-    Symbol.StringIndex  = Entry.n_strx;
-    Symbol.Type         = Entry.n_type;
+    Symbol.StringIndex = Entry.n_strx;
+    Symbol.Type = Entry.n_type;
     Symbol.SectionIndex = Entry.n_sect;
-    Symbol.Flags        = Entry.n_desc;
-    Symbol.Value        = Entry.n_value;
+    Symbol.Flags = Entry.n_desc;
+    Symbol.Value = Entry.n_value;
     return;
   }
   MachO::nlist_64 Entry = Obj->getSymbol64TableEntry(DRI);
-  Symbol.StringIndex  = Entry.n_strx;
-  Symbol.Type         = Entry.n_type;
+  Symbol.StringIndex = Entry.n_strx;
+  Symbol.Type = Entry.n_type;
   Symbol.SectionIndex = Entry.n_sect;
-  Symbol.Flags        = Entry.n_desc;
-  Symbol.Value        = Entry.n_value;
+  Symbol.Flags = Entry.n_desc;
+  Symbol.Value = Entry.n_value;
 }
 
 void MachODumper::printFileHeaders() {
   DictScope H(W, "MachHeader");
   if (!Obj->is64Bit()) {
     printFileHeaders(Obj->getHeader());
   } else {
     printFileHeaders(Obj->getHeader64());
     W.printHex("Reserved", Obj->getHeader64().reserved);
   }
 }
 
-template<class MachHeader>
+template <class MachHeader>
 void MachODumper::printFileHeaders(const MachHeader &Header) {
   W.printEnum("Magic", Header.magic, makeArrayRef(MachOMagics));
   W.printEnum("CpuType", Header.cputype, makeArrayRef(MachOHeaderCpuTypes));
   uint32_t subtype = Header.cpusubtype & ~MachO::CPU_SUBTYPE_MASK;
   switch (Header.cputype) {
   case MachO::CPU_TYPE_X86:
     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesX86));
     break;
   case MachO::CPU_TYPE_X86_64:
     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesX64));
     break;
   case MachO::CPU_TYPE_ARM:
     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesARM));
     break;
   case MachO::CPU_TYPE_POWERPC:
     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesPPC));
     break;
   case MachO::CPU_TYPE_SPARC:
-    W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesSPARC));
+    W.printEnum("CpuSubType", subtype,
+                makeArrayRef(MachOHeaderCpuSubtypesSPARC));
     break;
   case MachO::CPU_TYPE_ARM64:
-    W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesARM64));
+    W.printEnum("CpuSubType", subtype,
+                makeArrayRef(MachOHeaderCpuSubtypesARM64));
     break;
   case MachO::CPU_TYPE_POWERPC64:
   default:
     W.printHex("CpuSubtype", subtype);
   }
   W.printEnum("FileType", Header.filetype, makeArrayRef(MachOHeaderFileTypes));
   W.printNumber("NumOfLoadCommands", Header.ncmds);
   W.printNumber("SizeOfLoadCommands", Header.sizeofcmds);
if (opts::ExpandRelocs) {
     if (IsScattered) {
       // Scattered relocations don't really have an associated symbol for some
       // reason, even if one exists in the symtab at the correct address.
       SymbolNameOrOffset += utohexstr(Obj->getScatteredRelocationValue(RE));
     } else {
       SymbolNameOrOffset = TargetName;
     }
 
-    raw_ostream& OS = W.startLine();
-    OS << W.hex(Offset)
-       << " " << Obj->getAnyRelocationPCRel(RE)
-       << " " << Obj->getAnyRelocationLength(RE);
+    raw_ostream &OS = W.startLine();
+    OS << W.hex(Offset) << " " << Obj->getAnyRelocationPCRel(RE) << " "
+       << Obj->getAnyRelocationLength(RE);
     if (IsScattered)
       OS << " n/a";
     else
       OS << " " << Obj->getPlainRelocationExternal(RE);
-    OS << " " << RelocName
-       << " " << IsScattered
-       << " " << SymbolNameOrOffset
+    OS << " " << RelocName << " " << IsScattered << " " << SymbolNameOrOffset
        << "\n";
   }
 }
 
 StringRef MachODumper::getSymbolName(const SymbolRef &Symbol) {
   Expected<StringRef> SymbolNameOrErr = Symbol.getName();
   if (!SymbolNameOrErr) {
     reportError(SymbolNameOrErr.takeError(), Obj->getFileName());
if (StackMapSection == object::SectionRef())
     return;
 
   StringRef StackMapContents =
       unwrapOrError(Obj->getFileName(), StackMapSection.getContents());
   ArrayRef<uint8_t> StackMapContentsArray =
       arrayRefFromStringRef(StackMapContents);
 
   if (Obj->isLittleEndian())
-    prettyPrintStackMap(
-        W, StackMapParser<support::little>(StackMapContentsArray));
+    prettyPrintStackMap(W,
+                        StackMapParser<support::little>(StackMapContentsArray));
   else
-    prettyPrintStackMap(
-        W, StackMapParser<support::big>(StackMapContentsArray));
+    prettyPrintStackMap(W, StackMapParser<support::big>(StackMapContentsArray));
 }
 
 void MachODumper::printCGProfile() {
   object::SectionRef CGProfileSection;
   for (auto Sec : Obj->sections()) {
     StringRef Name;
     if (Expected<StringRef> NameOrErr = Sec.getName())
       Name = *NameOrErr;
for (const auto &Command : Obj->load_commands()) {
     if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||
         Command.C.cmd == MachO::LC_ID_DYLIB ||
         Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
         Command.C.cmd == MachO::LC_REEXPORT_DYLIB ||
         Command.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
         Command.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
       MachO::dylib_command Dl = Obj->getDylibIDLoadCommand(Command);
       if (Dl.dylib.name < Dl.cmdsize) {
-        auto *P = static_cast<const char*>(Command.Ptr) + Dl.dylib.name;
+        auto *P = static_cast<const char *>(Command.Ptr) + Dl.dylib.name;
         Libs.push_back(P);
       }
     }
   }
 
   llvm::stable_sort(Libs);
 
   for (const auto &L : Libs) {
     W.startLine() << L << "\n";
   }
 }
 
 void MachODumper::printMachODataInCode() {
   for (const auto &Load : Obj->load_commands()) {
-    if (Load.C.cmd  == MachO::LC_DATA_IN_CODE) {
+    if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
       MachO::linkedit_data_command LLC = Obj->getLinkeditDataLoadCommand(Load);
       DictScope Group(W, "DataInCode");
       W.printNumber("Data offset", LLC.dataoff);
       W.printNumber("Data size", LLC.datasize);
       ListScope D(W, "Data entries");
       unsigned NumRegions = LLC.datasize / sizeof(MachO::data_in_code_entry);
       for (unsigned i = 0; i < NumRegions; ++i) {
-        MachO::data_in_code_entry DICE = Obj->getDataInCodeTableEntry(
-                                                              LLC.dataoff, i);
+        MachO::data_in_code_entry DICE =
+            Obj->getDataInCodeTableEntry(LLC.dataoff, i);
         DictScope Group(W, "Entry");
         W.printNumber("Index", i);
         W.printNumber("Offset", DICE.offset);
         W.printNumber("Length", DICE.length);
         W.printNumber("Kind", DICE.kind);
       }
     }
   }
if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
       MachO::linker_option_command LOLC = Obj->getLinkerOptionLoadCommand(Load);
       DictScope Group(W, "Linker Options");
       W.printNumber("Size", LOLC.cmdsize);
       ListScope D(W, "Strings");
       uint64_t DataSize = LOLC.cmdsize - sizeof(MachO::linker_option_command);
       const char *P = Load.Ptr + sizeof(MachO::linker_option_command);
       StringRef Data(P, DataSize);
       for (unsigned i = 0; i < LOLC.count; ++i) {
-        std::pair<StringRef,StringRef> Split = Data.split('\0');
+        std::pair<StringRef, StringRef> Split = Data.split('\0');
         W.printString("Value", Split.first);
         Data = Split.second;
       }
     }
   }
 }

llvm/tools/llvm-readobj/ObjDumper.h

 
 namespace llvm {
 namespace object {
 class Archive;
 class COFFImportFile;
 class ObjectFile;
 class XCOFFObjectFile;
 class ELFObjectFileBase;
-}
+} // namespace object
 namespace codeview {
 class GlobalTypeTableBuilder;
 class MergingTypeTableBuilder;
 } // namespace codeview
 
 class ScopedPrinter;
 
 class ObjDumper {
virtual void printProgramHeaders(bool PrintProgramHeaders,
     if (PrintSectionMapping == cl::BOU_TRUE)
       printSectionMapping();
   }
 
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
   virtual void printDependentLibs() {}
-  virtual void printDynamicRelocations() { }
-  virtual void printDynamicTable() { }
-  virtual void printNeededLibraries() { }
+  virtual void printDynamicRelocations() {}
+  virtual void printDynamicTable() {}
+  virtual void printNeededLibraries() {}
   virtual void printSectionAsHex(StringRef SectionName) {}
-  virtual void printHashTable() { }
+  virtual void printHashTable() {}
   virtual void printGnuHashTable() {}
   virtual void printHashSymbols() {}
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistograms() {}
   virtual void printCGProfile() {}
   virtual void printBBAddrMaps() {}
   virtual void printAddrsig() {}
   virtual void printNotes() {}
   virtual void printELFLinkerOptions() {}
   virtual void printStackSizes() {}
   virtual void printSectionDetails() {}
   virtual void printArchSpecificInfo() {}
 
   // Only implemented for PE/COFF.
-  virtual void printCOFFImports() { }
-  virtual void printCOFFExports() { }
-  virtual void printCOFFDirectives() { }
-  virtual void printCOFFBaseReloc() { }
-  virtual void printCOFFDebugDirectory() { }
+  virtual void printCOFFImports() {}
+  virtual void printCOFFExports() {}
+  virtual void printCOFFDirectives() {}
+  virtual void printCOFFBaseReloc() {}
+  virtual void printCOFFDebugDirectory() {}
   virtual void printCOFFTLSDirectory() {}
   virtual void printCOFFResources() {}
-  virtual void printCOFFLoadConfig() { }
-  virtual void printCodeViewDebugInfo() { }
+  virtual void printCOFFLoadConfig() {}
+  virtual void printCodeViewDebugInfo() {}
   virtual void
   mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
                      llvm::codeview::MergingTypeTableBuilder &CVTypes,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
                      bool GHash) {}
 
   // Only implement for XCOFF
   virtual void printAuxiliaryHeader() {}
 
   // Only implemented for MachO.
-  virtual void printMachODataInCode() { }
-  virtual void printMachOVersionMin() { }
-  virtual void printMachODysymtab() { }
-  virtual void printMachOSegment() { }
-  virtual void printMachOIndirectSymbols() { }
-  virtual void printMachOLinkerOptions() { }
+  virtual void printMachODataInCode() {}
+  virtual void printMachOVersionMin() {}
+  virtual void printMachODysymtab() {}
+  virtual void printMachOSegment() {}
+  virtual void printMachOIndirectSymbols() {}
+  virtual void printMachOLinkerOptions() {}
 
   // Currently only implemented for XCOFF.
-  virtual void printStringTable() { }
+  virtual void printStringTable() {}
 
   virtual void printStackMap() const = 0;
 
   void printAsStringList(StringRef StringContent, size_t StringDataOffset = 0);
 
   void printSectionsAsString(const object::ObjectFile &Obj,
                              ArrayRef<std::string> Sections);
   void printSectionsAsHex(const object::ObjectFile &Obj,

llvm/tools/llvm-readobj/StackMapPrinter.h

 #include "llvm/Support/ScopedPrinter.h"
 
 namespace llvm {
 
 // Pretty print a stackmap to the given ostream.
 template <typename StackMapParserT>
 void prettyPrintStackMap(ScopedPrinter &W, const StackMapParserT &SMP) {
 
-  W.printNumber("LLVM StackMap Version",  SMP.getVersion());
+  W.printNumber("LLVM StackMap Version", SMP.getVersion());
   W.printNumber("Num Functions", SMP.getNumFunctions());
 
   // Functions:
   for (const auto &F : SMP.functions())
     W.startLine() << "  Function address: " << F.getFunctionAddress()
                   << ", stack size: " << F.getStackSize()
                   << ", callsite record count: " << F.getRecordCount() << "\n";
 
   // Constants:
   W.printNumber("Num Constants", SMP.getNumConstants());
   unsigned ConstantIndex = 0;
   for (const auto &C : SMP.constants())
     W.startLine() << "  #" << ++ConstantIndex << ": " << C.getValue() << "\n";
 
   // Records:
for (const auto &Loc : R.locations()) {
         break;
       }
       OS << ", size: " << Loc.getSizeInBytes() << "\n";
     }
 
     raw_ostream &OS = W.startLine();
     OS << "    " << R.getNumLiveOuts() << " live-outs: [ ";
     for (const auto &LO : R.liveouts())
-      OS << "R#" << LO.getDwarfRegNum() << " ("
-         << LO.getSizeInBytes() << "-bytes) ";
+      OS << "R#" << LO.getDwarfRegNum() << " (" << LO.getSizeInBytes()
+         << "-bytes) ";
     OS << "]\n";
   }
 }
 
-}
+} // namespace llvm
 
 #endif

llvm/tools/llvm-readobj/WasmDumper.cpp

 
 using namespace llvm;
 using namespace object;
 
 namespace {
 
 const EnumEntry<unsigned> WasmSymbolTypes[] = {
 #define ENUM_ENTRY(X)                                                          \
-  { #X, wasm::WASM_SYMBOL_TYPE_##X }
+  {                                                                            \
+#X, wasm::WASM_SYMBOL_TYPE_##X                                             \
+  }
     ENUM_ENTRY(FUNCTION), ENUM_ENTRY(DATA), ENUM_ENTRY(GLOBAL),
     ENUM_ENTRY(SECTION),  ENUM_ENTRY(TAG),  ENUM_ENTRY(TABLE),
 #undef ENUM_ENTRY
 };
 
 const EnumEntry<uint32_t> WasmSectionTypes[] = {
 #define ENUM_ENTRY(X)                                                          \
-  { #X, wasm::WASM_SEC_##X }
+  {                                                                            \
+#X, wasm::WASM_SEC_##X                                                     \
+  }
     ENUM_ENTRY(CUSTOM),   ENUM_ENTRY(TYPE),      ENUM_ENTRY(IMPORT),
     ENUM_ENTRY(FUNCTION), ENUM_ENTRY(TABLE),     ENUM_ENTRY(MEMORY),
     ENUM_ENTRY(GLOBAL),   ENUM_ENTRY(TAG),       ENUM_ENTRY(EXPORT),
     ENUM_ENTRY(START),    ENUM_ENTRY(ELEM),      ENUM_ENTRY(CODE),
     ENUM_ENTRY(DATA),     ENUM_ENTRY(DATACOUNT),
 #undef ENUM_ENTRY
 };
 
 const EnumEntry<unsigned> WasmSymbolFlags[] = {
 #define ENUM_ENTRY(X)                                                          \
-  { #X, wasm::WASM_SYMBOL_##X }
-  ENUM_ENTRY(BINDING_GLOBAL),
-  ENUM_ENTRY(BINDING_WEAK),
-  ENUM_ENTRY(BINDING_LOCAL),
-  ENUM_ENTRY(VISIBILITY_DEFAULT),
-  ENUM_ENTRY(VISIBILITY_HIDDEN),
-  ENUM_ENTRY(UNDEFINED),
-  ENUM_ENTRY(EXPORTED),
-  ENUM_ENTRY(EXPLICIT_NAME),
+  {                                                                            \
+#X, wasm::WASM_SYMBOL_##X                                                  \
+  }
+    ENUM_ENTRY(BINDING_GLOBAL),    ENUM_ENTRY(BINDING_WEAK),
+    ENUM_ENTRY(BINDING_LOCAL),     ENUM_ENTRY(VISIBILITY_DEFAULT),
+    ENUM_ENTRY(VISIBILITY_HIDDEN), ENUM_ENTRY(UNDEFINED),
+    ENUM_ENTRY(EXPORTED),          ENUM_ENTRY(EXPLICIT_NAME),
     ENUM_ENTRY(NO_STRIP),
 #undef ENUM_ENTRY
 };
 
 class WasmDumper : public ObjDumper {
 public:
   WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer, Obj->getFileName()), Obj(Obj) {}
 

llvm/tools/llvm-readobj/Win64EHDumper.h

 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Win64EH.h"
 
 namespace llvm {
 namespace object {
 class COFFObjectFile;
 class SymbolRef;
 struct coff_section;
-}
+} // namespace object
 
 namespace Win64EH {
 class Dumper {
   ScopedPrinter &SW;
   raw_ostream &OS;
 
 public:
   typedef std::error_code (*SymbolResolver)(const object::coff_section *,
                                             uint64_t, object::SymbolRef &,
                                             void *);
 
   struct Context {
     const object::COFFObjectFile &COFF;
     SymbolResolver ResolveSymbol;
     void *UserData;
 
     Context(const object::COFFObjectFile &COFF, SymbolResolver Resolver,
             void *UserData)
         : COFF(COFF), ResolveSymbol(Resolver), UserData(UserData) {}
   };
 
 private:
   void printRuntimeFunctionEntry(const Context &Ctx,
                                  const object::coff_section *Section,
                                  uint64_t SectionOffset,
                                  const RuntimeFunction &RF);
-  void printUnwindCode(const UnwindInfo& UI, ArrayRef<UnwindCode> UC);
+  void printUnwindCode(const UnwindInfo &UI, ArrayRef<UnwindCode> UC);
   void printUnwindInfo(const Context &Ctx, const object::coff_section *Section,
                        off_t Offset, const UnwindInfo &UI);
   void printRuntimeFunction(const Context &Ctx,
                             const object::coff_section *Section,
                             uint64_t SectionOffset, const RuntimeFunction &RF);
 
 public:
   Dumper(ScopedPrinter &SW) : SW(SW), OS(SW.getOStream()) {}
 
   void printData(const Context &Ctx);
 };
-}
-}
+} // namespace Win64EH
+} // namespace llvm
 
 #endif

llvm/tools/llvm-readobj/Win64EHDumper.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::Win64EH;
 
 const EnumEntry<unsigned> UnwindFlags[] = {
-  { "ExceptionHandler", UNW_ExceptionHandler },
-  { "TerminateHandler", UNW_TerminateHandler },
-  { "ChainInfo"       , UNW_ChainInfo        }
-};
+    {"ExceptionHandler", UNW_ExceptionHandler},
+    {"TerminateHandler", UNW_TerminateHandler},
+    {"ChainInfo", UNW_ChainInfo}};
 
 const EnumEntry<unsigned> UnwindOpInfo[] = {
-  { "RAX",  0 },
-  { "RCX",  1 },
-  { "RDX",  2 },
-  { "RBX",  3 },
-  { "RSP",  4 },
-  { "RBP",  5 },
-  { "RSI",  6 },
-  { "RDI",  7 },
-  { "R8",   8 },
-  { "R9",   9 },
-  { "R10", 10 },
-  { "R11", 11 },
-  { "R12", 12 },
-  { "R13", 13 },
-  { "R14", 14 },
-  { "R15", 15 }
-};
+    {"RAX", 0},  {"RCX", 1},  {"RDX", 2},  {"RBX", 3}, {"RSP", 4},  {"RBP", 5},
+    {"RSI", 6},  {"RDI", 7},  {"R8", 8},   {"R9", 9},  {"R10", 10}, {"R11", 11},
+    {"R12", 12}, {"R13", 13}, {"R14", 14}, {"R15", 15}};
 
-static uint64_t getOffsetOfLSDA(const UnwindInfo& UI) {
-  return static_cast<const char*>(UI.getLanguageSpecificData())
-         - reinterpret_cast<const char*>(&UI);
+static uint64_t getOffsetOfLSDA(const UnwindInfo &UI) {
+  return static_cast<const char *>(UI.getLanguageSpecificData()) -
+         reinterpret_cast<const char *>(&UI);
 }
 
 static uint32_t getLargeSlotValue(ArrayRef<UnwindCode> UC) {
   if (UC.size() < 3)
     return 0;
   return UC[1].FrameOffset + (static_cast<uint32_t>(UC[2].FrameOffset) << 16);
 }
 
 // Returns the name of the unwind code.
 static StringRef getUnwindCodeTypeName(uint8_t Code) {
   switch (Code) {
-  default: llvm_unreachable("Invalid unwind code");
-  case UOP_PushNonVol: return "PUSH_NONVOL";
-  case UOP_AllocLarge: return "ALLOC_LARGE";
-  case UOP_AllocSmall: return "ALLOC_SMALL";
-  case UOP_SetFPReg: return "SET_FPREG";
-  case UOP_SaveNonVol: return "SAVE_NONVOL";
-  case UOP_SaveNonVolBig: return "SAVE_NONVOL_FAR";
-  case UOP_SaveXMM128: return "SAVE_XMM128";
-  case UOP_SaveXMM128Big: return "SAVE_XMM128_FAR";
-  case UOP_PushMachFrame: return "PUSH_MACHFRAME";
+  default:
+    llvm_unreachable("Invalid unwind code");
+  case UOP_PushNonVol:
+    return "PUSH_NONVOL";
+  case UOP_AllocLarge:
+    return "ALLOC_LARGE";
+  case UOP_AllocSmall:
+    return "ALLOC_SMALL";
+  case UOP_SetFPReg:
+    return "SET_FPREG";
+  case UOP_SaveNonVol:
+    return "SAVE_NONVOL";
+  case UOP_SaveNonVolBig:
+    return "SAVE_NONVOL_FAR";
+  case UOP_SaveXMM128:
+    return "SAVE_XMM128";
+  case UOP_SaveXMM128Big:
+    return "SAVE_XMM128_FAR";
+  case UOP_PushMachFrame:
+    return "PUSH_MACHFRAME";
   }
 }
 
 // Returns the name of a referenced register.
 static StringRef getUnwindRegisterName(uint8_t Reg) {
   switch (Reg) {
-  default: llvm_unreachable("Invalid register");
-  case 0: return "RAX";
-  case 1: return "RCX";
-  case 2: return "RDX";
-  case 3: return "RBX";
-  case 4: return "RSP";
-  case 5: return "RBP";
-  case 6: return "RSI";
-  case 7: return "RDI";
-  case 8: return "R8";
-  case 9: return "R9";
-  case 10: return "R10";
-  case 11: return "R11";
-  case 12: return "R12";
-  case 13: return "R13";
-  case 14: return "R14";
-  case 15: return "R15";
+  default:
+    llvm_unreachable("Invalid register");
+  case 0:
+    return "RAX";
+  case 1:
+    return "RCX";
+  case 2:
+    return "RDX";
+  case 3:
+    return "RBX";
+  case 4:
+    return "RSP";
+  case 5:
+    return "RBP";
+  case 6:
+    return "RSI";
+  case 7:
+    return "RDI";
+  case 8:
+    return "R8";
+  case 9:
+    return "R9";
+  case 10:
+    return "R10";
+  case 11:
+    return "R11";
+  case 12:
+    return "R12";
+  case 13:
+    return "R13";
+  case 14:
+    return "R14";
+  case 15:
+    return "R15";
   }
 }
 
 // Calculates the number of array slots required for the unwind code.
 static unsigned getNumUsedSlots(const UnwindCode &UnwindCode) {
   switch (UnwindCode.getUnwindOp()) {
-  default: llvm_unreachable("Invalid unwind code");
+  default:
+    llvm_unreachable("Invalid unwind code");
   case UOP_PushNonVol:
   case UOP_AllocSmall:
   case UOP_SetFPReg:
   case UOP_PushMachFrame:
     return 1;
   case UOP_SaveNonVol:
   case UOP_SaveXMM128:
     return 2;
SW.printString("EndAddress",
                               /*IsRangeEnd=*/true));
   SW.printString("UnwindInfoAddress",
                  formatSymbol(Ctx, Section, Offset + 8, RF.UnwindInfoOffset));
 }
 
 // Prints one unwind code. Because an unwind code can occupy up to 3 slots in
 // the unwind codes array, this function requires that the correct number of
 // slots is provided.
-void Dumper::printUnwindCode(const UnwindInfo& UI, ArrayRef<UnwindCode> UC) {
+void Dumper::printUnwindCode(const UnwindInfo &UI, ArrayRef<UnwindCode> UC) {
   assert(UC.size() >= getNumUsedSlots(UC[0]));
 
   SW.startLine() << format("0x%02X: ", unsigned(UC[0].u.CodeOffset))
                  << getUnwindCodeTypeName(UC[0].getUnwindOp());
 
   switch (UC[0].getUnwindOp()) {
   case UOP_PushNonVol:
     OS << " reg=" << getUnwindRegisterName(UC[0].getOpInfo());
if (UI.getFrameRegister()) {
     SW.printString("FrameRegister", StringRef("-"));
     SW.printString("FrameOffset", StringRef("-"));
   }
 
   SW.printNumber("UnwindCodeCount", UI.NumCodes);
   {
     ListScope UCS(SW, "UnwindCodes");
     ArrayRef<UnwindCode> UC(&UI.UnwindCodes[0], UI.NumCodes);
-    for (const UnwindCode *UCI = UC.begin(), *UCE = UC.end(); UCI < UCE; ++UCI) {
+    for (const UnwindCode *UCI = UC.begin(), *UCE = UC.end(); UCI < UCE;
+         ++UCI) {
       unsigned UsedSlots = getNumUsedSlots(*UCI);
       if (UsedSlots > UC.size()) {
         errs() << "corrupt unwind data";
         return;
       }
 
       printUnwindCode(UI, makeArrayRef(UCI, UCE));
       UCI = UCI + UsedSlots - 1;
if (Error E = Ctx.COFF.getSectionContents(XData, Contents))
     reportError(std::move(E), Ctx.COFF.getFileName());
 
   if (Contents.empty())
     return;
 
   if (Offset > Contents.size())
     return;
 
-  const auto UI = reinterpret_cast<const UnwindInfo*>(Contents.data() + Offset);
+  const auto UI =
+      reinterpret_cast<const UnwindInfo *>(Contents.data() + Offset);
   printUnwindInfo(Ctx, XData, Offset, *UI);
 }
 
 void Dumper::printData(const Context &Ctx) {
   for (const auto &Section : Ctx.COFF.sections()) {
     StringRef Name;
     if (Expected<StringRef> NameOrErr = Section.getName())
       Name = *NameOrErr;
     else
       consumeError(NameOrErr.takeError());
 
     if (Name != ".pdata" && !Name.startswith(".pdata$"))
       continue;
 
     const coff_section *PData = Ctx.COFF.getCOFFSection(Section);
     ArrayRef<uint8_t> Contents;
 
     if (Error E = Ctx.COFF.getSectionContents(PData, Contents))
       reportError(std::move(E), Ctx.COFF.getFileName());
     if (Contents.empty())
       continue;
 
     const RuntimeFunction *Entries =
         reinterpret_cast<const RuntimeFunction *>(Contents.data());
     const size_t Count = Contents.size() / sizeof(RuntimeFunction);
     ArrayRef<RuntimeFunction> RuntimeFunctions(Entries, Count);
 
     size_t Index = 0;
     for (const auto &RF : RuntimeFunctions) {
       printRuntimeFunction(Ctx, Ctx.COFF.getCOFFSection(Section),
                            Index * sizeof(RuntimeFunction), RF);
       ++Index;
     }
   }
 }
-}
-}
-
+} // namespace Win64EH
+} // namespace llvm

llvm/tools/llvm-readobj/XCOFFDumper.cpp

void XCOFFDumper::printRelocations() {
   if (Obj.is64Bit())
     printRelocations<XCOFFSectionHeader64, XCOFFRelocation64>(Obj.sections64());
   else
     printRelocations<XCOFFSectionHeader32, XCOFFRelocation32>(Obj.sections32());
 }
 
 const EnumEntry<XCOFF::RelocationType> RelocationTypeNameclass[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(R_POS),    ECase(R_RL),     ECase(R_RLA),    ECase(R_NEG),
     ECase(R_REL),    ECase(R_TOC),    ECase(R_TRL),    ECase(R_TRLA),
     ECase(R_GL),     ECase(R_TCL),    ECase(R_REF),    ECase(R_BA),
     ECase(R_BR),     ECase(R_RBA),    ECase(R_RBR),    ECase(R_TLS),
     ECase(R_TLS_IE), ECase(R_TLS_LD), ECase(R_TLS_LE), ECase(R_TLSM),
     ECase(R_TLSML),  ECase(R_TOCU),   ECase(R_TOCL)
 #undef ECase
 };
void XCOFFDumper::printRelocations(ArrayRef<Shdr> Sections) {
   ListScope LS(W, "Relocations");
   uint16_t Index = 0;
   for (const Shdr &Sec : Sections) {
     ++Index;
     // Only the .text, .data, .tdata, and STYP_DWARF sections have relocation.
     if (Sec.Flags != XCOFF::STYP_TEXT && Sec.Flags != XCOFF::STYP_DATA &&
         Sec.Flags != XCOFF::STYP_TDATA && Sec.Flags != XCOFF::STYP_DWARF)
       continue;
-    Expected<ArrayRef<RelTy>> ErrOrRelocations = Obj.relocations<Shdr, RelTy>(Sec);
+    Expected<ArrayRef<RelTy>> ErrOrRelocations =
+        Obj.relocations<Shdr, RelTy>(Sec);
     if (Error E = ErrOrRelocations.takeError()) {
       reportUniqueWarning(std::move(E));
       continue;
     }
 
     const ArrayRef<RelTy> Relocations = *ErrOrRelocations;
     if (Relocations.empty())
       continue;
 
     W.startLine() << "Section (index: " << Index << ") " << Sec.getName()
                   << " {\n";
     W.indent();
 
     for (const RelTy Reloc : Relocations)
       printRelocation(Reloc);
 
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
 const EnumEntry<XCOFF::CFileStringType> FileStringType[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(XFT_FN), ECase(XFT_CT), ECase(XFT_CV), ECase(XFT_CD)
 #undef ECase
 };
 
 const EnumEntry<XCOFF::SymbolAuxType> SymAuxType[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(AUX_EXCEPT), ECase(AUX_FCN), ECase(AUX_SYM), ECase(AUX_FILE),
     ECase(AUX_CSECT),  ECase(AUX_SECT)
 #undef ECase
 };
 
 void XCOFFDumper::printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr) {
   assert((!Obj.is64Bit() || AuxEntPtr->AuxType == XCOFF::AUX_FILE) &&
          "Mismatched auxiliary type!");
if (Obj.is64Bit()) {
     W.printEnum("Auxiliary Type", static_cast<uint8_t>(AuxEntPtr->AuxType),
                 makeArrayRef(SymAuxType));
   }
 }
 
 static const EnumEntry<XCOFF::StorageMappingClass> CsectStorageMappingClass[] =
     {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
         ECase(XMC_PR), ECase(XMC_RO), ECase(XMC_DB),   ECase(XMC_GL),
         ECase(XMC_XO), ECase(XMC_SV), ECase(XMC_SV64), ECase(XMC_SV3264),
         ECase(XMC_TI), ECase(XMC_TB), ECase(XMC_RW),   ECase(XMC_TC0),
         ECase(XMC_TC), ECase(XMC_TD), ECase(XMC_DS),   ECase(XMC_UA),
         ECase(XMC_BS), ECase(XMC_UC), ECase(XMC_TL),   ECase(XMC_UL),
         ECase(XMC_TE)
 #undef ECase
 };
 
 const EnumEntry<XCOFF::SymbolType> CsectSymbolTypeClass[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(XTY_ER), ECase(XTY_SD), ECase(XTY_LD), ECase(XTY_CM)
 #undef ECase
 };
 
 void XCOFFDumper::printCsectAuxEnt(XCOFFCsectAuxRef AuxEntRef) {
   assert((!Obj.is64Bit() || AuxEntRef.getAuxType64() == XCOFF::AUX_CSECT) &&
          "Mismatched auxiliary type!");
 
void XCOFFDumper::printSectAuxEntForDWARF(const T *AuxEntPtr) {
   W.printNumber("NumberOfRelocEntries", AuxEntPtr->NumberOfRelocEnt);
   if (Obj.is64Bit())
     W.printEnum("Auxiliary Type", static_cast<uint8_t>(XCOFF::AUX_SECT),
                 makeArrayRef(SymAuxType));
 }
 
 const EnumEntry<XCOFF::StorageClass> SymStorageClass[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(C_NULL),  ECase(C_AUTO),    ECase(C_EXT),     ECase(C_STAT),
     ECase(C_REG),   ECase(C_EXTDEF),  ECase(C_LABEL),   ECase(C_ULABEL),
     ECase(C_MOS),   ECase(C_ARG),     ECase(C_STRTAG),  ECase(C_MOU),
     ECase(C_UNTAG), ECase(C_TPDEF),   ECase(C_USTATIC), ECase(C_ENTAG),
     ECase(C_MOE),   ECase(C_REGPARM), ECase(C_FIELD),   ECase(C_BLOCK),
     ECase(C_FCN),   ECase(C_EOS),     ECase(C_FILE),    ECase(C_LINE),
     ECase(C_ALIAS), ECase(C_HIDDEN),  ECase(C_HIDEXT),  ECase(C_BINCL),
     ECase(C_EINCL), ECase(C_INFO),    ECase(C_WEAKEXT), ECase(C_DWARF),
case XCOFF::C_ECOML:
     return "";
   default:
     return "Value";
   }
 }
 
 const EnumEntry<XCOFF::CFileLangId> CFileLangIdClass[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(TB_C), ECase(TB_CPLUSPLUS)
 #undef ECase
 };
 
 const EnumEntry<XCOFF::CFileCpuId> CFileCpuIdClass[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(TCPU_PPC64), ECase(TCPU_COM), ECase(TCPU_970)
 #undef ECase
 };
 
 template <typename T> const T *XCOFFDumper::getAuxEntPtr(uintptr_t AuxAddress) {
   const T *AuxEntPtr = reinterpret_cast<const T *>(AuxAddress);
   Obj.checkSymbolEntryPointer(reinterpret_cast<uintptr_t>(AuxEntPtr));
   return AuxEntPtr;
if (StrIndex % 3 == 1)
       BaseWidth = std::max(BaseWidth, CurrentLen);
   }
 
   auto &OS = static_cast<formatted_raw_ostream &>(W.startLine());
   // Each entry consists of 3 strings: the path_name, base_name and
   // archive_member_name. The first entry is a default LIBPATH value and other
   // entries have no path_name. We just dump the base_name and
   // archive_member_name here.
-  OS << left_justify("BASE", BaseWidth)  << " MEMBER\n";
+  OS << left_justify("BASE", BaseWidth) << " MEMBER\n";
   CurrentStr = ImportFileTable.data();
   for (size_t StrIndex = 0; CurrentStr < TableEnd;
        ++StrIndex, CurrentStr += strlen(CurrentStr) + 1) {
     if (StrIndex >= 3 && StrIndex % 3 != 0) {
       if (StrIndex % 3 == 1)
         OS << "  " << left_justify(CurrentStr, BaseWidth) << " ";
       else
         OS << CurrentStr << "\n";
     }
   }
 }
 
 const EnumEntry<XCOFF::SectionTypeFlags> SectionTypeFlagsNames[] = {
 #define ECase(X)                                                               \
-  { #X, XCOFF::X }
+  {                                                                            \
+#X, XCOFF::X                                                               \
+  }
     ECase(STYP_PAD),    ECase(STYP_DWARF), ECase(STYP_TEXT),
     ECase(STYP_DATA),   ECase(STYP_BSS),   ECase(STYP_EXCEPT),
     ECase(STYP_INFO),   ECase(STYP_TDATA), ECase(STYP_TBSS),
     ECase(STYP_LOADER), ECase(STYP_DEBUG), ECase(STYP_TYPCHK),
     ECase(STYP_OVRFLO)
 #undef ECase
 };
 

llvm/tools/llvm-readobj/llvm-readobj.h

 //===-- llvm-readobj.h ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_LLVM_READOBJ_H
 #define LLVM_TOOLS_LLVM_READOBJ_LLVM_READOBJ_H
 
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
 #include <string>
 
 namespace llvm {
-  namespace object {
-    class RelocationRef;
-  }
 
-  // Various helper functions.
-  [[noreturn]] void reportError(Error Err, StringRef Input);
-  void reportWarning(Error Err, StringRef Input);
 
-  template <class T> T unwrapOrError(StringRef Input, Expected<T> EO) {
-    if (EO)
-      return *EO;
-    reportError(EO.takeError(), Input);
-  }
 } // namespace llvm
 
 namespace opts {
 extern bool SectionRelocations;
 extern bool SectionSymbols;
 extern bool SectionData;
 extern bool ExpandRelocs;
 extern bool RawRelr;
 extern bool CodeViewSubsectionBytes;
 extern bool Demangle;
 enum OutputStyleTy { LLVM, GNU, JSON, UNKNOWN };
 extern OutputStyleTy Output;
 } // namespace opts
 
-#define LLVM_READOBJ_ENUM_ENT(ns, enum) \
-  { #enum, ns::enum }
+#define LLVM_READOBJ_ENUM_ENT(ns, enum)                                        \
+  {                                                                            \
+#enum, ns::enum                                                            \
+  }
 
-#define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
-  { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
+#define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum)                          \
+  {                                                                            \
+#enum, std::underlying_type < enum_class> ::type(enum_class::enum)         \
+  }
 
 #endif

llvm/tools/llvm-readobj/llvm-readobj.cpp

 /// Dumps \a WinRes, Windows Resource (.res) file;
 static void dumpWindowsResourceFile(WindowsResource *WinRes,
                                     ScopedPrinter &Printer) {
   WindowsRes::Dumper Dumper(WinRes, Printer);
   if (auto Err = Dumper.printData())
     reportError(std::move(Err), WinRes->getFileName());
 }
 
-
 /// Opens \a File and dumps it.
 static void dumpInput(StringRef File, ScopedPrinter &Writer) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
                                    /*RequiresNullTerminator=*/false);
   if (std::error_code EC = FileOrErr.getError())
     return reportError(errorCodeToError(EC), File);