[LLD] Implement /guard:[no]ehcont

[pengfei]

Add EHCont to load config table.

[pengfei]

Hi @rnk , I'm implementing EHCont guard in LLD referring to your longjmp patch. Currently the binary's EHCont table always be null. I guess it results from I haven't told lld where's the place it should put the EHCont table in the load config table.
But I didn't find any related code in longjmp patch. Could you point me where the code is? Or I misunderstood something?

[rnk]

In D99078#2644001, @pengfei wrote:

Hi @rnk , I'm implementing EHCont guard in LLD referring to your longjmp patch. Currently the binary's EHCont table always be null. I guess it results from I haven't told lld where's the place it should put the EHCont table in the load config table.
But I didn't find any related code in longjmp patch. Could you point me where the code is? Or I misunderstood something?

The CRT is actually responsible for providing a struct defining the load configuration. You can see in the LLD gfids tests that they all have a blob like this:

        .section .rdata,"dr"
.globl _load_config_used
_load_config_used:
        .long 256
        .fill 124, 1, 0
        .quad __guard_fids_table
        .quad __guard_fids_count
        .long __guard_flags
        .fill 128, 1, 0

To add ehcont tests, you will need to provide a similar load config that llvm-readobj can parse. Hopefully that answers your question.

[pengfei]

Solved the problems.

[pengfei]

In D99078#2645963, @rnk wrote:

In D99078#2644001, @pengfei wrote:

Hi @rnk , I'm implementing EHCont guard in LLD referring to your longjmp patch. Currently the binary's EHCont table always be null. I guess it results from I haven't told lld where's the place it should put the EHCont table in the load config table.
But I didn't find any related code in longjmp patch. Could you point me where the code is? Or I misunderstood something?

The CRT is actually responsible for providing a struct defining the load configuration. You can see in the LLD gfids tests that they all have a blob like this:

        .section .rdata,"dr"
.globl _load_config_used
_load_config_used:
        .long 256
        .fill 124, 1, 0
        .quad __guard_fids_table
        .quad __guard_fids_count
        .long __guard_flags
        .fill 128, 1, 0

To add ehcont tests, you will need to provide a similar load config that llvm-readobj can parse. Hopefully that answers your question.

Yes. It solves my problems. Thanks very much.
Now, the last question: I found it works with a given load configuration in the test (That's why I'm sure it's the right direction), but still doesn't work when using clang-cl or/and lld-link to build a cpp file. I guess it maybe related to the lld-link that doesn't use the latest CRT. Do you know how to fix this problem?

lld/test/COFF/pdb-natvis.test

17

I have no idea how this been affected by this patch.

[pengfei]

1. Remove lib dependency to make linux testing happy.
2. Revert the change to pdb-natvis.test.

[pengfei]

lld/test/COFF/pdb-natvis.test

17

Since the change results in the build server fail, I suspect if it is my local problem. Reverted it to see if the build server happy.

[rnk]

Looks good!

[pengfei]

In D99078#2687146, @rnk wrote:

Looks good!

Thanks for the review.

[alvinhochun]

lld/COFF/DriverUtils.cpp

104–114

This changed the behaviour of /guard:cf. Before this change, /guard:cf is equivalent to /guard:cf,longjmp by default, but after this change one must explicitly pass /guard:longjmp to`lld-link for it to generate the guard long jump table.

This also does not match the behaviour of MSVC's link.exe. From my quick testing, /guard:cf, /guard:longjmp and /guard:cf,longjmp all do the same thing for it to enable both CFGuard and the long jump table. Only when you pass /guard:cf,nolongjmp is the jump table not present in the final image.

[pengfei]

lld/COFF/DriverUtils.cpp

104–114

Thanks for raising the problem. I don't find any description about the longjmp option in official document. Unless there's explicit document about the relationship between /guard:cf, /guard:longjmp and /guard:cf,longjmp, I don't think we need to match the exact behavior with MSVC. The single /guard:cf has ambiguity since we are supporting ehcont. So I'm not sure if the current MSVC behavior is constant in future versions.

[alvinhochun]

lld/COFF/DriverUtils.cpp

104–114

I just think that, long jump guard seems to be a rather cheap hardening measure when control flow guard is already in use. Not enabling it by default perhaps seems a bit odd, especially since this feels like an unintentional change. But fine with me either way (I don't really use MSVC or Clang with MSVC target, just noticed the difference when investigating this LLD feature.)

[pengfei]

lld/COFF/DriverUtils.cpp

104–114

Thanks for the point. I'm not a MSVC/clang-cl user either. So I couldn't weight how cheap the long jump guard is. I designed it in the perspective of a junior user, to whom it's hard to understand the longjmp is on by default for some reason and need nolongjmp to disable it, while ehcont is on the contrary.
It would have value from the perspective of backward compatibility if we chose this way at the beginning. But the patch was merged more than one year... So let's keep it as is :)

[rnk]

lld/COFF/DriverUtils.cpp

104–114

I agree, longjump protections should be implied by /guard:cf. The nolongjump flag exists merely as a backwards compatibility escape hatch. Users should generally not specify /guard:longjump.

[mstorsjo]

lld/COFF/DriverUtils.cpp

104–114

Also, FWIW, even if the exact behaviour of Microsoft's tools isn't documented, such a detail like this would most probably not change randomly from one version to another. I also would prefer that we match link.exe's behaviour exactly on this point, instead of making up our own rules for how these flags interact.

[pengfei]

lld/COFF/DriverUtils.cpp

104–114

Thanks @rnk @mstorsjo ! That makes sense to me. I put D132901 to revert the behavior, please take a look, thanks!

lld/COFF/Chunks.h

public:
   explicit RVATableChunk(SymbolRVASet s) : syms(std::move(s)) {}
   size_t getSize() const override { return syms.size() * 4; }
   void writeTo(uint8_t *buf) const override;
 
 private:
   SymbolRVASet syms;
 };
 
+// Table which contains symbol RVAs with flags. Used for /guard:ehcont.
+class RVAFlagTableChunk : public NonSectionChunk {
+public:
+  explicit RVAFlagTableChunk(SymbolRVASet s) : syms(std::move(s)) {}
+  size_t getSize() const override { return syms.size() * 5; }
+  void writeTo(uint8_t *buf) const override;
+
+private:
+  SymbolRVASet syms;
+};
+
 // Windows-specific.
 // This class represents a block in .reloc section.
 // See the PE/COFF spec 5.6 for details.
 class BaserelChunk : public NonSectionChunk {
 public:
   BaserelChunk(uint32_t page, Baserel *begin, Baserel *end);
   size_t getSize() const override { return data.size(); }
   void writeTo(uint8_t *buf) const override;

lld/COFF/Chunks.cpp

void RVATableChunk::writeTo(uint8_t *buf) const {
   size_t cnt = 0;
   for (const ChunkAndOffset &co : syms)
     begin[cnt++] = co.inputChunk->getRVA() + co.offset;
   std::sort(begin, begin + cnt);
   assert(std::unique(begin, begin + cnt) == begin + cnt &&
          "RVA tables should be de-duplicated");
 }
 
+void RVAFlagTableChunk::writeTo(uint8_t *buf) const {
+  struct RVAFlag {
+    ulittle32_t RVA;
+    uint8_t flag;
+  };
+  RVAFlag *begin = reinterpret_cast<RVAFlag *>(buf);
+  size_t cnt = 0;
+  for (const ChunkAndOffset &co : syms) {
+    begin[cnt].RVA = co.inputChunk->getRVA() + co.offset;
+    begin[cnt].flag = 0;
+    ++cnt;
+  }
+  auto LT = [](RVAFlag &A, RVAFlag &B) { return A.RVA < B.RVA; };
+  auto EQ = [](RVAFlag &A, RVAFlag &B) { return A.RVA == B.RVA; };
+  std::sort(begin, begin + cnt, LT);
+  assert(std::unique(begin, begin + cnt, EQ) == begin + cnt &&
+         "RVA tables should be de-duplicated");
+}
+
 // MinGW specific, for the "automatic import of variables from DLLs" feature.
 size_t PseudoRelocTableChunk::getSize() const {
   if (relocs.empty())
     return 0;
   return 12 + 12 * relocs.size();
 }
 
 // MinGW specific.

lld/COFF/Config.h

 
 enum class DebugType {
   None  = 0x0,
   CV    = 0x1,  /// CodeView
   PData = 0x2,  /// Procedure Data
   Fixup = 0x4,  /// Relocation Table
 };
 
-enum class GuardCFLevel {
-  Off,
-  NoLongJmp, // Emit gfids but no longjmp tables
-  Full,      // Enable all protections.
+enum GuardCFLevel {
+  Off     = 0x0,
+  CF      = 0x1, /// Emit gfids tables
+  LongJmp = 0x2, /// Emit longjmp tables
+  EHCont  = 0x4, /// Emit ehcont tables
+  All     = 0x7  /// Enable all protections
 };
 
 enum class ICFLevel {
   None,
   Safe, // Safe ICF for all sections.
   All,  // Aggressive ICF for code, but safe ICF for data, similar to MSVC's
         // behavior.
 };
struct Configuration {
   bool hadExplicitExports;
   std::set<std::string> delayLoads;
   std::map<std::string, int> dllOrder;
   Symbol *delayLoadHelper = nullptr;
 
   bool saveTemps = false;
 
   // /guard:cf
-  GuardCFLevel guardCF = GuardCFLevel::Off;
+  int guardCF = GuardCFLevel::Off;
 
   // Used for SafeSEH.
   bool safeSEH = false;
   Symbol *sehTable = nullptr;
   Symbol *sehCount = nullptr;
   bool noSEH = false;
 
   // Used for /opt:lldlto=N

lld/COFF/Driver.cpp

void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   symtab->addAbsolute(mangle("__guard_fids_table"), 0);
   symtab->addAbsolute(mangle("__guard_flags"), 0);
   symtab->addAbsolute(mangle("__guard_iat_count"), 0);
   symtab->addAbsolute(mangle("__guard_iat_table"), 0);
   symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
   symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
   // Needed for MSVC 2017 15.5 CRT.
   symtab->addAbsolute(mangle("__enclave_config"), 0);
+  // Needed for MSVC 2019 16.8 CRT.
+  symtab->addAbsolute(mangle("__guard_eh_cont_count"), 0);
+  symtab->addAbsolute(mangle("__guard_eh_cont_table"), 0);
 
   if (config->pseudoRelocs) {
     symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0);
     symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0);
   }
   if (config->mingw) {
     symtab->addAbsolute(mangle("__CTOR_LIST__"), 0);
     symtab->addAbsolute(mangle("__DTOR_LIST__"), 0);

lld/COFF/DriverUtils.cpp

 }
 
 void parseGuard(StringRef fullArg) {
   SmallVector<StringRef, 1> splitArgs;
   fullArg.split(splitArgs, ",");
   for (StringRef arg : splitArgs) {
     if (arg.equals_lower("no"))
       config->guardCF = GuardCFLevel::Off;
     else if (arg.equals_lower("nolongjmp"))
-      config->guardCF = GuardCFLevel::NoLongJmp;
-    else if (arg.equals_lower("cf") || arg.equals_lower("longjmp"))
-      config->guardCF = GuardCFLevel::Full;
+      config->guardCF &= ~GuardCFLevel::LongJmp;
+    else if (arg.equals_lower("noehcont"))
+      config->guardCF &= ~GuardCFLevel::EHCont;
+    else if (arg.equals_lower("cf"))
+      config->guardCF = GuardCFLevel::CF;
+    else if (arg.equals_lower("longjmp"))
+      config->guardCF |= GuardCFLevel::CF | GuardCFLevel::LongJmp;
+    else if (arg.equals_lower("ehcont"))
+      config->guardCF |= GuardCFLevel::CF | GuardCFLevel::EHCont;
     else
       fatal("invalid argument to /guard: " + arg);
   }
 }
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
 void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
                     uint32_t *minor, bool *gotVersion) {
   StringRef sysStr, ver;

lld/COFF/InputFiles.h

public:
   void parse() override;
   MachineTypes getMachineType() override;
   ArrayRef<Chunk *> getChunks() { return chunks; }
   ArrayRef<SectionChunk *> getDebugChunks() { return debugChunks; }
   ArrayRef<SectionChunk *> getSXDataChunks() { return sxDataChunks; }
   ArrayRef<SectionChunk *> getGuardFidChunks() { return guardFidChunks; }
   ArrayRef<SectionChunk *> getGuardIATChunks() { return guardIATChunks; }
   ArrayRef<SectionChunk *> getGuardLJmpChunks() { return guardLJmpChunks; }
+  ArrayRef<SectionChunk *> getGuardEHContChunks() { return guardEHContChunks; }
   ArrayRef<Symbol *> getSymbols() { return symbols; }
 
   MutableArrayRef<Symbol *> getMutableSymbols() { return symbols; }
 
   ArrayRef<uint8_t> getDebugSection(StringRef secName);
 
   // Returns a Symbol object for the symbolIndex'th symbol in the
   // underlying object file.
public:
   // like stack guard, safeseh, /guard:cf, or other things.
   uint32_t feat00Flags = 0;
 
   // True if this object file is compatible with SEH.  COFF-specific and
   // x86-only. COFF spec 5.10.1. The .sxdata section.
   bool hasSafeSEH() { return feat00Flags & 0x1; }
 
   // True if this file was compiled with /guard:cf.
-  bool hasGuardCF() { return feat00Flags & 0x800; }
+  bool hasGuardCF() { return feat00Flags & 0x4800; }
 
   // Pointer to the PDB module descriptor builder. Various debug info records
   // will reference object files by "module index", which is here. Things like
   // source files and section contributions are also recorded here. Will be null
   // if we are not producing a PDB.
   llvm::pdb::DbiModuleDescriptorBuilder *moduleDBI = nullptr;
 
   const coff_section *addrsigSec = nullptr;
private:
   // CodeView debug info sections.
   std::vector<SectionChunk *> debugChunks;
 
   // Chunks containing symbol table indices of exception handlers. Only used for
   // 32-bit x86.
   std::vector<SectionChunk *> sxDataChunks;
 
   // Chunks containing symbol table indices of address taken symbols, address
-  // taken IAT entries, and longjmp targets. These are not linked into the
-  // final binary when /guard:cf is set.
+  // taken IAT entries, longjmp and ehcont targets. These are not linked into
+  // the final binary when /guard:cf is set.
   std::vector<SectionChunk *> guardFidChunks;
   std::vector<SectionChunk *> guardIATChunks;
   std::vector<SectionChunk *> guardLJmpChunks;
+  std::vector<SectionChunk *> guardEHContChunks;
 
   // This vector contains a list of all symbols defined or referenced by this
   // file. They are indexed such that you can get a Symbol by symbol
   // index. Nonexistent indices (which are occupied by auxiliary
   // symbols in the real symbol table) are filled with null pointers.
   std::vector<Symbol *> symbols;
 
   // This vector contains the same chunks as Chunks, but they are

lld/COFF/InputFiles.cpp

SectionChunk *ObjFile::readSection(uint32_t sectionNumber,
   if (c->isCodeView())
     debugChunks.push_back(c);
   else if (name == ".gfids$y")
     guardFidChunks.push_back(c);
   else if (name == ".giats$y")
     guardIATChunks.push_back(c);
   else if (name == ".gljmp$y")
     guardLJmpChunks.push_back(c);
+  else if (name == ".gehcont$y")
+    guardEHContChunks.push_back(c);
   else if (name == ".sxdata")
     sxDataChunks.push_back(c);
   else if (config->tailMerge && sec->NumberOfRelocations == 0 &&
            name == ".rdata" && leaderName.startswith("??_C@"))
     // COFF sections that look like string literal sections (i.e. no
     // relocations, in .rdata, leader symbol name matches the MSVC name mangling
     // for string literals) are subject to string tail merging.
     MergeChunk::addSection(c);

lld/COFF/Writer.cpp

private:
   void createGuardCFTables();
   void markSymbolsForRVATable(ObjFile *file,
                               ArrayRef<SectionChunk *> symIdxChunks,
                               SymbolRVASet &tableSymbols);
   void getSymbolsFromSections(ObjFile *file,
                               ArrayRef<SectionChunk *> symIdxChunks,
                               std::vector<Symbol *> &symbols);
   void maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
-                        StringRef countSym);
+                        StringRef countSym, bool HasFlag=false);
   void setSectionPermissions();
   void writeSections();
   void writeBuildId();
   void sortSections();
   void sortExceptionTable();
   void sortCRTSectionChunks(std::vector<Chunk *> &chunks);
   void addSyntheticIdata();
   void fixPartialSectionChars(StringRef name, uint32_t chars);

 // Create the guard function id table. This is a table of RVAs of all
 // address-taken functions. It is sorted and uniqued, just like the safe SEH
 // table.
 void Writer::createGuardCFTables() {
   SymbolRVASet addressTakenSyms;
   SymbolRVASet giatsRVASet;
   std::vector<Symbol *> giatsSymbols;
   SymbolRVASet longJmpTargets;
+  SymbolRVASet ehContTargets;
   for (ObjFile *file : ObjFile::instances) {
     // If the object was compiled with /guard:cf, the address taken symbols
-    // are in .gfids$y sections, and the longjmp targets are in .gljmp$y
-    // sections. If the object was not compiled with /guard:cf, we assume there
-    // were no setjmp targets, and that all code symbols with relocations are
-    // possibly address-taken.
+    // are in .gfids$y sections, the longjmp targets are in .gljmp$y sections,
+    // and ehcont targets are in .gehcont$y sections. If the object was not
+    // compiled with /guard:cf, we assume there were no setjmp and ehcont
+    // targets, and that all code symbols with relocations are possibly
+    // address-taken.
     if (file->hasGuardCF()) {
       markSymbolsForRVATable(file, file->getGuardFidChunks(), addressTakenSyms);
       markSymbolsForRVATable(file, file->getGuardIATChunks(), giatsRVASet);
       getSymbolsFromSections(file, file->getGuardIATChunks(), giatsSymbols);
       markSymbolsForRVATable(file, file->getGuardLJmpChunks(), longJmpTargets);
+      markSymbolsForRVATable(file, file->getGuardEHContChunks(), ehContTargets);
     } else {
       markSymbolsWithRelocations(file, addressTakenSyms);
     }
   }
 
   // Mark the image entry as address-taken.
   if (config->entry)
     maybeAddAddressTakenFunction(addressTakenSyms, config->entry);
void Writer::createGuardCFTables() {
   maybeAddRVATable(std::move(addressTakenSyms), "__guard_fids_table",
                    "__guard_fids_count");
 
   // Add the Guard Address Taken IAT Entry Table (.giats).
   maybeAddRVATable(std::move(giatsRVASet), "__guard_iat_table",
                    "__guard_iat_count");
 
   // Add the longjmp target table unless the user told us not to.
-  if (config->guardCF == GuardCFLevel::Full)
+  if (config->guardCF & GuardCFLevel::LongJmp)
     maybeAddRVATable(std::move(longJmpTargets), "__guard_longjmp_table",
                      "__guard_longjmp_count");
 
+  // Add the ehcont target table unless the user told us not to.
+  if (config->guardCF & GuardCFLevel::EHCont)
+    maybeAddRVATable(std::move(ehContTargets), "__guard_eh_cont_table",
+                     "__guard_eh_cont_count", true);
+
   // Set __guard_flags, which will be used in the load config to indicate that
   // /guard:cf was enabled.
   uint32_t guardFlags = uint32_t(coff_guard_flags::CFInstrumented) |
                         uint32_t(coff_guard_flags::HasFidTable);
-  if (config->guardCF == GuardCFLevel::Full)
+  if (config->guardCF & GuardCFLevel::LongJmp)
     guardFlags |= uint32_t(coff_guard_flags::HasLongJmpTable);
+  if (config->guardCF & GuardCFLevel::EHCont)
+    guardFlags |= uint32_t(coff_guard_flags::HasEHContTable);
   Symbol *flagSym = symtab->findUnderscore("__guard_flags");
   cast<DefinedAbsolute>(flagSym)->setVA(guardFlags);
 }
 
 // Take a list of input sections containing symbol table indices and add those
 // symbols to a vector. The challenge is that symbol RVAs are not known and
 // depend on the table size, so we can't directly build a set of integers.
 void Writer::getSymbolsFromSections(ObjFile *file,
void Writer::markSymbolsForRVATable(ObjFile *file,
   for (Symbol *s : syms)
     addSymbolToRVASet(tableSymbols, cast<Defined>(s));
 }
 
 // Replace the absolute table symbol with a synthetic symbol pointing to
 // tableChunk so that we can emit base relocations for it and resolve section
 // relative relocations.
 void Writer::maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
-                              StringRef countSym) {
+                              StringRef countSym, bool HasFlag) {
   if (tableSymbols.empty())
     return;
 
-  RVATableChunk *tableChunk = make<RVATableChunk>(std::move(tableSymbols));
+  NonSectionChunk *tableChunk;
+  if (HasFlag)
+    tableChunk = make<RVAFlagTableChunk>(std::move(tableSymbols));
+  else
+    tableChunk = make<RVATableChunk>(std::move(tableSymbols));
   rdataSec->addChunk(tableChunk);
 
   Symbol *t = symtab->findUnderscore(tableSym);
   Symbol *c = symtab->findUnderscore(countSym);
   replaceSymbol<DefinedSynthetic>(t, t->getName(), tableChunk);
-  cast<DefinedAbsolute>(c)->setVA(tableChunk->getSize() / 4);
+  cast<DefinedAbsolute>(c)->setVA(tableChunk->getSize() / (HasFlag ? 5 : 4));
 }
 
 // MinGW specific. Gather all relocations that are imported from a DLL even
 // though the code didn't expect it to, produce the table that the runtime
 // uses for fixing them up, and provide the synthetic symbols that the
 // runtime uses for finding the table.
 void Writer::createRuntimePseudoRelocs() {
   std::vector<RuntimePseudoReloc> rels;

lld/test/COFF/gfids-corrupt.s

 # REQUIRES: x86
 # RUN: llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o %t.obj
-# RUN: lld-link %t.obj -opt:noref -guard:nolongjmp -out:%t.exe -entry:main 2>&1 | FileCheck %s --check-prefix=ERRS
+# RUN: lld-link %t.obj -opt:noref -guard:cf -out:%t.exe -entry:main 2>&1 | FileCheck %s --check-prefix=ERRS
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s
 
 # ERRS: warning: ignoring .gfids$y symbol table index section in object {{.*}}gfids-corrupt{{.*}}
 # ERRS: warning: ignoring invalid symbol table index in section .gfids$y in object {{.*}}gfids-corrupt{{.*}}
 
 # The table is arbitrary, really.
 # CHECK: ImageBase: 0x140000000
 # CHECK: LoadConfig [

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:nolongjmp -out:%t.exe -entry:main -opt:noref
+# 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

lld/test/COFF/gfids-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o %t.obj
-# RUN: lld-link %t.obj -guard:nolongjmp -out:%t.exe -opt:noref -entry:main
+# RUN: lld-link %t.obj -guard:cf -out:%t.exe -opt:noref -entry:main
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s --check-prefix=CHECK-NOGC
-# RUN: lld-link %t.obj -guard:nolongjmp -out:%t.exe -opt:noref -entry:main -debug:dwarf
+# RUN: lld-link %t.obj -guard:cf -out:%t.exe -opt:noref -entry:main -debug:dwarf
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s --check-prefix=CHECK-NOGC
-# RUN: lld-link %t.obj -guard:nolongjmp -out:%t.exe -opt:ref -entry:main
+# RUN: lld-link %t.obj -guard:cf -out:%t.exe -opt:ref -entry:main
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s --check-prefix=CHECK-GC
 
 # This assembly is meant to mimic what CL emits for this kind of C code when
 # /Gw (-fdata-sections) is enabled:
 # int f() { return 42; }
 # int g() { return 13; }
 # int (*fp1)() = &f;
 # int (*fp2)() = &g;

lld/test/COFF/gfids-icf.s

 # REQUIRES: x86
 # RUN: llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o %t.obj
-# RUN: lld-link %t.obj -guard:nolongjmp -out:%t.exe -opt:icf -entry:main
+# RUN: lld-link %t.obj -guard:cf -out:%t.exe -opt:icf -entry:main
 # RUN: llvm-readobj --file-headers --coff-load-config %t.exe | FileCheck %s --check-prefix=CHECK
 
 # This assembly is meant to mimic what CL emits for this kind of C code:
 # int icf1() { return 42; }
 # int icf2() { return 42; }
 # int (*fp1)() = &icf1;
 # int (*fp2)() = &icf2;
 # int main() {

lld/test/COFF/giats.s

 # REQUIRES: x86
 
 # Make a DLL that exports exportfn1.
 # RUN: yaml2obj %p/Inputs/export.yaml -o %basename_t-exp.obj
 # RUN: lld-link /out:%basename_t-exp.dll /dll %basename_t-exp.obj /export:exportfn1 /implib:%basename_t-exp.lib
 
 # Make an object file that imports exportfn1.
 # RUN: llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o %basename_t.obj
 
 # Check that the Guard address-taken IAT entry tables are propagated to the final executable.
-# RUN: lld-link %basename_t.obj -guard:cf -entry:main -out:%basename_t-nodelay.exe %basename_t-exp.lib
+# 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:   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 -entry:main -out:%basename_t-delay.exe %basename_t-exp.lib -alternatename:__delayLoadHelper2=main -delayload:%basename_t-exp.dll
+# 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:   GuardAddressTakenIatEntryTable: 0x14000211C
_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: 2
+# CHECK:   GuardFlags: 0x400500
+# CHECK:   GuardAddressTakenIatEntryTable: 0x0
+# CHECK:   GuardAddressTakenIatEntryCount: 0
+# CHECK:   GuardEHContinuationTable: 0x14000{{.*}}
+# CHECK:   GuardEHContinuationCount: 1
+# CHECK: ]
+# CHECK:      GuardEHContTable [
+# CHECK-NEXT:   0x14000{{.*}}
+# CHECK-NEXT: ]
+
+
+# This assembly is reduced from C code like:
+# int main()
+# {
+#   try {
+#     throw 3;
+#   }
+#   catch (int e) {
+#     return e != 3;
+#   }
+#   return 2;
+# }
+
+# We need @feat.00 to have 0x4000 to indicate /guard:ehcont.
+        .def     @feat.00;
+        .scl    3;
+        .type   0;
+        .endef
+        .globl  @feat.00
+@feat.00 = 0x4000
+        .def     main; .scl    2; .type   32; .endef
+        .globl  main                            # -- Begin function main
+        .p2align  4, 0x90
+main:                                   # @main
+.Lfunc_begin0:
+.seh_proc main
+.intel_syntax
+        .seh_handler __CxxFrameHandler3, @unwind, @except
+# %bb.0:                                # %entry
+        push  rbp
+        .seh_pushreg rbp
+        sub rsp, 64
+        .seh_stackalloc 64
+        lea rbp, [rsp + 64]
+        .seh_setframe rbp, 64
+        .seh_endprologue
+        mov qword ptr [rbp - 16], -2
+        mov dword ptr [rbp - 20], 0
+        mov dword ptr [rbp - 24], 3
+.Ltmp0:
+        lea rdx, [rip + _TI1H]
+        lea rcx, [rbp - 24]
+        call  _CxxThrowException
+.Ltmp1:
+        jmp .LBB0_3
+.LBB0_2:                                # Block address taken
+                                        # %catchret.dest
+$ehgcr_0_2:
+        mov  eax, dword ptr [rbp - 20]
+        add rsp, 64
+        pop rbp
+        ret
+.LBB0_3:                                # %unreachable
+        int3
+        .seh_handlerdata
+        .long ($cppxdata$main)@IMGREL
+        .text
+        .seh_endproc
+        .def   "?catch$1@?0?main@4HA";
+        .scl  3;
+        .type 32;
+        .endef
+        .p2align  4, 0x90
+"?catch$1@?0?main@4HA":
+.seh_proc "?catch$1@?0?main@4HA"
+        .seh_handler __CxxFrameHandler3, @unwind, @except
+.LBB0_1:                                # %catch
+        mov qword ptr [rsp + 16], rdx
+        push  rbp
+        .seh_pushreg rbp
+        sub rsp, 32
+        .seh_stackalloc 32
+        lea rbp, [rdx + 64]
+        .seh_endprologue
+        mov  eax, dword ptr [rbp - 4]
+        sub eax, 3
+        setne al
+        movzx eax, al
+        mov dword ptr [rbp - 20], eax
+        lea rax, [rip + .LBB0_2]
+        add rsp, 32
+        pop rbp
+        ret                                     # CATCHRET
+        .def     free; .scl    2; .type   32; .endef
+        .globl  free
+free:
+        ret
+        .def     __CxxFrameHandler3; .scl    2; .type   32; .endef
+        .globl  __CxxFrameHandler3
+__CxxFrameHandler3:
+        ret
+        .def     _CxxThrowException; .scl    2; .type   32; .endef
+        .globl  _CxxThrowException
+_CxxThrowException:
+        ret
+.Lfunc_end0:
+        .seh_handlerdata
+        .long ($cppxdata$main)@IMGREL
+        .text
+        .seh_endproc
+        .section  .xdata,"dr"
+        .p2align  2
+$cppxdata$main:
+        .long 429065506                       # MagicNumber
+        .long 2                               # MaxState
+        .long ($stateUnwindMap$main)@IMGREL   # UnwindMap
+        .long 1                               # NumTryBlocks
+        .long ($tryMap$main)@IMGREL           # TryBlockMap
+        .long 4                               # IPMapEntries
+        .long ($ip2state$main)@IMGREL         # IPToStateXData
+        .long 48                              # UnwindHelp
+        .long 0                               # ESTypeList
+        .long 1                               # EHFlags
+$stateUnwindMap$main:
+        .long -1                              # ToState
+        .long 0                               # Action
+        .long -1                              # ToState
+        .long 0                               # Action
+$tryMap$main:
+        .long 0                               # TryLow
+        .long 0                               # TryHigh
+        .long 1                               # CatchHigh
+        .long 1                               # NumCatches
+        .long ($handlerMap$0$main)@IMGREL     # HandlerArray
+$handlerMap$0$main:
+        .long 0                               # Adjectives
+        .long "??_R0H@8"@IMGREL               # Type
+        .long 60                              # CatchObjOffset
+        .long "?catch$1@?0?main@4HA"@IMGREL   # Handler
+        .long 56                              # ParentFrameOffset
+$ip2state$main:
+        .long .Lfunc_begin0@IMGREL            # IP
+        .long -1                              # ToState
+        .long .Ltmp0@IMGREL+1                 # IP
+        .long 0                               # ToState
+        .long .Ltmp1@IMGREL+1                 # IP
+        .long -1                              # ToState
+        .long "?catch$1@?0?main@4HA"@IMGREL   # IP
+        .long 1                               # ToState
+        .text
+                                        # -- End function
+        .section  .data,"dw",discard,"??_R0H@8"
+        .globl  "??_R0H@8"                      # @"??_R0H@8"
+        .p2align  4
+"??_R0H@8":
+        .quad "??_7type_info@@6B@"
+        .quad 0
+        .asciz  ".H"
+        .zero 5
+
+        .section  .xdata,"dr",discard,"_CT??_R0H@84"
+        .globl  "_CT??_R0H@84"                  # @"_CT??_R0H@84"
+        .p2align  4
+"_CT??_R0H@84":
+        .long 1                               # 0x1
+        .long "??_R0H@8"@IMGREL
+        .long 0                               # 0x0
+        .long 4294967295                      # 0xffffffff
+        .long 0                               # 0x0
+        .long 4                               # 0x4
+        .long 0                               # 0x0
+
+        .section  .xdata,"dr",discard,_CTA1H
+        .globl  _CTA1H                          # @_CTA1H
+        .p2align  3
+_CTA1H:
+        .long 1                               # 0x1
+        .long "_CT??_R0H@84"@IMGREL
+
+        .section  .xdata,"dr",discard,_TI1H
+        .globl  _TI1H                           # @_TI1H
+        .p2align  3
+_TI1H:
+        .long 0                               # 0x0
+        .long 0                               # 0x0
+        .long 0                               # 0x0
+        .long _CTA1H@IMGREL
+
+        .section  .drectve,"yn"
+        .ascii  " /DEFAULTLIB:libcmt.lib"
+        .ascii  " /DEFAULTLIB:oldnames.lib"
+        .section  .gehcont$y,"dr"
+        .symidx $ehgcr_0_2
+        .addrsig_sym _CxxThrowException
+        .addrsig_sym __CxxFrameHandler3
+        .addrsig_sym "??_7type_info@@6B@"
+        .addrsig_sym "??_R0H@8"
+        .addrsig_sym __ImageBase
+        .section  .rdata,"dr"
+.globl _load_config_used
+_load_config_used:
+        .long 312
+        .fill 124, 1, 0
+        .quad __guard_fids_table
+        .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_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 -out:%t.exe -entry:main
+# 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
_load_config_used:
         .fill 124, 1, 0
         .quad __guard_fids_table
         .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
+        .quad __guard_longjmp_count
         .fill 84, 1, 0

lld/test/COFF/guardcf-lto.ll

 ; REQUIRES: x86
 ; Set up an import library for a DLL that will do the indirect call.
 ; RUN: echo -e 'LIBRARY library\nEXPORTS\n  do_indirect_call\n' > %t.def
 ; RUN: lld-link -def:%t.def -out:%t.lib -machine:x64
 
 ; Generate an object that will have the load configuration normally provided by
 ; the CRT.
 ; RUN: llvm-mc -triple x86_64-windows-msvc -filetype=obj %S/Inputs/loadconfig-cfg-x64.s -o %t.ldcfg.obj
 
 ; RUN: llvm-as %s -o %t.bc
-; RUN: lld-link -entry:main -guard:cf -dll %t.bc %t.lib %t.ldcfg.obj -out:%t2.dll
+; 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

lld/test/COFF/pdb-natvis.test

 REQUIRES: diasdk
 
 RUN: yaml2obj %p/Inputs/generic.yaml -o %t.obj
 RUN: lld-link /DEBUG %t.obj /nodefaultlib /entry:main /NATVIS:%p/Inputs/natvis-1.natvis \
 RUN:   /NATVIS:%p/Inputs/natvis-2.natvis /NATVIS:%p/Inputs/natvis-3.natvis /OUT:%t.exe \
 RUN:   /PDB:%t.pdb
 RUN: llvm-pdbutil pretty -injected-sources -injected-source-content %t.pdb | FileCheck \
 RUN:   --check-prefix=CHECK-FIRST %s
 RUN: llvm-pdbutil pretty -injected-sources -injected-source-content %t.pdb | FileCheck \
 RUN:   --check-prefix=CHECK-SECOND %s
 RUN: llvm-pdbutil pretty -injected-sources -injected-source-content %t.pdb | FileCheck \
 RUN:   --check-prefix=CHECK-THIRD %s
 
 RUN: lld-link /DEBUG %t.obj /nodefaultlib /entry:main /NATVIS:%p/Inputs/test2.natvis \
 RUN:   /OUT:%t.exe /PDB:%t.pdb 2>&1 | FileCheck --check-prefix=CHECK-MISSING %s
 
-CHECK-FIRST:      {{.*}}natvis-1.natvis (16 bytes): obj=<null>, vname={{.*}}natvis-1.natvis, crc=355285096, compression=None
+CHECK-FIRST:      {{.*}}natvis-1.natvis (17 bytes): obj=<null>, vname={{.*}}natvis-1.natvis, crc=3974675339, compression=None
 CHECK-FIRST-NEXT: 1st Natvis Test
 
-CHECK-SECOND:      {{.*}}natvis-2.natvis (19 bytes): obj=<null>, vname={{.*}}natvis-2.natvis, crc=4252640062, compression=None
+CHECK-SECOND:      {{.*}}natvis-2.natvis (20 bytes): obj=<null>, vname={{.*}}natvis-2.natvis, crc=1846024273, compression=None
 CHECK-SECOND-NEXT: Second Natvis Test
 
-CHECK-THIRD:      {{.*}}natvis-3.natvis (18 bytes): obj=<null>, vname={{.*}}natvis-3.natvis, crc=2069719849, compression=None
+CHECK-THIRD:      {{.*}}natvis-3.natvis (19 bytes): obj=<null>, vname={{.*}}natvis-3.natvis, crc=3982342878, compression=None
 CHECK-THIRD-NEXT: Third Natvis Test
 
 CHECK-MISSING: Cannot open input file: {{.*}}test2.natvis
 No newline at end of file

llvm/include/llvm/Object/COFF.h

 
 /// Bits in control flow guard flags as we understand them.
 enum class coff_guard_flags : uint32_t {
   CFInstrumented = 0x00000100,
   HasFidTable = 0x00000400,
   ProtectDelayLoadIAT = 0x00001000,
   DelayLoadIATSection = 0x00002000, // Delay load in separate section
   HasLongJmpTable = 0x00010000,
+  HasEHContTable = 0x00400000,
   FidTableHasFlags = 0x10000000, // Indicates that fid tables are 5 bytes
 };
 
 enum class frame_type : uint16_t { Fpo = 0, Trap = 1, Tss = 2, NonFpo = 3 };
 
 struct coff_load_config_code_integrity {
   support::ulittle16_t Flags;
   support::ulittle16_t Catalog;
struct coff_load_configuration32 {
   support::ulittle32_t CHPEMetadataPointer;
   support::ulittle32_t GuardRFFailureRoutine;
   support::ulittle32_t GuardRFFailureRoutineFunctionPointer;
   support::ulittle32_t DynamicValueRelocTableOffset;
   support::ulittle16_t DynamicValueRelocTableSection;
   support::ulittle16_t Reserved2;
   support::ulittle32_t GuardRFVerifyStackPointerFunctionPointer;
   support::ulittle32_t HotPatchTableOffset;
+
+  // Added in MSVC 2019
+  support::ulittle32_t Reserved3;
+  support::ulittle32_t EnclaveConfigurationPointer;
+  support::ulittle32_t VolatileMetadataPointer;
+  support::ulittle32_t GuardEHContinuationTable;
+  support::ulittle32_t GuardEHContinuationCount;
+  support::ulittle32_t GuardXFGCheckFunctionPointer;
+  support::ulittle32_t GuardXFGDispatchFunctionPointer;
+  support::ulittle32_t GuardXFGTableDispatchFunctionPointer;
+  support::ulittle32_t CastGuardOsDeterminedFailureMode;
 };
 
 /// 64-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY64)
 struct coff_load_configuration64 {
   support::ulittle32_t Size;
   support::ulittle32_t TimeDateStamp;
   support::ulittle16_t MajorVersion;
   support::ulittle16_t MinorVersion;
struct coff_load_configuration64 {
   support::ulittle64_t CHPEMetadataPointer;
   support::ulittle64_t GuardRFFailureRoutine;
   support::ulittle64_t GuardRFFailureRoutineFunctionPointer;
   support::ulittle32_t DynamicValueRelocTableOffset;
   support::ulittle16_t DynamicValueRelocTableSection;
   support::ulittle16_t Reserved2;
   support::ulittle64_t GuardRFVerifyStackPointerFunctionPointer;
   support::ulittle32_t HotPatchTableOffset;
+
+  // Added in MSVC 2019
+  support::ulittle32_t Reserved3;
+  support::ulittle64_t EnclaveConfigurationPointer;
+  support::ulittle64_t VolatileMetadataPointer;
+  support::ulittle64_t GuardEHContinuationTable;
+  support::ulittle64_t GuardEHContinuationCount;
+  support::ulittle64_t GuardXFGCheckFunctionPointer;
+  support::ulittle64_t GuardXFGDispatchFunctionPointer;
+  support::ulittle64_t GuardXFGTableDispatchFunctionPointer;
+  support::ulittle64_t CastGuardOsDeterminedFailureMode;
 };
 
 struct coff_runtime_function_x64 {
   support::ulittle32_t BeginAddress;
   support::ulittle32_t EndAddress;
   support::ulittle32_t UnwindInformation;
 };
 

llvm/tools/llvm-readobj/COFFDumper.cpp

struct LoadConfigTables {
   uint64_t SEHTableCount = 0;
   uint32_t GuardFlags = 0;
   uint64_t GuardFidTableVA = 0;
   uint64_t GuardFidTableCount = 0;
   uint64_t GuardIatTableVA = 0;
   uint64_t GuardIatTableCount = 0;
   uint64_t GuardLJmpTableVA = 0;
   uint64_t GuardLJmpTableCount = 0;
+  uint64_t GuardEHContTableVA = 0;
+  uint64_t GuardEHContTableCount = 0;
 };
 
 class COFFDumper : public ObjDumper {
 public:
   friend class COFFObjectDumpDelegate;
   COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer, Obj->getFileName()), Obj(Obj), Writer(Writer),
         Types(100) {}
void COFFDumper::printCOFFLoadConfig() {
   else
     printCOFFLoadConfig(Obj->getLoadConfig32(), Tables);
 
   if (Tables.SEHTableVA) {
     ListScope LS(W, "SEHTable");
     printRVATable(Tables.SEHTableVA, Tables.SEHTableCount, 4);
   }
 
-  if (Tables.GuardFidTableVA) {
-    ListScope LS(W, "GuardFidTable");
-    if (Tables.GuardFlags & uint32_t(coff_guard_flags::FidTableHasFlags)) {
-      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 {
+    else
       printRVATable(Tables.GuardFidTableVA, Tables.GuardFidTableCount, 4);
-    }
-  }
 
   if (Tables.GuardIatTableVA) {
     ListScope LS(W, "GuardIatTable");
     printRVATable(Tables.GuardIatTableVA, Tables.GuardIatTableCount, 4);
   }
 
   if (Tables.GuardLJmpTableVA) {
     ListScope LS(W, "GuardLJmpTable");
     printRVATable(Tables.GuardLJmpTableVA, Tables.GuardLJmpTableCount, 4);
   }
+
+  if (Tables.GuardEHContTableVA) {
+    ListScope LS(W, "GuardEHContTable");
+    printRVATable(Tables.GuardEHContTableVA, Tables.GuardEHContTableCount, 5,
+                  PrintGuardFlags);
+  }
 }
 
 template <typename T>
 void COFFDumper::printCOFFLoadConfig(const T *Conf, LoadConfigTables &Tables) {
   if (!Conf)
     return;
 
   ListScope LS(W, "LoadConfig");
void COFFDumper::printCOFFLoadConfig(const T *Conf, LoadConfigTables &Tables) {
   W.printHex("GuardCFFunctionTable", Conf->GuardCFFunctionTable);
   W.printNumber("GuardCFFunctionCount", Conf->GuardCFFunctionCount);
   W.printHex("GuardFlags", Conf->GuardFlags);
 
   Tables.GuardFidTableVA = Conf->GuardCFFunctionTable;
   Tables.GuardFidTableCount = Conf->GuardCFFunctionCount;
   Tables.GuardFlags = Conf->GuardFlags;
 
-  // Print the rest. (2017)
-  if (Conf->Size < sizeof(T))
+  // Print everything before Reserved3. (2017)
+  if (Conf->Size < offsetof(T, Reserved3))
     return;
   W.printHex("GuardAddressTakenIatEntryTable",
              Conf->GuardAddressTakenIatEntryTable);
   W.printNumber("GuardAddressTakenIatEntryCount",
                 Conf->GuardAddressTakenIatEntryCount);
   W.printHex("GuardLongJumpTargetTable", Conf->GuardLongJumpTargetTable);
   W.printNumber("GuardLongJumpTargetCount", Conf->GuardLongJumpTargetCount);
   W.printHex("DynamicValueRelocTable", Conf->DynamicValueRelocTable);
W.printHex("GuardRFVerifyStackPointerFunctionPointer",
              Conf->GuardRFVerifyStackPointerFunctionPointer);
   W.printHex("HotPatchTableOffset", Conf->HotPatchTableOffset);
 
   Tables.GuardIatTableVA = Conf->GuardAddressTakenIatEntryTable;
   Tables.GuardIatTableCount = Conf->GuardAddressTakenIatEntryCount;
 
   Tables.GuardLJmpTableVA = Conf->GuardLongJumpTargetTable;
   Tables.GuardLJmpTableCount = Conf->GuardLongJumpTargetCount;
+
+  // Print the rest. (2019)
+  if (Conf->Size < sizeof(T))
+    return;
+  W.printHex("EnclaveConfigurationPointer", Conf->EnclaveConfigurationPointer);
+  W.printHex("VolatileMetadataPointer", Conf->VolatileMetadataPointer);
+  W.printHex("GuardEHContinuationTable", Conf->GuardEHContinuationTable);
+  W.printNumber("GuardEHContinuationCount", Conf->GuardEHContinuationCount);
+
+  Tables.GuardEHContTableVA = Conf->GuardEHContinuationTable;
+  Tables.GuardEHContTableCount = Conf->GuardEHContinuationCount;
 }
 
 void COFFDumper::printBaseOfDataField(const pe32_header *Hdr) {
   W.printHex("BaseOfData", Hdr->BaseOfData);
 }
 
 void COFFDumper::printBaseOfDataField(const pe32plus_header *) {}