diff options
Diffstat (limited to 'src/VBox/VMM/testcase/tstVMStruct.h')
| -rw-r--r-- | src/VBox/VMM/testcase/tstVMStruct.h | 1442 |
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 |