[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

853

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

853

Sure, I've made D132924.

[rnk]

Looks good, thanks

llvm/tools/llvm-readobj/COFFDumper.cpp

853

Thanks!

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,
+  /// 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,
+                                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;