VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstVMStruct.h@ 78177

Last change on this file since 78177 was 77609, checked in by vboxsync, 6 years ago

VMM/CPUM: Nested VMX: bugref:9180 Add a bool for tracking virtual-NMI blocking for upcoming changes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 60.2 KB
Line 
1/* $Id: tstVMStruct.h 77609 2019-03-08 09:22:16Z vboxsync $ */
2/** @file
3 * tstVMMStruct - Statements for generating VM and VMCPU offset and size tests.
4 *
5 * This is used by tstVMStructRC.cpp and tstVMStructDTrace.cpp. Tests that
6 * are not yet available in DTrace are blocked by VBOX_FOR_DTRACE_LIB.
7 */
8
9/*
10 * Copyright (C) 2006-2019 Oracle Corporation
11 *
12 * This file is part of VirtualBox Open Source Edition (OSE), as
13 * available from http://www.virtualbox.org. This file is free software;
14 * you can redistribute it and/or modify it under the terms of the GNU
15 * General Public License (GPL) as published by the Free Software
16 * Foundation, in version 2 as it comes in the "COPYING" file of the
17 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19 */
20
21
22#ifndef VBOX_FOR_DTRACE_LIB
23 GEN_CHECK_SIZE(CFGM);
24#endif
25
26 GEN_CHECK_SIZE(X86CPUIDFEATECX);
27
28 GEN_CHECK_SIZE(CPUM); // has .mac
29 GEN_CHECK_OFF(CPUM, offCPUMCPU0);
30 GEN_CHECK_OFF(CPUM, fHostUseFlags);
31 GEN_CHECK_OFF(CPUM, CR4);
32#ifndef VBOX_FOR_DTRACE_LIB
33 GEN_CHECK_OFF(CPUM, u8PortableCpuIdLevel);
34 GEN_CHECK_OFF(CPUM, fPendingRestore);
35#endif
36 GEN_CHECK_OFF(CPUM, aGuestCpuIdPatmStd);
37 GEN_CHECK_OFF(CPUM, aGuestCpuIdPatmExt);
38 GEN_CHECK_OFF(CPUM, aGuestCpuIdPatmCentaur);
39
40 GEN_CHECK_SIZE(CPUMCPU); // has .mac
41 GEN_CHECK_OFF(CPUMCPU, Hyper);
42 GEN_CHECK_OFF(CPUMCPU, Host);
43#ifdef VBOX_WITH_CRASHDUMP_MAGIC
44 GEN_CHECK_OFF(CPUMCPU, aMagic);
45 GEN_CHECK_OFF(CPUMCPU, uMagic);
46#endif
47 GEN_CHECK_OFF(CPUMCPU, Guest);
48 GEN_CHECK_OFF(CPUMCPU, GuestMsrs);
49 GEN_CHECK_OFF(CPUMCPU, fUseFlags);
50 GEN_CHECK_OFF(CPUMCPU, fChanged);
51 GEN_CHECK_OFF(CPUMCPU, offCPUM);
52 GEN_CHECK_OFF(CPUMCPU, u32RetCode);
53#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
54 GEN_CHECK_OFF(CPUMCPU, pvApicBase);
55 GEN_CHECK_OFF(CPUMCPU, fApicDisVectors);
56 GEN_CHECK_OFF(CPUMCPU, fX2Apic);
57#endif
58 GEN_CHECK_OFF(CPUMCPU, fRawEntered);
59 GEN_CHECK_OFF(CPUMCPU, fRemEntered);
60
61 GEN_CHECK_SIZE(CPUMHOSTCTX);
62 GEN_CHECK_OFF(CPUMHOSTCTX, pXStateR3);
63 GEN_CHECK_OFF(CPUMHOSTCTX, pXStateR0);
64 GEN_CHECK_OFF(CPUMHOSTCTX, pXStateRC);
65#if HC_ARCH_BITS == 64
66 GEN_CHECK_OFF(CPUMHOSTCTX, rbx);
67 GEN_CHECK_OFF(CPUMHOSTCTX, rdi);
68 GEN_CHECK_OFF(CPUMHOSTCTX, rsi);
69 GEN_CHECK_OFF(CPUMHOSTCTX, rbp);
70 GEN_CHECK_OFF(CPUMHOSTCTX, rsp);
71 GEN_CHECK_OFF(CPUMHOSTCTX, r10);
72 GEN_CHECK_OFF(CPUMHOSTCTX, r11);
73 GEN_CHECK_OFF(CPUMHOSTCTX, r12);
74 GEN_CHECK_OFF(CPUMHOSTCTX, r13);
75 GEN_CHECK_OFF(CPUMHOSTCTX, r14);
76 GEN_CHECK_OFF(CPUMHOSTCTX, r15);
77 GEN_CHECK_OFF(CPUMHOSTCTX, rflags);
78#endif
79#if HC_ARCH_BITS == 32
80 GEN_CHECK_OFF(CPUMHOSTCTX, ebx);
81 GEN_CHECK_OFF(CPUMHOSTCTX, edi);
82 GEN_CHECK_OFF(CPUMHOSTCTX, esi);
83 GEN_CHECK_OFF(CPUMHOSTCTX, ebp);
84 GEN_CHECK_OFF(CPUMHOSTCTX, eflags);
85 GEN_CHECK_OFF(CPUMHOSTCTX, esp);
86#endif
87 GEN_CHECK_OFF(CPUMHOSTCTX, ss);
88 GEN_CHECK_OFF(CPUMHOSTCTX, gs);
89 GEN_CHECK_OFF(CPUMHOSTCTX, fs);
90 GEN_CHECK_OFF(CPUMHOSTCTX, es);
91 GEN_CHECK_OFF(CPUMHOSTCTX, ds);
92 GEN_CHECK_OFF(CPUMHOSTCTX, cs);
93#if HC_ARCH_BITS == 32
94 GEN_CHECK_OFF(CPUMHOSTCTX, cr0);
95 GEN_CHECK_OFF(CPUMHOSTCTX, cr3);
96 GEN_CHECK_OFF(CPUMHOSTCTX, cr4);
97 GEN_CHECK_OFF(CPUMHOSTCTX, dr0);
98 GEN_CHECK_OFF(CPUMHOSTCTX, dr1);
99 GEN_CHECK_OFF(CPUMHOSTCTX, dr2);
100 GEN_CHECK_OFF(CPUMHOSTCTX, dr3);
101 GEN_CHECK_OFF(CPUMHOSTCTX, dr6);
102 GEN_CHECK_OFF(CPUMHOSTCTX, dr7);
103 GEN_CHECK_OFF(CPUMHOSTCTX, gdtr);
104 GEN_CHECK_OFF(CPUMHOSTCTX, idtr);
105 GEN_CHECK_OFF(CPUMHOSTCTX, ldtr);
106 GEN_CHECK_OFF(CPUMHOSTCTX, tr);
107 GEN_CHECK_OFF(CPUMHOSTCTX, SysEnter);
108 GEN_CHECK_OFF(CPUMHOSTCTX, efer);
109#elif HC_ARCH_BITS == 64
110 GEN_CHECK_OFF(CPUMHOSTCTX, cr0);
111 GEN_CHECK_OFF(CPUMHOSTCTX, cr3);
112 GEN_CHECK_OFF(CPUMHOSTCTX, cr4);
113 GEN_CHECK_OFF(CPUMHOSTCTX, cr8);
114 GEN_CHECK_OFF(CPUMHOSTCTX, dr0);
115 GEN_CHECK_OFF(CPUMHOSTCTX, dr1);
116 GEN_CHECK_OFF(CPUMHOSTCTX, dr2);
117 GEN_CHECK_OFF(CPUMHOSTCTX, dr3);
118 GEN_CHECK_OFF(CPUMHOSTCTX, dr6);
119 GEN_CHECK_OFF(CPUMHOSTCTX, dr7);
120 GEN_CHECK_OFF(CPUMHOSTCTX, gdtr);
121 GEN_CHECK_OFF(CPUMHOSTCTX, idtr);
122 GEN_CHECK_OFF(CPUMHOSTCTX, ldtr);
123 GEN_CHECK_OFF(CPUMHOSTCTX, tr);
124 GEN_CHECK_OFF(CPUMHOSTCTX, SysEnter);
125 GEN_CHECK_OFF(CPUMHOSTCTX, FSbase);
126 GEN_CHECK_OFF(CPUMHOSTCTX, GSbase);
127 GEN_CHECK_OFF(CPUMHOSTCTX, efer);
128#else
129# error HC_ARCH_BITS not defined
130#endif
131
132 GEN_CHECK_SIZE(CPUMCTX);
133 GEN_CHECK_OFF(CPUMCTX, hwvirt);
134 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.uMsrHSavePa);
135 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.GCPhysVmcb);
136 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.pVmcbR0);
137 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.pVmcbR3);
138 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.HostState);
139 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.uPrevPauseTick);
140 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.cPauseFilter);
141 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.cPauseFilterThreshold);
142 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.fInterceptEvents);
143 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.pvMsrBitmapR0);
144 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.pvMsrBitmapR3);
145 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.pvIoBitmapR0);
146 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.pvIoBitmapR3);
147 GEN_CHECK_OFF(CPUMCTX, hwvirt.svm.HCPhysVmcb);
148 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.GCPhysVmxon);
149 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.GCPhysVmcs);
150 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.enmDiag);
151 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.enmAbort);
152 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uAbortAux);
153 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fInVmxRootMode);
154 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode);
155 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fInterceptEvents);
156 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret);
157 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pVmcsR0);
158 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pVmcsR3);
159 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pShadowVmcsR0);
160 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pShadowVmcsR3);
161 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0);
162 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3);
163 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0);
164 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3);
165 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0);
166 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3);
167 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR0);
168 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR3);
169 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0);
170 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3);
171 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvIoBitmapR0);
172 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.pvIoBitmapR3);
173 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick);
174 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uPrevPauseTick);
175 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.uVmentryTick);
176 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.offVirtApicWrite);
177 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking);
178 GEN_CHECK_OFF(CPUMCTX, hwvirt.vmx.Msrs);
179 GEN_CHECK_OFF(CPUMCTX, hwvirt.enmHwvirt);
180 GEN_CHECK_OFF(CPUMCTX, hwvirt.fGif);
181 GEN_CHECK_OFF(CPUMCTX, hwvirt.fLocalForcedActions);
182 /** @todo NSTVMX: add rest of hwvirt fields when code is more
183 * finalized. */
184 GEN_CHECK_OFF(CPUMCTX, pXStateR0);
185 GEN_CHECK_OFF(CPUMCTX, pXStateR3);
186 GEN_CHECK_OFF(CPUMCTX, pXStateRC);
187 GEN_CHECK_OFF(CPUMCTX, rdi);
188 GEN_CHECK_OFF(CPUMCTX, rsi);
189 GEN_CHECK_OFF(CPUMCTX, rbp);
190 GEN_CHECK_OFF(CPUMCTX, rax);
191 GEN_CHECK_OFF(CPUMCTX, rbx);
192 GEN_CHECK_OFF(CPUMCTX, rdx);
193 GEN_CHECK_OFF(CPUMCTX, rcx);
194 GEN_CHECK_OFF(CPUMCTX, rsp);
195 GEN_CHECK_OFF(CPUMCTX, es);
196#ifndef VBOX_FOR_DTRACE_LIB
197 GEN_CHECK_OFF(CPUMCTX, es.Sel);
198 GEN_CHECK_OFF(CPUMCTX, es.ValidSel);
199 GEN_CHECK_OFF(CPUMCTX, es.fFlags);
200 GEN_CHECK_OFF(CPUMCTX, es.u64Base);
201 GEN_CHECK_OFF(CPUMCTX, es.u32Limit);
202 GEN_CHECK_OFF(CPUMCTX, es.Attr);
203#endif
204 GEN_CHECK_OFF(CPUMCTX, cs);
205 GEN_CHECK_OFF(CPUMCTX, ss);
206 GEN_CHECK_OFF(CPUMCTX, ds);
207 GEN_CHECK_OFF(CPUMCTX, fs);
208 GEN_CHECK_OFF(CPUMCTX, gs);
209 GEN_CHECK_OFF(CPUMCTX, rflags);
210 GEN_CHECK_OFF(CPUMCTX, rip);
211 GEN_CHECK_OFF(CPUMCTX, r8);
212 GEN_CHECK_OFF(CPUMCTX, r9);
213 GEN_CHECK_OFF(CPUMCTX, r10);
214 GEN_CHECK_OFF(CPUMCTX, r11);
215 GEN_CHECK_OFF(CPUMCTX, r12);
216 GEN_CHECK_OFF(CPUMCTX, r13);
217 GEN_CHECK_OFF(CPUMCTX, r14);
218 GEN_CHECK_OFF(CPUMCTX, r15);
219 GEN_CHECK_OFF(CPUMCTX, cr0);
220 GEN_CHECK_OFF(CPUMCTX, cr2);
221 GEN_CHECK_OFF(CPUMCTX, cr3);
222 GEN_CHECK_OFF(CPUMCTX, cr4);
223 GEN_CHECK_OFF(CPUMCTX, dr);
224 GEN_CHECK_OFF(CPUMCTX, gdtr);
225 GEN_CHECK_OFF(CPUMCTX, idtr);
226 GEN_CHECK_OFF(CPUMCTX, ldtr);
227 GEN_CHECK_OFF(CPUMCTX, tr);
228 GEN_CHECK_OFF(CPUMCTX, SysEnter);
229 GEN_CHECK_OFF(CPUMCTX, msrEFER);
230 GEN_CHECK_OFF(CPUMCTX, msrSTAR);
231 GEN_CHECK_OFF(CPUMCTX, msrPAT);
232 GEN_CHECK_OFF(CPUMCTX, msrLSTAR);
233 GEN_CHECK_OFF(CPUMCTX, msrCSTAR);
234 GEN_CHECK_OFF(CPUMCTX, msrSFMASK);
235 GEN_CHECK_OFF(CPUMCTX, msrKERNELGSBASE);
236 GEN_CHECK_OFF(CPUMCTX, ldtr);
237 GEN_CHECK_OFF(CPUMCTX, tr);
238#ifndef VBOX_FOR_DTRACE_LIB
239 GEN_CHECK_OFF(CPUMCTX, tr.Sel);
240 GEN_CHECK_OFF(CPUMCTX, tr.ValidSel);
241 GEN_CHECK_OFF(CPUMCTX, tr.fFlags);
242 GEN_CHECK_OFF(CPUMCTX, tr.u64Base);
243 GEN_CHECK_OFF(CPUMCTX, tr.u32Limit);
244 GEN_CHECK_OFF(CPUMCTX, tr.Attr);
245#endif
246
247 GEN_CHECK_SIZE(CPUMCTXMSRS);
248 GEN_CHECK_SIZE(CPUMCTXCORE);
249
250#ifndef VBOX_FOR_DTRACE_LIB
251 GEN_CHECK_SIZE(STAMRATIOU32);
252 GEN_CHECK_SIZE(AVLOHCPHYSNODECORE);
253 GEN_CHECK_SIZE(AVLOGCPHYSNODECORE);
254 GEN_CHECK_SIZE(AVLROGCPHYSNODECORE);
255 GEN_CHECK_SIZE(AVLOGCPTRNODECORE);
256 GEN_CHECK_SIZE(AVLROGCPTRNODECORE);
257 GEN_CHECK_SIZE(AVLOIOPORTNODECORE);
258 GEN_CHECK_SIZE(AVLROIOPORTNODECORE);
259
260 GEN_CHECK_SIZE(DBGF);
261 GEN_CHECK_OFF(DBGF, bmHardIntBreakpoints);
262 GEN_CHECK_OFF(DBGF, bmSoftIntBreakpoints);
263 GEN_CHECK_OFF(DBGF, bmSelectedEvents);
264 GEN_CHECK_OFF(DBGF, cHardIntBreakpoints);
265 GEN_CHECK_OFF(DBGF, cSoftIntBreakpoints);
266 GEN_CHECK_OFF(DBGF, cSelectedEvents);
267 GEN_CHECK_OFF(DBGF, fAttached);
268 GEN_CHECK_OFF(DBGF, fStoppedInHyper);
269 GEN_CHECK_OFF(DBGF, PingPong);
270 GEN_CHECK_OFF(DBGF, DbgEvent);
271 GEN_CHECK_OFF(DBGF, enmVMMCmd);
272 GEN_CHECK_OFF(DBGF, VMMCmdData);
273 //GEN_CHECK_OFF(DBGF, pInfoFirst);
274 //GEN_CHECK_OFF(DBGF, InfoCritSect);
275 GEN_CHECK_OFF(DBGF, cEnabledHwBreakpoints);
276 GEN_CHECK_OFF(DBGF, cEnabledHwIoBreakpoints);
277 GEN_CHECK_OFF(DBGF, aHwBreakpoints);
278 GEN_CHECK_OFF(DBGF, aBreakpoints);
279 GEN_CHECK_OFF(DBGF, Mmio);
280 GEN_CHECK_OFF(DBGF, PortIo);
281 GEN_CHECK_OFF(DBGF, Int3);
282 //GEN_CHECK_OFF(DBGF, hAsDbLock);
283 //GEN_CHECK_OFF(DBGF, hRegDbLock);
284 //GEN_CHECK_OFF(DBGF, RegSetSpace);
285 //GEN_CHECK_OFF(DBGF, pCurOS);
286 GEN_CHECK_SIZE(DBGFEVENT);
287
288 GEN_CHECK_SIZE(DBGFCPU);
289 GEN_CHECK_OFF(DBGFCPU, iActiveBp);
290 GEN_CHECK_OFF(DBGFCPU, fSingleSteppingRaw);
291 GEN_CHECK_OFF(DBGFCPU, cEvents);
292 GEN_CHECK_OFF(DBGFCPU, aEvents);
293 GEN_CHECK_OFF(DBGFCPU, aEvents[1]);
294 GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event);
295 GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event.enmCtx);
296 GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event.enmType);
297 GEN_CHECK_OFF(DBGFCPU, aEvents[1].Event.u.Bp.iBp);
298 GEN_CHECK_OFF(DBGFCPU, aEvents[1].rip);
299 GEN_CHECK_OFF(DBGFCPU, aEvents[1].enmState);
300 //GEN_CHECK_OFF(DBGFCPU, pGuestRegSet);
301 //GEN_CHECK_OFF(DBGFCPU, pHyperRegSet);
302
303 GEN_CHECK_SIZE(EM);
304 GEN_CHECK_OFF(EM, offVM);
305 GEN_CHECK_OFF(EMCPU, enmState);
306 GEN_CHECK_OFF(EMCPU, fForceRAW);
307 GEN_CHECK_OFF_DOT(EMCPU, u.achPaddingFatalLongJump);
308 GEN_CHECK_OFF(EMCPU, DisState);
309 GEN_CHECK_OFF(EMCPU, StatForcedActions);
310 GEN_CHECK_OFF(EMCPU, StatTotalClis);
311 GEN_CHECK_OFF(EMCPU, pStatsR3);
312 GEN_CHECK_OFF(EMCPU, pStatsR0);
313 GEN_CHECK_OFF(EMCPU, pStatsRC);
314 GEN_CHECK_OFF(EMCPU, pCliStatTree);
315 GEN_CHECK_OFF(EMCPU, PendingIoPortAccess);
316 GEN_CHECK_OFF_DOT(EMCPU, PendingIoPortAccess.uPort);
317 GEN_CHECK_OFF_DOT(EMCPU, PendingIoPortAccess.cbValue);
318 GEN_CHECK_OFF_DOT(EMCPU, PendingIoPortAccess.uValue);
319 GEN_CHECK_OFF(EMCPU, MWait);
320 GEN_CHECK_OFF_DOT(EMCPU, MWait.fWait);
321 GEN_CHECK_OFF_DOT(EMCPU, MWait.uMWaitRAX);
322 GEN_CHECK_OFF_DOT(EMCPU, MWait.uMWaitRCX);
323 GEN_CHECK_OFF_DOT(EMCPU, MWait.uMonitorRAX);
324 GEN_CHECK_OFF_DOT(EMCPU, MWait.uMonitorRCX);
325 GEN_CHECK_OFF_DOT(EMCPU, MWait.uMonitorRDX);
326
327 GEN_CHECK_SIZE(IEMCPU);
328 GEN_CHECK_OFF(IEMCPU, enmCpuMode);
329 GEN_CHECK_OFF(IEMCPU, fPrefixes);
330 GEN_CHECK_OFF(IEMCPU, abOpcode);
331 GEN_CHECK_OFF(IEMCPU, cActiveMappings);
332 GEN_CHECK_OFF(IEMCPU, iNextMapping);
333 GEN_CHECK_OFF(IEMCPU, aMemMappings);
334 GEN_CHECK_OFF(IEMCPU, aMemMappings[1]);
335 GEN_CHECK_OFF(IEMCPU, aBounceBuffers);
336 GEN_CHECK_OFF(IEMCPU, aBounceBuffers[1]);
337 GEN_CHECK_OFF(IEMCPU, aMemBbMappings);
338 GEN_CHECK_OFF(IEMCPU, aMemBbMappings[1]);
339 GEN_CHECK_OFF(IEMCPU, cLogRelRdMsr);
340 GEN_CHECK_OFF(IEMCPU, cLogRelWrMsr);
341 GEN_CHECK_OFF(IEMCPU, DataTlb);
342 GEN_CHECK_OFF(IEMCPU, CodeTlb);
343
344 GEN_CHECK_SIZE(IOM);
345 GEN_CHECK_OFF(IOM, pTreesRC);
346 GEN_CHECK_OFF(IOM, pTreesR3);
347 GEN_CHECK_OFF(IOM, pTreesR0);
348
349 GEN_CHECK_SIZE(IOMCPU);
350 GEN_CHECK_OFF(IOMCPU, DisState);
351 GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite);
352 GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite.IOPort);
353 GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite.u32Value);
354 GEN_CHECK_OFF(IOMCPU, PendingIOPortWrite.cbValue);
355 GEN_CHECK_OFF(IOMCPU, PendingMmioWrite);
356 GEN_CHECK_OFF(IOMCPU, PendingMmioWrite.GCPhys);
357 GEN_CHECK_OFF(IOMCPU, PendingMmioWrite.abValue);
358 GEN_CHECK_OFF(IOMCPU, PendingMmioWrite.cbValue);
359 GEN_CHECK_OFF(IOMCPU, pMMIORangeLastR3);
360 GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastR3);
361 GEN_CHECK_OFF(IOMCPU, pMMIORangeLastR0);
362 GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastR0);
363 GEN_CHECK_OFF(IOMCPU, pMMIORangeLastRC);
364 GEN_CHECK_OFF(IOMCPU, pMMIOStatsLastRC);
365 GEN_CHECK_OFF(IOMCPU, pRangeLastReadR0);
366 GEN_CHECK_OFF(IOMCPU, pRangeLastReadRC);
367
368 GEN_CHECK_SIZE(IOMMMIORANGE);
369 GEN_CHECK_OFF(IOMMMIORANGE, GCPhys);
370 GEN_CHECK_OFF(IOMMMIORANGE, cb);
371 GEN_CHECK_OFF(IOMMMIORANGE, cRefs);
372 GEN_CHECK_OFF(IOMMMIORANGE, fFlags);
373 GEN_CHECK_OFF(IOMMMIORANGE, pszDesc);
374 GEN_CHECK_OFF(IOMMMIORANGE, pvUserR3);
375 GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR3);
376 GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR3);
377 GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR3);
378 GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR3);
379 GEN_CHECK_OFF(IOMMMIORANGE, pvUserR0);
380 GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR0);
381 GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR0);
382 GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR0);
383 GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR0);
384 GEN_CHECK_OFF(IOMMMIORANGE, pvUserRC);
385 GEN_CHECK_OFF(IOMMMIORANGE, pDevInsRC);
386 GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackRC);
387 GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackRC);
388 GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackRC);
389
390 GEN_CHECK_SIZE(IOMMMIOSTATS);
391 GEN_CHECK_OFF(IOMMMIOSTATS, Accesses);
392 GEN_CHECK_OFF(IOMMMIOSTATS, WriteRZToR3);
393
394 GEN_CHECK_SIZE(IOMIOPORTRANGER0);
395 GEN_CHECK_OFF(IOMIOPORTRANGER0, Port);
396 GEN_CHECK_OFF(IOMIOPORTRANGER0, cPorts);
397 GEN_CHECK_OFF(IOMIOPORTRANGER0, pvUser);
398 GEN_CHECK_OFF(IOMIOPORTRANGER0, pDevIns);
399 GEN_CHECK_OFF(IOMIOPORTRANGER0, pszDesc);
400
401 GEN_CHECK_SIZE(IOMIOPORTRANGERC);
402 GEN_CHECK_OFF(IOMIOPORTRANGERC, Port);
403 GEN_CHECK_OFF(IOMIOPORTRANGERC, cPorts);
404 GEN_CHECK_OFF(IOMIOPORTRANGERC, pvUser);
405 GEN_CHECK_OFF(IOMIOPORTRANGERC, pDevIns);
406 GEN_CHECK_OFF(IOMIOPORTRANGERC, pszDesc);
407
408 GEN_CHECK_SIZE(IOMIOPORTSTATS);
409 GEN_CHECK_OFF(IOMIOPORTSTATS, InR3);
410
411 GEN_CHECK_SIZE(IOMTREES);
412 GEN_CHECK_OFF(IOMTREES, IOPortTreeR3);
413 GEN_CHECK_OFF(IOMTREES, IOPortTreeR0);
414 GEN_CHECK_OFF(IOMTREES, IOPortTreeRC);
415 GEN_CHECK_OFF(IOMTREES, MMIOTree);
416 GEN_CHECK_OFF(IOMTREES, IOPortStatTree);
417 GEN_CHECK_OFF(IOMTREES, MmioStatTree);
418
419 GEN_CHECK_SIZE(MM);
420 GEN_CHECK_OFF(MM, offVM);
421 GEN_CHECK_OFF(MM, offHyperNextStatic);
422 GEN_CHECK_OFF(MM, cbHyperArea);
423 GEN_CHECK_OFF(MM, fDoneMMR3InitPaging);
424 GEN_CHECK_OFF(MM, fPGMInitialized);
425 GEN_CHECK_OFF(MM, offLookupHyper);
426 GEN_CHECK_OFF(MM, pHyperHeapRC);
427 GEN_CHECK_OFF(MM, pHyperHeapR3);
428 GEN_CHECK_OFF(MM, pHyperHeapR0);
429 GEN_CHECK_OFF(MM, pPagePoolR3);
430 GEN_CHECK_OFF(MM, pPagePoolLowR3);
431#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE
432 GEN_CHECK_OFF(MM, pPagePoolR0);
433 GEN_CHECK_OFF(MM, pPagePoolLowR0);
434#endif
435 GEN_CHECK_OFF(MM, pvDummyPage);
436 GEN_CHECK_OFF(MM, HCPhysDummyPage);
437 GEN_CHECK_OFF(MM, cbRamBase);
438 GEN_CHECK_OFF(MM, cBasePages);
439 GEN_CHECK_OFF(MM, cHandyPages);
440 GEN_CHECK_OFF(MM, cShadowPages);
441 GEN_CHECK_OFF(MM, cFixedPages);
442 GEN_CHECK_SIZE(MMHYPERSTAT);
443 GEN_CHECK_SIZE(MMHYPERCHUNK);
444 GEN_CHECK_SIZE(MMHYPERCHUNKFREE);
445 GEN_CHECK_SIZE(MMHYPERHEAP);
446 GEN_CHECK_OFF(MMHYPERHEAP, u32Magic);
447 GEN_CHECK_OFF(MMHYPERHEAP, cbHeap);
448 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapR3);
449 GEN_CHECK_OFF(MMHYPERHEAP, pVMR3);
450 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapR0);
451 GEN_CHECK_OFF(MMHYPERHEAP, pVMR0);
452 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapRC);
453 GEN_CHECK_OFF(MMHYPERHEAP, pVMRC);
454 GEN_CHECK_OFF(MMHYPERHEAP, cbFree);
455 GEN_CHECK_OFF(MMHYPERHEAP, offFreeHead);
456 GEN_CHECK_OFF(MMHYPERHEAP, offFreeTail);
457 GEN_CHECK_OFF(MMHYPERHEAP, offPageAligned);
458 GEN_CHECK_OFF(MMHYPERHEAP, HyperHeapStatTree);
459 GEN_CHECK_SIZE(MMLOOKUPHYPER);
460 GEN_CHECK_OFF(MMLOOKUPHYPER, offNext);
461 GEN_CHECK_OFF(MMLOOKUPHYPER, off);
462 GEN_CHECK_OFF(MMLOOKUPHYPER, cb);
463 GEN_CHECK_OFF(MMLOOKUPHYPER, enmType);
464 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.Locked.pvR3);
465 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.Locked.pvR0);
466 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.Locked.paHCPhysPages);
467 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.HCPhys.pvR3);
468 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.HCPhys.HCPhys);
469 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.GCPhys.GCPhys);
470 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.pDevIns);
471 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.iSubDev);
472 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.iRegion);
473 GEN_CHECK_OFF_DOT(MMLOOKUPHYPER, u.MMIO2.off);
474 GEN_CHECK_OFF(MMLOOKUPHYPER, pszDesc);
475
476 GEN_CHECK_SIZE(NEM);
477 GEN_CHECK_SIZE(NEMCPU);
478
479 GEN_CHECK_SIZE(PDM);
480 GEN_CHECK_OFF(PDM, CritSect);
481 GEN_CHECK_OFF(PDM, NopCritSect);
482 GEN_CHECK_OFF(PDM, pDevs);
483 GEN_CHECK_OFF(PDM, pDevInstances);
484 GEN_CHECK_OFF(PDM, pUsbDevs);
485 GEN_CHECK_OFF(PDM, pUsbInstances);
486 GEN_CHECK_OFF(PDM, pDrvs);
487 GEN_CHECK_OFF(PDM, aPciBuses);
488 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].iBus);
489 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pDevInsR3);
490 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnSetIrqR3);
491 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnRegisterR3);
492 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnIORegionRegisterR3);
493 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pDevInsR0);
494 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnSetIrqR0);
495 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pDevInsRC);
496 GEN_CHECK_OFF_DOT(PDM, aPciBuses[0].pfnSetIrqRC);
497 GEN_CHECK_OFF(PDM, Pic);
498 GEN_CHECK_OFF_DOT(PDM, Pic.pDevInsR3);
499 GEN_CHECK_OFF_DOT(PDM, Pic.pfnSetIrqR3);
500 GEN_CHECK_OFF_DOT(PDM, Pic.pfnGetInterruptR3);
501 GEN_CHECK_OFF_DOT(PDM, Pic.pDevInsR0);
502 GEN_CHECK_OFF_DOT(PDM, Pic.pfnSetIrqR0);
503 GEN_CHECK_OFF_DOT(PDM, Pic.pfnGetInterruptR0);
504 GEN_CHECK_OFF_DOT(PDM, Pic.pDevInsRC);
505 GEN_CHECK_OFF_DOT(PDM, Pic.pfnSetIrqRC);
506 GEN_CHECK_OFF_DOT(PDM, Pic.pfnGetInterruptRC);
507 GEN_CHECK_OFF(PDM, Apic);
508 GEN_CHECK_OFF_DOT(PDM, Apic.pDevInsR3);
509 GEN_CHECK_OFF_DOT(PDM, Apic.pDevInsR0);
510 GEN_CHECK_OFF_DOT(PDM, Apic.pDevInsRC);
511 GEN_CHECK_OFF(PDM, IoApic);
512 GEN_CHECK_OFF_DOT(PDM, IoApic.pDevInsR3);
513 GEN_CHECK_OFF_DOT(PDM, IoApic.pfnSetIrqR3);
514 GEN_CHECK_OFF_DOT(PDM, IoApic.pDevInsR0);
515 GEN_CHECK_OFF_DOT(PDM, IoApic.pfnSetIrqR0);
516 GEN_CHECK_OFF_DOT(PDM, IoApic.pDevInsRC);
517 GEN_CHECK_OFF_DOT(PDM, IoApic.pfnSetIrqRC);
518 GEN_CHECK_OFF(PDM, pDmac);
519 GEN_CHECK_OFF(PDM, pRtc);
520 GEN_CHECK_OFF(PDM, pUsbHubs);
521 GEN_CHECK_OFF(PDM, pDevHlpQueueR3);
522 GEN_CHECK_OFF(PDM, pDevHlpQueueR0);
523 GEN_CHECK_OFF(PDM, pDevHlpQueueRC);
524 GEN_CHECK_OFF(PDMCPU, cQueuedCritSectLeaves);
525 GEN_CHECK_OFF(PDMCPU, apQueuedCritSectLeaves);
526 GEN_CHECK_OFF(PDMCPU, cQueuedCritSectRwExclLeaves);
527 GEN_CHECK_OFF(PDMCPU, apQueuedCritSectRwExclLeaves);
528 GEN_CHECK_OFF(PDMCPU, cQueuedCritSectRwShrdLeaves);
529 GEN_CHECK_OFF(PDMCPU, apQueuedCritSectRwShrdLeaves);
530 GEN_CHECK_OFF(PDM, pQueueFlushR0);
531 GEN_CHECK_OFF(PDM, pQueueFlushRC);
532 GEN_CHECK_OFF(PDM, StatQueuedCritSectLeaves);
533
534 GEN_CHECK_SIZE(PDMDEVINSINT);
535 GEN_CHECK_OFF(PDMDEVINSINT, pNextR3);
536 GEN_CHECK_OFF(PDMDEVINSINT, pPerDeviceNextR3);
537 GEN_CHECK_OFF(PDMDEVINSINT, pDevR3);
538 GEN_CHECK_OFF(PDMDEVINSINT, pLunsR3);
539 GEN_CHECK_OFF(PDMDEVINSINT, pfnAsyncNotify);
540 GEN_CHECK_OFF(PDMDEVINSINT, pCfgHandle);
541 GEN_CHECK_OFF(PDMDEVINSINT, pVMR3);
542 GEN_CHECK_OFF(PDMDEVINSINT, pVMR0);
543 GEN_CHECK_OFF(PDMDEVINSINT, pVMRC);
544 GEN_CHECK_OFF(PDMDEVINSINT, pHeadPciDevR3);
545 GEN_CHECK_OFF(PDMDEVINSINT, pHeadPciDevR0);
546 GEN_CHECK_OFF(PDMDEVINSINT, pHeadPciDevRC);
547 GEN_CHECK_OFF(PDMDEVINSINT, fIntFlags);
548 GEN_CHECK_OFF(PDMDEVINSINT, uLastIrqTag);
549 GEN_CHECK_OFF(PDMDEVINS, u32Version);
550 GEN_CHECK_OFF(PDMDEVINS, iInstance);
551 GEN_CHECK_OFF(PDMDEVINS, pHlpRC);
552 GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataRC);
553 GEN_CHECK_OFF(PDMDEVINS, pHlpR0);
554 GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR0);
555 GEN_CHECK_OFF(PDMDEVINS, pHlpR3);
556 GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR3);
557 GEN_CHECK_OFF(PDMDEVINS, pReg);
558 GEN_CHECK_OFF(PDMDEVINS, pCfg);
559 GEN_CHECK_OFF(PDMDEVINS, IBase);
560 GEN_CHECK_OFF(PDMDEVINS, Internal);
561 GEN_CHECK_OFF(PDMDEVINS, achInstanceData);
562
563 GEN_CHECK_SIZE(PDMDRVINSINT);
564 GEN_CHECK_OFF(PDMDRVINSINT, pUp);
565 GEN_CHECK_OFF(PDMDRVINSINT, pDown);
566 GEN_CHECK_OFF(PDMDRVINSINT, pLun);
567 GEN_CHECK_OFF(PDMDRVINSINT, pDrv);
568 GEN_CHECK_OFF(PDMDRVINSINT, pVMR3);
569 GEN_CHECK_OFF(PDMDRVINSINT, pVMR0);
570 GEN_CHECK_OFF(PDMDRVINSINT, pVMRC);
571 GEN_CHECK_OFF(PDMDRVINSINT, fDetaching);
572 GEN_CHECK_OFF(PDMDRVINSINT, fVMSuspended);
573 GEN_CHECK_OFF(PDMDRVINSINT, fVMReset);
574 GEN_CHECK_OFF(PDMDRVINSINT, pfnAsyncNotify);
575 GEN_CHECK_OFF(PDMDRVINSINT, pCfgHandle);
576 GEN_CHECK_OFF(PDMDRVINS, u32Version);
577 GEN_CHECK_OFF(PDMDRVINS, iInstance);
578 GEN_CHECK_OFF(PDMDRVINS, pHlpRC);
579 GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataRC);
580 GEN_CHECK_OFF(PDMDRVINS, pHlpR0);
581 GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataR0);
582 GEN_CHECK_OFF(PDMDRVINS, pHlpR3);
583 GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataR3);
584 GEN_CHECK_OFF(PDMDRVINS, pReg);
585 GEN_CHECK_OFF(PDMDRVINS, pCfg);
586 GEN_CHECK_OFF(PDMDRVINS, IBase);
587 GEN_CHECK_OFF(PDMDRVINS, Internal);
588 GEN_CHECK_OFF(PDMDRVINS, achInstanceData);
589
590 GEN_CHECK_SIZE(PDMCRITSECTINT);
591 GEN_CHECK_OFF(PDMCRITSECTINT, Core);
592 GEN_CHECK_OFF(PDMCRITSECTINT, pNext);
593 GEN_CHECK_OFF(PDMCRITSECTINT, pvKey);
594 GEN_CHECK_OFF(PDMCRITSECTINT, pVMR3);
595 GEN_CHECK_OFF(PDMCRITSECTINT, pVMR0);
596 GEN_CHECK_OFF(PDMCRITSECTINT, pVMRC);
597 GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionRZLock);
598 GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionRZUnlock);
599 GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionR3);
600 GEN_CHECK_OFF(PDMCRITSECTINT, StatLocked);
601 GEN_CHECK_SIZE(PDMCRITSECT);
602 GEN_CHECK_SIZE(PDMCRITSECTRWINT);
603 GEN_CHECK_OFF(PDMCRITSECTRWINT, Core);
604 GEN_CHECK_OFF(PDMCRITSECTRWINT, pNext);
605 GEN_CHECK_OFF(PDMCRITSECTRWINT, pvKey);
606 GEN_CHECK_OFF(PDMCRITSECTRWINT, pVMR3);
607 GEN_CHECK_OFF(PDMCRITSECTRWINT, pVMR0);
608 GEN_CHECK_OFF(PDMCRITSECTRWINT, pVMRC);
609 GEN_CHECK_OFF(PDMCRITSECTRWINT, pszName);
610 GEN_CHECK_OFF(PDMCRITSECTRWINT, StatContentionRZEnterExcl);
611 GEN_CHECK_OFF(PDMCRITSECTRWINT, StatWriteLocked);
612 GEN_CHECK_SIZE(PDMCRITSECTRW);
613 GEN_CHECK_SIZE(PDMQUEUE);
614 GEN_CHECK_OFF(PDMQUEUE, pNext);
615 GEN_CHECK_OFF(PDMQUEUE, enmType);
616 GEN_CHECK_OFF(PDMQUEUE, u);
617 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Dev.pfnCallback);
618 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Dev.pDevIns);
619 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Drv.pfnCallback);
620 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Drv.pDrvIns);
621 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Int.pfnCallback);
622 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Ext.pfnCallback);
623 GEN_CHECK_OFF_DOT(PDMQUEUE, u.Ext.pvUser);
624 GEN_CHECK_OFF(PDMQUEUE, pVMR3);
625 GEN_CHECK_OFF(PDMQUEUE, pVMR0);
626 GEN_CHECK_OFF(PDMQUEUE, pVMRC);
627 GEN_CHECK_OFF(PDMQUEUE, cMilliesInterval);
628 GEN_CHECK_OFF(PDMQUEUE, pTimer);
629 GEN_CHECK_OFF(PDMQUEUE, cbItem);
630 GEN_CHECK_OFF(PDMQUEUE, cItems);
631 GEN_CHECK_OFF(PDMQUEUE, pPendingR3);
632 GEN_CHECK_OFF(PDMQUEUE, pPendingR0);
633 GEN_CHECK_OFF(PDMQUEUE, pPendingRC);
634 GEN_CHECK_OFF(PDMQUEUE, iFreeHead);
635 GEN_CHECK_OFF(PDMQUEUE, iFreeTail);
636 GEN_CHECK_OFF(PDMQUEUE, pszName);
637 GEN_CHECK_OFF(PDMQUEUE, StatAllocFailures);
638 GEN_CHECK_OFF(PDMQUEUE, StatInsert);
639 GEN_CHECK_OFF(PDMQUEUE, StatFlush);
640 GEN_CHECK_OFF(PDMQUEUE, StatFlushLeftovers);
641 GEN_CHECK_OFF(PDMQUEUE, aFreeItems);
642 GEN_CHECK_OFF(PDMQUEUE, aFreeItems[1]);
643 GEN_CHECK_OFF_DOT(PDMQUEUE, aFreeItems[0].pItemR3);
644 GEN_CHECK_OFF_DOT(PDMQUEUE, aFreeItems[0].pItemR0);
645 GEN_CHECK_OFF_DOT(PDMQUEUE, aFreeItems[1].pItemRC);
646 GEN_CHECK_SIZE(PDMDEVHLPTASK);
647 GEN_CHECK_OFF(PDMDEVHLPTASK, Core);
648 GEN_CHECK_OFF(PDMDEVHLPTASK, pDevInsR3);
649 GEN_CHECK_OFF(PDMDEVHLPTASK, enmOp);
650 GEN_CHECK_OFF(PDMDEVHLPTASK, u);
651 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IsaSetIRQ.iIrq);
652 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IsaSetIRQ.iLevel);
653 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IsaSetIRQ.uTagSrc);
654 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IoApicSetIRQ.iIrq);
655 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IoApicSetIRQ.iLevel);
656 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.IoApicSetIRQ.uTagSrc);
657 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.pPciDevR3);
658 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.iIrq);
659 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.iLevel);
660 GEN_CHECK_OFF_DOT(PDMDEVHLPTASK, u.PciSetIRQ.uTagSrc);
661
662 GEN_CHECK_SIZE(PGM);
663 GEN_CHECK_OFF(PGM, offVM);
664 GEN_CHECK_OFF(PGM, fRamPreAlloc);
665 GEN_CHECK_OFF(PGM, paDynPageMap32BitPTEsGC);
666 GEN_CHECK_OFF(PGM, paDynPageMapPaePTEsGC);
667 GEN_CHECK_OFF(PGM, enmHostMode);
668 GEN_CHECK_OFF(PGMCPU, offVM);
669 GEN_CHECK_OFF(PGMCPU, offVCpu);
670 GEN_CHECK_OFF(PGMCPU, offPGM);
671#if defined(VBOX_WITH_2X_4GB_ADDR_SPACE) || defined(VBOX_WITH_RAW_MODE)
672 GEN_CHECK_OFF(PGMCPU, AutoSet);
673#endif
674 GEN_CHECK_OFF(PGMCPU, GCPhysA20Mask);
675 GEN_CHECK_OFF(PGMCPU, fA20Enabled);
676 GEN_CHECK_OFF(PGMCPU, fSyncFlags);
677 GEN_CHECK_OFF(PGMCPU, enmShadowMode);
678 GEN_CHECK_OFF(PGMCPU, enmGuestMode);
679 GEN_CHECK_OFF(PGMCPU, GCPhysCR3);
680 GEN_CHECK_OFF(PGM, GCPtrCR3Mapping);
681 GEN_CHECK_OFF(PGMCPU, pGst32BitPdR3);
682#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE
683 GEN_CHECK_OFF(PGMCPU, pGst32BitPdR0);
684#endif
685 GEN_CHECK_OFF(PGMCPU, pGst32BitPdRC);
686 GEN_CHECK_OFF(PGMCPU, pGstPaePdptR3);
687#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE
688 GEN_CHECK_OFF(PGMCPU, pGstPaePdptR0);
689#endif
690 GEN_CHECK_OFF(PGMCPU, pGstPaePdptRC);
691 GEN_CHECK_OFF(PGMCPU, apGstPaePDsR3);
692#ifndef VBOX_WITH_2X_4GB_ADDR_SPACE
693 GEN_CHECK_OFF(PGMCPU, apGstPaePDsR0);
694#endif
695 GEN_CHECK_OFF(PGMCPU, apGstPaePDsRC);
696 GEN_CHECK_OFF(PGMCPU, aGCPhysGstPaePDs);
697 GEN_CHECK_OFF(PGMCPU, aGCPhysGstPaePDsMonitored);
698 GEN_CHECK_OFF(PGMCPU, pShwPageCR3R3);
699 GEN_CHECK_OFF(PGMCPU, pShwPageCR3R0);
700 GEN_CHECK_OFF(PGMCPU, pShwPageCR3RC);
701 GEN_CHECK_OFF(PGMCPU, DisState);
702 GEN_CHECK_OFF(PGMCPU, cGuestModeChanges);
703#ifdef VBOX_WITH_STATISTICS
704 GEN_CHECK_OFF(PGMCPU, pStatsR0);
705 GEN_CHECK_OFF(PGMCPU, pStatTrap0eAttributionR0);
706 GEN_CHECK_OFF(PGMCPU, pStatsRC);
707 GEN_CHECK_OFF(PGMCPU, pStatTrap0eAttributionRC);
708 GEN_CHECK_OFF(PGMCPU, pStatsR3);
709#endif
710 GEN_CHECK_OFF(PGM, offVM);
711 GEN_CHECK_OFF(PGM, offVCpuPGM);
712 GEN_CHECK_OFF(PGM, fRamPreAlloc);
713 GEN_CHECK_OFF(PGM, paDynPageMap32BitPTEsGC);
714 GEN_CHECK_OFF(PGM, paDynPageMapPaePTEsGC);
715 GEN_CHECK_OFF(PGM, enmHostMode);
716 GEN_CHECK_OFF(PGM, fRestoreRomPagesOnReset);
717 GEN_CHECK_OFF(PGM, fZeroRamPagesOnReset);
718 GEN_CHECK_OFF(PGM, GCPhys4MBPSEMask);
719 GEN_CHECK_OFF(PGM, pRamRangesXR3);
720 GEN_CHECK_OFF(PGM, pRamRangesXR0);
721 GEN_CHECK_OFF(PGM, pRamRangesXRC);
722 GEN_CHECK_OFF(PGM, pRomRangesR3);
723 GEN_CHECK_OFF(PGM, pRomRangesR0);
724 GEN_CHECK_OFF(PGM, pRomRangesRC);
725 GEN_CHECK_OFF(PGM, pTreesR3);
726 GEN_CHECK_OFF(PGM, pTreesR0);
727 GEN_CHECK_OFF(PGM, pTreesRC);
728 GEN_CHECK_OFF(PGM, pMappingsR3);
729 GEN_CHECK_OFF(PGM, pMappingsRC);
730 GEN_CHECK_OFF(PGM, pMappingsR0);
731 GEN_CHECK_OFF(PGM, fFinalizedMappings);
732 GEN_CHECK_OFF(PGM, fMappingsFixed);
733 GEN_CHECK_OFF(PGM, fMappingsFixedRestored);
734 GEN_CHECK_OFF(PGM, GCPtrMappingFixed);
735 GEN_CHECK_OFF(PGM, cbMappingFixed);
736 GEN_CHECK_OFF(PGM, pInterPD);
737 GEN_CHECK_OFF(PGM, apInterPTs);
738 GEN_CHECK_OFF(PGM, apInterPaePTs);
739 GEN_CHECK_OFF(PGM, apInterPaePDs);
740 GEN_CHECK_OFF(PGM, pInterPaePDPT);
741 GEN_CHECK_OFF(PGM, pInterPaePDPT64);
742 GEN_CHECK_OFF(PGM, pInterPaePML4);
743 GEN_CHECK_OFF(PGM, HCPhysInterPD);
744 GEN_CHECK_OFF(PGM, HCPhysInterPaePDPT);
745 GEN_CHECK_OFF(PGM, HCPhysInterPaePML4);
746 GEN_CHECK_OFF(PGM, pbDynPageMapBaseGC);
747 GEN_CHECK_OFF(PGM, pRCDynMap);
748 GEN_CHECK_OFF(PGM, pvR0DynMapUsed);
749 GEN_CHECK_OFF(PGM, GCPhys4MBPSEMask);
750 GEN_CHECK_OFF(PGMCPU, GCPhysA20Mask);
751 GEN_CHECK_OFF(PGMCPU, fA20Enabled);
752 GEN_CHECK_OFF(PGMCPU, fSyncFlags);
753 GEN_CHECK_OFF(PGM, CritSectX);
754 GEN_CHECK_OFF(PGM, pPoolR3);
755 GEN_CHECK_OFF(PGM, pPoolR0);
756 GEN_CHECK_OFF(PGM, pPoolRC);
757 GEN_CHECK_OFF(PGM, fNoMorePhysWrites);
758 GEN_CHECK_OFF(PGM, ChunkR3Map);
759 GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.pTree);
760 GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.Tlb);
761 GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.c);
762 GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.cMax);
763 GEN_CHECK_OFF_DOT(PGM, ChunkR3Map.iNow);
764 GEN_CHECK_OFF(PGM, PhysTlbHC);
765 GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[0]);
766 GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1]);
767 GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].GCPhys);
768 GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].pMap);
769 GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].pPage);
770 GEN_CHECK_OFF_DOT(PGM, PhysTlbHC.aEntries[1].pv);
771 GEN_CHECK_OFF(PGM, HCPhysZeroPg);
772 GEN_CHECK_OFF(PGM, pvZeroPgR3);
773 GEN_CHECK_OFF(PGM, pvZeroPgR0);
774 GEN_CHECK_OFF(PGM, pvZeroPgRC);
775 GEN_CHECK_OFF(PGM, cHandyPages);
776 GEN_CHECK_OFF(PGM, aHandyPages);
777 GEN_CHECK_OFF_DOT(PGM, aHandyPages[1]);
778 GEN_CHECK_OFF_DOT(PGM, aHandyPages[1].HCPhysGCPhys);
779 GEN_CHECK_OFF_DOT(PGM, aHandyPages[1].idPage);
780 GEN_CHECK_OFF_DOT(PGM, aHandyPages[1].idSharedPage);
781 GEN_CHECK_OFF(PGM, cAllPages);
782 GEN_CHECK_OFF(PGM, cPrivatePages);
783 GEN_CHECK_OFF(PGM, cSharedPages);
784 GEN_CHECK_OFF(PGM, cZeroPages);
785 GEN_CHECK_OFF(PGM, cPureMmioPages);
786 GEN_CHECK_OFF(PGM, cMonitoredPages);
787 GEN_CHECK_OFF(PGM, cWrittenToPages);
788 GEN_CHECK_OFF(PGM, cWriteLockedPages);
789 GEN_CHECK_OFF(PGM, cReadLockedPages);
790 GEN_CHECK_OFF(PGM, cRelocations);
791#ifdef VBOX_WITH_STATISTICS
792 GEN_CHECK_OFF(PGMCPU, pStatsR0);
793 GEN_CHECK_OFF(PGMCPU, pStatsRC);
794 GEN_CHECK_OFF(PGMCPU, pStatsR3);
795#endif
796
797 GEN_CHECK_SIZE(PGMMAPPING);
798 GEN_CHECK_OFF(PGMMAPPING, pNextR3);
799 GEN_CHECK_OFF(PGMMAPPING, pNextRC);
800 GEN_CHECK_OFF(PGMMAPPING, pNextR0);
801 GEN_CHECK_OFF(PGMMAPPING, GCPtr);
802 GEN_CHECK_OFF(PGMMAPPING, GCPtrLast);
803 GEN_CHECK_OFF(PGMMAPPING, cb);
804 GEN_CHECK_OFF(PGMMAPPING, pfnRelocate);
805 GEN_CHECK_OFF(PGMMAPPING, pvUser);
806 GEN_CHECK_OFF(PGMMAPPING, pszDesc);
807 GEN_CHECK_OFF(PGMMAPPING, cPTs);
808 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].HCPhysPT);
809 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].pPTR3);
810 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].pPTR0);
811 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].pPTRC);
812 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].HCPhysPaePT0);
813 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].HCPhysPaePT1);
814 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].paPaePTsR3);
815 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].paPaePTsRC);
816 GEN_CHECK_OFF_DOT(PGMMAPPING, aPTs[1].paPaePTsR0);
817 GEN_CHECK_SIZE(PGMPHYSHANDLER);
818 GEN_CHECK_OFF(PGMPHYSHANDLER, Core);
819 GEN_CHECK_SIZE(((PPGMPHYSHANDLER)0)->Core);
820 GEN_CHECK_OFF(PGMPHYSHANDLER, cPages);
821 GEN_CHECK_OFF(PGMPHYSHANDLER, cAliasedPages);
822 GEN_CHECK_OFF(PGMPHYSHANDLER, cTmpOffPages);
823 GEN_CHECK_OFF(PGMPHYSHANDLER, hType);
824 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR3);
825 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR0);
826 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserRC);
827 //GEN_CHECK_OFF(PGMPHYSHANDLER, pszDesc);
828 GEN_CHECK_SIZE(PGMPHYSHANDLERTYPEINT);
829 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, u32Magic);
830 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, cRefs);
831 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, ListNode);
832 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, enmKind);
833 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, uState);
834 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR3);
835 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR0);
836 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerR0);
837 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerRC);
838 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerRC);
839 GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pszDesc);
840 GEN_CHECK_SIZE(PGMPHYS2VIRTHANDLER);
841 GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, Core);
842 GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, offVirtHandler);
843 GEN_CHECK_SIZE(PGMVIRTHANDLER);
844 GEN_CHECK_OFF(PGMVIRTHANDLER, Core);
845 GEN_CHECK_OFF(PGMVIRTHANDLER, hType);
846 GEN_CHECK_OFF(PGMVIRTHANDLER, cb);
847 GEN_CHECK_OFF(PGMVIRTHANDLER, cPages);
848 GEN_CHECK_OFF(PGMVIRTHANDLER, pszDesc);
849 GEN_CHECK_OFF(PGMVIRTHANDLER, aPhysToVirt);
850 GEN_CHECK_SIZE(PGMVIRTHANDLERTYPEINT);
851 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, u32Magic);
852 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, cRefs);
853 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, ListNode);
854 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, enmKind);
855 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, uState);
856 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, fRelocUserRC);
857 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnHandlerRC);
858 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnPfHandlerRC);
859 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnInvalidateR3);
860 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnHandlerR3);
861 GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pszDesc);
862 GEN_CHECK_SIZE(PGMPAGE);
863 GEN_CHECK_OFF_DOT(PGMPAGE, s.cReadLocksY);
864 GEN_CHECK_OFF_DOT(PGMPAGE, s.cWriteLocksY);
865 GEN_CHECK_OFF_DOT(PGMPAGE, s.u16TrackingY);
866 GEN_CHECK_SIZE(PGMRAMRANGE);
867 GEN_CHECK_OFF(PGMRAMRANGE, pNextR3);
868 GEN_CHECK_OFF(PGMRAMRANGE, pNextR0);
869 GEN_CHECK_OFF(PGMRAMRANGE, pNextRC);
870 GEN_CHECK_OFF(PGMRAMRANGE, GCPhys);
871 GEN_CHECK_OFF(PGMRAMRANGE, GCPhysLast);
872 GEN_CHECK_OFF(PGMRAMRANGE, cb);
873 GEN_CHECK_OFF(PGMRAMRANGE, fFlags);
874 GEN_CHECK_OFF(PGMRAMRANGE, pvR3);
875 GEN_CHECK_OFF(PGMRAMRANGE, pszDesc);
876 GEN_CHECK_OFF(PGMRAMRANGE, aPages);
877 GEN_CHECK_OFF(PGMRAMRANGE, aPages[1]);
878 GEN_CHECK_SIZE(PGMROMPAGE);
879 GEN_CHECK_OFF(PGMROMPAGE, Virgin);
880 GEN_CHECK_OFF(PGMROMPAGE, Shadow);
881 GEN_CHECK_OFF(PGMROMPAGE, enmProt);
882 GEN_CHECK_SIZE(PGMROMRANGE);
883 GEN_CHECK_OFF(PGMROMRANGE, pNextR3);
884 GEN_CHECK_OFF(PGMROMRANGE, pNextR0);
885 GEN_CHECK_OFF(PGMROMRANGE, pNextRC);
886 GEN_CHECK_OFF(PGMROMRANGE, GCPhys);
887 GEN_CHECK_OFF(PGMROMRANGE, GCPhysLast);
888 GEN_CHECK_OFF(PGMROMRANGE, cb);
889 GEN_CHECK_OFF(PGMROMRANGE, fFlags);
890 GEN_CHECK_OFF(PGMROMRANGE, cbOriginal);
891 GEN_CHECK_OFF(PGMROMRANGE, pvOriginal);
892 GEN_CHECK_OFF(PGMROMRANGE, pszDesc);
893 GEN_CHECK_OFF(PGMROMRANGE, aPages);
894 GEN_CHECK_OFF(PGMROMRANGE, aPages[1]);
895 GEN_CHECK_SIZE(PGMREGMMIORANGE);
896 GEN_CHECK_OFF(PGMREGMMIORANGE, pDevInsR3);
897 GEN_CHECK_OFF(PGMREGMMIORANGE, pNextR3);
898 GEN_CHECK_OFF(PGMREGMMIORANGE, fFlags);
899 GEN_CHECK_OFF(PGMREGMMIORANGE, iRegion);
900 GEN_CHECK_OFF(PGMREGMMIORANGE, pPhysHandlerR3);
901 GEN_CHECK_OFF(PGMREGMMIORANGE, RamRange);
902 GEN_CHECK_SIZE(PGMTREES);
903 GEN_CHECK_OFF(PGMTREES, PhysHandlers);
904 GEN_CHECK_OFF(PGMTREES, HeadPhysHandlerTypes);
905#ifdef VBOX_WITH_RAW_MODE
906 GEN_CHECK_OFF(PGMTREES, VirtHandlers);
907 GEN_CHECK_OFF(PGMTREES, PhysToVirtHandlers);
908 GEN_CHECK_OFF(PGMTREES, HyperVirtHandlers);
909 GEN_CHECK_OFF(PGMTREES, HeadVirtHandlerTypes);
910#endif
911 GEN_CHECK_SIZE(PGMPOOLPAGE);
912 GEN_CHECK_OFF(PGMPOOLPAGE, Core);
913 GEN_CHECK_OFF(PGMPOOLPAGE, GCPhys);
914 GEN_CHECK_OFF(PGMPOOLPAGE, pvPageR3);
915 GEN_CHECK_OFF(PGMPOOLPAGE, enmKind);
916 GEN_CHECK_OFF(PGMPOOLPAGE, enmAccess);
917 //GEN_CHECK_OFF(PGMPOOLPAGE, fA20Enabled);
918 //GEN_CHECK_OFF(PGMPOOLPAGE, fSeenNonGlobal);
919 //GEN_CHECK_OFF(PGMPOOLPAGE, fMonitored);
920 //GEN_CHECK_OFF(PGMPOOLPAGE, fCached);
921 //GEN_CHECK_OFF(PGMPOOLPAGE, fReusedFlushPending);
922 GEN_CHECK_OFF(PGMPOOLPAGE, idx);
923 GEN_CHECK_OFF(PGMPOOLPAGE, iNext);
924 GEN_CHECK_OFF(PGMPOOLPAGE, iUserHead);
925 GEN_CHECK_OFF(PGMPOOLPAGE, cPresent);
926 GEN_CHECK_OFF(PGMPOOLPAGE, iFirstPresent);
927 GEN_CHECK_OFF(PGMPOOLPAGE, cModifications);
928 GEN_CHECK_OFF(PGMPOOLPAGE, iModifiedNext);
929 GEN_CHECK_OFF(PGMPOOLPAGE, iModifiedPrev);
930 GEN_CHECK_OFF(PGMPOOLPAGE, iMonitoredNext);
931 GEN_CHECK_OFF(PGMPOOLPAGE, iMonitoredPrev);
932 GEN_CHECK_OFF(PGMPOOLPAGE, iAgeNext);
933 GEN_CHECK_OFF(PGMPOOLPAGE, iAgePrev);
934 GEN_CHECK_OFF(PGMPOOLPAGE, idxDirtyEntry);
935 GEN_CHECK_OFF(PGMPOOLPAGE, GCPtrLastAccessHandlerRip);
936 GEN_CHECK_OFF(PGMPOOLPAGE, GCPtrLastAccessHandlerFault);
937 GEN_CHECK_OFF(PGMPOOLPAGE, cLastAccessHandler);
938 GEN_CHECK_OFF(PGMPOOLPAGE, cLocked);
939#ifdef VBOX_STRICT
940 GEN_CHECK_OFF(PGMPOOLPAGE, GCPtrDirtyFault);
941#endif
942 GEN_CHECK_SIZE(PGMPOOL);
943 GEN_CHECK_OFF(PGMPOOL, pVMR3);
944 GEN_CHECK_OFF(PGMPOOL, pVMR0);
945 GEN_CHECK_OFF(PGMPOOL, pVMRC);
946 GEN_CHECK_OFF(PGMPOOL, cMaxPages);
947 GEN_CHECK_OFF(PGMPOOL, cCurPages);
948 GEN_CHECK_OFF(PGMPOOL, iFreeHead);
949 GEN_CHECK_OFF(PGMPOOL, u16Padding);
950#ifdef PGMPOOL_WITH_USER_TRACKING
951 GEN_CHECK_OFF(PGMPOOL, iUserFreeHead);
952 GEN_CHECK_OFF(PGMPOOL, cMaxUsers);
953 GEN_CHECK_OFF(PGMPOOL, cPresent);
954 GEN_CHECK_OFF(PGMPOOL, paUsersR3);
955 GEN_CHECK_OFF(PGMPOOL, paUsersR0);
956 GEN_CHECK_OFF(PGMPOOL, paUsersRC);
957#endif /* PGMPOOL_WITH_USER_TRACKING */
958#ifdef PGMPOOL_WITH_GCPHYS_TRACKING
959 GEN_CHECK_OFF(PGMPOOL, iPhysExtFreeHead);
960 GEN_CHECK_OFF(PGMPOOL, cMaxPhysExts);
961 GEN_CHECK_OFF(PGMPOOL, paPhysExtsR3);
962 GEN_CHECK_OFF(PGMPOOL, paPhysExtsR0);
963 GEN_CHECK_OFF(PGMPOOL, paPhysExtsRC);
964#endif
965#ifdef PGMPOOL_WITH_CACHE
966 GEN_CHECK_OFF(PGMPOOL, aiHash);
967 GEN_CHECK_OFF(PGMPOOL, iAgeHead);
968 GEN_CHECK_OFF(PGMPOOL, iAgeTail);
969 GEN_CHECK_OFF(PGMPOOL, fCacheEnabled);
970#endif
971#ifdef PGMPOOL_WITH_MONITORING
972 GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerRC);
973 GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerR0);
974 GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerR3);
975 GEN_CHECK_OFF(PGMPOOL, pszAccessHandler);
976 GEN_CHECK_OFF(PGMPOOL, iModifiedHead);
977 GEN_CHECK_OFF(PGMPOOL, cModifiedPages);
978#endif
979 GEN_CHECK_OFF(PGMPOOL, cUsedPages);
980#ifdef VBOX_WITH_STATISTICS
981 GEN_CHECK_OFF(PGMPOOL, cUsedPagesHigh);
982 GEN_CHECK_OFF(PGMPOOL, StatAlloc);
983 GEN_CHECK_OFF(PGMPOOL, StatClearAll);
984#endif
985 GEN_CHECK_OFF(PGMPOOL, HCPhysTree);
986 GEN_CHECK_OFF(PGMPOOL, aPages);
987 GEN_CHECK_OFF(PGMPOOL, aPages[1]);
988 GEN_CHECK_OFF(PGMPOOL, aPages[PGMPOOL_IDX_FIRST - 1]);
989 GEN_CHECK_SIZE(PGMRCDYNMAP);
990 GEN_CHECK_OFF(PGMRCDYNMAP, u32Magic);
991 GEN_CHECK_OFF(PGMRCDYNMAP, paPages);
992 GEN_CHECK_OFF(PGMRCDYNMAP, cPages);
993 GEN_CHECK_OFF(PGMRCDYNMAP, cLoad);
994 GEN_CHECK_OFF(PGMRCDYNMAP, cMaxLoad);
995 GEN_CHECK_OFF(PGMRCDYNMAP, cGuardPages);
996 GEN_CHECK_OFF(PGMRCDYNMAP, cUsers);
997 GEN_CHECK_SIZE(PGMRCDYNMAPENTRY);
998 GEN_CHECK_OFF(PGMRCDYNMAPENTRY, HCPhys);
999 GEN_CHECK_OFF(PGMRCDYNMAPENTRY, pvPage);
1000 GEN_CHECK_OFF(PGMRCDYNMAPENTRY, cRefs);
1001 GEN_CHECK_OFF_DOT(PGMRCDYNMAPENTRY, uPte.pLegacy);
1002 GEN_CHECK_OFF_DOT(PGMRCDYNMAPENTRY, uPte.pPae);
1003 GEN_CHECK_OFF(PGMMAPSETENTRY, pvPage);
1004 GEN_CHECK_OFF(PGMMAPSETENTRY, iPage);
1005 GEN_CHECK_OFF(PGMMAPSETENTRY, cRefs);
1006 GEN_CHECK_OFF(PGMMAPSETENTRY, cInlinedRefs);
1007 GEN_CHECK_OFF(PGMMAPSETENTRY, cUnrefs);
1008 GEN_CHECK_OFF(PGMMAPSETENTRY, HCPhys);
1009
1010 GEN_CHECK_SIZE(REM);
1011 GEN_CHECK_OFF(REM, pCtx);
1012 GEN_CHECK_OFF(REM, cCanExecuteRaw);
1013 GEN_CHECK_OFF(REM, aGCPtrInvalidatedPages);
1014 GEN_CHECK_OFF(REM, idxPendingList);
1015 GEN_CHECK_OFF(REM, aHandlerNotifications);
1016 GEN_CHECK_OFF(REM, idxFreeList);
1017 GEN_CHECK_OFF(REM, CritSectRegister);
1018 GEN_CHECK_OFF(REM, rc);
1019 GEN_CHECK_OFF(REM, StatsInQEMU);
1020 GEN_CHECK_OFF(REM, Env);
1021
1022 GEN_CHECK_SIZE(REMHANDLERNOTIFICATION);
1023 GEN_CHECK_OFF(REMHANDLERNOTIFICATION, enmKind);
1024 GEN_CHECK_OFF(REMHANDLERNOTIFICATION, u);
1025 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.GCPhys);
1026 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.cb);
1027 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.enmKind);
1028 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalRegister.fHasHCHandler);
1029 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.GCPhys);
1030 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.cb);
1031 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.enmKind);
1032 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.fHasHCHandler);
1033 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.fRestoreAsRAM);
1034 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.GCPhysOld);
1035 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.GCPhysNew);
1036 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.cb);
1037 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.enmKind);
1038 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.fHasHCHandler);
1039 GEN_CHECK_OFF_DOT(REMHANDLERNOTIFICATION, u.PhysicalModify.fRestoreAsRAM);
1040 GEN_CHECK_OFF(REMHANDLERNOTIFICATION, idxSelf);
1041 GEN_CHECK_OFF(REMHANDLERNOTIFICATION, idxNext);
1042
1043 GEN_CHECK_SIZE(SELM);
1044 GEN_CHECK_OFF(SELM, offVM);
1045 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_CS]);
1046 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_DS]);
1047 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_CS64]);
1048 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS]);
1049 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS_TRAP08]);
1050 GEN_CHECK_OFF(SELM, hShadowGdtWriteHandlerType);
1051 GEN_CHECK_OFF(SELM, hGuestGdtWriteHandlerType);
1052 GEN_CHECK_OFF(SELM, paGdtR3);
1053 GEN_CHECK_OFF(SELM, paGdtRC);
1054 GEN_CHECK_OFF(SELM, GuestGdtr);
1055 GEN_CHECK_OFF(SELM, cbEffGuestGdtLimit);
1056 GEN_CHECK_OFF(SELM, hShadowLdtWriteHandlerType);
1057 GEN_CHECK_OFF(SELM, hGuestLdtWriteHandlerType);
1058 GEN_CHECK_OFF(SELM, pvLdtR3);
1059 GEN_CHECK_OFF(SELM, pvLdtRC);
1060 GEN_CHECK_OFF(SELM, GCPtrGuestLdt);
1061 GEN_CHECK_OFF(SELM, cbLdtLimit);
1062 GEN_CHECK_OFF(SELM, offLdtHyper);
1063 GEN_CHECK_OFF(SELM, Tss);
1064 GEN_CHECK_OFF(SELM, TssTrap08);
1065 GEN_CHECK_OFF(SELM, hShadowTssWriteHandlerType);
1066 GEN_CHECK_OFF(SELM, hGuestTssWriteHandlerType);
1067 GEN_CHECK_OFF(SELM, pvMonShwTssRC);
1068 GEN_CHECK_OFF(SELM, GCPtrGuestTss);
1069 GEN_CHECK_OFF(SELM, cbGuestTss);
1070 GEN_CHECK_OFF(SELM, fGuestTss32Bit);
1071 GEN_CHECK_OFF(SELM, cbMonitoredGuestTss);
1072 GEN_CHECK_OFF(SELM, GCSelTss);
1073 GEN_CHECK_OFF(SELM, fGDTRangeRegistered);
1074 GEN_CHECK_OFF(SELM, StatUpdateFromCPUM);
1075 GEN_CHECK_OFF(SELM, StatStaleToUnstaleSReg);
1076 GEN_CHECK_OFF(SELM, StatLoadHidSelGstNoGood);
1077
1078 GEN_CHECK_SIZE(TM);
1079 GEN_CHECK_OFF(TM, offVM);
1080 GEN_CHECK_OFF(TM, pvGIPR3);
1081 //GEN_CHECK_OFF(TM, pvGIPR0);
1082 GEN_CHECK_OFF(TM, pvGIPRC);
1083 GEN_CHECK_OFF(TMCPU, fTSCTicking);
1084 GEN_CHECK_OFF(TM, enmTSCMode);
1085 GEN_CHECK_OFF(TM, fTSCTiedToExecution);
1086 GEN_CHECK_OFF(TMCPU, offTSCRawSrc);
1087 GEN_CHECK_OFF(TMCPU, u64TSC);
1088 GEN_CHECK_OFF(TM, cTSCTicksPerSecond);
1089 GEN_CHECK_OFF(TM, cVirtualTicking);
1090 GEN_CHECK_OFF(TM, fVirtualWarpDrive);
1091 GEN_CHECK_OFF(TM, fVirtualSyncTicking);
1092 GEN_CHECK_OFF(TM, fVirtualSyncCatchUp);
1093 GEN_CHECK_OFF(TM, u32VirtualWarpDrivePercentage);
1094 GEN_CHECK_OFF(TM, u64VirtualOffset);
1095 GEN_CHECK_OFF(TM, u64Virtual);
1096 GEN_CHECK_OFF(TM, u64VirtualRawPrev);
1097 GEN_CHECK_OFF(TM, VirtualGetRawDataR3);
1098 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.pu64Prev);
1099 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.pfnBad);
1100 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.pfnRediscover);
1101 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.c1nsSteps);
1102 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.cBadPrev);
1103 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.cExpired);
1104 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR3.cUpdateRaces);
1105 GEN_CHECK_OFF(TM, VirtualGetRawDataR0);
1106 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.pu64Prev);
1107 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.pfnBad);
1108 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.pfnRediscover);
1109 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.c1nsSteps);
1110 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.cBadPrev);
1111 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.cExpired);
1112 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataR0.cUpdateRaces);
1113 GEN_CHECK_OFF(TM, VirtualGetRawDataRC);
1114 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.pu64Prev);
1115 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.pfnBad);
1116 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.pfnRediscover);
1117 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.c1nsSteps);
1118 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.cBadPrev);
1119 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.cExpired);
1120 GEN_CHECK_OFF_DOT(TM, VirtualGetRawDataRC.cUpdateRaces);
1121 GEN_CHECK_OFF(TM, pfnVirtualGetRawR3);
1122 GEN_CHECK_OFF(TM, pfnVirtualGetRawR0);
1123 GEN_CHECK_OFF(TM, pfnVirtualGetRawRC);
1124 GEN_CHECK_OFF(TM, u64VirtualWarpDriveStart);
1125 GEN_CHECK_OFF(TM, u64VirtualSync);
1126 GEN_CHECK_OFF(TM, offVirtualSync);
1127 GEN_CHECK_OFF(TM, offVirtualSyncGivenUp);
1128 GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpPrev);
1129 GEN_CHECK_OFF(TM, u32VirtualSyncCatchUpPercentage);
1130 GEN_CHECK_OFF(TM, u32VirtualSyncScheduleSlack);
1131 GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpStopThreshold);
1132 GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpGiveUpThreshold);
1133 GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods);
1134 GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[0].u64Start);
1135 GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[0].u32Percentage);
1136 GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[1].u64Start);
1137 GEN_CHECK_OFF_DOT(TM, aVirtualSyncCatchUpPeriods[1].u32Percentage);
1138 GEN_CHECK_OFF(TM, pTimer);
1139 GEN_CHECK_OFF(TM, u32TimerMillies);
1140 GEN_CHECK_OFF(TM, pFree);
1141 GEN_CHECK_OFF(TM, pCreated);
1142 GEN_CHECK_OFF(TM, paTimerQueuesR3);
1143 GEN_CHECK_OFF(TM, paTimerQueuesR0);
1144 GEN_CHECK_OFF(TM, paTimerQueuesRC);
1145 GEN_CHECK_OFF(TM, TimerCritSect);
1146 GEN_CHECK_OFF(TM, VirtualSyncLock);
1147 GEN_CHECK_OFF(TM, StatDoQueues);
1148 GEN_CHECK_OFF(TM, StatTimerCallbackSetFF);
1149 GEN_CHECK_SIZE(TMTIMER);
1150 GEN_CHECK_OFF(TMTIMER, u64Expire);
1151 GEN_CHECK_OFF(TMTIMER, enmClock);
1152 GEN_CHECK_OFF(TMTIMER, enmType);
1153 GEN_CHECK_OFF_DOT(TMTIMER, u.Dev.pfnTimer);
1154 GEN_CHECK_OFF_DOT(TMTIMER, u.Dev.pDevIns);
1155 GEN_CHECK_OFF_DOT(TMTIMER, u.Drv.pfnTimer);
1156 GEN_CHECK_OFF_DOT(TMTIMER, u.Drv.pDrvIns);
1157 GEN_CHECK_OFF_DOT(TMTIMER, u.Internal.pfnTimer);
1158 GEN_CHECK_OFF_DOT(TMTIMER, u.External.pfnTimer);
1159 GEN_CHECK_OFF(TMTIMER, enmState);
1160 GEN_CHECK_OFF(TMTIMER, offScheduleNext);
1161 GEN_CHECK_OFF(TMTIMER, offNext);
1162 GEN_CHECK_OFF(TMTIMER, offPrev);
1163 GEN_CHECK_OFF(TMTIMER, pVMR0);
1164 GEN_CHECK_OFF(TMTIMER, pVMR3);
1165 GEN_CHECK_OFF(TMTIMER, pVMRC);
1166 GEN_CHECK_OFF(TMTIMER, uHzHint);
1167 GEN_CHECK_OFF(TMTIMER, pvUser);
1168 GEN_CHECK_OFF(TMTIMER, pCritSect);
1169 GEN_CHECK_OFF(TMTIMER, pBigNext);
1170 GEN_CHECK_OFF(TMTIMER, pBigPrev);
1171 GEN_CHECK_OFF(TMTIMER, pszDesc);
1172 GEN_CHECK_SIZE(TMTIMERQUEUE);
1173 GEN_CHECK_OFF(TMTIMERQUEUE, offActive);
1174 GEN_CHECK_OFF(TMTIMERQUEUE, offSchedule);
1175 GEN_CHECK_OFF(TMTIMERQUEUE, enmClock);
1176
1177 GEN_CHECK_SIZE(TRPM); // has .mac
1178 GEN_CHECK_SIZE(TRPMCPU); // has .mac
1179 GEN_CHECK_SIZE(VM); // has .mac
1180 GEN_CHECK_SIZE(VMM);
1181 GEN_CHECK_OFF(VMM, offVM);
1182 GEN_CHECK_OFF(VMM, cbCoreCode);
1183 GEN_CHECK_OFF(VMM, HCPhysCoreCode);
1184 GEN_CHECK_OFF(VMM, pvCoreCodeR3);
1185 GEN_CHECK_OFF(VMM, pvCoreCodeR0);
1186 GEN_CHECK_OFF(VMM, pvCoreCodeRC);
1187 GEN_CHECK_OFF(VMM, enmSwitcher);
1188 GEN_CHECK_OFF(VMM, aoffSwitchers);
1189 GEN_CHECK_OFF_DOT(VMM, aoffSwitchers[1]);
1190 GEN_CHECK_OFF(VMM, pfnR0ToRawMode);
1191 GEN_CHECK_OFF(VMM, pfnRCToHost);
1192 GEN_CHECK_OFF(VMM, pfnCallTrampolineRC);
1193 GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuest);
1194 GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuestV86);
1195 GEN_CHECK_OFF(VMM, pRCLoggerRC);
1196 GEN_CHECK_OFF(VMM, pRCLoggerR3);
1197 GEN_CHECK_OFF(VMM, cbRCLogger);
1198 GEN_CHECK_OFF(VMM, fRCLoggerFlushingDisabled);
1199 GEN_CHECK_OFF(VMM, fStackGuardsStationed);
1200 GEN_CHECK_OFF(VMM, fUsePeriodicPreemptionTimers);
1201 GEN_CHECK_OFF(VMM, pYieldTimer);
1202 GEN_CHECK_OFF(VMM, cYieldResumeMillies);
1203 GEN_CHECK_OFF(VMM, cYieldEveryMillies);
1204 GEN_CHECK_OFF(VMM, pahEvtRendezvousEnterOrdered);
1205 GEN_CHECK_OFF(VMM, hEvtRendezvousEnterOneByOne);
1206 GEN_CHECK_OFF(VMM, hEvtMulRendezvousEnterAllAtOnce);
1207 GEN_CHECK_OFF(VMM, hEvtMulRendezvousDone);
1208 GEN_CHECK_OFF(VMM, hEvtRendezvousDoneCaller);
1209 GEN_CHECK_OFF(VMM, pfnRendezvous);
1210 GEN_CHECK_OFF(VMM, pvRendezvousUser);
1211 GEN_CHECK_OFF(VMM, fRendezvousFlags);
1212 GEN_CHECK_OFF(VMM, cRendezvousEmtsEntered);
1213 GEN_CHECK_OFF(VMM, cRendezvousEmtsDone);
1214 GEN_CHECK_OFF(VMM, cRendezvousEmtsReturned);
1215 GEN_CHECK_OFF(VMM, i32RendezvousStatus);
1216 GEN_CHECK_OFF(VMM, u32RendezvousLock);
1217 GEN_CHECK_OFF(VMM, szRing0AssertMsg1);
1218 GEN_CHECK_OFF(VMM, szRing0AssertMsg2);
1219 GEN_CHECK_OFF(VMM, StatRunRC);
1220 GEN_CHECK_OFF(VMM, StatRZCallPGMLock);
1221 GEN_CHECK_OFF(VMMCPU, iLastGZRc);
1222 GEN_CHECK_OFF(VMMCPU, pbEMTStackR3);
1223 GEN_CHECK_OFF(VMMCPU, pbEMTStackRC);
1224 GEN_CHECK_OFF(VMMCPU, pbEMTStackBottomRC);
1225#ifdef LOG_ENABLED
1226 GEN_CHECK_OFF(VMMCPU, pR0LoggerR0);
1227 GEN_CHECK_OFF(VMMCPU, pR0LoggerR3);
1228#endif
1229 GEN_CHECK_OFF(VMMCPU, cCallRing3Disabled);
1230 GEN_CHECK_OFF(VMMCPU, enmCallRing3Operation);
1231 GEN_CHECK_OFF(VMMCPU, rcCallRing3);
1232 GEN_CHECK_OFF(VMMCPU, u64CallRing3Arg);
1233 GEN_CHECK_OFF(VMMCPU, CallRing3JmpBufR0);
1234 GEN_CHECK_OFF_DOT(VMMCPU, CallRing3JmpBufR0.SpCheck);
1235 GEN_CHECK_OFF_DOT(VMMCPU, CallRing3JmpBufR0.SpResume);
1236
1237 GEN_CHECK_SIZE(RTPINGPONG);
1238 GEN_CHECK_SIZE(RTCRITSECT);
1239 GEN_CHECK_OFF(RTCRITSECT, u32Magic);
1240 GEN_CHECK_OFF(RTCRITSECT, cLockers);
1241 GEN_CHECK_OFF(RTCRITSECT, NativeThreadOwner);
1242 GEN_CHECK_OFF(RTCRITSECT, cNestings);
1243 GEN_CHECK_OFF(RTCRITSECT, fFlags);
1244 GEN_CHECK_OFF(RTCRITSECT, EventSem);
1245 GEN_CHECK_OFF(RTCRITSECT, pValidatorRec);
1246
1247 GEN_CHECK_SIZE(CSAM);
1248 GEN_CHECK_OFF(CSAM, offVM);
1249 GEN_CHECK_OFF(CSAM, pPageTree);
1250 GEN_CHECK_OFF(CSAM, aDangerousInstr);
1251 GEN_CHECK_OFF(CSAM, aDangerousInstr[1]);
1252 GEN_CHECK_OFF(CSAM, aDangerousInstr[CSAM_MAX_DANGR_INSTR - 1]);
1253 GEN_CHECK_OFF(CSAM, cDangerousInstr);
1254 GEN_CHECK_OFF(CSAM, iDangerousInstr);
1255 GEN_CHECK_OFF(CSAM, pPDBitmapGC);
1256 GEN_CHECK_OFF(CSAM, pPDHCBitmapGC);
1257 GEN_CHECK_OFF(CSAM, pPDBitmapHC);
1258 GEN_CHECK_OFF(CSAM, pPDGCBitmapHC);
1259 GEN_CHECK_OFF(CSAM, savedstate);
1260 GEN_CHECK_OFF_DOT(CSAM, savedstate.pSSM);
1261 GEN_CHECK_OFF_DOT(CSAM, savedstate.cPageRecords);
1262 GEN_CHECK_OFF_DOT(CSAM, savedstate.cPatchPageRecords);
1263 GEN_CHECK_OFF(CSAM, cDirtyPages);
1264 GEN_CHECK_OFF(CSAM, pvDirtyBasePage);
1265 GEN_CHECK_OFF_DOT(CSAM, pvDirtyBasePage[1]);
1266 GEN_CHECK_OFF_DOT(CSAM, pvDirtyBasePage[CSAM_MAX_DIRTY_PAGES - 1]);
1267 GEN_CHECK_OFF(CSAM, pvDirtyFaultPage);
1268 GEN_CHECK_OFF_DOT(CSAM, pvDirtyFaultPage[1]);
1269 GEN_CHECK_OFF_DOT(CSAM, pvDirtyFaultPage[CSAM_MAX_DIRTY_PAGES - 1]);
1270 GEN_CHECK_OFF(CSAM, pvCallInstruction);
1271 GEN_CHECK_OFF(CSAM, iCallInstruction);
1272 GEN_CHECK_OFF(CSAM, fScanningStarted);
1273 GEN_CHECK_OFF(CSAM, fGatesChecked);
1274 GEN_CHECK_OFF(CSAM, StatNrTraps);
1275 GEN_CHECK_OFF(CSAM, StatNrPages);
1276
1277 GEN_CHECK_SIZE(PATM);
1278 GEN_CHECK_OFF(PATM, offVM);
1279 GEN_CHECK_OFF(PATM, pPatchMemGC);
1280 GEN_CHECK_OFF(PATM, pPatchMemHC);
1281 GEN_CHECK_OFF(PATM, cbPatchMem);
1282 GEN_CHECK_OFF(PATM, offPatchMem);
1283 GEN_CHECK_OFF(PATM, fOutOfMemory);
1284 GEN_CHECK_OFF(PATM, deltaReloc);
1285 GEN_CHECK_OFF(PATM, pGCStateGC);
1286 GEN_CHECK_OFF(PATM, pGCStateHC);
1287 GEN_CHECK_OFF(PATM, pGCStackGC);
1288 GEN_CHECK_OFF(PATM, pGCStackHC);
1289 GEN_CHECK_OFF(PATM, pCPUMCtxGC);
1290 GEN_CHECK_OFF(PATM, pStatsGC);
1291 GEN_CHECK_OFF(PATM, pStatsHC);
1292 GEN_CHECK_OFF(PATM, uCurrentPatchIdx);
1293 GEN_CHECK_OFF(PATM, ulCallDepth);
1294 GEN_CHECK_OFF(PATM, cPageRecords);
1295 GEN_CHECK_OFF(PATM, pPatchedInstrGCLowest);
1296 GEN_CHECK_OFF(PATM, pPatchedInstrGCHighest);
1297 GEN_CHECK_OFF(PATM, PatchLookupTreeHC);
1298 GEN_CHECK_OFF(PATM, PatchLookupTreeGC);
1299 GEN_CHECK_OFF(PATM, pfnHelperCallGC);
1300 GEN_CHECK_OFF(PATM, pfnHelperRetGC);
1301 GEN_CHECK_OFF(PATM, pfnHelperJumpGC);
1302 GEN_CHECK_OFF(PATM, pfnHelperIretGC);
1303 GEN_CHECK_OFF(PATM, pGlobalPatchRec);
1304 GEN_CHECK_OFF(PATM, pfnSysEnterGC);
1305 GEN_CHECK_OFF(PATM, pfnSysEnterPatchGC);
1306 GEN_CHECK_OFF(PATM, uSysEnterPatchIdx);
1307 GEN_CHECK_OFF(PATM, pvFaultMonitor);
1308 GEN_CHECK_OFF(PATM, mmio);
1309 GEN_CHECK_OFF_DOT(PATM, mmio.GCPhys);
1310 GEN_CHECK_OFF_DOT(PATM, mmio.pCachedData);
1311 GEN_CHECK_OFF(PATM, savedstate);
1312 GEN_CHECK_OFF_DOT(PATM, savedstate.pSSM);
1313 GEN_CHECK_OFF_DOT(PATM, savedstate.cPatches);
1314 GEN_CHECK_OFF(PATM, StatNrOpcodeRead);
1315 GEN_CHECK_OFF(PATM, StatU32FunctionMaxSlotsUsed);
1316
1317 GEN_CHECK_SIZE(PATMGCSTATE);
1318 GEN_CHECK_OFF(PATMGCSTATE, uVMFlags);
1319 GEN_CHECK_OFF(PATMGCSTATE, uPendingAction);
1320 GEN_CHECK_OFF(PATMGCSTATE, uPatchCalls);
1321 GEN_CHECK_OFF(PATMGCSTATE, uScratch);
1322 GEN_CHECK_OFF(PATMGCSTATE, uIretEFlags);
1323 GEN_CHECK_OFF(PATMGCSTATE, uIretCS);
1324 GEN_CHECK_OFF(PATMGCSTATE, uIretEIP);
1325 GEN_CHECK_OFF(PATMGCSTATE, Psp);
1326 GEN_CHECK_OFF(PATMGCSTATE, fPIF);
1327 GEN_CHECK_OFF(PATMGCSTATE, GCPtrInhibitInterrupts);
1328 GEN_CHECK_OFF(PATMGCSTATE, Restore);
1329 GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uEAX);
1330 GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uECX);
1331 GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uEDI);
1332 GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.eFlags);
1333 GEN_CHECK_OFF_DOT(PATMGCSTATE, Restore.uFlags);
1334 GEN_CHECK_SIZE(PATMTREES);
1335 GEN_CHECK_OFF(PATMTREES, PatchTree);
1336 GEN_CHECK_OFF(PATMTREES, PatchTreeByPatchAddr);
1337 GEN_CHECK_OFF(PATMTREES, PatchTreeByPage);
1338 GEN_CHECK_SIZE(PATMPATCHREC);
1339 GEN_CHECK_OFF(PATMPATCHREC, Core);
1340 GEN_CHECK_OFF(PATMPATCHREC, CoreOffset);
1341 GEN_CHECK_OFF(PATMPATCHREC, patch);
1342 GEN_CHECK_SIZE(PATCHINFO);
1343 GEN_CHECK_OFF(PATCHINFO, uState);
1344 GEN_CHECK_OFF(PATCHINFO, uOldState);
1345 GEN_CHECK_OFF(PATCHINFO, uOpMode);
1346 GEN_CHECK_OFF(PATCHINFO, unusedHC);
1347 GEN_CHECK_OFF(PATCHINFO, pPrivInstrGC);
1348 GEN_CHECK_OFF(PATCHINFO, aPrivInstr);
1349 GEN_CHECK_OFF(PATCHINFO, aPrivInstr[1]);
1350 GEN_CHECK_OFF(PATCHINFO, aPrivInstr[MAX_INSTR_SIZE - 1]);
1351 GEN_CHECK_OFF(PATCHINFO, cbPrivInstr);
1352 GEN_CHECK_OFF(PATCHINFO, opcode);
1353 GEN_CHECK_OFF(PATCHINFO, cbPatchJump);
1354 GEN_CHECK_OFF(PATCHINFO, pPatchJumpDestGC);
1355 GEN_CHECK_OFF(PATCHINFO, pPatchBlockOffset);
1356 GEN_CHECK_OFF(PATCHINFO, cbPatchBlockSize);
1357 GEN_CHECK_OFF(PATCHINFO, uCurPatchOffset);
1358 GEN_CHECK_OFF(PATCHINFO, flags);
1359 GEN_CHECK_OFF(PATCHINFO, pInstrGCLowest);
1360 GEN_CHECK_OFF(PATCHINFO, pInstrGCHighest);
1361 GEN_CHECK_OFF(PATCHINFO, FixupTree);
1362 GEN_CHECK_OFF(PATCHINFO, nrFixups);
1363 GEN_CHECK_OFF(PATCHINFO, JumpTree);
1364 GEN_CHECK_OFF(PATCHINFO, nrJumpRecs);
1365 GEN_CHECK_OFF(PATCHINFO, Patch2GuestAddrTree);
1366 GEN_CHECK_OFF(PATCHINFO, Guest2PatchAddrTree);
1367 GEN_CHECK_OFF(PATCHINFO, nrPatch2GuestRecs);
1368 GEN_CHECK_OFF(PATCHINFO, unused);
1369 GEN_CHECK_OFF_DOT(PATCHINFO, unused.pPatchLocStartHC);
1370 GEN_CHECK_OFF_DOT(PATCHINFO, unused.pPatchLocEndHC);
1371 GEN_CHECK_OFF_DOT(PATCHINFO, unused.pGuestLoc);
1372 GEN_CHECK_OFF_DOT(PATCHINFO, unused.opsize);
1373 GEN_CHECK_OFF(PATCHINFO, pTempInfo);
1374 GEN_CHECK_OFF(PATCHINFO, pTrampolinePatchesHead);
1375 GEN_CHECK_OFF(PATCHINFO, cCodeWrites);
1376 GEN_CHECK_OFF(PATCHINFO, cTraps);
1377 GEN_CHECK_OFF(PATCHINFO, cInvalidWrites);
1378 GEN_CHECK_OFF(PATCHINFO, uPatchIdx);
1379 GEN_CHECK_OFF(PATCHINFO, bDirtyOpcode);
1380 GEN_CHECK_SIZE(PATMPATCHPAGE);
1381 GEN_CHECK_OFF(PATMPATCHPAGE, Core);
1382 GEN_CHECK_OFF(PATMPATCHPAGE, pLowestAddrGC);
1383 GEN_CHECK_OFF(PATMPATCHPAGE, pHighestAddrGC);
1384 GEN_CHECK_OFF(PATMPATCHPAGE, cCount);
1385 GEN_CHECK_OFF(PATMPATCHPAGE, cMaxPatches);
1386 GEN_CHECK_OFF(PATMPATCHPAGE, papPatch);
1387#endif
1388
1389 GEN_CHECK_SIZE(APIC);
1390 GEN_CHECK_OFF(APIC, pApicDevR0);
1391 GEN_CHECK_OFF(APIC, pApicDevR3);
1392 GEN_CHECK_OFF(APIC, pApicDevRC);
1393 GEN_CHECK_OFF(APIC, pvApicPibR0);
1394 GEN_CHECK_OFF(APIC, pvApicPibR3);
1395 GEN_CHECK_OFF(APIC, pvApicPibRC);
1396 GEN_CHECK_OFF(APIC, cbApicPib);
1397 GEN_CHECK_OFF(APIC, enmMaxMode);
1398 GEN_CHECK_OFF(APICCPU, pvApicPageR0);
1399 GEN_CHECK_OFF(APICCPU, pvApicPageR3);
1400 GEN_CHECK_OFF(APICCPU, pvApicPageRC);
1401 GEN_CHECK_OFF(APICCPU, pvApicPageRC);
1402 GEN_CHECK_OFF(APICCPU, cbApicPage);
1403 GEN_CHECK_OFF(APICCPU, pvApicPibR0);
1404 GEN_CHECK_OFF(APICCPU, pvApicPibR3);
1405 GEN_CHECK_OFF(APICCPU, pvApicPibRC);
1406 GEN_CHECK_OFF(APICCPU, ApicPibLevel);
1407 GEN_CHECK_OFF(APICCPU, pTimerR0);
1408 GEN_CHECK_OFF(APICCPU, pTimerR3);
1409 GEN_CHECK_OFF(APICCPU, pTimerRC);
1410 GEN_CHECK_OFF(APICCPU, TimerCritSect);
1411
1412 GEN_CHECK_SIZE(VM);
1413 GEN_CHECK_OFF(VM, enmVMState);
1414 GEN_CHECK_OFF(VM, fGlobalForcedActions);
1415 GEN_CHECK_OFF(VM, paVMPagesR3);
1416 GEN_CHECK_OFF(VM, pSession);
1417 GEN_CHECK_OFF(VM, pUVM);
1418 GEN_CHECK_OFF(VM, pVMR3);
1419 GEN_CHECK_OFF(VM, pVMR0);
1420 GEN_CHECK_OFF(VM, pVMRC);
1421 GEN_CHECK_OFF(VM, hSelf);
1422 GEN_CHECK_OFF(VM, cCpus);
1423 GEN_CHECK_OFF(VM, uCpuExecutionCap);
1424 GEN_CHECK_OFF(VM, cbSelf);
1425 GEN_CHECK_OFF(VM, pfnVMMRCToHostAsm);
1426 GEN_CHECK_OFF(VM, pfnVMMRCToHostAsmNoReturn);
1427 GEN_CHECK_OFF(VM, bMainExecutionEngine);
1428 GEN_CHECK_OFF(VM, fRecompileUser);
1429 GEN_CHECK_OFF(VM, fRecompileSupervisor);
1430 GEN_CHECK_OFF(VM, fPATMEnabled);
1431 GEN_CHECK_OFF(VM, fCSAMEnabled);
1432 GEN_CHECK_OFF(VM, fHMEnabled);
1433 GEN_CHECK_OFF(VM, fFaultTolerantMaster);
1434 GEN_CHECK_OFF(VM, fUseLargePages);
1435 GEN_CHECK_OFF(VM, hTraceBufRC);
1436 GEN_CHECK_OFF(VM, hTraceBufR3);
1437 GEN_CHECK_OFF(VM, hTraceBufR0);
1438 GEN_CHECK_OFF(VM, StatTotalQemuToGC);
1439 GEN_CHECK_OFF(VM, StatTotalGCToQemu);
1440 GEN_CHECK_OFF(VM, StatTotalInGC);
1441 GEN_CHECK_OFF(VM, StatTotalInQemu);
1442 GEN_CHECK_OFF(VM, StatSwitcherToGC);
1443 GEN_CHECK_OFF(VM, StatSwitcherToHC);
1444 GEN_CHECK_OFF(VM, StatSwitcherSaveRegs);
1445 GEN_CHECK_OFF(VM, StatSwitcherSysEnter);
1446 GEN_CHECK_OFF(VM, StatSwitcherDebug);
1447 GEN_CHECK_OFF(VM, StatSwitcherCR0);
1448 GEN_CHECK_OFF(VM, StatSwitcherCR4);
1449 GEN_CHECK_OFF(VM, StatSwitcherJmpCR3);
1450 GEN_CHECK_OFF(VM, StatSwitcherRstrRegs);
1451 GEN_CHECK_OFF(VM, StatSwitcherLgdt);
1452 GEN_CHECK_OFF(VM, StatSwitcherLidt);
1453 GEN_CHECK_OFF(VM, StatSwitcherLldt);
1454 GEN_CHECK_OFF(VM, StatSwitcherTSS);
1455 GEN_CHECK_OFF(VM, cpum);
1456 GEN_CHECK_OFF(VM, vmm);
1457 GEN_CHECK_OFF(VM, pgm);
1458 GEN_CHECK_OFF(VM, hm);
1459 GEN_CHECK_OFF(VM, trpm);
1460 GEN_CHECK_OFF(VM, selm);
1461 GEN_CHECK_OFF(VM, mm);
1462 GEN_CHECK_OFF(VM, pdm);
1463 GEN_CHECK_OFF(VM, iom);
1464#ifdef VBOX_WITH_RAW_MODE
1465 GEN_CHECK_OFF(VM, patm);
1466 GEN_CHECK_OFF(VM, csam);
1467#endif
1468 GEN_CHECK_OFF(VM, em);
1469 GEN_CHECK_OFF(VM, tm);
1470 GEN_CHECK_OFF(VM, dbgf);
1471 GEN_CHECK_OFF(VM, ssm);
1472 GEN_CHECK_OFF(VM, ftm);
1473#ifdef VBOX_WITH_REM
1474 GEN_CHECK_OFF(VM, rem);
1475#endif
1476 GEN_CHECK_OFF(VM, gim);
1477 GEN_CHECK_OFF(VM, vm);
1478 GEN_CHECK_OFF(VM, cfgm);
1479 GEN_CHECK_OFF(VM, apic);
1480 GEN_CHECK_OFF(VM, aCpus);
1481
1482
1483 GEN_CHECK_SIZE(VMCPU);
1484 GEN_CHECK_OFF(VMCPU, fLocalForcedActions);
1485 GEN_CHECK_OFF(VMCPU, enmState);
1486 GEN_CHECK_OFF(VMCPU, pUVCpu);
1487 GEN_CHECK_OFF(VMCPU, pVMR3);
1488 GEN_CHECK_OFF(VMCPU, pVMR0);
1489 GEN_CHECK_OFF(VMCPU, pVMRC);
1490 GEN_CHECK_OFF(VMCPU, idCpu);
1491 GEN_CHECK_OFF(VMCPU, hNativeThread);
1492 GEN_CHECK_OFF(VMCPU, hNativeThreadR0);
1493 GEN_CHECK_OFF(VMCPU, idHostCpu);
1494 GEN_CHECK_OFF(VMCPU, fTraceGroups);
1495 GEN_CHECK_OFF(VMCPU, uAdHoc);
1496 GEN_CHECK_OFF(VMCPU, aStatAdHoc);
1497 GEN_CHECK_OFF(VMCPU, hm);
1498 GEN_CHECK_OFF(VMCPU, em);
1499 GEN_CHECK_OFF(VMCPU, iem);
1500 GEN_CHECK_OFF(VMCPU, trpm);
1501 GEN_CHECK_OFF(VMCPU, tm);
1502 GEN_CHECK_OFF(VMCPU, vmm);
1503 GEN_CHECK_OFF(VMCPU, pdm);
1504 GEN_CHECK_OFF(VMCPU, iom);
1505 GEN_CHECK_OFF(VMCPU, dbgf);
1506 GEN_CHECK_OFF(VMCPU, gim);
1507 GEN_CHECK_OFF(VMCPU, apic);
1508 GEN_CHECK_OFF(VMCPU, pgm);
1509 GEN_CHECK_OFF(VMCPU, cpum);
1510
1511#ifndef VBOX_FOR_DTRACE_LIB
1512 GEN_CHECK_SIZE(DISCPUSTATE);
1513 GEN_CHECK_OFF(DISCPUSTATE, Param1);
1514 GEN_CHECK_OFF(DISCPUSTATE, Param2);
1515 GEN_CHECK_OFF(DISCPUSTATE, Param3);
1516 GEN_CHECK_OFF(DISCPUSTATE, i32SibDisp);
1517 GEN_CHECK_OFF(DISCPUSTATE, fFilter);
1518 GEN_CHECK_OFF(DISCPUSTATE, uInstrAddr);
1519 GEN_CHECK_OFF(DISCPUSTATE, abInstr);
1520 GEN_CHECK_OFF(DISCPUSTATE, pvUser);
1521#endif
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette