[yaml2obj] Add support for load config section data.

[jacek]

Summary

This makes testing load config much nicer and will allow more readable tests in D149091. Currently llvm-readobj uses binary blobs in tests, with this patch we could rewrite them to use yaml2obj instead.

[jacek]

A new version with yaml2obj.rst changes.

[jacek]

Rebased on top of D149439 changes.

[jacek]

Updated with additional use in arm64ec-chpe.yaml.

[jhenderson]

I'd recommend you have test cases where all the fields are present and none of them are. For the purposes of yaml2obj testing, it doesn't actually need to make sense as an output file!

lld/COFF/Config.h

107 ↗

(On Diff #536243)

Unrelated? Perhaps should be a follow-up change...

llvm/lib/ObjectYAML/COFFEmitter.cpp

608

You should have a test case for the behaviours in this function.

[jhenderson]

Oh, looks like clang-format is failing in pre-merge. Please make sure you've formatted the new code you've added.

[jacek]

Rebased on top of D149439 changes, added more tests and removed unrelated change. Thanks for review!

[jhenderson]

llvm/lib/ObjectYAML/COFFEmitter.cpp

606

Having now reread this bit of code, I now see that S.Size is being cast to size_t, whereas I misread it originally as being a sizeof due ot the similarity it has with the sizeof(S) earlier in the line. Perhaps a static_cast would be more obvious?

I'm assuming that S.Size corresponds to the Size field in the YAML. Assuming that is the case, what happens if a load config member would be written AFTER the end of a truncated block (i.e. where S.Size is less than sizeof(S))? Should this have a distinct test case?

llvm/test/tools/yaml2obj/COFF/load-config-empty.yaml

32 ↗

(On Diff #536896)

Is this equivalent to having a Size: 0 case? If so, it might be worth being explicit about it. If not, it might be worth having that test case too.

llvm/test/tools/yaml2obj/COFF/load-config32-large.yaml

1 ↗

(On Diff #536896)

It would be useful having an explanatory comment at the top of each of these tests briefly outlining what they are specifically testing.

[jacek]

Rebased, changed size_t casts, added more offset checks and more tests.

For the context: load config size grows over time. Microsoft occasionally extends it with new fields appended to the end. To manifest the version used, users set load config's first field, Size, to the size of variant of the structure that they use. The handling that I wrote is meant to allow specifying various versions of the struct.

With the previous version, members that did not fit specified size were silently ignored. The new version checks for that, so that it will be considered an invalid yaml, it may help catch mistakes.

[jhenderson]

llvm/lib/ObjectYAML/COFFYAML.cpp

565–566

Are you sure that wants to be sizeof(S.Size) in these two lines? Would it be worth giving S a more descriptive name?

llvm/test/tools/yaml2obj/COFF/load-config-empty.yaml

1 ↗

(On Diff #537186)

Nit: in newer tools tests, we tend to use ## for comments, to help distinguish them from RUN/CHECK lines etc. Same throughout.

llvm/test/tools/yaml2obj/COFF/load-config-large.yaml

1 ↗

(On Diff #537186)

I'm beginning to think it might be worth grouping all these tests into a single test file, with multiple YAMLs (using yaml2obj --docnum to pick the relevant YAML). This is because the behaviour is all closely related to each other, and having the tests in the same file would therefore make it easier to find all tests to do with a particular feature.

[jacek]

llvm/lib/ObjectYAML/COFFYAML.cpp

565–566

Yes, that's what I meant. Size is the first member of load config structs. Load config that's too small to even fit the size field itself wouldn't make much sense. I will add a comment to clarify that, but I can also remove the check if you prefer (the check is not required from yaml2obj's point of view, I added it for completeness, it has a chance to catch some user errors).

[jacek]

Moved tests to a single file, added comments, renamed load config struct.

[jhenderson]

llvm/lib/ObjectYAML/COFFYAML.cpp

559

565–566

In other areas of yaml2obj (at least in the ELF side), we try to be as permissable as possible, as long as the object could be reasonably representable in the file format. For example, you could have an ELF symbol table without any symbols at all, even though the ELF file format states that there must be at least one symbol at index 0. So in this case, it might be reasonable to allow a zero-sized LoadConfig structure, so that you could test that consumer tools (e.g. llvm-readobj) can handle such a situation (even if it's just a case of reporting an error).

TL;DR: I don't really mind what you do. It largely depends how you want to use the tool.

llvm/test/tools/yaml2obj/COFF/load-config.yaml

1 ↗

(On Diff #537320)

With multi-case tests like this, if they aren't sharing the same checks/inputs, I tend to write them like this:

## Test case comment.
# RUN: ...
# RUN: ... | FileChcek %s --check-prefix=FOO

# FOO: ...

<yaml for test case 1>

## Test case 2 comment.
# RUN: ...
# RUN: ... | FileChcek %s --check-prefix=BOO

# BOO: ...

<yaml for test case 2>

etc, as this makes it easier to see the parts of the respective test case. OTOH, if the inputs are shared between many test cases, possibly through the use of yaml2obj's -D option, I tend to put the input at the end of the block of test caes that use it.

[jacek]

llvm/lib/ObjectYAML/COFFYAML.cpp

565–566

For sizes like 2 I think it would be cleaner to use '-Binary: 0200' instead of LoadConfig and there is not much that llvm-readobj can do about such config: it will try to interpret bytes following load config as part of the size field. My opinion is not strong, but it felt right to have the check if we also have size checks for other members, so since you don't mind, I will leave it.

[jacek]

Reorganized test content.

[jacek]

I misread your suggestion, sorry. The attached version moves yaml contents as well.

[MaskRay]

llvm/test/tools/yaml2obj/COFF/load-config.yaml

10 ↗

(On Diff #538339)

I think we generally add -NEXT. When something goes off, FileCheck will give a better error. This does mean some maintenance overhead when adding a new field, but in general the advantage outweighs the downside.

[jhenderson]

LGTM, with two nits and MaskRay's comment addressed.

llvm/lib/ObjectYAML/COFFYAML.cpp

559

Ping this comment.

llvm/test/tools/yaml2obj/COFF/load-config.yaml

237 ↗

(On Diff #538339)

Nit

[jacek]

Thanks for reviews.

llvm/docs/yaml2obj.rst

mapping:
                             , IMAGE_SCN_MEM_READ
                             , IMAGE_SCN_MEM_WRITE
                             ]
                 - type: int
               SectionData: {type: str}
               Data:
                 - Binary: {type: str}
                 - Int32: {type: int}
+                - LoadConfig:
+                    Size: {type: int}
+                    TimeDateStamp: {type: int}
+                    MajorVersion: {type: int}
+                    MinorVersion: {type: int}
+                    GlobalFlagsClear: {type: int}
+                    GlobalFlagsSet: {type: int}
+                    CriticalSectionDefaultTimeout: {type: int}
+                    DeCommitFreeBlockThreshold: {type: int}
+                    DeCommitTotalFreeThreshold: {type: int}
+                    LockPrefixTable: {type: int}
+                    MaximumAllocationSize: {type: int}
+                    VirtualMemoryThreshold: {type: int}
+                    ProcessAffinityMask: {type: int}
+                    ProcessHeapFlags: {type: int}
+                    CSDVersion: {type: int}
+                    DependentLoadFlags: {type: int}
+                    EditList: {type: int}
+                    SecurityCookie: {type: int}
+                    SEHandlerTable: {type: int}
+                    SEHandlerCount: {type: int}
+                    GuardCFCheckFunction: {type: int}
+                    GuardCFCheckDispatch: {type: int}
+                    GuardCFFunctionTable: {type: int}
+                    GuardCFFunctionCount: {type: int}
+                    GuardFlags: {type: int}
+                    CodeIntegrity:
+                      Flags: {type: int}
+                      Catalog: {type: int}
+                      CatalogOffset: {type: int}
+                    GuardAddressTakenIatEntryTable: {type: int}
+                    GuardAddressTakenIatEntryCount: {type: int}
+                    GuardLongJumpTargetTable: {type: int}
+                    GuardLongJumpTargetCount: {type: int}
+                    DynamicValueRelocTable: {type: int}
+                    CHPEMetadataPointer: {type: int}
+                    GuardRFFailureRoutine: {type: int}
+                    GuardRFFailureRoutineFunctionPointer: {type: int}
+                    DynamicValueRelocTableOffset: {type: int}
+                    DynamicValueRelocTableSection: {type: int}
+                    GuardRFVerifyStackPointerFunctionPointer: {type: int}
+                    HotPatchTableOffset: {type: int}
+                    EnclaveConfigurationPointer: {type: int}
+                    VolatileMetadataPointer: {type: int}
+                    GuardEHContinuationTable: {type: int}
+                    GuardEHContinuationCount: {type: int}
+                    GuardXFGCheckFunctionPointer: {type: int}
+                    GuardXFGDispatchFunctionPointer: {type: int}
+                    GuardXFGTableDispatchFunctionPointer: {type: int}
+                    CastGuardOsDeterminedFailureMode: {type: int}
       symbols:
         type: seq
         sequence:
           - type: map
             mapping:
               Name: {type: str}
               Value: {type: int}
               SectionNumber: {type: int}

llvm/include/llvm/BinaryFormat/COFF.h

template <typename T> bool isArm64EC(T Machine) {
   return Machine == IMAGE_FILE_MACHINE_ARM64EC ||
          Machine == IMAGE_FILE_MACHINE_ARM64X;
 }
 
 template <typename T> bool isAnyArm64(T Machine) {
   return Machine == IMAGE_FILE_MACHINE_ARM64 || isArm64EC(Machine);
 }
 
+template <typename T> bool is64Bit(T Machine) {
+  return Machine == IMAGE_FILE_MACHINE_AMD64 || isAnyArm64(Machine);
+}
+
 enum Characteristics : unsigned {
   C_Invalid = 0,
 
   /// The file does not contain base relocations and must be loaded at its
   /// preferred base. If this cannot be done, the loader will error.
   IMAGE_FILE_RELOCS_STRIPPED = 0x0001,
   /// The file is valid and can be run.
   IMAGE_FILE_EXECUTABLE_IMAGE = 0x0002,

llvm/include/llvm/ObjectYAML/COFFYAML.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_COFFYAML_H
 #define LLVM_OBJECTYAML_COFFYAML_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/COFF.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h"
 #include "llvm/ObjectYAML/CodeViewYAMLTypeHashing.h"
 #include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include <cstdint>
 #include <optional>
 #include <vector>
 
struct Relocation {
   // same name or crafting intentionally broken files for testing.
   StringRef SymbolName;
   std::optional<uint32_t> SymbolTableIndex;
 };
 
 struct SectionDataEntry {
   std::optional<int32_t> Int32;
   yaml::BinaryRef Binary;
+  std::optional<object::coff_load_configuration32> LoadConfig32;
+  std::optional<object::coff_load_configuration64> LoadConfig64;
 
   size_t size() const;
   void writeAsBinary(raw_ostream &OS) const;
 };
 
 struct Section {
   COFF::section Header;
   unsigned Alignment = 0;

 template <> struct MappingTraits<COFF::AuxiliarySectionDefinition> {
   static void mapping(IO &IO, COFF::AuxiliarySectionDefinition &ASD);
 };
 
 template <> struct MappingTraits<COFF::AuxiliaryCLRToken> {
   static void mapping(IO &IO, COFF::AuxiliaryCLRToken &ACT);
 };
 
+template <> struct MappingTraits<object::coff_load_configuration32> {
+  static void mapping(IO &IO, object::coff_load_configuration32 &ACT);
+};
+
+template <> struct MappingTraits<object::coff_load_configuration64> {
+  static void mapping(IO &IO, object::coff_load_configuration64 &ACT);
+};
+
+template <> struct MappingTraits<object::coff_load_config_code_integrity> {
+  static void mapping(IO &IO, object::coff_load_config_code_integrity &ACT);
+};
+
 template <>
 struct MappingTraits<COFFYAML::Symbol> {
   static void mapping(IO &IO, COFFYAML::Symbol &S);
 };
 
 template <> struct MappingTraits<COFFYAML::SectionDataEntry> {
   static void mapping(IO &IO, COFFYAML::SectionDataEntry &Sec);
 };

llvm/lib/ObjectYAML/COFFEmitter.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
-#include "llvm/Object/COFF.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
struct COFFParser {
   }
 
   bool useBigObj() const {
     return static_cast<int32_t>(Obj.Sections.size()) >
            COFF::MaxNumberOfSections16;
   }
 
   bool isPE() const { return Obj.OptionalHeader.has_value(); }
-  bool is64Bit() const {
-    return Obj.Header.Machine == COFF::IMAGE_FILE_MACHINE_AMD64 ||
-           COFF::isAnyArm64(Obj.Header.Machine);
-  }
+  bool is64Bit() const { return COFF::is64Bit(Obj.Header.Machine); }
 
   uint32_t getFileAlignment() const {
     return Obj.OptionalHeader->Header.FileAlignment;
   }
 
   unsigned getHeaderSize() const {
     return useBigObj() ? COFF::Header32Size : COFF::Header16Size;
   }
if (CP.Obj.Header.PointerToSymbolTable)
     OS.write(&CP.StringTable[0], CP.StringTable.size());
   return true;
 }
 
 size_t COFFYAML::SectionDataEntry::size() const {
   size_t Size = Binary.binary_size();
   if (Int32)
     Size += sizeof(int32_t);
+  if (LoadConfig32)
+    Size += LoadConfig32->Size;
+  if (LoadConfig64)
+    Size += LoadConfig64->Size;
   return Size;
 }
 
+template <typename T> static void writeLoadConfig(T &S, raw_ostream &OS) {
+  OS.write(reinterpret_cast<const char *>(&S),
+           std::min(sizeof(S), size_t(S.Size)));
+  if (sizeof(S) < S.Size)
+    OS.write_zeros(S.Size - sizeof(S));
+}
+
 void COFFYAML::SectionDataEntry::writeAsBinary(raw_ostream &OS) const {
   if (Int32)
     OS << binary_le(*Int32);
   Binary.writeAsBinary(OS);
+  if (LoadConfig32)
+    writeLoadConfig(*LoadConfig32, OS);
+  if (LoadConfig64)
+    writeLoadConfig(*LoadConfig64, OS);
 }
 
 namespace llvm {
 namespace yaml {
 
 bool yaml2coff(llvm::COFFYAML::Object &Doc, raw_ostream &Out,
                ErrorHandler ErrHandler) {
   COFFParser CP(Doc, ErrHandler);

llvm/lib/ObjectYAML/COFFYAML.cpp

 
 void MappingTraits<COFF::AuxiliaryCLRToken>::mapping(
     IO &IO, COFF::AuxiliaryCLRToken &ACT) {
   MappingNormalization<NAuxTokenType, uint8_t> NATT(IO, ACT.AuxType);
   IO.mapRequired("AuxType", NATT->AuxType);
   IO.mapRequired("SymbolTableIndex", ACT.SymbolTableIndex);
 }
 
+void MappingTraits<object::coff_load_config_code_integrity>::mapping(
+    IO &IO, object::coff_load_config_code_integrity &S) {
+  IO.mapOptional("Flags", S.Flags);
+  IO.mapOptional("Catalog", S.Catalog);
+  IO.mapOptional("CatalogOffset", S.CatalogOffset);
+}
+
+template <typename T> void mapLoadConfig(IO &IO, T &S) {
+  IO.mapOptional("Size", S.Size, support::ulittle32_t(sizeof(S)));
+  IO.mapOptional("TimeDateStamp", S.TimeDateStamp);
+  IO.mapOptional("MajorVersion", S.MajorVersion);
+  IO.mapOptional("MinorVersion", S.MinorVersion);
+  IO.mapOptional("GlobalFlagsClear", S.GlobalFlagsClear);
+  IO.mapOptional("GlobalFlagsSet", S.GlobalFlagsSet);
+  IO.mapOptional("CriticalSectionDefaultTimeout",
+                 S.CriticalSectionDefaultTimeout);
+  IO.mapOptional("DeCommitFreeBlockThreshold", S.DeCommitFreeBlockThreshold);
+  IO.mapOptional("DeCommitTotalFreeThreshold", S.DeCommitTotalFreeThreshold);
+  IO.mapOptional("LockPrefixTable", S.LockPrefixTable);
+  IO.mapOptional("MaximumAllocationSize", S.MaximumAllocationSize);
+  IO.mapOptional("VirtualMemoryThreshold", S.VirtualMemoryThreshold);
+  IO.mapOptional("ProcessAffinityMask", S.ProcessAffinityMask);
+  IO.mapOptional("ProcessHeapFlags", S.ProcessHeapFlags);
+  IO.mapOptional("CSDVersion", S.CSDVersion);
+  IO.mapOptional("DependentLoadFlags", S.DependentLoadFlags);
+  IO.mapOptional("EditList", S.EditList);
+  IO.mapOptional("SecurityCookie", S.SecurityCookie);
+  IO.mapOptional("SEHandlerTable", S.SEHandlerTable);
+  IO.mapOptional("SEHandlerCount", S.SEHandlerCount);
+  IO.mapOptional("GuardCFCheckFunction", S.GuardCFCheckFunction);
+  IO.mapOptional("GuardCFCheckDispatch", S.GuardCFCheckDispatch);
+  IO.mapOptional("GuardCFFunctionTable", S.GuardCFFunctionTable);
+  IO.mapOptional("GuardCFFunctionCount", S.GuardCFFunctionCount);
+  IO.mapOptional("GuardFlags", S.GuardFlags);
+  IO.mapOptional("CodeIntegrity", S.CodeIntegrity);
+  IO.mapOptional("GuardAddressTakenIatEntryTable",
+                 S.GuardAddressTakenIatEntryTable);
+  IO.mapOptional("GuardAddressTakenIatEntryCount",
+                 S.GuardAddressTakenIatEntryCount);
+  IO.mapOptional("GuardLongJumpTargetTable", S.GuardLongJumpTargetTable);
+  IO.mapOptional("GuardLongJumpTargetCount", S.GuardLongJumpTargetCount);
+  IO.mapOptional("DynamicValueRelocTable", S.DynamicValueRelocTable);
+  IO.mapOptional("CHPEMetadataPointer", S.CHPEMetadataPointer);
+  IO.mapOptional("GuardRFFailureRoutine", S.GuardRFFailureRoutine);
+  IO.mapOptional("GuardRFFailureRoutineFunctionPointer",
+                 S.GuardRFFailureRoutineFunctionPointer);
+  IO.mapOptional("DynamicValueRelocTableOffset",
+                 S.DynamicValueRelocTableOffset);
+  IO.mapOptional("DynamicValueRelocTableSection",
+                 S.DynamicValueRelocTableSection);
+  IO.mapOptional("GuardRFVerifyStackPointerFunctionPointer",
+                 S.GuardRFVerifyStackPointerFunctionPointer);
+  IO.mapOptional("HotPatchTableOffset", S.HotPatchTableOffset);
+  IO.mapOptional("EnclaveConfigurationPointer", S.EnclaveConfigurationPointer);
+  IO.mapOptional("VolatileMetadataPointer", S.VolatileMetadataPointer);
+  IO.mapOptional("GuardEHContinuationTable", S.GuardEHContinuationTable);
+  IO.mapOptional("GuardEHContinuationCount", S.GuardEHContinuationCount);
+  IO.mapOptional("GuardXFGCheckFunctionPointer",
+                 S.GuardXFGCheckFunctionPointer);
+  IO.mapOptional("GuardXFGDispatchFunctionPointer",
+                 S.GuardXFGDispatchFunctionPointer);
+  IO.mapOptional("GuardXFGTableDispatchFunctionPointer",
+                 S.GuardXFGTableDispatchFunctionPointer);
+  IO.mapOptional("CastGuardOsDeterminedFailureMode",
+                 S.CastGuardOsDeterminedFailureMode);
+}
+
+void MappingTraits<object::coff_load_configuration32>::mapping(
+    IO &IO, object::coff_load_configuration32 &S) {
+  mapLoadConfig(IO, S);
+}
+
+void MappingTraits<object::coff_load_configuration64>::mapping(
+    IO &IO, object::coff_load_configuration64 &S) {
+  mapLoadConfig(IO, S);
+}
+
 void MappingTraits<COFFYAML::SectionDataEntry>::mapping(
     IO &IO, COFFYAML::SectionDataEntry &E) {
   IO.mapOptional("Int32", E.Int32);
   IO.mapOptional("Binary", E.Binary);
+
+  COFF::header &H = *static_cast<COFF::header *>(IO.getContext());
+  if (COFF::is64Bit(H.Machine))
+    IO.mapOptional("LoadConfig", E.LoadConfig64);
+  else
+    IO.mapOptional("LoadConfig", E.LoadConfig32);
 }
 
 void MappingTraits<COFFYAML::Symbol>::mapping(IO &IO, COFFYAML::Symbol &S) {
   MappingNormalization<NStorageClass, uint8_t> NS(IO, S.Header.StorageClass);
 
   IO.mapRequired("Name", S.Name);
   IO.mapRequired("Value", S.Header.Value);
   IO.mapRequired("SectionNumber", S.Header.SectionNumber);

llvm/test/tools/yaml2obj/COFF/load-config32.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --coff-load-config %t | FileCheck %s
+
+# CHECK: LoadConfig [
+# CHECK:   MaximumAllocationSize: 0x100000
+# CHECK:   VirtualMemoryThreshold: 0x2000000
+# CHECK:   CHPEMetadataPointer: 0
+
+--- !COFF
+OptionalHeader:
+  ImageBase:       0x180000000
+  SectionAlignment: 4096
+  FileAlignment:   512
+  DLLCharacteristics: [ ]
+  LoadConfigTable:
+    RelativeVirtualAddress: 0x1000
+    Size:            320
+header:
+  Machine:         IMAGE_FILE_MACHINE_I386
+  Characteristics: [ IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LARGE_ADDRESS_AWARE, IMAGE_FILE_DLL ]
+sections:
+  - Name:            .rdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  0x1000
+    VirtualSize:     320
+    Data:
+      - LoadConfig:
+          MaximumAllocationSize: 0x100000
+          VirtualMemoryThreshold: 0x2000000
+symbols: []
+...

llvm/test/tools/yaml2obj/COFF/load-config64.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --coff-load-config %t | FileCheck %s
+
+# CHECK: LoadConfig [
+# CHECK:   MaximumAllocationSize: 0x100000
+# CHECK:   VirtualMemoryThreshold: 0x2000000
+# CHECK:   CHPEMetadataPointer: 0
+
+--- !COFF
+OptionalHeader:
+  ImageBase:       0x180000000
+  SectionAlignment: 4096
+  FileAlignment:   512
+  DLLCharacteristics: [ ]
+  LoadConfigTable:
+    RelativeVirtualAddress: 0x1000
+    Size:            320
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [ IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LARGE_ADDRESS_AWARE, IMAGE_FILE_DLL ]
+sections:
+  - Name:            .rdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    VirtualAddress:  0x1000
+    VirtualSize:     320
+    Data:
+      - LoadConfig:
+          MaximumAllocationSize: 0x100000
+          VirtualMemoryThreshold: 0x2000000
+          CodeIntegrity:
+            Flags: 0x100
+symbols: []
+...