implement MachODumper::printFileHeaders

[chilledheart]

update for code format

[friss]

Thanks for working on this!

This needs some test coverage, you need to update test/tools/llvm-readobj/file-headers.test. Other comments inline.

tools/llvm-readobj/MachODumper.cpp

207–208 ↗

(On Diff #15911)

Not sure about the convention of llvm-readobj, but you might want to call that MachHeader instead (The ELF one is called ElfHeader, and moreover this would nicely match name of the structure it is describing)

209–228 ↗

(On Diff #15911)

I think this would be nicer with a little template helper to use the same code for dumping the common fields. And then just special case the Reserved field that appears only in the 64bits version (given the name, I'm wondering if it should be dumped at all).

And most of the fields could be pretty-printed, you can take inspiration from what is done in ELFDumper and use the various enum/helpers in llvm/Support/MachO.h.

[chilledheart]

the name "MachHeader" is better than plain "Header"

[chilledheart]

use a little template helper

[chilledheart]

print magic, filetype and cputype more pretty

[chilledheart]

correct some typos

[chilledheart]

update

test part is comming soon

[chilledheart]

update format

[chilledheart]

add test cases

[friss]

This LGTM, can you commit it, or do you want me to land it for you?

[chilledheart]

Really appreciate it if you land it for me.

[nrieck]

Since llvm-readobj is a low-level inspection tool, the Reserved field should also be printed (even more so than unused fields).

[chilledheart]

In D6163#26, @nrieck wrote:

Since llvm-readobj is a low-level inspection tool, the Reserved field should also be printed (even more so than unused fields).

Yeah. As I know, macho-dump does dump the reserved field for 64-bit version of Mach-O format, while otool -h and llvm-objdump don't.

tools/llvm-readobj/MachODumper.cpp

207–208 ↗

(On Diff #15911)

Yeah, MachHeader is better.

207–208 ↗

(On Diff #15911)

Maybe I am a bit overconcerned about this. Since it (the header) belongs to Mach-O format, is MachOHeader more suitable than MachHeader?

209–228 ↗

(On Diff #15911)

Thanks for pointing it out. I will work on it soon.

[chilledheart]

dump reserved field for 64bit mach-o object

[chilledheart]

Hi Frederic,
If you have some free time this weekend, could you land it for me? Btw I don't have a subversion account yet and am not able to do it myself.

Thanks!

[friss]

No problem, I'll do it before the end of the weekend. Sorry for the delay, I've been busy with other thinks.

Thanks!
Fred

[chilledheart]

No worry about that. Take your time.

Cheers,
Chilledheart

[friss]

Closed by commit rL222115 (authored by @friss).

llvm/trunk/test/tools/llvm-readobj/file-headers.test

 RUN: llvm-readobj -h %p/Inputs/trivial.obj.coff-arm \
 RUN:   | FileCheck %s -check-prefix COFF-ARM
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.coff-i386 \
 RUN:   | FileCheck %s -check-prefix COFF32
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.coff-x86-64 \
 RUN:   | FileCheck %s -check-prefix COFF64
 RUN: llvm-readobj -h %p/Inputs/trivial.exe.coff-i386 \
 RUN:   | FileCheck %s -check-prefix PE32
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-i386 \
 RUN:   | FileCheck %s -check-prefix ELF32
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-x86-64 \
 RUN:   | FileCheck %s -check-prefix ELF64
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-i386 \
+RUN:   | FileCheck %s -check-prefix MACHO32
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-x86-64 \
+RUN:   | FileCheck %s -check-prefix MACHO64
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-ppc \
+RUN:   | FileCheck %s -check-prefix MACHO-PPC
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-ppc64 \
+RUN:   | FileCheck %s -check-prefix MACHO-PPC64
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.macho-arm \
+RUN:   | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -h %p/Inputs/magic.coff-unknown \
 RUN:   | FileCheck %s -check-prefix COFF-UNKNOWN
 RUN: llvm-readobj -h %p/Inputs/magic.coff-importlib \
 RUN:   | FileCheck %s -check-prefix COFF-IMPORTLIB
 
 COFF-ARM:      File: {{(.*[/\\])?}}trivial.obj.coff-arm
 COFF-ARM-NEXT: Format: COFF-ARM
 COFF-ARM-NEXT: Arch: thumb

 ELF64-NEXT:   HeaderSize: 64
 ELF64-NEXT:   ProgramHeaderEntrySize: 0
 ELF64-NEXT:   ProgramHeaderCount: 0
 ELF64-NEXT:   SectionHeaderEntrySize: 64
 ELF64-NEXT:   SectionHeaderCount: 10
 ELF64-NEXT:   StringTableSectionIndex: 7
 ELF64-NEXT: }
 
+MACHO32:      File: {{(.*[/\\])?}}trivial.obj.macho-i386
+MACHO32-NEXT: Format: Mach-O 32-bit i386
+MACHO32-NEXT: Arch: i386
+MACHO32-NEXT: AddressSize: 32bit
+MACHO32-NEXT: MachHeader {
+MACHO32-NEXT:   Magic: Magic (0xFEEDFACE)
+MACHO32-NEXT:   CpuType: X86 (0x7)
+MACHO32-NEXT:   CpuSubType: CPU_SUBTYPE_I386_ALL (0x3)
+MACHO32-NEXT:   FileType: Relocatable (0x1)
+MACHO32-NEXT:   NumOfLoadCommands: 3
+MACHO32-NEXT:   SizeOfLoadCommands: 296
+MACHO32-NEXT:   Flags [ (0x2000)
+MACHO32-NEXT:     MH_SUBSECTIONS_VIA_SYMBOLS (0x2000)
+MACHO32-NEXT:   ]
+MACHO32-NEXT: }
+
+MACHO64:      File: {{(.*[/\\])?}}trivial.obj.macho-x86-64
+MACHO64-NEXT: Format: Mach-O 64-bit x86-64
+MACHO64-NEXT: Arch: x86_64
+MACHO64-NEXT: AddressSize: 64bit
+MACHO64-NEXT: MachHeader {
+MACHO64-NEXT:   Magic: Magic64 (0xFEEDFACF)
+MACHO64-NEXT:   CpuType: X86-64 (0x1000007)
+MACHO64-NEXT:   CpuSubType: CPU_SUBTYPE_X86_64_ALL (0x3)
+MACHO64-NEXT:   FileType: Relocatable (0x1)
+MACHO64-NEXT:   NumOfLoadCommands: 3
+MACHO64-NEXT:   SizeOfLoadCommands: 336
+MACHO64-NEXT:   Flags [ (0x2000)
+MACHO64-NEXT:     MH_SUBSECTIONS_VIA_SYMBOLS (0x2000)
+MACHO64-NEXT:   ]
+MACHO64-NEXT:   Reserved: 0x0
+MACHO64-NEXT: }
+
+MACHO-PPC:      File: {{(.*[/\\])?}}trivial.obj.macho-ppc
+MACHO-PPC-NEXT: Format: Mach-O 32-bit ppc
+MACHO-PPC-NEXT: Arch: powerpc
+MACHO-PPC-NEXT: AddressSize: 32bit
+MACHO-PPC-NEXT: MachHeader {
+MACHO-PPC-NEXT:   Magic: Magic (0xFEEDFACE)
+MACHO-PPC-NEXT:   CpuType: PowerPC (0x12)
+MACHO-PPC-NEXT:   CpuSubType: CPU_SUBTYPE_POWERPC_ALL (0x0)
+MACHO-PPC-NEXT:   FileType: Relocatable (0x1)
+MACHO-PPC-NEXT:   NumOfLoadCommands: 3
+MACHO-PPC-NEXT:   SizeOfLoadCommands: 500
+MACHO-PPC-NEXT:   Flags [ (0x2000)
+MACHO-PPC-NEXT:     MH_SUBSECTIONS_VIA_SYMBOLS (0x2000)
+MACHO-PPC-NEXT:   ]
+MACHO-PPC-NEXT: }
+
+MACHO-PPC64:      File: {{(.*[/\\])?}}trivial.obj.macho-ppc64
+MACHO-PPC64-NEXT: Format: Mach-O 64-bit ppc64
+MACHO-PPC64-NEXT: Arch: powerpc64
+MACHO-PPC64-NEXT: AddressSize: 64bit
+MACHO-PPC64-NEXT: MachHeader {
+MACHO-PPC64-NEXT:   Magic: Magic64 (0xFEEDFACF)
+MACHO-PPC64-NEXT:   CpuType: PowerPC64 (0x1000012)
+MACHO-PPC64-NEXT:   CpuSubtype: 0x0
+MACHO-PPC64-NEXT:   FileType: Relocatable (0x1)
+MACHO-PPC64-NEXT:   NumOfLoadCommands: 3
+MACHO-PPC64-NEXT:   SizeOfLoadCommands: 576
+MACHO-PPC64-NEXT:   Flags [ (0x2000)
+MACHO-PPC64-NEXT:     MH_SUBSECTIONS_VIA_SYMBOLS (0x2000)
+MACHO-PPC64-NEXT:   ]
+MACHO-PPC64-NEXT:   Reserved: 0x0
+MACHO-PPC64-NEXT: }
+
+MACHO-ARM:      File: {{(.*[/\\])?}}trivial.obj.macho-arm
+MACHO-ARM-NEXT: Format: Mach-O arm
+MACHO-ARM-NEXT: Arch: arm
+MACHO-ARM-NEXT: AddressSize: 32bit
+MACHO-ARM-NEXT: MachHeader {
+MACHO-ARM-NEXT:   Magic: Magic (0xFEEDFACE)
+MACHO-ARM-NEXT:   CpuType: Arm (0xC)
+MACHO-ARM-NEXT:   CpuSubType: CPU_SUBTYPE_ARM_V7 (0x9)
+MACHO-ARM-NEXT:   FileType: Relocatable (0x1)
+MACHO-ARM-NEXT:   NumOfLoadCommands: 3
+MACHO-ARM-NEXT:   SizeOfLoadCommands: 636
+MACHO-ARM-NEXT:   Flags [ (0x2000)
+MACHO-ARM-NEXT:     MH_SUBSECTIONS_VIA_SYMBOLS (0x2000)
+MACHO-ARM-NEXT:   ]
+MACHO-ARM-NEXT: }
+
 PE32:      File: {{(.*[/\\])?}}trivial.exe.coff-i386
 PE32-NEXT: Format: COFF-i386
 PE32-NEXT: Arch: i386
 PE32-NEXT: AddressSize: 32bit
 PE32-NEXT: ImageFileHeader {
 PE32-NEXT:   Machine: IMAGE_FILE_MACHINE_I386 (0x14C)
 PE32-NEXT:   SectionCount: 3
 PE32-NEXT:   TimeDateStamp: 2013-07-16 00:39:15 (0x51E49633)

llvm/trunk/tools/llvm-readobj/MachODumper.cpp

public:
   void printFileHeaders() override;
   void printSections() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
 
 private:
+  template<class MachHeader>
+  void printFileHeaders(const MachHeader &Header);
+
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
 
   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
 
   void printSections(const MachOObjectFile *Obj);
 
if (!MachOObj)
     return readobj_error::unsupported_obj_file_format;
 
   Result.reset(new MachODumper(MachOObj, Writer));
   return readobj_error::success;
 }
 
 } // namespace llvm
 
+static 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   },
+};
+
+static 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 },
+};
+
+static 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 },
+};
+
+static 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),
+};
+
+static 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),
+};
+
+static 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),
+};
+
+static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM64[] = {
+  LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_ALL),
+};
+
+static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesSPARC[] = {
+  LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_SPARC_ALL),
+};
+
+static 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),
+};
+
+static 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),
+};
 
 static const EnumEntry<unsigned> MachOSectionTypes[] = {
   { "Regular"                        , 0x00 },
   { "ZeroFill"                       , 0x01 },
   { "CStringLiterals"                , 0x02 },
   { "4ByteLiterals"                  , 0x03 },
   { "8ByteLiterals"                  , 0x04 },
   { "LiteralPointers"                , 0x05 },
static void getSymbol(const MachOObjectFile *Obj,
   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;
 }
 
 void MachODumper::printFileHeaders() {
-  W.startLine() << "FileHeaders not implemented.\n";
+  DictScope H(W, "MachHeader");
+  if (!Obj->is64Bit()) {
+    printFileHeaders(Obj->getHeader());
+  } else {
+    printFileHeaders(Obj->getHeader64());
+    W.printHex("Reserved", Obj->getHeader64().reserved);
+  }
+}
+
+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));
+    break;
+  case MachO::CPU_TYPE_ARM64:
+    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);
+  W.printFlags("Flags", Header.flags, makeArrayRef(MachOHeaderFlags));
 }
 
 void MachODumper::printSections() {
   return printSections(Obj);
 }
 
 void MachODumper::printSections(const MachOObjectFile *Obj) {
   ListScope Group(W, "Sections");