[llvm-readobj][COFF] Print load config GuardFlags as enum flags

[alvinhochun]

Summary

Print flags as documented in MS docs.
https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#load-configuration-layout
https://docs.microsoft.com/en-us/windows/win32/secbp/pe-metadata

EH_CONTINUATION_TABLE_PRESENT is not mentioned in the docs but is
instead taken from Windows SDK headers.

[alvinhochun]

Add reference link

[alvinhochun]

Fix tests

[rnk]

Thanks!

llvm/tools/llvm-readobj/COFFDumper.cpp

855

Please replace the existing coff_guard_flags enum with the new enum that you just added. It only has 7 hits across the codebase, but some are in LLD. That can also be a follow up CL, if you prefer, but I don't want to carry both duplicate enums long term.

[alvinhochun]

llvm/tools/llvm-readobj/COFFDumper.cpp

855

Sure, I've made D132924.

[rnk]

Looks good, thanks

llvm/tools/llvm-readobj/COFFDumper.cpp

855

Thanks!

lld/test/COFF/gfids-corrupt.s

 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [
 # CHECK:   SEHandlerTable: 0x0
 # CHECK:   SEHandlerCount: 0
 # CHECK:   GuardCFCheckFunction: 0x0
 # CHECK:   GuardCFCheckDispatch: 0x0
 # CHECK:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK:   GuardCFFunctionCount: 2
-# CHECK:   GuardFlags: 0x500
+# CHECK:   GuardFlags [ (0x500)
+# CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK:     CF_INSTRUMENTED (0x100)
+# CHECK:   ]
 # CHECK:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK:   GuardAddressTakenIatEntryCount: 0
 # CHECK:   GuardLongJumpTargetTable: 0x0
 # CHECK:   GuardLongJumpTargetCount: 0
 # CHECK: ]
 # CHECK:      GuardFidTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT:   0x14000{{.*}}

lld/test/COFF/gfids-fallback.s

 # REQUIRES: x86
 # RUN: grep -B99999 [S]PLITMARKER %s | llvm-mc -triple x86_64-windows-msvc -filetype=obj -o %t1.obj
 # RUN: grep -A99999 [S]PLITMARKER %s | llvm-mc -triple x86_64-windows-msvc -filetype=obj -o %t2.obj
 # RUN: lld-link %t1.obj %t2.obj -guard:cf -out:%t.exe -entry:main -opt:noref
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s
 
 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [
 # CHECK:   SEHandlerTable: 0x0
 # CHECK:   SEHandlerCount: 0
 # CHECK:   GuardCFCheckFunction: 0x0
 # CHECK:   GuardCFCheckDispatch: 0x0
 # CHECK:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK:   GuardCFFunctionCount: 3
-# CHECK:   GuardFlags: 0x500
+# CHECK:   GuardFlags [ (0x500)
+# CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK:     CF_INSTRUMENTED (0x100)
+# CHECK:   ]
 # CHECK:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK:   GuardAddressTakenIatEntryCount: 0
 # CHECK:   GuardLongJumpTargetTable: 0x0
 # CHECK:   GuardLongJumpTargetCount: 0
 # CHECK: ]
 # CHECK:      GuardFidTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT:   0x14000{{.*}}

lld/test/COFF/gfids-gc.s

 # CHECK-NOGC: ImageBase: 0x140000000
 # CHECK-NOGC: LoadConfig [
 # CHECK-NOGC:   SEHandlerTable: 0x0
 # CHECK-NOGC:   SEHandlerCount: 0
 # CHECK-NOGC:   GuardCFCheckFunction: 0x0
 # CHECK-NOGC:   GuardCFCheckDispatch: 0x0
 # CHECK-NOGC:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK-NOGC:   GuardCFFunctionCount: 3
-# CHECK-NOGC:   GuardFlags: 0x500
+# CHECK-NOGC:   GuardFlags [ (0x500)
+# CHECK-NOGC:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK-NOGC:     CF_INSTRUMENTED (0x100)
+# CHECK-NOGC:   ]
 # CHECK-NOGC:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK-NOGC:   GuardAddressTakenIatEntryCount: 0
 # CHECK-NOGC:   GuardLongJumpTargetTable: 0x0
 # CHECK-NOGC:   GuardLongJumpTargetCount: 0
 # CHECK-NOGC: ]
 # CHECK-NOGC:      GuardFidTable [
 # CHECK-NOGC-NEXT:   0x14000{{.*}}
 # CHECK-NOGC-NEXT:   0x14000{{.*}}
 # CHECK-NOGC-NEXT:   0x14000{{.*}}
 # CHECK-NOGC-NEXT: ]
 
 # Expect 2 entries: main and f. fp2 was discarded, so g was only used as a
 # direct call target.
 
 # CHECK-GC: ImageBase: 0x140000000
 # CHECK-GC: LoadConfig [
 # CHECK-GC:   SEHandlerTable: 0x0
 # CHECK-GC:   SEHandlerCount: 0
 # CHECK-GC:   GuardCFCheckFunction: 0x0
 # CHECK-GC:   GuardCFCheckDispatch: 0x0
 # CHECK-GC:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK-GC:   GuardCFFunctionCount: 2
-# CHECK-GC:   GuardFlags: 0x500
+# CHECK-GC:   GuardFlags [ (0x500)
+# CHECK-GC:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK-GC:     CF_INSTRUMENTED (0x100)
+# CHECK-GC:   ]
 # CHECK-GC:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK-GC:   GuardAddressTakenIatEntryCount: 0
 # CHECK-GC:   GuardLongJumpTargetTable: 0x0
 # CHECK-GC:   GuardLongJumpTargetCount: 0
 # CHECK-GC: ]
 # CHECK-GC:      GuardFidTable [
 # CHECK-GC-NEXT:   0x14000{{.*}}
 # CHECK-GC-NEXT:   0x14000{{.*}}

lld/test/COFF/gfids-icf.s

 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [
 # CHECK:   SEHandlerTable: 0x0
 # CHECK:   SEHandlerCount: 0
 # CHECK:   GuardCFCheckFunction: 0x0
 # CHECK:   GuardCFCheckDispatch: 0x0
 # CHECK:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK:   GuardCFFunctionCount: 2
-# CHECK:   GuardFlags: 0x500
+# CHECK:   GuardFlags [ (0x500)
+# CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK:     CF_INSTRUMENTED (0x100)
+# CHECK:   ]
 # CHECK:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK:   GuardAddressTakenIatEntryCount: 0
 # CHECK:   GuardLongJumpTargetTable: 0x0
 # CHECK:   GuardLongJumpTargetCount: 0
 # CHECK: ]
 # CHECK:      GuardFidTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT:   0x14000{{.*}}

lld/test/COFF/giats.s

 # Check that the Guard address-taken IAT entry tables are propagated to the final executable.
 # RUN: lld-link %basename_t.obj -guard:cf -guard:longjmp -entry:main -out:%basename_t-nodelay.exe %basename_t-exp.lib
 # RUN: llvm-readobj --file-headers --coff-load-config %basename_t-nodelay.exe | FileCheck %s --check-prefix CHECK
 
 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [
 # CHECK:   GuardCFFunctionTable: 0x140002114
 # CHECK:   GuardCFFunctionCount: 1
-# CHECK:   GuardFlags: 0x10500
+# CHECK:   GuardFlags [ (0x10500)
+# CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK:     CF_INSTRUMENTED (0x100)
+# CHECK:     CF_LONGJUMP_TABLE_PRESENT (0x10000)
+# CHECK:   ]
 # CHECK:   GuardAddressTakenIatEntryTable: 0x140002118
 # CHECK:   GuardAddressTakenIatEntryCount: 1
 # CHECK: ]
 # CHECK:      GuardFidTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT: ]
 # CHECK:      GuardIatTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT: ]
 
 
 # Check that the additional load thunk symbol is added to the GFIDs table.
 # RUN: lld-link %basename_t.obj -guard:cf -guard:longjmp -entry:main -out:%basename_t-delay.exe %basename_t-exp.lib -alternatename:__delayLoadHelper2=main -delayload:%basename_t-exp.dll
 # RUN: llvm-readobj --file-headers --coff-load-config %basename_t-delay.exe | FileCheck %s --check-prefix DELAY-CHECK
 
 # DELAY-CHECK: ImageBase: 0x140000000
 # DELAY-CHECK: LoadConfig [
 # DELAY-CHECK:   GuardCFFunctionTable: 0x140002114
 # DELAY-CHECK:   GuardCFFunctionCount: 2
-# DELAY-CHECK:   GuardFlags: 0x10500
+# DELAY-CHECK:   GuardFlags [ (0x10500)
+# DELAY-CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# DELAY-CHECK:     CF_INSTRUMENTED (0x100)
+# DELAY-CHECK:     CF_LONGJUMP_TABLE_PRESENT (0x10000)
+# DELAY-CHECK:   ]
 # DELAY-CHECK:   GuardAddressTakenIatEntryTable: 0x14000211C
 # DELAY-CHECK:   GuardAddressTakenIatEntryCount: 1
 # DELAY-CHECK: ]
 # DELAY-CHECK:      GuardFidTable [
 # DELAY-CHECK-NEXT:   0x14000{{.*}}
 # DELAY-CHECK-NEXT:   0x14000{{.*}}
 # DELAY-CHECK-NEXT: ]
 # DELAY-CHECK:      GuardIatTable [
_load_config_used:
         .quad __guard_fids_count
         .long __guard_flags
         .fill 12, 1, 0
         .quad __guard_iat_table
         .quad __guard_iat_count
         .quad __guard_longjmp_table
         .quad __guard_fids_count
         .fill 84, 1, 0
 No newline at end of file

lld/test/COFF/guard-ehcont.s

 # REQUIRES: x86
 # RUN: llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o %t.obj
 # RUN: lld-link %t.obj -guard:cf -guard:ehcont -out:%t.exe -entry:main
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s
 
 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [
 # CHECK:   SEHandlerTable: 0x0
 # CHECK:   SEHandlerCount: 0
 # CHECK:   GuardCFCheckFunction: 0x0
 # CHECK:   GuardCFCheckDispatch: 0x0
 # CHECK:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK:   GuardCFFunctionCount: 1
-# CHECK:   GuardFlags: 0x400500
+# CHECK:   GuardFlags [ (0x400500)
+# CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK:     CF_INSTRUMENTED (0x100)
+# CHECK:     EH_CONTINUATION_TABLE_PRESENT (0x400000)
+# CHECK:   ]
 # CHECK:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK:   GuardAddressTakenIatEntryCount: 0
 # CHECK:   GuardEHContinuationTable: 0x14000{{.*}}
 # CHECK:   GuardEHContinuationCount: 1
 # CHECK: ]
 # CHECK:      GuardEHContTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT: ]
_load_config_used:
         .quad __guard_iat_table
         .quad __guard_iat_count
         .quad __guard_longjmp_table
         .quad __guard_longjmp_count
         .fill 72, 1, 0
         .quad __guard_eh_cont_table
         .quad __guard_eh_cont_count
         .fill 32, 1, 0
 No newline at end of file

lld/test/COFF/guard-longjmp.s

 # REQUIRES: x86
 # RUN: llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o %t.obj
 # RUN: lld-link %t.obj -guard:cf -guard:longjmp -out:%t.exe -entry:main
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s
 
 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [
 # CHECK:   SEHandlerTable: 0x0
 # CHECK:   SEHandlerCount: 0
 # CHECK:   GuardCFCheckFunction: 0x0
 # CHECK:   GuardCFCheckDispatch: 0x0
 # CHECK:   GuardCFFunctionTable: 0x14000{{.*}}
 # CHECK:   GuardCFFunctionCount: 1
-# CHECK:   GuardFlags: 0x10500
+# CHECK:   GuardFlags [ (0x10500)
+# CHECK:     CF_FUNCTION_TABLE_PRESENT (0x400)
+# CHECK:     CF_INSTRUMENTED (0x100)
+# CHECK:     CF_LONGJUMP_TABLE_PRESENT (0x10000)
+# CHECK:   ]
 # CHECK:   GuardAddressTakenIatEntryTable: 0x0
 # CHECK:   GuardAddressTakenIatEntryCount: 0
 # CHECK:   GuardLongJumpTargetTable: 0x14000{{.*}}
 # CHECK:   GuardLongJumpTargetCount: 1
 # CHECK: ]
 # CHECK:      GuardLJmpTable [
 # CHECK-NEXT:   0x14000{{.*}}
 # CHECK-NEXT: ]

lld/test/COFF/guardcf-lto.ll

 ; RUN: lld-link -entry:main -guard:cf -guard:longjmp -dll %t.bc %t.lib %t.ldcfg.obj -out:%t2.dll
 ; RUN: llvm-readobj --coff-load-config %t2.dll | FileCheck %s
 
 ; There must be *two* entries in the table: DLL entry point, and my_handler.
 
 ; CHECK:      LoadConfig [
 ; CHECK:        GuardCFFunctionTable: 0x{{[^0].*}}
 ; CHECK-NEXT:   GuardCFFunctionCount: 2
-; CHECK-NEXT:   GuardFlags: 0x10500
+; CHECK-NEXT:   GuardFlags [ (0x10500)
+; CHECK-NEXT:     CF_FUNCTION_TABLE_PRESENT (0x400)
+; CHECK-NEXT:     CF_INSTRUMENTED (0x100)
+; CHECK-NEXT:     CF_LONGJUMP_TABLE_PRESENT (0x10000)
+; CHECK-NEXT:   ]
 ; CHECK:      ]
 ; CHECK:      GuardFidTable [
 ; CHECK-NEXT:   0x180{{.*}}
 ; CHECK-NEXT:   0x180{{.*}}
 ; CHECK-NEXT: ]
 
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.12.25835"

llvm/include/llvm/BinaryFormat/COFF.h

enum ImportNameType : unsigned {
   /// The import name is the public symbol name, but skipping the leading ?,
   /// @, or optionally _.
   IMPORT_NAME_NOPREFIX = 2,
   /// The import name is the public symbol name, but skipping the leading ?,
   /// @, or optionally _, and truncating at the first @.
   IMPORT_NAME_UNDECORATE = 3
 };
 
+enum class GuardFlags : uint32_t {
+  /// Module performs control flow integrity checks using system-supplied
+  /// support.
+  CF_INSTRUMENTED = 0x100,
+  /// Module performs control flow and write integrity checks.
+  CFW_INSTRUMENTED = 0x200,
+  /// Module contains valid control flow target metadata.
+  CF_FUNCTION_TABLE_PRESENT = 0x400,
+  /// Module does not make use of the /GS security cookie.
+  SECURITY_COOKIE_UNUSED = 0x800,
+  /// Module supports read only delay load IAT.
+  PROTECT_DELAYLOAD_IAT = 0x1000,
+  /// Delayload import table in its own .didat section (with nothing else in it)
+  /// that can be freely reprotected.
+  DELAYLOAD_IAT_IN_ITS_OWN_SECTION = 0x2000,
+  /// Module contains suppressed export information. This also infers that the
+  /// address taken IAT table is also present in the load config.
+  CF_EXPORT_SUPPRESSION_INFO_PRESENT = 0x4000,
+  /// Module enables suppression of exports.
+  CF_ENABLE_EXPORT_SUPPRESSION = 0x8000,
+  /// Module contains longjmp target information.
+  CF_LONGJUMP_TABLE_PRESENT = 0x10000,
+  /// Module contains EH continuation target information.
+  EH_CONTINUATION_TABLE_PRESENT = 0x400000,
+  /// Mask for the subfield that contains the stride of Control Flow Guard
+  /// function table entries (that is, the additional count of bytes per table
+  /// entry).
+  CF_FUNCTION_TABLE_SIZE_MASK = 0xF0000000,
+  CF_FUNCTION_TABLE_SIZE_5BYTES = 0x10000000,
+  CF_FUNCTION_TABLE_SIZE_6BYTES = 0x20000000,
+  CF_FUNCTION_TABLE_SIZE_7BYTES = 0x30000000,
+  CF_FUNCTION_TABLE_SIZE_8BYTES = 0x40000000,
+  CF_FUNCTION_TABLE_SIZE_9BYTES = 0x50000000,
+  CF_FUNCTION_TABLE_SIZE_10BYTES = 0x60000000,
+  CF_FUNCTION_TABLE_SIZE_11BYTES = 0x70000000,
+  CF_FUNCTION_TABLE_SIZE_12BYTES = 0x80000000,
+  CF_FUNCTION_TABLE_SIZE_13BYTES = 0x90000000,
+  CF_FUNCTION_TABLE_SIZE_14BYTES = 0xA0000000,
+  CF_FUNCTION_TABLE_SIZE_15BYTES = 0xB0000000,
+  CF_FUNCTION_TABLE_SIZE_16BYTES = 0xC0000000,
+  CF_FUNCTION_TABLE_SIZE_17BYTES = 0xD0000000,
+  CF_FUNCTION_TABLE_SIZE_18BYTES = 0xE0000000,
+  CF_FUNCTION_TABLE_SIZE_19BYTES = 0xF0000000,
+};
+
 struct ImportHeader {
   uint16_t Sig1; ///< Must be IMAGE_FILE_MACHINE_UNKNOWN (0).
   uint16_t Sig2; ///< Must be 0xFFFF.
   uint16_t Version;
   uint16_t Machine;
   uint32_t TimeDateStamp;
   uint32_t SizeOfData;
   uint16_t OrdinalHint;

llvm/test/tools/llvm-readobj/COFF/load-config.test

 X86:   EditList: 0x0
 X86:   SecurityCookie: 0x10003004
 X86:   SEHandlerTable: 0x100021C0
 X86:   SEHandlerCount: 2
 X86:   GuardCFCheckFunction: 0x1000207C
 X86:   GuardCFCheckDispatch: 0x0
 X86:   GuardCFFunctionTable: 0x100020A4
 X86:   GuardCFFunctionCount: 11
-X86:   GuardFlags: 0x13500
+X86:   GuardFlags [ (0x13500)
+X86:     CF_FUNCTION_TABLE_PRESENT (0x400)
+X86:     CF_INSTRUMENTED (0x100)
+X86:     CF_LONGJUMP_TABLE_PRESENT (0x10000)
+X86:     DELAYLOAD_IAT_IN_ITS_OWN_SECTION (0x2000)
+X86:     PROTECT_DELAYLOAD_IAT (0x1000)
+X86:   ]
 X86: ]
 X86: SEHTable [
 X86:   0x10001BE0
 X86:   0x10001E30
 X86: ]
 X86: GuardFidTable [
 X86:   0x10001000
 X86:   0x10001040

 X64:   EditList: 0x0
 X64:   SecurityCookie: 0x180003018
 X64:   SEHandlerTable: 0
 X64:   SEHandlerCount: 0
 X64:   GuardCFCheckFunction: 0x180002100
 X64:   GuardCFCheckDispatch: 0x180002108
 X64:   GuardCFFunctionTable: 0x180002158
 X64:   GuardCFFunctionCount: 9
-X64:   GuardFlags: 0x13500
+X64:  GuardFlags [ (0x13500)
+X64:    CF_FUNCTION_TABLE_PRESENT (0x400)
+X64:    CF_INSTRUMENTED (0x100)
+X64:    CF_LONGJUMP_TABLE_PRESENT (0x10000)
+X64:    DELAYLOAD_IAT_IN_ITS_OWN_SECTION (0x2000)
+X64:    PROTECT_DELAYLOAD_IAT (0x1000)
+X64:  ]
 X64: ]
 X64-NOT: SEHTable
 X64: GuardFidTable [
 X64:   0x180001000
 X64:   0x180001050
 X64:   0x180001070
 X64:   0x1800010E0
 X64:   0x180001110

llvm/tools/llvm-readobj/COFFDumper.cpp

 
 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),
 };
 
+const EnumEntry<uint32_t> PELoadConfigGuardFlags[] = {
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_INSTRUMENTED),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CFW_INSTRUMENTED),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_FUNCTION_TABLE_PRESENT),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, SECURITY_COOKIE_UNUSED),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, PROTECT_DELAYLOAD_IAT),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                DELAYLOAD_IAT_IN_ITS_OWN_SECTION),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_EXPORT_SUPPRESSION_INFO_PRESENT),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_ENABLE_EXPORT_SUPPRESSION),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_LONGJUMP_TABLE_PRESENT),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                EH_CONTINUATION_TABLE_PRESENT),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_5BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_6BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_7BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_8BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_9BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_10BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_11BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_12BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_13BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_14BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_15BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_16BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_17BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_18BYTES),
+    LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
+                                CF_FUNCTION_TABLE_SIZE_19BYTES),
+};
+
 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());
   return std::error_code();
void COFFDumper::printCOFFLoadConfig() {
   auto PrintGuardFlags = [](raw_ostream &OS, const uint8_t *Entry) {
     uint8_t Flags = *reinterpret_cast<const uint8_t *>(Entry + 4);
     if (Flags)
       OS << " flags " << utohexstr(Flags);
   };
 
   if (Tables.GuardFidTableVA) {
     ListScope LS(W, "GuardFidTable");
     if (Tables.GuardFlags & uint32_t(coff_guard_flags::FidTableHasFlags))
       printRVATable(Tables.GuardFidTableVA, Tables.GuardFidTableCount, 5,
                     PrintGuardFlags);
     else
       printRVATable(Tables.GuardFidTableVA, Tables.GuardFidTableCount, 4);
   }
 
   if (Tables.GuardIatTableVA) {
     ListScope LS(W, "GuardIatTable");
void COFFDumper::printCOFFLoadConfig(const T *Conf, LoadConfigTables &Tables) {
 
   // Print everything before CodeIntegrity. (2015)
   if (Conf->Size < offsetof(T, CodeIntegrity))
     return;
   W.printHex("GuardCFCheckFunction", Conf->GuardCFCheckFunction);
   W.printHex("GuardCFCheckDispatch", Conf->GuardCFCheckDispatch);
   W.printHex("GuardCFFunctionTable", Conf->GuardCFFunctionTable);
   W.printNumber("GuardCFFunctionCount", Conf->GuardCFFunctionCount);
-  W.printHex("GuardFlags", Conf->GuardFlags);
+  W.printFlags("GuardFlags", Conf->GuardFlags,
+               makeArrayRef(PELoadConfigGuardFlags),
+               (uint32_t)COFF::GuardFlags::CF_FUNCTION_TABLE_SIZE_MASK);
 
   Tables.GuardFidTableVA = Conf->GuardCFFunctionTable;
   Tables.GuardFidTableCount = Conf->GuardCFFunctionCount;
   Tables.GuardFlags = Conf->GuardFlags;
 
   // Print everything before Reserved3. (2017)
   if (Conf->Size < offsetof(T, Reserved3))
     return;