tstVMStruct.h@ 61886

Last change on this file since 61886 was 61776, checked in by vboxsync, 8 years ago

CPUM,APIC: Per-CPU APIC CPUID feature bit and MSR_IA32_APICBASE GP mask adjustments.

Changed the PDMAPICHLPR3::pfnChangeFeature to pfnSetFeatureLevel, removing the RC and R0 versions.
Only use pfnSetFeatureLevel from the APIC constructor to communicate to CPUM the max APIC feature level, not to globally flip CPUID[1].EDX[9].
Renamed APIC enmOriginalMode to enmMaxMode, changing the type of it and the corresponding config values to PDMAPICMODE. This makes the above simpler and eliminates two conversion functions. It also makes APICMODE private to the APIC again.
Introduced CPUMSetGuestCpuIdPerCpuApicFeature for the per-CPU APIC feature bit management.
Introduced CPUMCPUIDLEAF_F_CONTAINS_APIC which works same as CPUMCPUIDLEAF_F_CONTAINS_OSXSAVE and CPUMCPUIDLEAF_F_CONTAINS_APIC_ID. Updated existing CPU profiles with this.
Made the patch manager helper function actually handle CPUMCPUIDLEAF_F_CONTAINS_APIC and CPUMCPUIDLEAF_F_CONTAINS_OSXSAVE (the latter previously relied on CPUMSetGuestCpuIdFeature/CPUMClearGuestCpuIdFeature from CPUMSetGuestCR4).
Pushed CPUMSetGuestCpuIdFeature, CPUMGetGuestCpuIdFeature and CPUMClearGuestCpuIdFeature down to ring-3 only (now CPUMR3*). The latter two function are deprecated.
Added call to CPUMSetGuestCpuIdPerCpuApicFeature from load function just in case the APIC is disabled by the guest at the time of saving.
CPUMSetGuestCpuIdFeature ensures we've got a MSR_IA32_APICBASE register when enabling the APIC.
CPUMSetGuestCpuIdFeature adjust the MSR_IA32_APICBASE GP mask when enabling x2APIC so setting MSR_IA32_APICBASE_EXTD does not trap.

Property svn:eol-style set to native
Property svn:keywords set to Id

File size: 59.2 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: