Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1442 insertions, 0 deletions

diff --git a/src/VBox/VMM/testcase/tstVMStruct.h b/src/VBox/VMM/testcase/tstVMStruct.h
new file mode 100644
index 00000000..55728bb0
--- /dev/null
+++ b/src/VBox/VMM/testcase/tstVMStruct.h
@@ -0,0 +1,1442 @@
+/* $Id: tstVMStruct.h $ */
+/** @file
+ * tstVMMStruct - Statements for generating VM and VMCPU offset and size tests.
+ *
+ * This is used by tstVMStructRC.cpp and tstVMStructDTrace.cpp.  Tests that
+ * are not yet available in DTrace are blocked by VBOX_FOR_DTRACE_LIB.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+#ifndef VBOX_FOR_DTRACE_LIB
+    GEN_CHECK_SIZE(CFGM);
+#endif
+
+    GEN_CHECK_SIZE(X86CPUIDFEATECX);
+
+    GEN_CHECK_SIZE(CPUM);    // has .mac
+    GEN_CHECK_OFF(CPUM, fHostUseFlags);
+    GEN_CHECK_OFF(CPUM, CR4);
+#ifndef VBOX_FOR_DTRACE_LIB
+    GEN_CHECK_OFF(CPUM, u8PortableCpuIdLevel);
+    GEN_CHECK_OFF(CPUM, fPendingRestore);
+#endif
+    GEN_CHECK_OFF(CPUM, aGuestCpuIdPatmStd);
+    GEN_CHECK_OFF(CPUM, aGuestCpuIdPatmExt);
+    GEN_CHECK_OFF(CPUM, aGuestCpuIdPatmCentaur);
+
+    GEN_CHECK_SIZE(CPUMCPU); // has .mac
+    GEN_CHECK_OFF(CPUMCPU, Hyper);
+    GEN_CHECK_OFF(CPUMCPU, Host);
+#ifdef VBOX_WITH_CRASHDUMP_MAGIC
+    GEN_CHECK_OFF(CPUMCPU, aMagic);
+    GEN_CHECK_OFF(CPUMCPU, uMagic);
+#endif
+    GEN_CHECK_OFF(CPUMCPU, Guest);
+    GEN_CHECK_OFF(CPUMCPU, GuestMsrs);
+    GEN_CHECK_OFF(CPUMCPU, fUseFlags);
+    GEN_CHECK_OFF(CPUMCPU, fChanged);
+    GEN_CHECK_OFF(CPUMCPU, u32RetCode);
+    GEN_CHECK_OFF(CPUMCPU, fCpuIdApicFeatureVisible);
+
+    GEN_CHECK_SIZE(CPUMHOSTCTX);
+    GEN_CHECK_OFF(CPUMHOSTCTX, XState);
+    GEN_CHECK_OFF(CPUMHOSTCTX, abXState);
+#if HC_ARCH_BITS == 64
+    GEN_CHECK_OFF(CPUMHOSTCTX, rbx);
+    GEN_CHECK_OFF(CPUMHOSTCTX, rdi);
+    GEN_CHECK_OFF(CPUMHOSTCTX, rsi);
+    GEN_CHECK_OFF(CPUMHOSTCTX, rbp);
+    GEN_CHECK_OFF(CPUMHOSTCTX, rsp);
+    GEN_CHECK_OFF(CPUMHOSTCTX, r10);
+    GEN_CHECK_OFF(CPUMHOSTCTX, r11);
+    GEN_CHECK_OFF(CPUMHOSTCTX, r12);
+    GEN_CHECK_OFF(CPUMHOSTCTX, r13);
+    GEN_CHECK_OFF(CPUMHOSTCTX, r14);
+    GEN_CHECK_OFF(CPUMHOSTCTX, r15);
+    GEN_CHECK_OFF(CPUMHOSTCTX, rflags);
+#endif
+#if HC_ARCH_BITS == 32
+    GEN_CHECK_OFF(CPUMHOSTCTX, ebx);
+    GEN_CHECK_OFF(CPUMHOSTCTX, edi);
+    GEN_CHECK_OFF(CPUMHOSTCTX, esi);
+    GEN_CHECK_OFF(CPUMHOSTCTX, ebp);
+    GEN_CHECK_OFF(CPUMHOSTCTX, eflags);
+    GEN_CHECK_OFF(CPUMHOSTCTX, esp);
+#endif
+    GEN_CHECK_OFF(CPUMHOSTCTX, ss);
+    GEN_CHECK_OFF(CPUMHOSTCTX, gs);
+    GEN_CHECK_OFF(CPUMHOSTCTX, fs);
+    GEN_CHECK_OFF(CPUMHOSTCTX, es);
+    GEN_CHECK_OFF(CPUMHOSTCTX, ds);
+    GEN_CHECK_OFF(CPUMHOSTCTX, cs);
+#if HC_ARCH_BITS == 32
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr0);
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr3);
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr4);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr0);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr1);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr2);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr3);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr6);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr7);
+    GEN_CHECK_OFF(CPUMHOSTCTX, gdtr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, idtr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, ldtr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, tr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, SysEnter);
+    GEN_CHECK_OFF(CPUMHOSTCTX, efer);
+#elif HC_ARCH_BITS == 64
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr0);
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr3);
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr4);
+    GEN_CHECK_OFF(CPUMHOSTCTX, cr8);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr0);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr1);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr2);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr3);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr6);
+    GEN_CHECK_OFF(CPUMHOSTCTX, dr7);
+    GEN_CHECK_OFF(CPUMHOSTCTX, gdtr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, idtr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, ldtr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, tr);
+    GEN_CHECK_OFF(CPUMHOSTCTX, SysEnter);
+    GEN_CHECK_OFF(CPUMHOSTCTX, FSbase);
+    GEN_CHECK_OFF(CPUMHOSTCTX, GSbase);
+    GEN_CHECK_OFF(CPUMHOSTCTX, efer);
+#else
+# error HC_ARCH_BITS not defined
+#endif
+
+    GEN_CHECK_SIZE(CPUMCTX);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.Vmcb);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.abMsrBitmap);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.abIoBitmap);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.uMsrHSavePa);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.GCPhysVmcb);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.HostState);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.uPrevPauseTick);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.cPauseFilter);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.cPauseFilterThreshold);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.fInterceptEvents);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.GCPhysVmxon);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.GCPhysVmcs);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.enmDiag);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.enmAbort);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uDiagAux);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uAbortAux);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fInVmxRootMode);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fInterceptEvents);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uPrevPauseTick);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uEntryTick);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.offVirtApicWrite);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.Msrs);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.enmHwvirt);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.fGif);
+    GEN_CHECK_OFF(CPUMCTX, hwvirt.fSavedInhibit);
+    /** @todo NSTVMX: add rest of hwvirt fields when code is more
+     *        finalized. */
+    GEN_CHECK_OFF(CPUMCTX, XState);
+    GEN_CHECK_OFF(CPUMCTX, rdi);
+    GEN_CHECK_OFF(CPUMCTX, rsi);
+    GEN_CHECK_OFF(CPUMCTX, rbp);
+    GEN_CHECK_OFF(CPUMCTX, rax);
+    GEN_CHECK_OFF(CPUMCTX, rbx);
+    GEN_CHECK_OFF(CPUMCTX, rdx);
+    GEN_CHECK_OFF(CPUMCTX, rcx);
+    GEN_CHECK_OFF(CPUMCTX, rsp);
+    GEN_CHECK_OFF(CPUMCTX, es);
+#ifndef VBOX_FOR_DTRACE_LIB
+    GEN_CHECK_OFF(CPUMCTX, es.Sel);
+    GEN_CHECK_OFF(CPUMCTX, es.ValidSel);
+    GEN_CHECK_OFF(CPUMCTX, es.fFlags);
+    GEN_CHECK_OFF(CPUMCTX, es.u64Base);
+    GEN_CHECK_OFF(CPUMCTX, es.u32Limit);
+    GEN_CHECK_OFF(CPUMCTX, es.Attr);
+#endif
+    GEN_CHECK_OFF(CPUMCTX, cs);
+    GEN_CHECK_OFF(CPUMCTX, ss);
+    GEN_CHECK_OFF(CPUMCTX, ds);
+    GEN_CHECK_OFF(CPUMCTX, fs);
+    GEN_CHECK_OFF(CPUMCTX, gs);
+    GEN_CHECK_OFF(CPUMCTX, rflags);
+    GEN_CHECK_OFF(CPUMCTX, rip);
+    GEN_CHECK_OFF(CPUMCTX, r8);
+    GEN_CHECK_OFF(CPUMCTX, r9);
+    GEN_CHECK_OFF(CPUMCTX, r10);
+    GEN_CHECK_OFF(CPUMCTX, r11);
+    GEN_CHECK_OFF(CPUMCTX, r12);
+    GEN_CHECK_OFF(CPUMCTX, r13);
+    GEN_CHECK_OFF(CPUMCTX, r14);
+    GEN_CHECK_OFF(CPUMCTX, r15);
+    GEN_CHECK_OFF(CPUMCTX, cr0);
+    GEN_CHECK_OFF(CPUMCTX, cr2);
+    GEN_CHECK_OFF(CPUMCTX, cr3);
+    GEN_CHECK_OFF(CPUMCTX, cr4);
+    GEN_CHECK_OFF(CPUMCTX, dr);
+    GEN_CHECK_OFF(CPUMCTX, gdtr);
+    GEN_CHECK_OFF(CPUMCTX, idtr);
+    GEN_CHECK_OFF(CPUMCTX, ldtr);
+    GEN_CHECK_OFF(CPUMCTX, tr);
+    GEN_CHECK_OFF(CPUMCTX, SysEnter);
+    GEN_CHECK_OFF(CPUMCTX, msrEFER);
+    GEN_CHECK_OFF(CPUMCTX, msrSTAR);
+    GEN_CHECK_OFF(CPUMCTX, msrPAT);
+    GEN_CHECK_OFF(CPUMCTX, msrLSTAR);
+    GEN_CHECK_OFF(CPUMCTX, msrCSTAR);
+    GEN_CHECK_OFF(CPUMCTX, msrSFMASK);
+    GEN_CHECK_OFF(CPUMCTX, msrKERNELGSBASE);
+    GEN_CHECK_OFF(CPUMCTX, ldtr);
+    GEN_CHECK_OFF(CPUMCTX, tr);
+#ifndef VBOX_FOR_DTRACE_LIB
+    GEN_CHECK_OFF(CPUMCTX, tr.Sel);
+    GEN_CHECK_OFF(CPUMCTX, tr.ValidSel);
+    GEN_CHECK_OFF(CPUMCTX, tr.fFlags);
+    GEN_CHECK_OFF(CPUMCTX, tr.u64Base);
+    GEN_CHECK_OFF(CPUMCTX, tr.u32Limit);
+    GEN_CHECK_OFF(CPUMCTX, tr.Attr);
+#endif
+
+    GEN_CHECK_SIZE(CPUMCTXMSRS);
+
+#ifndef VBOX_FOR_DTRACE_LIB
+    GEN_CHECK_SIZE(STAMRATIOU32);
+    GEN_CHECK_SIZE(AVLOHCPHYSNODECORE);
+    GEN_CHECK_SIZE(AVLOGCPHYSNODECORE);
+    GEN_CHECK_SIZE(AVLROGCPHYSNODECORE);
+    GEN_CHECK_SIZE(AVLOGCPTRNODECORE);
+    GEN_CHECK_SIZE(AVLROGCPTRNODECORE);
+    GEN_CHECK_SIZE(AVLOIOPORTNODECORE);
+    GEN_CHECK_SIZE(AVLROIOPORTNODECORE);
+
+    GEN_CHECK_SIZE(DBGF);
+    GEN_CHECK_OFF(DBGF, bmHardIntBreakpoints);
+    GEN_CHECK_OFF(DBGF, bmSoftIntBreakpoints);
+    GEN_CHECK_OFF(DBGF, bmSelectedEvents);
+    GEN_CHECK_OFF(DBGF, cHardIntBreakpoints);
+    GEN_CHECK_OFF(DBGF, cSoftIntBreakpoints);
+    GEN_CHECK_OFF(DBGF, cSelectedEvents);
+    GEN_CHECK_OFF(DBGF, fAttached);
+    //GEN_CHECK_OFF(DBGF, pInfoFirst);
+    //GEN_CHECK_OFF(DBGF, InfoCritSect);
+    GEN_CHECK_OFF(DBGF, cEnabledHwBreakpoints);
+    GEN_CHECK_OFF(DBGF, cEnabledHwIoBreakpoints);
+    GEN_CHECK_OFF(DBGF, aHwBreakpoints);
+    GEN_CHECK_OFF(DBGF, aBreakpoints);
+    GEN_CHECK_OFF(DBGF, Mmio);
+    GEN_CHECK_OFF(DBGF, PortIo);
+    GEN_CHECK_OFF(DBGF, Int3);
+    //GEN_CHECK_OFF(DBGF, hAsDbLock);
+    //GEN_CHECK_OFF(DBGF, hRegDbLock);
+    //GEN_CHECK_OFF(DBGF, RegSetSpace);
+    //GEN_CHECK_OFF(DBGF, pCurOS);
+    GEN_CHECK_SIZE(DBGFEVENT);
+
+    GEN_CHECK_SIZE(DBGFCPU);
+    GEN_CHECK_OFF(DBGFCPU, iActiveBp);
+    GEN_CHECK_OFF(DBGFCPU, fSingleSteppingRaw);
+    GEN_CHECK_OFF(DBGFCPU, cEvents);
+    GEN_CHECK_OFF(DBGFCPU, aEvents);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1]);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event.enmCtx);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event.enmType);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event.u.Bp.iBp);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1].rip);
+    GEN_CHECK_OFF(DBGFCPU, aEvents[1].enmState);
+    //GEN_CHECK_OFF(DBGFCPU, pGuestRegSet);
+    //GEN_CHECK_OFF(DBGFCPU, pHyperRegSet);
+
+    GEN_CHECK_SIZE(EM);
+    GEN_CHECK_OFF(EM, offVM);
+    GEN_CHECK_OFF(EMCPU, enmState);
+    GEN_CHECK_OFF_DOT(EMCPU, u.achPaddingFatalLongJump);
+    GEN_CHECK_OFF(EMCPU, DisState);
+    GEN_CHECK_OFF(EMCPU, StatForcedActions);
+    GEN_CHECK_OFF(EMCPU, StatTotalClis);
+    GEN_CHECK_OFF(EMCPU, pStatsR3);
+    GEN_CHECK_OFF(EMCPU, pStatsR0);
+    GEN_CHECK_OFF(EMCPU, pStatsRC);
+    GEN_CHECK_OFF(EMCPU, pCliStatTree);
+    GEN_CHECK_OFF(EMCPU, PendingIoPortAccess);
+    GEN_CHECK_OFF_DOT(EMCPU, PendingIoPortAccess.uPort);
+    GEN_CHECK_OFF_DOT(EMCPU, PendingIoPortAccess.cbValue);
+    GEN_CHECK_OFF_DOT(EMCPU, PendingIoPortAccess.uValue);
+    GEN_CHECK_OFF(EMCPU, MWait);
+    GEN_CHECK_OFF_DOT(EMCPU, MWait.fWait);
+    GEN_CHECK_OFF_DOT(EMCPU, MWait.uMWaitRAX);
+    GEN_CHECK_OFF_DOT(EMCPU, MWait.uMWaitRCX);
+    GEN_CHECK_OFF_DOT(EMCPU, MWait.uMonitorRAX);
+    GEN_CHECK_OFF_DOT(EMCPU, MWait.uMonitorRCX);
+    GEN_CHECK_OFF_DOT(EMCPU, MWait.uMonitorRDX);
+
+    GEN_CHECK_SIZE(IEMCPU);
+    GEN_CHECK_OFF(IEMCPU, enmCpuMode);
+    GEN_CHECK_OFF(IEMCPU, fPrefixes);
+    GEN_CHECK_OFF(IEMCPU, abOpcode);
+    GEN_CHECK_OFF(IEMCPU, cActiveMappings);
+    GEN_CHECK_OFF(IEMCPU, iNextMapping);
+    GEN_CHECK_OFF(IEMCPU, aMemMappings);
+    GEN_CHECK_OFF(IEMCPU, aMemMappings[1]);
+    GEN_CHECK_OFF(IEMCPU, aBounceBuffers);
+    GEN_CHECK_OFF(IEMCPU, aBounceBuffers[1]);
+    GEN_CHECK_OFF(IEMCPU, aMemBbMappings);
+    GEN_CHECK_OFF(IEMCPU, aMemBbMappings[1]);
+    GEN_CHECK_OFF(IEMCPU, cLogRelRdMsr);
+    GEN_CHECK_OFF(IEMCPU, cLogRelWrMsr);
+    GEN_CHECK_OFF(IEMCPU, DataTlb);
+    GEN_CHECK_OFF(IEMCPU, CodeTlb);
+
+    GEN_CHECK_SIZE(IOM);
+    GEN_CHECK_OFF(IOM, pTreesRC);
+    GEN_CHECK_OFF(IOM, pTreesR3);
+    GEN_CHECK_OFF(IOM, pTreesR0);
+
+    GEN_CHECK_SIZE(IOMCPU);
+    GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite);
+    GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite.IOPort);
+    GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite.u32Value);
+    GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite.cbValue);
+    GEN_CHECK_OFF(IOMCPU, PendingMmioWrite);
+    GEN_CHECK_OFF(IOMCPU, PendingMmioWrite.GCPhys);
+    GEN_CHECK_OFF(IOMCPU, PendingMmioWrite.abValue);
+    GEN_CHECK_OFF(IOMCPU, PendingMmioWrite.cbValue);
+    GEN_CHECK_OFF(IOMCPU, pMMIORangeLastR3);
+    GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastR3);
+    GEN_CHECK_OFF(IOMCPU, pMMIORangeLastR0);
+    GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastR0);
+    GEN_CHECK_OFF(IOMCPU, pMMIORangeLastRC);
+    GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastRC);
+    GEN_CHECK_OFF(IOMCPU, pRangeLastReadR0);
+    GEN_CHECK_OFF(IOMCPU, pRangeLastReadRC);
+
+    GEN_CHECK_SIZE(IOMMMIORANGE);
+    GEN_CHECK_OFF(IOMMMIORANGE, GCPhys);
+    GEN_CHECK_OFF(IOMMMIORANGE, cb);
+    GEN_CHECK_OFF(IOMMMIORANGE, cRefs);
+    GEN_CHECK_OFF(IOMMMIORANGE, fFlags);
+    GEN_CHECK_OFF(IOMMMIORANGE, pszDesc);
+    GEN_CHECK_OFF(IOMMMIORANGE, pvUserR3);
+    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR3);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR3);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR3);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR3);
+    GEN_CHECK_OFF(IOMMMIORANGE, pvUserR0);
+    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR0);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR0);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR0);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR0);
+    GEN_CHECK_OFF(IOMMMIORANGE, pvUserRC);
+    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsRC);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackRC);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackRC);
+    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackRC);
+
+    GEN_CHECK_SIZE(IOMMMIOSTATS);
+    GEN_CHECK_OFF(IOMMMIOSTATS, Accesses);
+    GEN_CHECK_OFF(IOMMMIOSTATS, WriteRZToR3);
+
+    GEN_CHECK_SIZE(IOMIOPORTRANGER0);
+    GEN_CHECK_OFF(IOMIOPORTRANGER0, Port);
+    GEN_CHECK_OFF(IOMIOPORTRANGER0, cPorts);
+    GEN_CHECK_OFF(IOMIOPORTRANGER0, pvUser);
+    GEN_CHECK_OFF(IOMIOPORTRANGER0, pDevIns);
+    GEN_CHECK_OFF(IOMIOPORTRANGER0, pszDesc);
+
+    GEN_CHECK_SIZE(IOMIOPORTRANGERC);
+    GEN_CHECK_OFF(IOMIOPORTRANGERC, Port);
+    GEN_CHECK_OFF(IOMIOPORTRANGERC, cPorts);
+    GEN_CHECK_OFF(IOMIOPORTRANGERC, pvUser);
+    GEN_CHECK_OFF(IOMIOPORTRANGERC, pDevIns);
+    GEN_CHECK_OFF(IOMIOPORTRANGERC, pszDesc);
+
+    GEN_CHECK_SIZE(IOMIOPORTSTATS);
+    GEN_CHECK_OFF(IOMIOPORTSTATS, InR3);
+
+    GEN_CHECK_SIZE(IOMTREES);
+    GEN_CHECK_OFF(IOMTREES, IOPortTreeR3);
+    GEN_CHECK_OFF(IOMTREES, IOPortTreeR0);
+    GEN_CHECK_OFF(IOMTREES, IOPortTreeRC);
+    GEN_CHECK_OFF(IOMTREES, MMIOTree);
+    GEN_CHECK_OFF(IOMTREES, IOPortStatTree);
+    GEN_CHECK_OFF(IOMTREES, MmioStatTree);
+
+    GEN_CHECK_SIZE(MM);
+    GEN_CHECK_OFF(MM, offVM);
+    GEN_CHECK_OFF(MM, offHyperNextStatic);
+    GEN_CHECK_OFF(MM, cbHyperArea);
+    GEN_CHECK_OFF(MM, fDoneMMR3InitPaging);
+    GEN_CHECK_OFF(MM, fPGMInitialized);
+    GEN_CHECK_OFF(MM, offLookupHyper);
+    GEN_CHECK_OFF(MM, pHyperHeapRC);
+    GEN_CHECK_OFF(MM, pHyperHeapR3);
+    GEN_CHECK_OFF(MM, pHyperHeapR0);
+    GEN_CHECK_OFF(MM, pPagePoolR3);
+    GEN_CHECK_OFF(MM, pPagePoolLowR3);
+    GEN_CHECK_OFF(MM, pPagePoolR0);
+    GEN_CHECK_OFF(MM, pPagePoolLowR0);
+    GEN_CHECK_OFF(MM, pvDummyPage);
+    GEN_CHECK_OFF(MM, HCPhysDummyPage);
+    GEN_CHECK_OFF(MM, cbRamBase);
+    GEN_CHECK_OFF(MM, cBasePages);
+    GEN_CHECK_OFF(MM, cHandyPages);
+    GEN_CHECK_OFF(MM, cShadowPages);
+    GEN_CHECK_OFF(MM, cFixedPages);
+    GEN_CHECK_SIZE(MMHYPERSTAT);
+    GEN_CHECK_SIZE(MMHYPERCHUNK);
+    GEN_CHECK_SIZE(MMHYPERCHUNKFREE);
+    GEN_CHECK_SIZE(MMHYPERHEAP);
+    GEN_CHECK_OFF(MMHYPERHEAP, u32Magic);
+    GEN_CHECK_OFF(MMHYPERHEAP, cbHeap);
+    GEN_CHECK_OFF(MMHYPERHEAP, pbHeapR3);
+    GEN_CHECK_OFF(MMHYPERHEAP, pVMR3);
+    GEN_CHECK_OFF(MMHYPERHEAP, pbHeapR0);
+    GEN_CHECK_OFF(MMHYPERHEAP, pVMR0);
+    GEN_CHECK_OFF(MMHYPERHEAP, pbHeapRC);
+    GEN_CHECK_OFF(MMHYPERHEAP, pVMRC);
+    GEN_CHECK_OFF(MMHYPERHEAP, cbFree);
+    GEN_CHECK_OFF(MMHYPERHEAP, offFreeHead);
+    GEN_CHECK_OFF(MMHYPERHEAP, offFreeTail);
+    GEN_CHECK_OFF(MMHYPERHEAP, offPageAligned);
+    GEN_CHECK_OFF(MMHYPERHEAP, HyperHeapStatTree);
+    GEN_CHECK_SIZE(MMLOOKUPHYPER);
+    GEN_CHECK_OFF(MMLOOKUPHYPER, offNext);
+    GEN_CHECK_OFF(MMLOOKUPHYPER, off);
+    GEN_CHECK_OFF(MMLOOKUPHYPER, cb);
+    GEN_CHECK_OFF(MMLOOKUPHYPER, enmType);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.Locked.pvR3);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.Locked.pvR0);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.Locked.paHCPhysPages);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.HCPhys.pvR3);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.HCPhys.HCPhys);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.GCPhys.GCPhys);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.pDevIns);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.iSubDev);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.iRegion);
+    GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.off);
+    GEN_CHECK_OFF(MMLOOKUPHYPER, pszDesc);
+
+    GEN_CHECK_SIZE(NEM);
+    GEN_CHECK_SIZE(NEMCPU);
+
+    GEN_CHECK_SIZE(PDM);
+    GEN_CHECK_OFF(PDM, CritSect);
+    GEN_CHECK_OFF(PDM, NopCritSect);
+    GEN_CHECK_OFF(PDM, pDevs);
+    GEN_CHECK_OFF(PDM, pDevInstances);
+    GEN_CHECK_OFF(PDM, pUsbDevs);
+    GEN_CHECK_OFF(PDM, pUsbInstances);
+    GEN_CHECK_OFF(PDM, pDrvs);
+    GEN_CHECK_OFF(PDM, aPciBuses);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].iBus);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pDevInsR3);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnSetIrqR3);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnRegisterR3);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnIORegionRegisterR3);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pDevInsR0);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnSetIrqR0);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pDevInsRC);
+    GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnSetIrqRC);
+    GEN_CHECK_OFF(PDM, Pic);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pDevInsR3);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pfnSetIrqR3);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pfnGetInterruptR3);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pDevInsR0);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pfnSetIrqR0);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pfnGetInterruptR0);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pDevInsRC);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pfnSetIrqRC);
+    GEN_CHECK_OFF_DOT(PDM, Pic.pfnGetInterruptRC);
+    GEN_CHECK_OFF(PDM, Apic);
+    GEN_CHECK_OFF_DOT(PDM, Apic.pDevInsR3);
+    GEN_CHECK_OFF_DOT(PDM, Apic.pDevInsR0);
+    GEN_CHECK_OFF_DOT(PDM, Apic.pDevInsRC);
+    GEN_CHECK_OFF(PDM, IoApic);
+    GEN_CHECK_OFF_DOT(PDM, IoApic.pDevInsR3);
+    GEN_CHECK_OFF_DOT(PDM, IoApic.pfnSetIrqR3);
+    GEN_CHECK_OFF_DOT(PDM, IoApic.pDevInsR0);
+    GEN_CHECK_OFF_DOT(PDM, IoApic.pfnSetIrqR0);
+    GEN_CHECK_OFF_DOT(PDM, IoApic.pDevInsRC);
+    GEN_CHECK_OFF_DOT(PDM, IoApic.pfnSetIrqRC);
+    GEN_CHECK_OFF(PDM, pDmac);
+    GEN_CHECK_OFF(PDM, pRtc);
+    GEN_CHECK_OFF(PDM, pUsbHubs);
+    GEN_CHECK_OFF(PDM, pDevHlpQueueR3);
+    GEN_CHECK_OFF(PDM, pDevHlpQueueR0);
+    GEN_CHECK_OFF(PDM, pDevHlpQueueRC);
+    GEN_CHECK_OFF(PDMCPU, cQueuedCritSectLeaves);
+    GEN_CHECK_OFF(PDMCPU, apQueuedCritSectLeaves);
+    GEN_CHECK_OFF(PDMCPU, cQueuedCritSectRwExclLeaves);
+    GEN_CHECK_OFF(PDMCPU, apQueuedCritSectRwExclLeaves);
+    GEN_CHECK_OFF(PDMCPU, cQueuedCritSectRwShrdLeaves);
+    GEN_CHECK_OFF(PDMCPU, apQueuedCritSectRwShrdLeaves);
+    GEN_CHECK_OFF(PDM, pQueueFlushR0);
+    GEN_CHECK_OFF(PDM, pQueueFlushRC);
+    GEN_CHECK_OFF(PDM, StatQueuedCritSectLeaves);
+
+    GEN_CHECK_SIZE(PDMDEVINSINT);
+    GEN_CHECK_OFF(PDMDEVINSINT, pNextR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPerDeviceNextR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pDevR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pLunsR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pfnAsyncNotify);
+    GEN_CHECK_OFF(PDMDEVINSINT, pCfgHandle);
+    GEN_CHECK_OFF(PDMDEVINSINT, pVMR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pVMR0);
+    GEN_CHECK_OFF(PDMDEVINSINT, pVMRC);
+    GEN_CHECK_OFF(PDMDEVINSINT, pHeadPciDevR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pHeadPciDevR0);
+    GEN_CHECK_OFF(PDMDEVINSINT, pHeadPciDevRC);
+    GEN_CHECK_OFF(PDMDEVINSINT, fIntFlags);
+    GEN_CHECK_OFF(PDMDEVINSINT, uLastIrqTag);
+    GEN_CHECK_OFF(PDMDEVINS, u32Version);
+    GEN_CHECK_OFF(PDMDEVINS, iInstance);
+    GEN_CHECK_OFF(PDMDEVINS, pHlpRC);
+    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataRC);
+    GEN_CHECK_OFF(PDMDEVINS, pHlpR0);
+    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR0);
+    GEN_CHECK_OFF(PDMDEVINS, pHlpR3);
+    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR3);
+    GEN_CHECK_OFF(PDMDEVINS, pReg);
+    GEN_CHECK_OFF(PDMDEVINS, pCfg);
+    GEN_CHECK_OFF(PDMDEVINS, IBase);
+    GEN_CHECK_OFF(PDMDEVINS, Internal);
+    GEN_CHECK_OFF(PDMDEVINS, achInstanceData);
+
+    GEN_CHECK_SIZE(PDMDRVINSINT);
+    GEN_CHECK_OFF(PDMDRVINSINT, pUp);
+    GEN_CHECK_OFF(PDMDRVINSINT, pDown);
+    GEN_CHECK_OFF(PDMDRVINSINT, pLun);
+    GEN_CHECK_OFF(PDMDRVINSINT, pDrv);
+    GEN_CHECK_OFF(PDMDRVINSINT, pVMR3);
+    GEN_CHECK_OFF(PDMDRVINSINT, pVMR0);
+    GEN_CHECK_OFF(PDMDRVINSINT, pVMRC);
+    GEN_CHECK_OFF(PDMDRVINSINT, fDetaching);
+    GEN_CHECK_OFF(PDMDRVINSINT, fVMSuspended);
+    GEN_CHECK_OFF(PDMDRVINSINT, fVMReset);
+    GEN_CHECK_OFF(PDMDRVINSINT, pfnAsyncNotify);
+    GEN_CHECK_OFF(PDMDRVINSINT, pCfgHandle);
+    GEN_CHECK_OFF(PDMDRVINS, u32Version);
+    GEN_CHECK_OFF(PDMDRVINS, iInstance);
+    GEN_CHECK_OFF(PDMDRVINS, pHlpRC);
+    GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataRC);
+    GEN_CHECK_OFF(PDMDRVINS, pHlpR0);
+    GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataR0);
+    GEN_CHECK_OFF(PDMDRVINS, pHlpR3);
+    GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataR3);
+    GEN_CHECK_OFF(PDMDRVINS, pReg);
+    GEN_CHECK_OFF(PDMDRVINS, pCfg);
+    GEN_CHECK_OFF(PDMDRVINS, IBase);
+    GEN_CHECK_OFF(PDMDRVINS, Internal);
+    GEN_CHECK_OFF(PDMDRVINS, achInstanceData);
+
+    GEN_CHECK_SIZE(PDMCRITSECTINT);
+    GEN_CHECK_OFF(PDMCRITSECTINT, Core);
+    GEN_CHECK_OFF(PDMCRITSECTINT, pNext);
+    GEN_CHECK_OFF(PDMCRITSECTINT, pvKey);
+    GEN_CHECK_OFF(PDMCRITSECTINT, pVMR3);
+    GEN_CHECK_OFF(PDMCRITSECTINT, pVMR0);
+    GEN_CHECK_OFF(PDMCRITSECTINT, pVMRC);
+    GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionRZLock);
+    GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionRZUnlock);
+    GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionR3);
+    GEN_CHECK_OFF(PDMCRITSECTINT, StatLocked);
+    GEN_CHECK_SIZE(PDMCRITSECT);
+    GEN_CHECK_SIZE(PDMCRITSECTRWINT);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, Core);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, pNext);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, pvKey);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, pVMR3);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, pVMR0);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, pVMRC);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, pszName);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, StatContentionRZEnterExcl);
+    GEN_CHECK_OFF(PDMCRITSECTRWINT, StatWriteLocked);
+    GEN_CHECK_SIZE(PDMCRITSECTRW);
+    GEN_CHECK_SIZE(PDMQUEUE);
+    GEN_CHECK_OFF(PDMQUEUE, pNext);
+    GEN_CHECK_OFF(PDMQUEUE, enmType);
+    GEN_CHECK_OFF(PDMQUEUE, u);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Dev.pfnCallback);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Dev.pDevIns);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Drv.pfnCallback);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Drv.pDrvIns);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Int.pfnCallback);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Ext.pfnCallback);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, u.Ext.pvUser);
+    GEN_CHECK_OFF(PDMQUEUE, pVMR3);
+    GEN_CHECK_OFF(PDMQUEUE, pVMR0);
+    GEN_CHECK_OFF(PDMQUEUE, pVMRC);
+    GEN_CHECK_OFF(PDMQUEUE, cMilliesInterval);
+    GEN_CHECK_OFF(PDMQUEUE, pTimer);
+    GEN_CHECK_OFF(PDMQUEUE, cbItem);
+    GEN_CHECK_OFF(PDMQUEUE, cItems);
+    GEN_CHECK_OFF(PDMQUEUE, pPendingR3);
+    GEN_CHECK_OFF(PDMQUEUE, pPendingR0);
+    GEN_CHECK_OFF(PDMQUEUE, pPendingRC);
+    GEN_CHECK_OFF(PDMQUEUE, iFreeHead);
+    GEN_CHECK_OFF(PDMQUEUE, iFreeTail);
+    GEN_CHECK_OFF(PDMQUEUE, pszName);
+    GEN_CHECK_OFF(PDMQUEUE, StatAllocFailures);
+    GEN_CHECK_OFF(PDMQUEUE, StatInsert);
+    GEN_CHECK_OFF(PDMQUEUE, StatFlush);
+    GEN_CHECK_OFF(PDMQUEUE, StatFlushLeftovers);
+    GEN_CHECK_OFF(PDMQUEUE, aFreeItems);
+    GEN_CHECK_OFF(PDMQUEUE, aFreeItems[1]);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, aFreeItems[0].pItemR3);
+    GEN_CHECK_OFF_DOT(PDMQUEUE, aFreeItems[0].pItemR0);
+    GEN_CHECK_SIZE(PDMDEVHLPTASK);
+    GEN_CHECK_OFF(PDMDEVHLPTASK, Core);
+    GEN_CHECK_OFF(PDMDEVHLPTASK, pDevInsR3);
+    GEN_CHECK_OFF(PDMDEVHLPTASK, enmOp);
+    GEN_CHECK_OFF(PDMDEVHLPTASK, u);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IsaSetIRQ.iIrq);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IsaSetIRQ.iLevel);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IsaSetIRQ.uTagSrc);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IoApicSetIRQ.iIrq);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IoApicSetIRQ.iLevel);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IoApicSetIRQ.uTagSrc);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.pPciDevR3);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.iIrq);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.iLevel);
+    GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.uTagSrc);
+
+    GEN_CHECK_SIZE(PGM);
+    GEN_CHECK_OFF(PGM, offVM);
+    GEN_CHECK_OFF(PGM, fRamPreAlloc);
+    GEN_CHECK_OFF(PGM, fUseLargePages);
+    GEN_CHECK_OFF(PGM, paDynPageMap32BitPTEsGC);
+    GEN_CHECK_OFF(PGM, paDynPageMapPaePTEsGC);
+    GEN_CHECK_OFF(PGM, enmHostMode);
+    GEN_CHECK_OFF(PGMCPU, offVM);
+    GEN_CHECK_OFF(PGMCPU, offVCpu);
+    GEN_CHECK_OFF(PGMCPU, offPGM);
+    GEN_CHECK_OFF(PGMCPU, GCPhysA20Mask);
+    GEN_CHECK_OFF(PGMCPU, fA20Enabled);
+    GEN_CHECK_OFF(PGMCPU, fSyncFlags);
+    GEN_CHECK_OFF(PGMCPU, enmShadowMode);
+    GEN_CHECK_OFF(PGMCPU, enmGuestMode);
+    GEN_CHECK_OFF(PGMCPU, GCPhysCR3);
+    GEN_CHECK_OFF(PGM, GCPtrCR3Mapping);
+    GEN_CHECK_OFF(PGMCPU, pGst32BitPdR3);
+    GEN_CHECK_OFF(PGMCPU, pGst32BitPdR0);
+    GEN_CHECK_OFF(PGMCPU, pGst32BitPdRC);
+    GEN_CHECK_OFF(PGMCPU, pGstPaePdptR3);
+    GEN_CHECK_OFF(PGMCPU, pGstPaePdptR0);
+    GEN_CHECK_OFF(PGMCPU, pGstPaePdptRC);
+    GEN_CHECK_OFF(PGMCPU, apGstPaePDsR3);
+    GEN_CHECK_OFF(PGMCPU, apGstPaePDsR0);
+    GEN_CHECK_OFF(PGMCPU, apGstPaePDsRC);
+    GEN_CHECK_OFF(PGMCPU, aGCPhysGstPaePDs);
+    GEN_CHECK_OFF(PGMCPU, pShwPageCR3R3);
+    GEN_CHECK_OFF(PGMCPU, pShwPageCR3R0);
+    GEN_CHECK_OFF(PGMCPU, pShwPageCR3RC);
+    GEN_CHECK_OFF(PGMCPU, DisState);
+    GEN_CHECK_OFF(PGMCPU, cGuestModeChanges);
+#ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(PGMCPU, pStatsR0);
+    GEN_CHECK_OFF(PGMCPU, pStatTrap0eAttributionR0);
+    GEN_CHECK_OFF(PGMCPU, pStatsRC);
+    GEN_CHECK_OFF(PGMCPU, pStatTrap0eAttributionRC);
+    GEN_CHECK_OFF(PGMCPU, pStatsR3);
+#endif
+    GEN_CHECK_OFF(PGM, offVM);
+    GEN_CHECK_OFF(PGM, offVCpuPGM);
+    GEN_CHECK_OFF(PGM, fRamPreAlloc);
+    GEN_CHECK_OFF(PGM, paDynPageMap32BitPTEsGC);
+    GEN_CHECK_OFF(PGM, paDynPageMapPaePTEsGC);
+    GEN_CHECK_OFF(PGM, enmHostMode);
+    GEN_CHECK_OFF(PGM, fRestoreRomPagesOnReset);
+    GEN_CHECK_OFF(PGM, fZeroRamPagesOnReset);
+    GEN_CHECK_OFF(PGM, GCPhys4MBPSEMask);
+    GEN_CHECK_OFF(PGM, pRamRangesXR3);
+    GEN_CHECK_OFF(PGM, pRamRangesXR0);
+    GEN_CHECK_OFF(PGM, pRamRangesXRC);
+    GEN_CHECK_OFF(PGM, pRomRangesR3);
+    GEN_CHECK_OFF(PGM, pRomRangesR0);
+    GEN_CHECK_OFF(PGM, pRomRangesRC);
+    GEN_CHECK_OFF(PGM, pTreesR3);
+    GEN_CHECK_OFF(PGM, pTreesR0);
+    GEN_CHECK_OFF(PGM, pTreesRC);
+    GEN_CHECK_OFF(PGM, pMappingsR3);
+    GEN_CHECK_OFF(PGM, pMappingsRC);
+    GEN_CHECK_OFF(PGM, pMappingsR0);
+    GEN_CHECK_OFF(PGM, fFinalizedMappings);
+    GEN_CHECK_OFF(PGM, fMappingsFixed);
+    GEN_CHECK_OFF(PGM, fMappingsFixedRestored);
+    GEN_CHECK_OFF(PGM, GCPtrMappingFixed);
+    GEN_CHECK_OFF(PGM, cbMappingFixed);
+    GEN_CHECK_OFF(PGM, pInterPD);
+    GEN_CHECK_OFF(PGM, apInterPTs);
+    GEN_CHECK_OFF(PGM, apInterPaePTs);
+    GEN_CHECK_OFF(PGM, apInterPaePDs);
+    GEN_CHECK_OFF(PGM, pInterPaePDPT);
+    GEN_CHECK_OFF(PGM, pInterPaePDPT64);
+    GEN_CHECK_OFF(PGM, pInterPaePML4);
+    GEN_CHECK_OFF(PGM, HCPhysInterPD);
+    GEN_CHECK_OFF(PGM, HCPhysInterPaePDPT);
+    GEN_CHECK_OFF(PGM, HCPhysInterPaePML4);
+    GEN_CHECK_OFF(PGM, pbDynPageMapBaseGC);
+    GEN_CHECK_OFF(PGM, pRCDynMap);
+    GEN_CHECK_OFF(PGM, pvR0DynMapUsed);
+    GEN_CHECK_OFF(PGM, GCPhys4MBPSEMask);
+    GEN_CHECK_OFF(PGMCPU, GCPhysA20Mask);
+    GEN_CHECK_OFF(PGMCPU, fA20Enabled);
+    GEN_CHECK_OFF(PGMCPU, fSyncFlags);
+    GEN_CHECK_OFF(PGM, CritSectX);
+    GEN_CHECK_OFF(PGM, pPoolR3);
+    GEN_CHECK_OFF(PGM, pPoolR0);
+    GEN_CHECK_OFF(PGM, pPoolRC);
+    GEN_CHECK_OFF(PGM, fNoMorePhysWrites);
+    GEN_CHECK_OFF(PGM, ChunkR3Map);
+    GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.pTree);
+    GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.Tlb);
+    GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.c);
+    GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.cMax);
+    GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.iNow);
+    GEN_CHECK_OFF(PGM, PhysTlbHC);
+    GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[0]);
+    GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1]);
+    GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].GCPhys);
+    GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].pMap);
+    GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].pPage);
+    GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].pv);
+    GEN_CHECK_OFF(PGM, HCPhysZeroPg);
+    GEN_CHECK_OFF(PGM, pvZeroPgR3);
+    GEN_CHECK_OFF(PGM, pvZeroPgR0);
+    GEN_CHECK_OFF(PGM, pvZeroPgRC);
+    GEN_CHECK_OFF(PGM, cHandyPages);
+    GEN_CHECK_OFF(PGM, aHandyPages);
+    GEN_CHECK_OFF_DOT(PGM, aHandyPages[1]);
+    GEN_CHECK_OFF_DOT(PGM, aHandyPages[1].HCPhysGCPhys);
+    GEN_CHECK_OFF_DOT(PGM, aHandyPages[1].idPage);
+    GEN_CHECK_OFF_DOT(PGM, aHandyPages[1].idSharedPage);
+    GEN_CHECK_OFF(PGM, cAllPages);
+    GEN_CHECK_OFF(PGM, cPrivatePages);
+    GEN_CHECK_OFF(PGM, cSharedPages);
+    GEN_CHECK_OFF(PGM, cZeroPages);
+    GEN_CHECK_OFF(PGM, cPureMmioPages);
+    GEN_CHECK_OFF(PGM, cMonitoredPages);
+    GEN_CHECK_OFF(PGM, cWrittenToPages);
+    GEN_CHECK_OFF(PGM, cWriteLockedPages);
+    GEN_CHECK_OFF(PGM, cReadLockedPages);
+    GEN_CHECK_OFF(PGM, cRelocations);
+#ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(PGMCPU, pStatsR0);
+    GEN_CHECK_OFF(PGMCPU, pStatsRC);
+    GEN_CHECK_OFF(PGMCPU, pStatsR3);
+#endif
+
+    GEN_CHECK_SIZE(PGMMAPPING);
+    GEN_CHECK_OFF(PGMMAPPING, pNextR3);
+    GEN_CHECK_OFF(PGMMAPPING, pNextRC);
+    GEN_CHECK_OFF(PGMMAPPING, pNextR0);
+    GEN_CHECK_OFF(PGMMAPPING, GCPtr);
+    GEN_CHECK_OFF(PGMMAPPING, GCPtrLast);
+    GEN_CHECK_OFF(PGMMAPPING, cb);
+    GEN_CHECK_OFF(PGMMAPPING, pfnRelocate);
+    GEN_CHECK_OFF(PGMMAPPING, pvUser);
+    GEN_CHECK_OFF(PGMMAPPING, pszDesc);
+    GEN_CHECK_OFF(PGMMAPPING, cPTs);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].HCPhysPT);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].pPTR3);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].pPTR0);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].pPTRC);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].HCPhysPaePT0);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].HCPhysPaePT1);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].paPaePTsR3);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].paPaePTsRC);
+    GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].paPaePTsR0);
+    GEN_CHECK_SIZE(PGMPHYSHANDLER);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, Core);
+    GEN_CHECK_SIZE(((PPGMPHYSHANDLER)0)->Core);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, cPages);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, cAliasedPages);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, cTmpOffPages);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, hType);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR3);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR0);
+    GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserRC);
+    //GEN_CHECK_OFF(PGMPHYSHANDLER, pszDesc);
+    GEN_CHECK_SIZE(PGMPHYSHANDLERTYPEINT);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, u32Magic);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, cRefs);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, ListNode);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, enmKind);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, uState);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR3);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR0);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerR0);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerRC);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerRC);
+    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pszDesc);
+    GEN_CHECK_SIZE(PGMPHYS2VIRTHANDLER);
+    GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, Core);
+    GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, offVirtHandler);
+    GEN_CHECK_SIZE(PGMVIRTHANDLER);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, Core);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, hType);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, cb);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, cPages);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, pszDesc);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, aPhysToVirt);
+    GEN_CHECK_SIZE(PGMVIRTHANDLERTYPEINT);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, u32Magic);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, cRefs);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, ListNode);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, enmKind);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, uState);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, fRelocUserRC);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnHandlerRC);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnPfHandlerRC);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnInvalidateR3);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnHandlerR3);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pszDesc);
+    GEN_CHECK_SIZE(PGMPAGE);
+    GEN_CHECK_OFF_DOT(PGMPAGE, s.cReadLocksY);
+    GEN_CHECK_OFF_DOT(PGMPAGE, s.cWriteLocksY);
+    GEN_CHECK_OFF_DOT(PGMPAGE, s.u16TrackingY);
+    GEN_CHECK_SIZE(PGMRAMRANGE);
+    GEN_CHECK_OFF(PGMRAMRANGE, pNextR3);
+    GEN_CHECK_OFF(PGMRAMRANGE, pNextR0);
+    GEN_CHECK_OFF(PGMRAMRANGE, pNextRC);
+    GEN_CHECK_OFF(PGMRAMRANGE, GCPhys);
+    GEN_CHECK_OFF(PGMRAMRANGE, GCPhysLast);
+    GEN_CHECK_OFF(PGMRAMRANGE, cb);
+    GEN_CHECK_OFF(PGMRAMRANGE, fFlags);
+    GEN_CHECK_OFF(PGMRAMRANGE, pvR3);
+    GEN_CHECK_OFF(PGMRAMRANGE, pszDesc);
+    GEN_CHECK_OFF(PGMRAMRANGE, aPages);
+    GEN_CHECK_OFF(PGMRAMRANGE, aPages[1]);
+    GEN_CHECK_SIZE(PGMROMPAGE);
+    GEN_CHECK_OFF(PGMROMPAGE, Virgin);
+    GEN_CHECK_OFF(PGMROMPAGE, Shadow);
+    GEN_CHECK_OFF(PGMROMPAGE, enmProt);
+    GEN_CHECK_SIZE(PGMROMRANGE);
+    GEN_CHECK_OFF(PGMROMRANGE, pNextR3);
+    GEN_CHECK_OFF(PGMROMRANGE, pNextR0);
+    GEN_CHECK_OFF(PGMROMRANGE, pNextRC);
+    GEN_CHECK_OFF(PGMROMRANGE, GCPhys);
+    GEN_CHECK_OFF(PGMROMRANGE, GCPhysLast);
+    GEN_CHECK_OFF(PGMROMRANGE, cb);
+    GEN_CHECK_OFF(PGMROMRANGE, fFlags);
+    GEN_CHECK_OFF(PGMROMRANGE, cbOriginal);
+    GEN_CHECK_OFF(PGMROMRANGE, pvOriginal);
+    GEN_CHECK_OFF(PGMROMRANGE, pszDesc);
+    GEN_CHECK_OFF(PGMROMRANGE, aPages);
+    GEN_CHECK_OFF(PGMROMRANGE, aPages[1]);
+    GEN_CHECK_SIZE(PGMREGMMIORANGE);
+    GEN_CHECK_OFF(PGMREGMMIORANGE, pDevInsR3);
+    GEN_CHECK_OFF(PGMREGMMIORANGE, pNextR3);
+    GEN_CHECK_OFF(PGMREGMMIORANGE, fFlags);
+    GEN_CHECK_OFF(PGMREGMMIORANGE, iRegion);
+    GEN_CHECK_OFF(PGMREGMMIORANGE, pPhysHandlerR3);
+    GEN_CHECK_OFF(PGMREGMMIORANGE, RamRange);
+    GEN_CHECK_SIZE(PGMTREES);
+    GEN_CHECK_OFF(PGMTREES, PhysHandlers);
+    GEN_CHECK_OFF(PGMTREES, HeadPhysHandlerTypes);
+#ifdef VBOX_WITH_RAW_MODE
+    GEN_CHECK_OFF(PGMTREES, VirtHandlers);
+    GEN_CHECK_OFF(PGMTREES, PhysToVirtHandlers);
+    GEN_CHECK_OFF(PGMTREES, HyperVirtHandlers);
+    GEN_CHECK_OFF(PGMTREES, HeadVirtHandlerTypes);
+#endif
+    GEN_CHECK_SIZE(PGMPOOLPAGE);
+    GEN_CHECK_OFF(PGMPOOLPAGE, Core);
+    GEN_CHECK_OFF(PGMPOOLPAGE, GCPhys);
+    GEN_CHECK_OFF(PGMPOOLPAGE, pvPageR3);
+    GEN_CHECK_OFF(PGMPOOLPAGE, enmKind);
+    GEN_CHECK_OFF(PGMPOOLPAGE, enmAccess);
+    //GEN_CHECK_OFF(PGMPOOLPAGE, fA20Enabled);
+    //GEN_CHECK_OFF(PGMPOOLPAGE, fSeenNonGlobal);
+    //GEN_CHECK_OFF(PGMPOOLPAGE, fMonitored);
+    //GEN_CHECK_OFF(PGMPOOLPAGE, fCached);
+    //GEN_CHECK_OFF(PGMPOOLPAGE, fReusedFlushPending);
+    GEN_CHECK_OFF(PGMPOOLPAGE, idx);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iNext);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iUserHead);
+    GEN_CHECK_OFF(PGMPOOLPAGE, cPresent);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iFirstPresent);
+    GEN_CHECK_OFF(PGMPOOLPAGE, cModifications);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iModifiedNext);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iModifiedPrev);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iMonitoredNext);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iMonitoredPrev);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iAgeNext);
+    GEN_CHECK_OFF(PGMPOOLPAGE, iAgePrev);
+    GEN_CHECK_OFF(PGMPOOLPAGE, idxDirtyEntry);
+    GEN_CHECK_OFF(PGMPOOLPAGE, GCPtrLastAccessHandlerRip);
+    GEN_CHECK_OFF(PGMPOOLPAGE, GCPtrLastAccessHandlerFault);
+    GEN_CHECK_OFF(PGMPOOLPAGE, cLastAccessHandler);
+    GEN_CHECK_OFF(PGMPOOLPAGE, cLocked);
+#ifdef VBOX_STRICT
+    GEN_CHECK_OFF(PGMPOOLPAGE, GCPtrDirtyFault);
+#endif
+    GEN_CHECK_SIZE(PGMPOOL);
+    GEN_CHECK_OFF(PGMPOOL, pVMR3);
+    GEN_CHECK_OFF(PGMPOOL, pVMR0);
+    GEN_CHECK_OFF(PGMPOOL, pVMRC);
+    GEN_CHECK_OFF(PGMPOOL, cMaxPages);
+    GEN_CHECK_OFF(PGMPOOL, cCurPages);
+    GEN_CHECK_OFF(PGMPOOL, iFreeHead);
+    GEN_CHECK_OFF(PGMPOOL, u16Padding);
+#ifdef PGMPOOL_WITH_USER_TRACKING
+    GEN_CHECK_OFF(PGMPOOL, iUserFreeHead);
+    GEN_CHECK_OFF(PGMPOOL, cMaxUsers);
+    GEN_CHECK_OFF(PGMPOOL, cPresent);
+    GEN_CHECK_OFF(PGMPOOL, paUsersR3);
+    GEN_CHECK_OFF(PGMPOOL, paUsersR0);
+    GEN_CHECK_OFF(PGMPOOL, paUsersRC);
+#endif /* PGMPOOL_WITH_USER_TRACKING */
+#ifdef PGMPOOL_WITH_GCPHYS_TRACKING
+    GEN_CHECK_OFF(PGMPOOL, iPhysExtFreeHead);
+    GEN_CHECK_OFF(PGMPOOL, cMaxPhysExts);
+    GEN_CHECK_OFF(PGMPOOL, paPhysExtsR3);
+    GEN_CHECK_OFF(PGMPOOL, paPhysExtsR0);
+    GEN_CHECK_OFF(PGMPOOL, paPhysExtsRC);
+#endif
+#ifdef PGMPOOL_WITH_CACHE
+    GEN_CHECK_OFF(PGMPOOL, aiHash);
+    GEN_CHECK_OFF(PGMPOOL, iAgeHead);
+    GEN_CHECK_OFF(PGMPOOL, iAgeTail);
+    GEN_CHECK_OFF(PGMPOOL, fCacheEnabled);
+#endif
+#ifdef PGMPOOL_WITH_MONITORING
+    GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerRC);
+    GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerR0);
+    GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerR3);
+    GEN_CHECK_OFF(PGMPOOL, pszAccessHandler);
+    GEN_CHECK_OFF(PGMPOOL, iModifiedHead);
+    GEN_CHECK_OFF(PGMPOOL, cModifiedPages);
+#endif
+    GEN_CHECK_OFF(PGMPOOL, cUsedPages);
+#ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(PGMPOOL, cUsedPagesHigh);
+    GEN_CHECK_OFF(PGMPOOL, StatAlloc);
+    GEN_CHECK_OFF(PGMPOOL, StatClearAll);
+#endif
+    GEN_CHECK_OFF(PGMPOOL, HCPhysTree);
+    GEN_CHECK_OFF(PGMPOOL, aPages);
+    GEN_CHECK_OFF(PGMPOOL, aPages[1]);
+    GEN_CHECK_OFF(PGMPOOL, aPages[PGMPOOL_IDX_FIRST - 1]);
+    GEN_CHECK_SIZE(PGMRCDYNMAP);
+    GEN_CHECK_OFF(PGMRCDYNMAP, u32Magic);
+    GEN_CHECK_OFF(PGMRCDYNMAP, paPages);
+    GEN_CHECK_OFF(PGMRCDYNMAP, cPages);
+    GEN_CHECK_OFF(PGMRCDYNMAP, cLoad);
+    GEN_CHECK_OFF(PGMRCDYNMAP, cMaxLoad);
+    GEN_CHECK_OFF(PGMRCDYNMAP, cGuardPages);
+    GEN_CHECK_OFF(PGMRCDYNMAP, cUsers);
+    GEN_CHECK_SIZE(PGMRCDYNMAPENTRY);
+    GEN_CHECK_OFF(PGMRCDYNMAPENTRY, HCPhys);
+    GEN_CHECK_OFF(PGMRCDYNMAPENTRY, pvPage);
+    GEN_CHECK_OFF(PGMRCDYNMAPENTRY, cRefs);
+    GEN_CHECK_OFF_DOT(PGMRCDYNMAPENTRY, uPte.pLegacy);
+    GEN_CHECK_OFF_DOT(PGMRCDYNMAPENTRY, uPte.pPae);
+    GEN_CHECK_OFF(PGMMAPSETENTRY, pvPage);
+    GEN_CHECK_OFF(PGMMAPSETENTRY, iPage);
+    GEN_CHECK_OFF(PGMMAPSETENTRY, cRefs);
+    GEN_CHECK_OFF(PGMMAPSETENTRY, cInlinedRefs);
+    GEN_CHECK_OFF(PGMMAPSETENTRY, cUnrefs);
+    GEN_CHECK_OFF(PGMMAPSETENTRY, HCPhys);
+
+    GEN_CHECK_SIZE(REM);
+    GEN_CHECK_OFF(REM, pCtx);
+    GEN_CHECK_OFF(REM, cCanExecuteRaw);
+    GEN_CHECK_OFF(REM, aGCPtrInvalidatedPages);
+    GEN_CHECK_OFF(REM, idxPendingList);
+    GEN_CHECK_OFF(REM, aHandlerNotifications);
+    GEN_CHECK_OFF(REM, idxFreeList);
+    GEN_CHECK_OFF(REM, CritSectRegister);
+    GEN_CHECK_OFF(REM, rc);
+    GEN_CHECK_OFF(REM, StatsInQEMU);
+    GEN_CHECK_OFF(REM, Env);
+
+    GEN_CHECK_SIZE(REMHANDLERNOTIFICATION);
+    GEN_CHECK_OFF(REMHANDLERNOTIFICATION, enmKind);
+    GEN_CHECK_OFF(REMHANDLERNOTIFICATION, u);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.GCPhys);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.cb);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.enmKind);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.fHasHCHandler);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.GCPhys);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.cb);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.enmKind);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.fHasHCHandler);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.fRestoreAsRAM);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.GCPhysOld);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.GCPhysNew);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.cb);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.enmKind);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.fHasHCHandler);
+    GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.fRestoreAsRAM);
+    GEN_CHECK_OFF(REMHANDLERNOTIFICATION, idxSelf);
+    GEN_CHECK_OFF(REMHANDLERNOTIFICATION, idxNext);
+
+    GEN_CHECK_SIZE(SELM);
+    GEN_CHECK_OFF(SELM, offVM);
+    GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_CS]);
+    GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_DS]);
+    GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_CS64]);
+    GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS]);
+    GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS_TRAP08]);
+    GEN_CHECK_OFF(SELM, hShadowGdtWriteHandlerType);
+    GEN_CHECK_OFF(SELM, hGuestGdtWriteHandlerType);
+    GEN_CHECK_OFF(SELM, paGdtR3);
+    GEN_CHECK_OFF(SELM, paGdtRC);
+    GEN_CHECK_OFF(SELM, GuestGdtr);
+    GEN_CHECK_OFF(SELM, cbEffGuestGdtLimit);
+    GEN_CHECK_OFF(SELM, hShadowLdtWriteHandlerType);
+    GEN_CHECK_OFF(SELM, hGuestLdtWriteHandlerType);
+    GEN_CHECK_OFF(SELM, pvLdtR3);
+    GEN_CHECK_OFF(SELM, pvLdtRC);
+    GEN_CHECK_OFF(SELM, GCPtrGuestLdt);
+    GEN_CHECK_OFF(SELM, cbLdtLimit);
+    GEN_CHECK_OFF(SELM, offLdtHyper);
+    GEN_CHECK_OFF(SELM, Tss);
+    GEN_CHECK_OFF(SELM, TssTrap08);
+    GEN_CHECK_OFF(SELM, hShadowTssWriteHandlerType);
+    GEN_CHECK_OFF(SELM, hGuestTssWriteHandlerType);
+    GEN_CHECK_OFF(SELM, pvMonShwTssRC);
+    GEN_CHECK_OFF(SELM, GCPtrGuestTss);
+    GEN_CHECK_OFF(SELM, cbGuestTss);
+    GEN_CHECK_OFF(SELM, fGuestTss32Bit);
+    GEN_CHECK_OFF(SELM, cbMonitoredGuestTss);
+    GEN_CHECK_OFF(SELM, GCSelTss);
+    GEN_CHECK_OFF(SELM, fGDTRangeRegistered);
+    GEN_CHECK_OFF(SELM, StatUpdateFromCPUM);
+    GEN_CHECK_OFF(SELM, StatStaleToUnstaleSReg);
+    GEN_CHECK_OFF(SELM, StatLoadHidSelGstNoGood);
+
+    GEN_CHECK_SIZE(TM);
+    GEN_CHECK_OFF(TM, offVM);
+    GEN_CHECK_OFF(TM, pvGIPR3);
+    //GEN_CHECK_OFF(TM, pvGIPR0);
+    GEN_CHECK_OFF(TM, pvGIPRC);
+    GEN_CHECK_OFF(TMCPU, fTSCTicking);
+    GEN_CHECK_OFF(TM, enmTSCMode);
+    GEN_CHECK_OFF(TM, fTSCTiedToExecution);
+    GEN_CHECK_OFF(TMCPU, offTSCRawSrc);
+    GEN_CHECK_OFF(TMCPU, u64TSC);
+    GEN_CHECK_OFF(TM, cTSCTicksPerSecond);
+    GEN_CHECK_OFF(TM, cVirtualTicking);
+    GEN_CHECK_OFF(TM, fVirtualWarpDrive);
+    GEN_CHECK_OFF(TM, fVirtualSyncTicking);
+    GEN_CHECK_OFF(TM, fVirtualSyncCatchUp);
+    GEN_CHECK_OFF(TM, u32VirtualWarpDrivePercentage);
+    GEN_CHECK_OFF(TM, u64VirtualOffset);
+    GEN_CHECK_OFF(TM, u64Virtual);
+    GEN_CHECK_OFF(TM, u64VirtualRawPrev);
+    GEN_CHECK_OFF(TM, VirtualGetRawDataR3);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.pu64Prev);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.pfnBad);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.pfnRediscover);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.c1nsSteps);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.cBadPrev);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.cExpired);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.cUpdateRaces);
+    GEN_CHECK_OFF(TM, VirtualGetRawDataR0);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.pu64Prev);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.pfnBad);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.pfnRediscover);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.c1nsSteps);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.cBadPrev);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.cExpired);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.cUpdateRaces);
+    GEN_CHECK_OFF(TM, VirtualGetRawDataRC);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.pu64Prev);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.pfnBad);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.pfnRediscover);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.c1nsSteps);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.cBadPrev);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.cExpired);
+    GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.cUpdateRaces);
+    GEN_CHECK_OFF(TM, pfnVirtualGetRawR3);
+    GEN_CHECK_OFF(TM, pfnVirtualGetRawR0);
+    GEN_CHECK_OFF(TM, pfnVirtualGetRawRC);
+    GEN_CHECK_OFF(TM, u64VirtualWarpDriveStart);
+    GEN_CHECK_OFF(TM, u64VirtualSync);
+    GEN_CHECK_OFF(TM, offVirtualSync);
+    GEN_CHECK_OFF(TM, offVirtualSyncGivenUp);
+    GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpPrev);
+    GEN_CHECK_OFF(TM, u32VirtualSyncCatchUpPercentage);
+    GEN_CHECK_OFF(TM, u32VirtualSyncScheduleSlack);
+    GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpStopThreshold);
+    GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpGiveUpThreshold);
+    GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods);
+    GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[0].u64Start);
+    GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[0].u32Percentage);
+    GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[1].u64Start);
+    GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[1].u32Percentage);
+    GEN_CHECK_OFF(TM, pTimer);
+    GEN_CHECK_OFF(TM, u32TimerMillies);
+    GEN_CHECK_OFF(TM, pFree);
+    GEN_CHECK_OFF(TM, pCreated);
+    GEN_CHECK_OFF(TM, paTimerQueuesR3);
+    GEN_CHECK_OFF(TM, paTimerQueuesR0);
+    GEN_CHECK_OFF(TM, paTimerQueuesRC);
+    GEN_CHECK_OFF(TM, TimerCritSect);
+    GEN_CHECK_OFF(TM, VirtualSyncLock);
+    GEN_CHECK_OFF(TM, StatDoQueues);
+    GEN_CHECK_OFF(TM, StatTimerCallbackSetFF);
+    GEN_CHECK_SIZE(TMTIMER);
+    GEN_CHECK_OFF(TMTIMER, u64Expire);
+    GEN_CHECK_OFF(TMTIMER, enmClock);
+    GEN_CHECK_OFF(TMTIMER, enmType);
+    GEN_CHECK_OFF_DOT(TMTIMER, u.Dev.pfnTimer);
+    GEN_CHECK_OFF_DOT(TMTIMER, u.Dev.pDevIns);
+    GEN_CHECK_OFF_DOT(TMTIMER, u.Drv.pfnTimer);
+    GEN_CHECK_OFF_DOT(TMTIMER, u.Drv.pDrvIns);
+    GEN_CHECK_OFF_DOT(TMTIMER, u.Internal.pfnTimer);
+    GEN_CHECK_OFF_DOT(TMTIMER, u.External.pfnTimer);
+    GEN_CHECK_OFF(TMTIMER, enmState);
+    GEN_CHECK_OFF(TMTIMER, offScheduleNext);
+    GEN_CHECK_OFF(TMTIMER, offNext);
+    GEN_CHECK_OFF(TMTIMER, offPrev);
+    GEN_CHECK_OFF(TMTIMER, pVMR0);
+    GEN_CHECK_OFF(TMTIMER, pVMR3);
+    GEN_CHECK_OFF(TMTIMER, pVMRC);
+    GEN_CHECK_OFF(TMTIMER, uHzHint);
+    GEN_CHECK_OFF(TMTIMER, pvUser);
+    GEN_CHECK_OFF(TMTIMER, pCritSect);
+    GEN_CHECK_OFF(TMTIMER, pBigNext);
+    GEN_CHECK_OFF(TMTIMER, pBigPrev);
+    GEN_CHECK_OFF(TMTIMER, pszDesc);
+    GEN_CHECK_SIZE(TMTIMERQUEUE);
+    GEN_CHECK_OFF(TMTIMERQUEUE, offActive);
+    GEN_CHECK_OFF(TMTIMERQUEUE, offSchedule);
+    GEN_CHECK_OFF(TMTIMERQUEUE, enmClock);
+
+    GEN_CHECK_SIZE(TRPM);
+    GEN_CHECK_SIZE(TRPMCPU);
+    GEN_CHECK_SIZE(VM);  // has .mac
+    GEN_CHECK_SIZE(VMM);
+    GEN_CHECK_OFF(VMM, offVM);
+    GEN_CHECK_OFF(VMM, cbCoreCode);
+    GEN_CHECK_OFF(VMM, HCPhysCoreCode);
+    GEN_CHECK_OFF(VMM, pvCoreCodeR3);
+    GEN_CHECK_OFF(VMM, pvCoreCodeR0);
+    GEN_CHECK_OFF(VMM, pvCoreCodeRC);
+    GEN_CHECK_OFF(VMM, enmSwitcher);
+    GEN_CHECK_OFF(VMM, aoffSwitchers);
+    GEN_CHECK_OFF_DOT(VMM, aoffSwitchers[1]);
+    GEN_CHECK_OFF(VMM, pfnR0ToRawMode);
+    GEN_CHECK_OFF(VMM, pfnRCToHost);
+    GEN_CHECK_OFF(VMM, pfnCallTrampolineRC);
+    GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuest);
+    GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuestV86);
+    GEN_CHECK_OFF(VMM, pRCLoggerRC);
+    GEN_CHECK_OFF(VMM, pRCLoggerR3);
+    GEN_CHECK_OFF(VMM, cbRCLogger);
+    GEN_CHECK_OFF(VMM, fRCLoggerFlushingDisabled);
+    GEN_CHECK_OFF(VMM, fStackGuardsStationed);
+    GEN_CHECK_OFF(VMM, fUsePeriodicPreemptionTimers);
+    GEN_CHECK_OFF(VMM, pYieldTimer);
+    GEN_CHECK_OFF(VMM, cYieldResumeMillies);
+    GEN_CHECK_OFF(VMM, cYieldEveryMillies);
+    GEN_CHECK_OFF(VMM, pahEvtRendezvousEnterOrdered);
+    GEN_CHECK_OFF(VMM, hEvtRendezvousEnterOneByOne);
+    GEN_CHECK_OFF(VMM, hEvtMulRendezvousEnterAllAtOnce);
+    GEN_CHECK_OFF(VMM, hEvtMulRendezvousDone);
+    GEN_CHECK_OFF(VMM, hEvtRendezvousDoneCaller);
+    GEN_CHECK_OFF(VMM, pfnRendezvous);
+    GEN_CHECK_OFF(VMM, pvRendezvousUser);
+    GEN_CHECK_OFF(VMM, fRendezvousFlags);
+    GEN_CHECK_OFF(VMM, cRendezvousEmtsEntered);
+    GEN_CHECK_OFF(VMM, cRendezvousEmtsDone);
+    GEN_CHECK_OFF(VMM, cRendezvousEmtsReturned);
+    GEN_CHECK_OFF(VMM, i32RendezvousStatus);
+    GEN_CHECK_OFF(VMM, u32RendezvousLock);
+    GEN_CHECK_OFF(VMM, szRing0AssertMsg1);
+    GEN_CHECK_OFF(VMM, szRing0AssertMsg2);
+    GEN_CHECK_OFF(VMM, StatRunRC);
+    GEN_CHECK_OFF(VMM, StatRZCallPGMLock);
+    GEN_CHECK_OFF(VMMCPU, iLastGZRc);
+    GEN_CHECK_OFF(VMMCPU, pbEMTStackR3);
+    GEN_CHECK_OFF(VMMCPU, pbEMTStackRC);
+    GEN_CHECK_OFF(VMMCPU, pbEMTStackBottomRC);
+#ifdef LOG_ENABLED
+    GEN_CHECK_OFF(VMMCPU, pR0LoggerR0);
+    GEN_CHECK_OFF(VMMCPU, pR0LoggerR3);
+#endif
+    GEN_CHECK_OFF(VMMCPU, cCallRing3Disabled);
+    GEN_CHECK_OFF(VMMCPU, enmCallRing3Operation);
+    GEN_CHECK_OFF(VMMCPU, CallRing3JmpBufR0);
+    GEN_CHECK_OFF_DOT(VMMCPU, CallRing3JmpBufR0.SpCheck);
+    GEN_CHECK_OFF_DOT(VMMCPU, CallRing3JmpBufR0.SpResume);
+
+    GEN_CHECK_SIZE(RTPINGPONG);
+    GEN_CHECK_SIZE(RTCRITSECT);
+    GEN_CHECK_OFF(RTCRITSECT, u32Magic);
+    GEN_CHECK_OFF(RTCRITSECT, cLockers);
+    GEN_CHECK_OFF(RTCRITSECT, NativeThreadOwner);
+    GEN_CHECK_OFF(RTCRITSECT, cNestings);
+    GEN_CHECK_OFF(RTCRITSECT, fFlags);
+    GEN_CHECK_OFF(RTCRITSECT, EventSem);
+    GEN_CHECK_OFF(RTCRITSECT, pValidatorRec);
+
+    GEN_CHECK_SIZE(CSAM);
+    GEN_CHECK_OFF(CSAM, offVM);
+    GEN_CHECK_OFF(CSAM, pPageTree);
+    GEN_CHECK_OFF(CSAM, aDangerousInstr);
+    GEN_CHECK_OFF(CSAM, aDangerousInstr[1]);
+    GEN_CHECK_OFF(CSAM, aDangerousInstr[CSAM_MAX_DANGR_INSTR - 1]);
+    GEN_CHECK_OFF(CSAM, cDangerousInstr);
+    GEN_CHECK_OFF(CSAM, iDangerousInstr);
+    GEN_CHECK_OFF(CSAM, pPDBitmapGC);
+    GEN_CHECK_OFF(CSAM, pPDHCBitmapGC);
+    GEN_CHECK_OFF(CSAM, pPDBitmapHC);
+    GEN_CHECK_OFF(CSAM, pPDGCBitmapHC);
+    GEN_CHECK_OFF(CSAM, savedstate);
+    GEN_CHECK_OFF_DOT(CSAM, savedstate.pSSM);
+    GEN_CHECK_OFF_DOT(CSAM, savedstate.cPageRecords);
+    GEN_CHECK_OFF_DOT(CSAM, savedstate.cPatchPageRecords);
+    GEN_CHECK_OFF(CSAM, cDirtyPages);
+    GEN_CHECK_OFF(CSAM, pvDirtyBasePage);
+    GEN_CHECK_OFF_DOT(CSAM, pvDirtyBasePage[1]);
+    GEN_CHECK_OFF_DOT(CSAM, pvDirtyBasePage[CSAM_MAX_DIRTY_PAGES - 1]);
+    GEN_CHECK_OFF(CSAM, pvDirtyFaultPage);
+    GEN_CHECK_OFF_DOT(CSAM, pvDirtyFaultPage[1]);
+    GEN_CHECK_OFF_DOT(CSAM, pvDirtyFaultPage[CSAM_MAX_DIRTY_PAGES - 1]);
+    GEN_CHECK_OFF(CSAM, pvCallInstruction);
+    GEN_CHECK_OFF(CSAM, iCallInstruction);
+    GEN_CHECK_OFF(CSAM, fScanningStarted);
+    GEN_CHECK_OFF(CSAM, fGatesChecked);
+    GEN_CHECK_OFF(CSAM, StatNrTraps);
+    GEN_CHECK_OFF(CSAM, StatNrPages);
+
+    GEN_CHECK_SIZE(PATM);
+    GEN_CHECK_OFF(PATM, offVM);
+    GEN_CHECK_OFF(PATM, pPatchMemGC);
+    GEN_CHECK_OFF(PATM, pPatchMemHC);
+    GEN_CHECK_OFF(PATM, cbPatchMem);
+    GEN_CHECK_OFF(PATM, offPatchMem);
+    GEN_CHECK_OFF(PATM, fOutOfMemory);
+    GEN_CHECK_OFF(PATM, deltaReloc);
+    GEN_CHECK_OFF(PATM, pGCStateGC);
+    GEN_CHECK_OFF(PATM, pGCStateHC);
+    GEN_CHECK_OFF(PATM, pGCStackGC);
+    GEN_CHECK_OFF(PATM, pGCStackHC);
+    GEN_CHECK_OFF(PATM, pCPUMCtxGC);
+    GEN_CHECK_OFF(PATM, pStatsGC);
+    GEN_CHECK_OFF(PATM, pStatsHC);
+    GEN_CHECK_OFF(PATM, uCurrentPatchIdx);
+    GEN_CHECK_OFF(PATM, ulCallDepth);
+    GEN_CHECK_OFF(PATM, cPageRecords);
+    GEN_CHECK_OFF(PATM, pPatchedInstrGCLowest);
+    GEN_CHECK_OFF(PATM, pPatchedInstrGCHighest);
+    GEN_CHECK_OFF(PATM, PatchLookupTreeHC);
+    GEN_CHECK_OFF(PATM, PatchLookupTreeGC);
+    GEN_CHECK_OFF(PATM, pfnHelperCallGC);
+    GEN_CHECK_OFF(PATM, pfnHelperRetGC);
+    GEN_CHECK_OFF(PATM, pfnHelperJumpGC);
+    GEN_CHECK_OFF(PATM, pfnHelperIretGC);
+    GEN_CHECK_OFF(PATM, pGlobalPatchRec);
+    GEN_CHECK_OFF(PATM, pfnSysEnterGC);
+    GEN_CHECK_OFF(PATM, pfnSysEnterPatchGC);
+    GEN_CHECK_OFF(PATM, uSysEnterPatchIdx);
+    GEN_CHECK_OFF(PATM, pvFaultMonitor);
+    GEN_CHECK_OFF(PATM, mmio);
+    GEN_CHECK_OFF_DOT(PATM, mmio.GCPhys);
+    GEN_CHECK_OFF_DOT(PATM, mmio.pCachedData);
+    GEN_CHECK_OFF(PATM, savedstate);
+    GEN_CHECK_OFF_DOT(PATM, savedstate.pSSM);
+    GEN_CHECK_OFF_DOT(PATM, savedstate.cPatches);
+    GEN_CHECK_OFF(PATM, StatNrOpcodeRead);
+    GEN_CHECK_OFF(PATM, StatU32FunctionMaxSlotsUsed);
+
+    GEN_CHECK_SIZE(PATMGCSTATE);
+    GEN_CHECK_OFF(PATMGCSTATE, uVMFlags);
+    GEN_CHECK_OFF(PATMGCSTATE, uPendingAction);
+    GEN_CHECK_OFF(PATMGCSTATE, uPatchCalls);
+    GEN_CHECK_OFF(PATMGCSTATE, uScratch);
+    GEN_CHECK_OFF(PATMGCSTATE, uIretEFlags);
+    GEN_CHECK_OFF(PATMGCSTATE, uIretCS);
+    GEN_CHECK_OFF(PATMGCSTATE, uIretEIP);
+    GEN_CHECK_OFF(PATMGCSTATE, Psp);
+    GEN_CHECK_OFF(PATMGCSTATE, fPIF);
+    GEN_CHECK_OFF(PATMGCSTATE, GCPtrInhibitInterrupts);
+    GEN_CHECK_OFF(PATMGCSTATE, Restore);
+    GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uEAX);
+    GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uECX);
+    GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uEDI);
+    GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.eFlags);
+    GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uFlags);
+    GEN_CHECK_SIZE(PATMTREES);
+    GEN_CHECK_OFF(PATMTREES, PatchTree);
+    GEN_CHECK_OFF(PATMTREES, PatchTreeByPatchAddr);
+    GEN_CHECK_OFF(PATMTREES, PatchTreeByPage);
+    GEN_CHECK_SIZE(PATMPATCHREC);
+    GEN_CHECK_OFF(PATMPATCHREC, Core);
+    GEN_CHECK_OFF(PATMPATCHREC, CoreOffset);
+    GEN_CHECK_OFF(PATMPATCHREC, patch);
+    GEN_CHECK_SIZE(PATCHINFO);
+    GEN_CHECK_OFF(PATCHINFO, uState);
+    GEN_CHECK_OFF(PATCHINFO, uOldState);
+    GEN_CHECK_OFF(PATCHINFO, uOpMode);
+    GEN_CHECK_OFF(PATCHINFO, unusedHC);
+    GEN_CHECK_OFF(PATCHINFO, pPrivInstrGC);
+    GEN_CHECK_OFF(PATCHINFO, aPrivInstr);
+    GEN_CHECK_OFF(PATCHINFO, aPrivInstr[1]);
+    GEN_CHECK_OFF(PATCHINFO, aPrivInstr[MAX_INSTR_SIZE - 1]);
+    GEN_CHECK_OFF(PATCHINFO, cbPrivInstr);
+    GEN_CHECK_OFF(PATCHINFO, opcode);
+    GEN_CHECK_OFF(PATCHINFO, cbPatchJump);
+    GEN_CHECK_OFF(PATCHINFO, pPatchJumpDestGC);
+    GEN_CHECK_OFF(PATCHINFO, pPatchBlockOffset);
+    GEN_CHECK_OFF(PATCHINFO, cbPatchBlockSize);
+    GEN_CHECK_OFF(PATCHINFO, uCurPatchOffset);
+    GEN_CHECK_OFF(PATCHINFO, flags);
+    GEN_CHECK_OFF(PATCHINFO, pInstrGCLowest);
+    GEN_CHECK_OFF(PATCHINFO, pInstrGCHighest);
+    GEN_CHECK_OFF(PATCHINFO, FixupTree);
+    GEN_CHECK_OFF(PATCHINFO, nrFixups);
+    GEN_CHECK_OFF(PATCHINFO, JumpTree);
+    GEN_CHECK_OFF(PATCHINFO, nrJumpRecs);
+    GEN_CHECK_OFF(PATCHINFO, Patch2GuestAddrTree);
+    GEN_CHECK_OFF(PATCHINFO, Guest2PatchAddrTree);
+    GEN_CHECK_OFF(PATCHINFO, nrPatch2GuestRecs);
+    GEN_CHECK_OFF(PATCHINFO, unused);
+    GEN_CHECK_OFF_DOT(PATCHINFO, unused.pPatchLocStartHC);
+    GEN_CHECK_OFF_DOT(PATCHINFO, unused.pPatchLocEndHC);
+    GEN_CHECK_OFF_DOT(PATCHINFO, unused.pGuestLoc);
+    GEN_CHECK_OFF_DOT(PATCHINFO, unused.opsize);
+    GEN_CHECK_OFF(PATCHINFO, pTempInfo);
+    GEN_CHECK_OFF(PATCHINFO, pTrampolinePatchesHead);
+    GEN_CHECK_OFF(PATCHINFO, cCodeWrites);
+    GEN_CHECK_OFF(PATCHINFO, cTraps);
+    GEN_CHECK_OFF(PATCHINFO, cInvalidWrites);
+    GEN_CHECK_OFF(PATCHINFO, uPatchIdx);
+    GEN_CHECK_OFF(PATCHINFO, bDirtyOpcode);
+    GEN_CHECK_SIZE(PATMPATCHPAGE);
+    GEN_CHECK_OFF(PATMPATCHPAGE, Core);
+    GEN_CHECK_OFF(PATMPATCHPAGE, pLowestAddrGC);
+    GEN_CHECK_OFF(PATMPATCHPAGE, pHighestAddrGC);
+    GEN_CHECK_OFF(PATMPATCHPAGE, cCount);
+    GEN_CHECK_OFF(PATMPATCHPAGE, cMaxPatches);
+    GEN_CHECK_OFF(PATMPATCHPAGE, papPatch);
+#endif
+
+    GEN_CHECK_SIZE(APIC);
+    GEN_CHECK_OFF(APIC, pvApicPibR0);
+    GEN_CHECK_OFF(APIC, pvApicPibR3);
+    GEN_CHECK_OFF(APIC, cbApicPib);
+    GEN_CHECK_OFF(APIC, enmMaxMode);
+    GEN_CHECK_OFF(APICCPU, pvApicPageR0);
+    GEN_CHECK_OFF(APICCPU, pvApicPageR3);
+    GEN_CHECK_OFF(APICCPU, cbApicPage);
+    GEN_CHECK_OFF(APICCPU, pvApicPibR0);
+    GEN_CHECK_OFF(APICCPU, pvApicPibR3);
+    GEN_CHECK_OFF(APICCPU, ApicPibLevel);
+    GEN_CHECK_OFF(APICCPU, hTimer);
+
+    GEN_CHECK_SIZE(VM);
+    GEN_CHECK_OFF(VM, enmVMState);
+    GEN_CHECK_OFF(VM, fGlobalForcedActions);
+    GEN_CHECK_OFF(VM, paVMPagesR3);
+    GEN_CHECK_OFF(VM, pSession);
+    GEN_CHECK_OFF(VM, pUVM);
+    GEN_CHECK_OFF(VM, pVMR3);
+    GEN_CHECK_OFF(VM, pVMR0ForCall);
+    GEN_CHECK_OFF(VM, pVMRC);
+#ifdef IN_RING0
+    GEN_CHECK_OFF(VM, hSelfUnsafe);
+    GEN_CHECK_OFF(VM, cCpusUnsafe);
+#else
+    GEN_CHECK_OFF(VM, hSelf);
+    GEN_CHECK_OFF(VM, cCpus);
+#endif
+    GEN_CHECK_OFF(VM, uCpuExecutionCap);
+    GEN_CHECK_OFF(VM, cbSelf);
+    GEN_CHECK_OFF(VM, bMainExecutionEngine);
+    GEN_CHECK_OFF(VM, fHMEnabled);
+    GEN_CHECK_OFF(VM, hTraceBufR3);
+    GEN_CHECK_OFF(VM, hTraceBufR0);
+    GEN_CHECK_OFF(VM, cpum);
+    GEN_CHECK_OFF(VM, vmm);
+    GEN_CHECK_OFF(VM, pgm);
+    GEN_CHECK_OFF(VM, hm);
+    GEN_CHECK_OFF(VM, trpm);
+    GEN_CHECK_OFF(VM, selm);
+    GEN_CHECK_OFF(VM, mm);
+    GEN_CHECK_OFF(VM, pdm);
+    GEN_CHECK_OFF(VM, iom);
+#ifdef VBOX_WITH_RAW_MODE
+    GEN_CHECK_OFF(VM, patm);
+    GEN_CHECK_OFF(VM, csam);
+#endif
+    GEN_CHECK_OFF(VM, em);
+    GEN_CHECK_OFF(VM, tm);
+    GEN_CHECK_OFF(VM, dbgf);
+    GEN_CHECK_OFF(VM, ssm);
+    GEN_CHECK_OFF(VM, gim);
+    GEN_CHECK_OFF(VM, vm);
+    GEN_CHECK_OFF(VM, cfgm);
+    GEN_CHECK_OFF(VM, apic);
+
+
+    GEN_CHECK_SIZE(VMCPU);
+    GEN_CHECK_OFF(VMCPU, fLocalForcedActions);
+    GEN_CHECK_OFF(VMCPU, enmState);
+    GEN_CHECK_OFF(VMCPU, pUVCpu);
+    GEN_CHECK_OFF(VMCPU, pVMR3);
+    GEN_CHECK_OFF(VMCPU, pVCpuR0ForVtg);
+    GEN_CHECK_OFF(VMCPU, pVMRC);
+    GEN_CHECK_OFF(VMCPU, idCpu);
+    GEN_CHECK_OFF(VMCPU, hNativeThread);
+    GEN_CHECK_OFF(VMCPU, hNativeThreadR0);
+    GEN_CHECK_OFF(VMCPU, fTraceGroups);
+    GEN_CHECK_OFF(VMCPU, abAdHoc);
+    GEN_CHECK_OFF(VMCPU, aStatAdHoc);
+    GEN_CHECK_OFF(VMCPU, hm);
+    GEN_CHECK_OFF(VMCPU, em);
+    GEN_CHECK_OFF(VMCPU, iem);
+    GEN_CHECK_OFF(VMCPU, trpm);
+    GEN_CHECK_OFF(VMCPU, tm);
+    GEN_CHECK_OFF(VMCPU, vmm);
+    GEN_CHECK_OFF(VMCPU, pdm);
+    GEN_CHECK_OFF(VMCPU, iom);
+    GEN_CHECK_OFF(VMCPU, dbgf);
+    GEN_CHECK_OFF(VMCPU, gim);
+    GEN_CHECK_OFF(VMCPU, apic);
+    GEN_CHECK_OFF(VMCPU, pgm);
+    GEN_CHECK_OFF(VMCPU, cpum);
+
+#ifndef VBOX_FOR_DTRACE_LIB
+    GEN_CHECK_SIZE(DISCPUSTATE);
+    GEN_CHECK_OFF(DISCPUSTATE, Param1);
+    GEN_CHECK_OFF(DISCPUSTATE, Param2);
+    GEN_CHECK_OFF(DISCPUSTATE, Param3);
+    GEN_CHECK_OFF(DISCPUSTATE, i32SibDisp);
+    GEN_CHECK_OFF(DISCPUSTATE, fFilter);
+    GEN_CHECK_OFF(DISCPUSTATE, uInstrAddr);
+    GEN_CHECK_OFF(DISCPUSTATE, abInstr);
+    GEN_CHECK_OFF(DISCPUSTATE, pvUser);
+#endif