[llvm-objdump] -p: Dump PE header for PE/COFF

[MaskRay]

Summary

For a trivial DLL built with clang --target=x86_64-windows -O2 -c a.c; lld-link -subsystem:console -dll a.o -out:a.dll,
objdump -p vs llvm-objdump -p:

-a.dll:     file format pei-x86-64
-
+a.dll: file format coff-x86-64
 Characteristics 0x2022
        executable
        large address aware
@@ -57,4 +56,4 @@
 Entry d 0000000000000000 00000000 Delay Import Directory
 Entry e 0000000000000000 00000000 CLR Runtime Header
 Entry f 0000000000000000 00000000 Reserved
-
+Export Table:

For a Linux image (vmlinuz-5.10.76-gentoo-r1) built with CONFIG_EFI_STUB=y
(https://www.kernel.org/doc/html/latest/admin-guide/efi-stub.html):

-vmlinuz-5.10.76-gentoo-r1:     file format pei-x86-64
-
-Characteristics 0x20e
+vmlinuz-5.10.76-gentoo-r1:     file format coff-x86-64
+Characteristics 0x206
        executable
        line numbers stripped
-       symbols stripped
        debugging information removed

 Time/Date              Wed Dec 31 16:00:00 1969
@@ -55,10 +53,4 @@
 Entry d 0000000000000000 00000000 Delay Import Directory
 Entry e 0000000000000000 00000000 CLR Runtime Header
 Entry f 0000000000000000 00000000 Reserved
-
-
-PE File Base Relocations (interpreted .reloc section contents)
-
-Virtual Address: 000037ca Chunk size 10 (0xa) Number of fixups 1
-       reloc    0 offset    0 [37ca] ABSOLUTE
-
+Export Table:

symbols stripped looks like a GNU objdump problem.

[alexander-shaposhnikov]

llvm/tools/llvm-objdump/COFFDump.cpp

42

explicit
maybe pass const ref ? (e.g. nullptr is not a valid value for the argument)

51

where is this method used ?

63

this method does not appear to use Obj or Is64, make it static ?

81

static constexpr ?

166

constexpr ?

185

maybe 16 can be replaced with a named constant or some expression ?

[MaskRay]

thanks for the review comments. applied

llvm/tools/llvm-objdump/COFFDump.cpp

42

OK, I switched printCOFFFileHeader as well.

81

constexpr suffices.

A non-template variable of non-volatile const-qualified type having namespace-scope has internal linkage ([basic.link]), so no need for static.

166

constexpr applies to the object declaration (DirName is a constexpr) which has a different meaning: the element type will be char* which will lead to -Wwrite-strings.

static constexpr const char *DirName[16] works but it is just unnecessarily verbose.

[alexander-shaposhnikov]

llvm/tools/llvm-objdump/COFFDump.cpp

166

Yeah, I meant the latter, perhaps, it doesn't matter much here.

[jhenderson]

llvm/test/tools/llvm-objdump/COFF/private-headers.yaml

70

Here and the other zero-valued fields, it might be advisable to use a non-zero value, to avoid any instances of variables not actually being assigned values properly (e.g. they were assigned to the wrong value/the wrong variable was assigned this variable's value etc).

llvm/tools/llvm-objdump/COFFDump.cpp

42

Looks like explicit is still needed?

[MaskRay]

improve tests

[MaskRay]

llvm/test/tools/llvm-objdump/COFF/private-headers.yaml

70

I copied the fields from an existing test. Updated.

[mstorsjo]

Nothing to add from me here, the patch looks fine to me (when others are ok with it).

[jhenderson]

LGTM, although best wait for @alexander-shaposhnikov

Thank you for your input! It has been quite beneficial to me!
redactle unlimited

llvm/test/tools/llvm-objdump/COFF/private-headers.yaml

+# RUN: yaml2obj --docnum=1 %s -o %t
+# RUN: llvm-objdump -p %t | FileCheck %s --check-prefix=PE32PLUS --strict-whitespace --match-full-lines
+
+#      PE32PLUS:{{.*}}file format coff-arm64
+# PE32PLUS-NEXT:Characteristics 0x22
+# PE32PLUS-NEXT:  executable
+# PE32PLUS-NEXT:  large address aware
+#PE32PLUS-EMPTY:
+# PE32PLUS-NEXT:Time/Date               {{.*}} 19{{69|70}}
+# PE32PLUS-NEXT:Magic                   020b  (PE32+)
+# PE32PLUS-NEXT:MajorLinkerVersion      0
+# PE32PLUS-NEXT:MinorLinkerVersion      0
+# PE32PLUS-NEXT:SizeOfCode              0000000000000200
+# PE32PLUS-NEXT:SizeOfInitializedData   0000000000000400
+# PE32PLUS-NEXT:SizeOfUninitializedData 0000000000000000
+# PE32PLUS-NEXT:AddressOfEntryPoint     0000000000001000
+# PE32PLUS-NEXT:BaseOfCode              0000000000001000
+# PE32PLUS-NEXT:ImageBase               0000000140000000
+# PE32PLUS-NEXT:SectionAlignment        00001000
+# PE32PLUS-NEXT:FileAlignment           00000200
+# PE32PLUS-NEXT:MajorOSystemVersion     6
+# PE32PLUS-NEXT:MinorOSystemVersion     1
+# PE32PLUS-NEXT:MajorImageVersion       7
+# PE32PLUS-NEXT:MinorImageVersion       2
+# PE32PLUS-NEXT:MajorSubsystemVersion   8
+# PE32PLUS-NEXT:MinorSubsystemVersion   3
+# PE32PLUS-NEXT:Win32Version            00000000
+# PE32PLUS-NEXT:SizeOfImage             00004000
+# PE32PLUS-NEXT:SizeOfHeaders           00000200
+# PE32PLUS-NEXT:CheckSum                00000000
+# PE32PLUS-NEXT:Subsystem               00000003  (Windows CUI)
+# PE32PLUS-NEXT:DllCharacteristics      00008160
+# PE32PLUS-NEXT:          HIGH_ENTROPY_VA
+# PE32PLUS-NEXT:          DYNAMIC_BASE
+# PE32PLUS-NEXT:          NX_COMPAT
+# PE32PLUS-NEXT:          TERMINAL_SERVER_AWARE
+# PE32PLUS-NEXT:SizeOfStackReserve      0000000000100000
+# PE32PLUS-NEXT:SizeOfStackCommit       0000000000001000
+# PE32PLUS-NEXT:SizeOfHeapReserve       0000000000100000
+# PE32PLUS-NEXT:SizeOfHeapCommit        0000000000001000
+# PE32PLUS-NEXT:LoaderFlags             00000000
+# PE32PLUS-NEXT:NumberOfRvaAndSizes     00000010
+#PE32PLUS-EMPTY:
+# PE32PLUS-NEXT:The Data Directory
+# PE32PLUS-NEXT:Entry 0 0000000000000000 00000000 Export Directory [.edata (or where ever we found it)]
+# PE32PLUS-NEXT:Entry 1 0000000000000000 00000000 Import Directory [parts of .idata]
+# PE32PLUS-NEXT:Entry 2 0000000000000000 00000000 Resource Directory [.rsrc]
+# PE32PLUS-NEXT:Entry 3 0000000000003000 00000008 Exception Directory [.pdata]
+# PE32PLUS-NEXT:Entry 4 0000000000000000 00000000 Security Directory
+# PE32PLUS-NEXT:Entry 5 0000000000000000 00000000 Base Relocation Directory [.reloc]
+# PE32PLUS-NEXT:Entry 6 0000000000000000 00000000 Debug Directory
+# PE32PLUS-NEXT:Entry 7 0000000000000000 00000000 Description Directory
+# PE32PLUS-NEXT:Entry 8 0000000000000000 00000000 Special Directory
+# PE32PLUS-NEXT:Entry 9 0000000000000000 00000000 Thread Storage Directory [.tls]
+# PE32PLUS-NEXT:Entry a 0000000000000000 00000000 Load Configuration Directory
+# PE32PLUS-NEXT:Entry b 0000000000000000 00000000 Bound Import Directory
+# PE32PLUS-NEXT:Entry c 0000000000000000 00000000 Import Address Table Directory
+# PE32PLUS-NEXT:Entry d 0000000000000000 00000000 Delay Import Directory
+# PE32PLUS-NEXT:Entry e 0000000000000000 00000000 CLR Runtime Header
+# PE32PLUS-NEXT:Entry f 0000000000000000 00000000 Reserved
+
+--- !COFF
+OptionalHeader:
+  AddressOfEntryPoint: 4096
+  ImageBase:           0x140000000
+  SectionAlignment:    4096
+  FileAlignment:       512
+  MajorOperatingSystemVersion: 6
+  MinorOperatingSystemVersion: 1
+  MajorImageVersion:   7
+  MinorImageVersion:   2
+  MajorSubsystemVersion: 8
+  MinorSubsystemVersion: 3
+  Subsystem:       IMAGE_SUBSYSTEM_WINDOWS_CUI
+  DLLCharacteristics: [ IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE ]
+  SizeOfStackReserve:  1048576
+  SizeOfStackCommit:   4096
+  SizeOfHeapReserve:   1048576
+  SizeOfHeapCommit:    4096
+  ExceptionTable:
+    RelativeVirtualAddress: 12288
+    Size:            8
+header:
+  Machine:         IMAGE_FILE_MACHINE_ARM64
+  Characteristics: [ IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LARGE_ADDRESS_AWARE ]
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  4096
+    VirtualSize:     4
+    SectionData:     C0035FD6
+  - Name:            .rdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  8192
+    VirtualSize:     12
+    SectionData:     0100400800000000E4E3E3E3
+  - Name:            .pdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  12288
+    VirtualSize:     8
+    SectionData:     '0010000000200000'
+symbols:         []
+...
+
+## Test 32-bit object with full Characteristics and DllCharacteristics.
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-objdump -p %t2 | FileCheck %s --check-prefix=PE32 --match-full-lines
+#      PE32:{{.*}}file format coff-i386
+#      PE32:Characteristics 0xffbf
+# PE32-NEXT:        relocations stripped
+# PE32-NEXT:        executable
+# PE32-NEXT:        line numbers stripped
+# PE32-NEXT:        symbols stripped
+# PE32-NEXT:        large address aware
+# PE32-NEXT:        little endian
+# PE32-NEXT:        32 bit words
+# PE32-NEXT:        debugging information removed
+# PE32-NEXT:        copy to swap file if on removable media
+# PE32-NEXT:        copy to swap file if on network media
+# PE32-NEXT:        system file
+# PE32-NEXT:        DLL
+# PE32-NEXT:        run only on uniprocessor machine
+# PE32-NEXT:        big endian
+#PE32-EMPTY:
+#      PE32:Time/Date               {{.*}}
+# PE32-NEXT:Magic                   010b  (PE32)
+# PE32-NEXT:MajorLinkerVersion      0
+# PE32-NEXT:MinorLinkerVersion      0
+# PE32-NEXT:SizeOfCode              00000004
+# PE32-NEXT:SizeOfInitializedData   00000000
+# PE32-NEXT:SizeOfUninitializedData 00000000
+# PE32-NEXT:AddressOfEntryPoint     00000000
+# PE32-NEXT:BaseOfCode              00001000
+# PE32-NEXT:BaseOfData              00000000
+# PE32-NEXT:ImageBase               00000000
+# PE32-NEXT:SectionAlignment        00000001
+# PE32-NEXT:FileAlignment           00000001
+# PE32-NEXT:MajorOSystemVersion     0
+# PE32-NEXT:MinorOSystemVersion     0
+# PE32-NEXT:MajorImageVersion       0
+# PE32-NEXT:MinorImageVersion       0
+# PE32-NEXT:MajorSubsystemVersion   0
+# PE32-NEXT:MinorSubsystemVersion   0
+# PE32-NEXT:Win32Version            00000000
+# PE32-NEXT:SizeOfImage             000001a4
+# PE32-NEXT:SizeOfHeaders           000001a0
+# PE32-NEXT:CheckSum                00000000
+# PE32-NEXT:Subsystem               0000000a  (EFI application)
+# PE32-NEXT:DllCharacteristics      0000ffe0
+# PE32-NEXT:          HIGH_ENTROPY_VA
+# PE32-NEXT:          DYNAMIC_BASE
+# PE32-NEXT:          FORCE_INTEGRITY
+# PE32-NEXT:          NX_COMPAT
+# PE32-NEXT:          NO_ISOLATION
+# PE32-NEXT:          NO_SEH
+# PE32-NEXT:          NO_BIND
+# PE32-NEXT:          APPCONTAINER
+# PE32-NEXT:          WDM_DRIVER
+# PE32-NEXT:          GUARD_CF
+# PE32-NEXT:          TERMINAL_SERVER_AWARE
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_I386
+  Characteristics: [ IMAGE_FILE_RELOCS_STRIPPED, IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LINE_NUMS_STRIPPED,
+                     IMAGE_FILE_LOCAL_SYMS_STRIPPED, IMAGE_FILE_AGGRESSIVE_WS_TRIM, IMAGE_FILE_LARGE_ADDRESS_AWARE,
+                     IMAGE_FILE_BYTES_REVERSED_LO, IMAGE_FILE_32BIT_MACHINE, IMAGE_FILE_DEBUG_STRIPPED,
+                     IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP, IMAGE_FILE_NET_RUN_FROM_SWAP, IMAGE_FILE_SYSTEM,
+                     IMAGE_FILE_DLL, IMAGE_FILE_UP_SYSTEM_ONLY, IMAGE_FILE_BYTES_REVERSED_HI ]
+OptionalHeader:
+  Subsystem:          IMAGE_SUBSYSTEM_EFI_APPLICATION
+  DLLCharacteristics: [ IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE,
+                        IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT,
+                        IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION, IMAGE_DLL_CHARACTERISTICS_NO_SEH,
+                        IMAGE_DLL_CHARACTERISTICS_NO_BIND, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER,
+                        IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER, IMAGE_DLL_CHARACTERISTICS_GUARD_CF,
+                        IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE ]
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  4096
+    VirtualSize:     4
+    SectionData:     C0035FD6
+symbols:

llvm/tools/llvm-objdump/COFFDump.h

 } // namespace object
 
 namespace objdump {
 Error getCOFFRelocationValueString(const object::COFFObjectFile *Obj,
                                    const object::RelocationRef &Rel,
                                    llvm::SmallVectorImpl<char> &Result);
 
 void printCOFFUnwindInfo(const object::COFFObjectFile *O);
-void printCOFFFileHeader(const object::ObjectFile *O);
+void printCOFFFileHeader(const object::COFFObjectFile &Obj);
 void printCOFFSymbolTable(const object::COFFImportFile *I);
 void printCOFFSymbolTable(const object::COFFObjectFile *O);
 } // namespace objdump
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objdump/COFFDump.cpp

 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::objdump;
 using namespace llvm::object;
 using namespace llvm::Win64EH;
 
+namespace {
+template <typename T> struct EnumEntry {
+  T Value;
+  StringRef Name;
+};
+
+class COFFDumper {
+public:
+  explicit COFFDumper(const llvm::object::COFFObjectFile &Obj) : Obj(Obj) {
+    Is64 = !Obj.getPE32Header();
+  }
+
+  template <class PEHeader> void printPEHeader(const PEHeader &Hdr) const;
+
+private:
+  template <typename T> FormattedNumber formatAddr(T V) const {
+    return format_hex_no_prefix(V, Is64 ? 16 : 8);
+  };
+
+  uint32_t getBaseOfData(const void *Hdr) const {
+    return Is64 ? 0 : static_cast<const pe32_header *>(Hdr)->BaseOfData;
+  }
+
+  const llvm::object::COFFObjectFile &Obj;
+  bool Is64;
+};
+} // namespace
+
+constexpr EnumEntry<uint16_t> PEHeaderMagic[] = {
+    {uint16_t(COFF::PE32Header::PE32), "PE32"},
+    {uint16_t(COFF::PE32Header::PE32_PLUS), "PE32+"},
+};
+
+constexpr EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
+    {COFF::IMAGE_SUBSYSTEM_UNKNOWN, "unspecified"},
+    {COFF::IMAGE_SUBSYSTEM_NATIVE, "NT native"},
+    {COFF::IMAGE_SUBSYSTEM_WINDOWS_GUI, "Windows GUI"},
+    {COFF::IMAGE_SUBSYSTEM_WINDOWS_CUI, "Windows CUI"},
+    {COFF::IMAGE_SUBSYSTEM_POSIX_CUI, "POSIX CUI"},
+    {COFF::IMAGE_SUBSYSTEM_WINDOWS_CE_GUI, "Wince CUI"},
+    {COFF::IMAGE_SUBSYSTEM_EFI_APPLICATION, "EFI application"},
+    {COFF::IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER, "EFI boot service driver"},
+    {COFF::IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER, "EFI runtime driver"},
+    {COFF::IMAGE_SUBSYSTEM_EFI_ROM, "SAL runtime driver"},
+    {COFF::IMAGE_SUBSYSTEM_XBOX, "XBOX"},
+};
+
+template <typename T, typename TEnum>
+static void printOptionalEnumName(T Value,
+                                  ArrayRef<EnumEntry<TEnum>> EnumValues) {
+  for (const EnumEntry<TEnum> &I : EnumValues)
+    if (I.Value == Value) {
+      outs() << "\t(" << I.Name << ')';
+      return;
+    }
+}
+
+template <class PEHeader>
+void COFFDumper::printPEHeader(const PEHeader &Hdr) const {
+  auto print = [](const char *K, auto V, const char *Fmt = "%d\n") {
+    outs() << format("%-23s ", K) << format(Fmt, V);
+  };
+  auto printU16 = [&](const char *K, support::ulittle16_t V,
+                      const char *Fmt = "%d\n") { print(K, uint16_t(V), Fmt); };
+  auto printU32 = [&](const char *K, support::ulittle32_t V,
+                      const char *Fmt = "%d\n") { print(K, uint32_t(V), Fmt); };
+  auto printAddr = [=](const char *K, uint64_t V) {
+    outs() << format("%-23s ", K) << formatAddr(V) << '\n';
+  };
+
+  printU16("Magic", Hdr.Magic, "%04x");
+  printOptionalEnumName(Hdr.Magic, makeArrayRef(PEHeaderMagic));
+  outs() << '\n';
+  print("MajorLinkerVersion", Hdr.MajorLinkerVersion);
+  print("MinorLinkerVersion", Hdr.MinorLinkerVersion);
+  printAddr("SizeOfCode", Hdr.SizeOfCode);
+  printAddr("SizeOfInitializedData", Hdr.SizeOfInitializedData);
+  printAddr("SizeOfUninitializedData", Hdr.SizeOfUninitializedData);
+  printAddr("AddressOfEntryPoint", Hdr.AddressOfEntryPoint);
+  printAddr("BaseOfCode", Hdr.BaseOfCode);
+  if (!Is64)
+    printAddr("BaseOfData", getBaseOfData(&Hdr));
+  printAddr("ImageBase", Hdr.ImageBase);
+  printU32("SectionAlignment", Hdr.SectionAlignment, "%08x\n");
+  printU32("FileAlignment", Hdr.FileAlignment, "%08x\n");
+  printU16("MajorOSystemVersion", Hdr.MajorOperatingSystemVersion);
+  printU16("MinorOSystemVersion", Hdr.MinorOperatingSystemVersion);
+  printU16("MajorImageVersion", Hdr.MajorImageVersion);
+  printU16("MinorImageVersion", Hdr.MinorImageVersion);
+  printU16("MajorSubsystemVersion", Hdr.MajorSubsystemVersion);
+  printU16("MinorSubsystemVersion", Hdr.MinorSubsystemVersion);
+  printU32("Win32Version", Hdr.Win32VersionValue, "%08x\n");
+  printU32("SizeOfImage", Hdr.SizeOfImage, "%08x\n");
+  printU32("SizeOfHeaders", Hdr.SizeOfHeaders, "%08x\n");
+  printU32("CheckSum", Hdr.CheckSum, "%08x\n");
+  printU16("Subsystem", Hdr.Subsystem, "%08x");
+  printOptionalEnumName(Hdr.Subsystem, makeArrayRef(PEWindowsSubsystem));
+  outs() << '\n';
+
+  printU16("DllCharacteristics", Hdr.DLLCharacteristics, "%08x\n");
+#define FLAG(Name)                                                             \
+  if (Hdr.DLLCharacteristics & COFF::IMAGE_DLL_CHARACTERISTICS_##Name)         \
+    outs() << "\t\t\t\t\t" << #Name << '\n';
+  FLAG(HIGH_ENTROPY_VA);
+  FLAG(DYNAMIC_BASE);
+  FLAG(FORCE_INTEGRITY);
+  FLAG(NX_COMPAT);
+  FLAG(NO_ISOLATION);
+  FLAG(NO_SEH);
+  FLAG(NO_BIND);
+  FLAG(APPCONTAINER);
+  FLAG(WDM_DRIVER);
+  FLAG(GUARD_CF);
+  FLAG(TERMINAL_SERVER_AWARE);
+#undef FLAG
+
+  printAddr("SizeOfStackReserve", Hdr.SizeOfStackReserve);
+  printAddr("SizeOfStackCommit", Hdr.SizeOfStackCommit);
+  printAddr("SizeOfHeapReserve", Hdr.SizeOfHeapReserve);
+  printAddr("SizeOfHeapCommit", Hdr.SizeOfHeapCommit);
+  printU32("LoaderFlags", Hdr.LoaderFlags, "%08x\n");
+  printU32("NumberOfRvaAndSizes", Hdr.NumberOfRvaAndSize, "%08x\n");
+
+  static const char *DirName[COFF::NUM_DATA_DIRECTORIES + 1] = {
+      "Export Directory [.edata (or where ever we found it)]",
+      "Import Directory [parts of .idata]",
+      "Resource Directory [.rsrc]",
+      "Exception Directory [.pdata]",
+      "Security Directory",
+      "Base Relocation Directory [.reloc]",
+      "Debug Directory",
+      "Description Directory",
+      "Special Directory",
+      "Thread Storage Directory [.tls]",
+      "Load Configuration Directory",
+      "Bound Import Directory",
+      "Import Address Table Directory",
+      "Delay Import Directory",
+      "CLR Runtime Header",
+      "Reserved",
+  };
+  outs() << "\nThe Data Directory\n";
+  for (uint32_t I = 0; I != array_lengthof(DirName); ++I) {
+    uint32_t Addr = 0, Size = 0;
+    if (const data_directory *Data = Obj.getDataDirectory(I)) {
+      Addr = Data->RelativeVirtualAddress;
+      Size = Data->Size;
+    }
+    outs() << format("Entry %x ", I) << formatAddr(Addr)
+           << format(" %08x %s\n", uint32_t(Size), DirName[I]);
+  }
+}
+
 // 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 "UOP_PushNonVol";
   case UOP_AllocLarge: return "UOP_AllocLarge";
   case UOP_AllocSmall: return "UOP_AllocSmall";
   case UOP_SetFPReg: return "UOP_SetFPReg";
void objdump::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
 
   for (const RuntimeFunction &RF : RFs) {
     uint64_t SectionOffset =
         std::distance(RFs.begin(), &RF) * sizeof(RuntimeFunction);
     printRuntimeFunctionRels(Obj, RF, SectionOffset, Rels);
   }
 }
 
-void objdump::printCOFFFileHeader(const object::ObjectFile *Obj) {
-  const COFFObjectFile *file = dyn_cast<const COFFObjectFile>(Obj);
-  printTLSDirectory(file);
-  printLoadConfiguration(file);
-  printImportTables(file);
-  printExportTable(file);
+void objdump::printCOFFFileHeader(const COFFObjectFile &Obj) {
+  COFFDumper CD(Obj);
+  const uint16_t Cha = Obj.getCharacteristics();
+  outs() << "Characteristics 0x" << Twine::utohexstr(Cha) << '\n';
+#define FLAG(F, Name)                                                          \
+  if (Cha & F)                                                                 \
+    outs() << '\t' << Name << '\n';
+  FLAG(COFF::IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
+  FLAG(COFF::IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
+  FLAG(COFF::IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
+  FLAG(COFF::IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
+  FLAG(COFF::IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
+  FLAG(COFF::IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
+  FLAG(COFF::IMAGE_FILE_32BIT_MACHINE, "32 bit words");
+  FLAG(COFF::IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
+  FLAG(COFF::IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP,
+       "copy to swap file if on removable media");
+  FLAG(COFF::IMAGE_FILE_NET_RUN_FROM_SWAP,
+       "copy to swap file if on network media");
+  FLAG(COFF::IMAGE_FILE_SYSTEM, "system file");
+  FLAG(COFF::IMAGE_FILE_DLL, "DLL");
+  FLAG(COFF::IMAGE_FILE_UP_SYSTEM_ONLY, "run only on uniprocessor machine");
+  FLAG(COFF::IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
+#undef FLAG
+
+  // TODO Support PE_IMAGE_DEBUG_TYPE_REPRO.
+  // Since ctime(3) returns a 26 character string of the form:
+  // "Sun Sep 16 01:03:52 1973\n\0"
+  // just print 24 characters.
+  const time_t Timestamp = Obj.getTimeDateStamp();
+  outs() << format("\nTime/Date               %.24s\n", ctime(&Timestamp));
+
+  if (const pe32_header *Hdr = Obj.getPE32Header())
+    CD.printPEHeader<pe32_header>(*Hdr);
+  else if (const pe32plus_header *Hdr = Obj.getPE32PlusHeader())
+    CD.printPEHeader<pe32plus_header>(*Hdr);
+
+  printTLSDirectory(&Obj);
+  printLoadConfiguration(&Obj);
+  printImportTables(&Obj);
+  printExportTable(&Obj);
 }
 
 void objdump::printCOFFSymbolTable(const object::COFFImportFile *i) {
   unsigned Index = 0;
   bool IsCode = i->getCOFFImportHeader()->getType() == COFF::IMPORT_CODE;
 
   for (const object::BasicSymbolRef &Sym : i->symbols()) {
     std::string Name;

llvm/tools/llvm-objdump/llvm-objdump.cpp

 static void printPrivateFileHeaders(const ObjectFile *O, bool OnlyFirst) {
   if (O->isELF()) {
     printELFFileHeader(O);
     printELFDynamicSection(O);
     printELFSymbolVersionInfo(O);
     return;
   }
   if (O->isCOFF())
-    return printCOFFFileHeader(O);
+    return printCOFFFileHeader(cast<object::COFFObjectFile>(*O));
   if (O->isWasm())
     return printWasmFileHeader(O);
   if (O->isMachO()) {
     printMachOFileHeader(O);
     if (!OnlyFirst)
       printMachOLoadCommands(O);
     return;
   }