VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp@ 13100

Last change on this file since 13100 was 13067, checked in by vboxsync, 16 years ago

#1865: More PGM changes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 39.1 KB
Line 
1/* $Id: tstVMStructGC.cpp 13067 2008-10-08 10:11:24Z vboxsync $ */
2/** @file
3 * tstVMMStructGC - Generate structure member and size checks from the GC perspective.
4 *
5 * This is built using the VBOXGC template but linked into a host
6 * ring-3 executable, rather hacky.
7 */
8
9/*
10 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
21 * Clara, CA 95054 USA or visit http://www.sun.com if you need
22 * additional information or have any questions.
23 */
24
25
26/*
27 * Sanity checks.
28 */
29#ifndef IN_GC
30# error Incorrect template!
31#endif
32#if defined(IN_RING3) || defined(IN_RING0)
33# error Incorrect template!
34#endif
35
36
37/*******************************************************************************
38* Header Files *
39*******************************************************************************/
40#include <VBox/cfgm.h>
41#include <VBox/cpum.h>
42#include <VBox/mm.h>
43#include <VBox/pgm.h>
44#include <VBox/selm.h>
45#include <VBox/trpm.h>
46#include <VBox/vmm.h>
47#include <VBox/stam.h>
48#include "PDMInternal.h"
49#include <VBox/pdm.h>
50#include "CFGMInternal.h"
51#include "CPUMInternal.h"
52#include "MMInternal.h"
53#include "PGMInternal.h"
54#include "SELMInternal.h"
55#include "TRPMInternal.h"
56#include "TMInternal.h"
57#include "IOMInternal.h"
58#include "REMInternal.h"
59#include "HWACCMInternal.h"
60#include "PATMInternal.h"
61#include "VMMInternal.h"
62#include "DBGFInternal.h"
63#include "STAMInternal.h"
64#include "CSAMInternal.h"
65#include "EMInternal.h"
66#include "REMInternal.h"
67#include <VBox/vm.h>
68#include <VBox/param.h>
69#include <VBox/x86.h>
70
71/* we don't use iprt here because we're pretending to be in GC! */
72#include <stdio.h>
73
74#define GEN_CHECK_SIZE(s) printf(" CHECK_SIZE(%s, %u);\n", #s, (unsigned)sizeof(s))
75#define GEN_CHECK_OFF(s, m) printf(" CHECK_OFF(%s, %u, %s);\n", #s, (unsigned)RT_OFFSETOF(s, m), #m)
76
77int main()
78{
79 GEN_CHECK_SIZE(CFGM);
80
81 GEN_CHECK_SIZE(CPUM); // has .mac
82 GEN_CHECK_SIZE(CPUMHOSTCTX);
83 GEN_CHECK_SIZE(CPUMCTX);
84 GEN_CHECK_SIZE(CPUMCTXCORE);
85 GEN_CHECK_SIZE(STAMRATIOU32);
86 GEN_CHECK_SIZE(AVLOHCPHYSNODECORE);
87 GEN_CHECK_SIZE(AVLOGCPHYSNODECORE);
88 GEN_CHECK_SIZE(AVLROGCPHYSNODECORE);
89 GEN_CHECK_SIZE(AVLOGCPTRNODECORE);
90 GEN_CHECK_SIZE(AVLROGCPTRNODECORE);
91 GEN_CHECK_SIZE(AVLOIOPORTNODECORE);
92 GEN_CHECK_SIZE(AVLROIOPORTNODECORE);
93
94 GEN_CHECK_SIZE(DBGF);
95 GEN_CHECK_OFF(DBGF, offVM);
96 GEN_CHECK_OFF(DBGF, fAttached);
97 GEN_CHECK_OFF(DBGF, fStoppedInHyper);
98 GEN_CHECK_OFF(DBGF, PingPong);
99 GEN_CHECK_OFF(DBGF, DbgEvent);
100 GEN_CHECK_OFF(DBGF, enmVMMCmd);
101 GEN_CHECK_OFF(DBGF, VMMCmdData);
102 GEN_CHECK_OFF(DBGF, pInfoFirst);
103 GEN_CHECK_OFF(DBGF, InfoCritSect);
104 GEN_CHECK_OFF(DBGF, SymbolTree);
105 GEN_CHECK_OFF(DBGF, pSymbolSpace);
106 GEN_CHECK_OFF(DBGF, fSymInited);
107 GEN_CHECK_OFF(DBGF, cHwBreakpoints);
108 GEN_CHECK_OFF(DBGF, cBreakpoints);
109 GEN_CHECK_OFF(DBGF, aHwBreakpoints);
110 GEN_CHECK_OFF(DBGF, aBreakpoints);
111 GEN_CHECK_OFF(DBGF, iActiveBp);
112 GEN_CHECK_OFF(DBGF, fSingleSteppingRaw);
113 GEN_CHECK_SIZE(DBGFEVENT);
114
115 GEN_CHECK_SIZE(EM);
116 GEN_CHECK_OFF(EM, offVM);
117 GEN_CHECK_OFF(EM, pCtx);
118 GEN_CHECK_OFF(EM, enmState);
119 GEN_CHECK_OFF(EM, fForceRAW);
120 GEN_CHECK_OFF(EM, u.achPaddingFatalLongJump);
121 GEN_CHECK_OFF(EM, StatForcedActions);
122 GEN_CHECK_OFF(EM, StatTotalClis);
123 GEN_CHECK_OFF(EM, pStatsR3);
124 GEN_CHECK_OFF(EM, pStatsR0);
125 GEN_CHECK_OFF(EM, pStatsRC);
126 GEN_CHECK_OFF(EM, pCliStatTree);
127
128 GEN_CHECK_SIZE(IOM);
129 GEN_CHECK_OFF(IOM, pTreesRC);
130 GEN_CHECK_OFF(IOM, pTreesR3);
131 GEN_CHECK_OFF(IOM, pTreesR0);
132 GEN_CHECK_OFF(IOM, pMMIORangeLastR3);
133 GEN_CHECK_OFF(IOM, pMMIOStatsLastR3);
134 GEN_CHECK_OFF(IOM, pMMIORangeLastR0);
135 GEN_CHECK_OFF(IOM, pMMIOStatsLastR0);
136 GEN_CHECK_OFF(IOM, pMMIORangeLastRC);
137 GEN_CHECK_OFF(IOM, pMMIOStatsLastRC);
138 GEN_CHECK_OFF(IOM, pRangeLastReadR0);
139 GEN_CHECK_OFF(IOM, pRangeLastReadRC);
140
141 GEN_CHECK_SIZE(IOMMMIORANGE);
142 GEN_CHECK_OFF(IOMMMIORANGE, GCPhys);
143 GEN_CHECK_OFF(IOMMMIORANGE, cb);
144 GEN_CHECK_OFF(IOMMMIORANGE, pszDesc);
145 GEN_CHECK_OFF(IOMMMIORANGE, pvUserR3);
146 GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR3);
147 GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR3);
148 GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR3);
149 GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR3);
150 GEN_CHECK_OFF(IOMMMIORANGE, pvUserR0);
151 GEN_CHECK_OFF(IOMMMIORANGE, pDevInsR0);
152 GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackR0);
153 GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR0);
154 GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR0);
155 GEN_CHECK_OFF(IOMMMIORANGE, pvUserRC);
156 GEN_CHECK_OFF(IOMMMIORANGE, pDevInsRC);
157 GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackRC);
158 GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackRC);
159 GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackRC);
160
161 GEN_CHECK_SIZE(IOMMMIOSTATS);
162 GEN_CHECK_OFF(IOMMMIOSTATS, ReadR3);
163
164 GEN_CHECK_SIZE(IOMIOPORTRANGER0);
165 GEN_CHECK_OFF(IOMIOPORTRANGER0, Port);
166 GEN_CHECK_OFF(IOMIOPORTRANGER0, cPorts);
167 GEN_CHECK_OFF(IOMIOPORTRANGER0, pvUser);
168 GEN_CHECK_OFF(IOMIOPORTRANGER0, pDevIns);
169 GEN_CHECK_OFF(IOMIOPORTRANGER0, pszDesc);
170
171 GEN_CHECK_SIZE(IOMIOPORTRANGERC);
172 GEN_CHECK_OFF(IOMIOPORTRANGERC, Port);
173 GEN_CHECK_OFF(IOMIOPORTRANGERC, cPorts);
174 GEN_CHECK_OFF(IOMIOPORTRANGERC, pvUser);
175 GEN_CHECK_OFF(IOMIOPORTRANGERC, pDevIns);
176 GEN_CHECK_OFF(IOMIOPORTRANGERC, pszDesc);
177
178 GEN_CHECK_SIZE(IOMIOPORTSTATS);
179 GEN_CHECK_OFF(IOMIOPORTSTATS, InR3);
180
181 GEN_CHECK_SIZE(IOMTREES);
182 GEN_CHECK_OFF(IOMTREES, IOPortTreeR3);
183 GEN_CHECK_OFF(IOMTREES, IOPortTreeR0);
184 GEN_CHECK_OFF(IOMTREES, IOPortTreeRC);
185 GEN_CHECK_OFF(IOMTREES, MMIOTree);
186 GEN_CHECK_OFF(IOMTREES, IOPortStatTree);
187 GEN_CHECK_OFF(IOMTREES, MMIOStatTree);
188
189 GEN_CHECK_SIZE(MM);
190 GEN_CHECK_OFF(MM, offVM);
191 GEN_CHECK_OFF(MM, offHyperNextStatic);
192 GEN_CHECK_OFF(MM, cbHyperArea);
193 GEN_CHECK_OFF(MM, fDoneMMR3InitPaging);
194 GEN_CHECK_OFF(MM, fPGMInitialized);
195 GEN_CHECK_OFF(MM, offLookupHyper);
196 GEN_CHECK_OFF(MM, pHyperHeapRC);
197 GEN_CHECK_OFF(MM, pHyperHeapR3);
198 GEN_CHECK_OFF(MM, pHyperHeapR0);
199 GEN_CHECK_OFF(MM, pLockedMem);
200 GEN_CHECK_OFF(MM, pPagePoolR3);
201 GEN_CHECK_OFF(MM, pPagePoolR0);
202 GEN_CHECK_OFF(MM, pPagePoolLowR3);
203 GEN_CHECK_OFF(MM, pPagePoolLowR0);
204 GEN_CHECK_OFF(MM, pvDummyPage);
205 GEN_CHECK_OFF(MM, HCPhysDummyPage);
206 GEN_CHECK_OFF(MM, cbRamBase);
207 GEN_CHECK_OFF(MM, cBasePages);
208 GEN_CHECK_OFF(MM, cShadowPages);
209 GEN_CHECK_OFF(MM, cFixedPages);
210 GEN_CHECK_SIZE(MMHYPERSTAT);
211 GEN_CHECK_SIZE(MMHYPERCHUNK);
212 GEN_CHECK_SIZE(MMHYPERCHUNKFREE);
213 GEN_CHECK_SIZE(MMHYPERHEAP);
214 GEN_CHECK_OFF(MMHYPERHEAP, u32Magic);
215 GEN_CHECK_OFF(MMHYPERHEAP, cbHeap);
216 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapR3);
217 GEN_CHECK_OFF(MMHYPERHEAP, pVMR3);
218 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapR0);
219 GEN_CHECK_OFF(MMHYPERHEAP, pVMR0);
220 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapRC);
221 GEN_CHECK_OFF(MMHYPERHEAP, pVMRC);
222 GEN_CHECK_OFF(MMHYPERHEAP, cbFree);
223 GEN_CHECK_OFF(MMHYPERHEAP, offFreeHead);
224 GEN_CHECK_OFF(MMHYPERHEAP, offFreeTail);
225 GEN_CHECK_OFF(MMHYPERHEAP, offPageAligned);
226 GEN_CHECK_OFF(MMHYPERHEAP, HyperHeapStatTree);
227 GEN_CHECK_SIZE(MMLOOKUPHYPER);
228 GEN_CHECK_OFF(MMLOOKUPHYPER, offNext);
229 GEN_CHECK_OFF(MMLOOKUPHYPER, off);
230 GEN_CHECK_OFF(MMLOOKUPHYPER, cb);
231 GEN_CHECK_OFF(MMLOOKUPHYPER, enmType);
232 GEN_CHECK_OFF(MMLOOKUPHYPER, u.Locked.pvR3);
233 GEN_CHECK_OFF(MMLOOKUPHYPER, u.Locked.pvR0);
234 GEN_CHECK_OFF(MMLOOKUPHYPER, u.Locked.pLockedMem);
235 GEN_CHECK_OFF(MMLOOKUPHYPER, u.HCPhys.pvR3);
236 GEN_CHECK_OFF(MMLOOKUPHYPER, u.HCPhys.HCPhys);
237 GEN_CHECK_OFF(MMLOOKUPHYPER, u.GCPhys.GCPhys);
238 GEN_CHECK_OFF(MMLOOKUPHYPER, pszDesc);
239
240 GEN_CHECK_SIZE(PDM);
241 GEN_CHECK_OFF(PDM, offVM);
242 GEN_CHECK_OFF(PDM, pDevs);
243 GEN_CHECK_OFF(PDM, pDevInstances);
244 GEN_CHECK_OFF(PDM, pUsbDevs);
245 GEN_CHECK_OFF(PDM, pUsbInstances);
246 GEN_CHECK_OFF(PDM, pDrvs);
247 GEN_CHECK_OFF(PDM, pCritSects);
248 GEN_CHECK_OFF(PDM, aPciBuses);
249 GEN_CHECK_OFF(PDM, aPciBuses[0].iBus);
250 GEN_CHECK_OFF(PDM, aPciBuses[0].pDevInsR3);
251 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnSetIrqR3);
252 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnRegisterR3);
253 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnIORegionRegisterR3);
254 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnSaveExecR3);
255 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnLoadExecR3);
256 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnFakePCIBIOSR3);
257 GEN_CHECK_OFF(PDM, aPciBuses[0].pDevInsR0);
258 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnSetIrqR0);
259 GEN_CHECK_OFF(PDM, aPciBuses[0].pDevInsRC);
260 GEN_CHECK_OFF(PDM, aPciBuses[0].pfnSetIrqRC);
261 GEN_CHECK_OFF(PDM, Pic);
262 GEN_CHECK_OFF(PDM, Pic.pDevInsR3);
263 GEN_CHECK_OFF(PDM, Pic.pfnSetIrqR3);
264 GEN_CHECK_OFF(PDM, Pic.pfnGetInterruptR3);
265 GEN_CHECK_OFF(PDM, Pic.pDevInsR0);
266 GEN_CHECK_OFF(PDM, Pic.pfnSetIrqR0);
267 GEN_CHECK_OFF(PDM, Pic.pfnGetInterruptR0);
268 GEN_CHECK_OFF(PDM, Pic.pDevInsRC);
269 GEN_CHECK_OFF(PDM, Pic.pfnSetIrqRC);
270 GEN_CHECK_OFF(PDM, Pic.pfnGetInterruptRC);
271 GEN_CHECK_OFF(PDM, Apic);
272 GEN_CHECK_OFF(PDM, Apic.pDevInsR3);
273 GEN_CHECK_OFF(PDM, Apic.pfnGetInterruptR3);
274 GEN_CHECK_OFF(PDM, Apic.pfnSetBaseR3);
275 GEN_CHECK_OFF(PDM, Apic.pfnGetBaseR3);
276 GEN_CHECK_OFF(PDM, Apic.pfnSetTPRR3);
277 GEN_CHECK_OFF(PDM, Apic.pfnWriteMSRR3);
278 GEN_CHECK_OFF(PDM, Apic.pfnReadMSRR3);
279 GEN_CHECK_OFF(PDM, Apic.pfnGetTPRR3);
280 GEN_CHECK_OFF(PDM, Apic.pfnBusDeliverR3);
281 GEN_CHECK_OFF(PDM, Apic.pDevInsR0);
282 GEN_CHECK_OFF(PDM, Apic.pfnGetInterruptR0);
283 GEN_CHECK_OFF(PDM, Apic.pfnSetBaseR0);
284 GEN_CHECK_OFF(PDM, Apic.pfnGetBaseR0);
285 GEN_CHECK_OFF(PDM, Apic.pfnSetTPRR0);
286 GEN_CHECK_OFF(PDM, Apic.pfnGetTPRR0);
287 GEN_CHECK_OFF(PDM, Apic.pfnWriteMSRR0);
288 GEN_CHECK_OFF(PDM, Apic.pfnReadMSRR0);
289 GEN_CHECK_OFF(PDM, Apic.pfnBusDeliverR0);
290 GEN_CHECK_OFF(PDM, Apic.pDevInsRC);
291 GEN_CHECK_OFF(PDM, Apic.pfnGetInterruptRC);
292 GEN_CHECK_OFF(PDM, Apic.pfnSetBaseRC);
293 GEN_CHECK_OFF(PDM, Apic.pfnGetBaseRC);
294 GEN_CHECK_OFF(PDM, Apic.pfnSetTPRRC);
295 GEN_CHECK_OFF(PDM, Apic.pfnGetTPRRC);
296 GEN_CHECK_OFF(PDM, Apic.pfnWriteMSRRC);
297 GEN_CHECK_OFF(PDM, Apic.pfnReadMSRRC);
298 GEN_CHECK_OFF(PDM, Apic.pfnBusDeliverRC);
299 GEN_CHECK_OFF(PDM, IoApic);
300 GEN_CHECK_OFF(PDM, IoApic.pDevInsR3);
301 GEN_CHECK_OFF(PDM, IoApic.pfnSetIrqR3);
302 GEN_CHECK_OFF(PDM, IoApic.pDevInsR0);
303 GEN_CHECK_OFF(PDM, IoApic.pfnSetIrqR0);
304 GEN_CHECK_OFF(PDM, IoApic.pDevInsRC);
305 GEN_CHECK_OFF(PDM, IoApic.pfnSetIrqRC);
306 GEN_CHECK_OFF(PDM, pDmac);
307 GEN_CHECK_OFF(PDM, pRtc);
308 GEN_CHECK_OFF(PDM, pUsbHubs);
309 GEN_CHECK_OFF(PDM, pDevHlpQueueR3);
310 GEN_CHECK_OFF(PDM, pDevHlpQueueR0);
311 GEN_CHECK_OFF(PDM, pDevHlpQueueRC);
312 GEN_CHECK_OFF(PDM, cQueuedCritSectLeaves);
313 GEN_CHECK_OFF(PDM, apQueuedCritSectsLeaves);
314 GEN_CHECK_OFF(PDM, pQueuesTimer);
315 GEN_CHECK_OFF(PDM, pQueuesForced);
316 GEN_CHECK_OFF(PDM, pQueueFlushR0);
317 GEN_CHECK_OFF(PDM, pQueueFlushRC);
318 GEN_CHECK_OFF(PDM, pThreads);
319 GEN_CHECK_OFF(PDM, pThreadsTail);
320 GEN_CHECK_OFF(PDM, cPollers);
321 GEN_CHECK_OFF(PDM, apfnPollers);
322 GEN_CHECK_OFF(PDM, aDrvInsPollers);
323 GEN_CHECK_OFF(PDM, pTimerPollers);
324 GEN_CHECK_OFF(PDM, CritSect);
325 GEN_CHECK_OFF(PDM, StatQueuedCritSectLeaves);
326 GEN_CHECK_SIZE(PDMDEVINSINT);
327 GEN_CHECK_OFF(PDMDEVINSINT, pNextR3);
328 GEN_CHECK_OFF(PDMDEVINSINT, pPerDeviceNextR3);
329 GEN_CHECK_OFF(PDMDEVINSINT, pDevR3);
330 GEN_CHECK_OFF(PDMDEVINSINT, pVMR3);
331 GEN_CHECK_OFF(PDMDEVINSINT, pVMR0);
332 GEN_CHECK_OFF(PDMDEVINSINT, pVMRC);
333 GEN_CHECK_OFF(PDMDEVINSINT, pLunsR3);
334 GEN_CHECK_OFF(PDMDEVINSINT, pCfgHandle);
335 GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceR3);
336 GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceR0);
337 GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceRC);
338 GEN_CHECK_OFF(PDMDEVINSINT, pPciBusR3);
339 GEN_CHECK_OFF(PDMDEVINSINT, pPciBusR0);
340 GEN_CHECK_OFF(PDMDEVINSINT, pPciBusRC);
341 GEN_CHECK_SIZE(PDMCRITSECTINT);
342 GEN_CHECK_OFF(PDMCRITSECTINT, Core);
343 GEN_CHECK_OFF(PDMCRITSECTINT, pNext);
344 GEN_CHECK_OFF(PDMCRITSECTINT, pvKey);
345 GEN_CHECK_OFF(PDMCRITSECTINT, pVMR3);
346 GEN_CHECK_OFF(PDMCRITSECTINT, pVMR0);
347 GEN_CHECK_OFF(PDMCRITSECTINT, pVMRC);
348 GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionRZLock);
349 GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionRZUnlock);
350 GEN_CHECK_OFF(PDMCRITSECTINT, StatContentionR3);
351 GEN_CHECK_OFF(PDMCRITSECTINT, StatLocked);
352 GEN_CHECK_SIZE(PDMQUEUE);
353 GEN_CHECK_OFF(PDMQUEUE, pNext);
354 GEN_CHECK_OFF(PDMQUEUE, enmType);
355 GEN_CHECK_OFF(PDMQUEUE, u);
356 GEN_CHECK_OFF(PDMQUEUE, u.Dev.pfnCallback);
357 GEN_CHECK_OFF(PDMQUEUE, u.Dev.pDevIns);
358 GEN_CHECK_OFF(PDMQUEUE, u.Drv.pfnCallback);
359 GEN_CHECK_OFF(PDMQUEUE, u.Drv.pDrvIns);
360 GEN_CHECK_OFF(PDMQUEUE, u.Int.pfnCallback);
361 GEN_CHECK_OFF(PDMQUEUE, u.Ext.pfnCallback);
362 GEN_CHECK_OFF(PDMQUEUE, u.Ext.pvUser);
363 GEN_CHECK_OFF(PDMQUEUE, pVMR3);
364 GEN_CHECK_OFF(PDMQUEUE, pVMR0);
365 GEN_CHECK_OFF(PDMQUEUE, pVMRC);
366 GEN_CHECK_OFF(PDMQUEUE, cMilliesInterval);
367 GEN_CHECK_OFF(PDMQUEUE, pTimer);
368 GEN_CHECK_OFF(PDMQUEUE, cbItem);
369 GEN_CHECK_OFF(PDMQUEUE, cItems);
370 GEN_CHECK_OFF(PDMQUEUE, pPendingR3);
371 GEN_CHECK_OFF(PDMQUEUE, pPendingR0);
372 GEN_CHECK_OFF(PDMQUEUE, pPendingRC);
373 GEN_CHECK_OFF(PDMQUEUE, iFreeHead);
374 GEN_CHECK_OFF(PDMQUEUE, iFreeTail);
375 GEN_CHECK_OFF(PDMQUEUE, aFreeItems);
376 GEN_CHECK_OFF(PDMQUEUE, aFreeItems[1]);
377 GEN_CHECK_OFF(PDMQUEUE, aFreeItems[0].pItemR3);
378 GEN_CHECK_OFF(PDMQUEUE, aFreeItems[0].pItemR0);
379 GEN_CHECK_OFF(PDMQUEUE, aFreeItems[1].pItemRC);
380 GEN_CHECK_SIZE(PDMDEVHLPTASK);
381 GEN_CHECK_OFF(PDMDEVHLPTASK, Core);
382 GEN_CHECK_OFF(PDMDEVHLPTASK, pDevInsR3);
383 GEN_CHECK_OFF(PDMDEVHLPTASK, enmOp);
384 GEN_CHECK_OFF(PDMDEVHLPTASK, u);
385 GEN_CHECK_OFF(PDMDEVHLPTASK, u.SetIRQ.iIrq);
386 GEN_CHECK_OFF(PDMDEVHLPTASK, u.SetIRQ.iLevel);
387
388 GEN_CHECK_SIZE(PGM);
389 GEN_CHECK_OFF(PGM, offVM);
390 GEN_CHECK_OFF(PGM, paDynPageMap32BitPTEsGC);
391 GEN_CHECK_OFF(PGM, paDynPageMapPaePTEsGC);
392 GEN_CHECK_OFF(PGM, enmHostMode);
393 GEN_CHECK_OFF(PGM, enmShadowMode);
394 GEN_CHECK_OFF(PGM, enmGuestMode);
395 GEN_CHECK_OFF(PGM, GCPhysCR3);
396 GEN_CHECK_OFF(PGM, GCPtrCR3Mapping);
397 GEN_CHECK_OFF(PGM, GCPhysGstCR3Monitored);
398 GEN_CHECK_OFF(PGM, pGuestPDHC);
399 GEN_CHECK_OFF(PGM, pGuestPDGC);
400 GEN_CHECK_OFF(PGM, pGstPaePDPTHC);
401 GEN_CHECK_OFF(PGM, pGstPaePDPTGC);
402 GEN_CHECK_OFF(PGM, apGstPaePDsHC);
403 GEN_CHECK_OFF(PGM, apGstPaePDsGC);
404 GEN_CHECK_OFF(PGM, aGCPhysGstPaePDs);
405 GEN_CHECK_OFF(PGM, aGCPhysGstPaePDsMonitored);
406 GEN_CHECK_OFF(PGM, pHC32BitPD);
407 GEN_CHECK_OFF(PGM, pGC32BitPD);
408 GEN_CHECK_OFF(PGM, HCPhys32BitPD);
409 GEN_CHECK_OFF(PGM, apHCPaePDs);
410 GEN_CHECK_OFF(PGM, apGCPaePDs);
411 GEN_CHECK_OFF(PGM, aHCPhysPaePDs);
412 GEN_CHECK_OFF(PGM, pHCPaePDPT);
413 GEN_CHECK_OFF(PGM, pGCPaePDPT);
414 GEN_CHECK_OFF(PGM, HCPhysPaePDPT);
415 GEN_CHECK_OFF(PGM, pHCPaePML4);
416 GEN_CHECK_OFF(PGM, HCPhysPaePML4);
417 GEN_CHECK_OFF(PGM, pfnR3ShwRelocate);
418 GEN_CHECK_OFF(PGM, pfnR3ShwExit);
419 GEN_CHECK_OFF(PGM, pfnR3ShwGetPage);
420 GEN_CHECK_OFF(PGM, pfnR3ShwModifyPage);
421 GEN_CHECK_OFF(PGM, pfnRCShwGetPage);
422 GEN_CHECK_OFF(PGM, pfnRCShwModifyPage);
423 GEN_CHECK_OFF(PGM, pfnR3GstRelocate);
424 GEN_CHECK_OFF(PGM, pfnR3GstExit);
425 GEN_CHECK_OFF(PGM, pfnR3GstMonitorCR3);
426 GEN_CHECK_OFF(PGM, pfnR3GstUnmonitorCR3);
427 GEN_CHECK_OFF(PGM, pfnR3GstMapCR3);
428 GEN_CHECK_OFF(PGM, pfnR3GstUnmapCR3);
429 GEN_CHECK_OFF(PGM, pfnR3GstGetPage);
430 GEN_CHECK_OFF(PGM, pfnR3GstModifyPage);
431 GEN_CHECK_OFF(PGM, pfnR3GstGetPDE);
432 GEN_CHECK_OFF(PGM, pfnRCGstGetPage);
433 GEN_CHECK_OFF(PGM, pfnRCGstModifyPage);
434 GEN_CHECK_OFF(PGM, pfnRCGstGetPDE);
435 GEN_CHECK_OFF(PGM, pfnR3BthRelocate);
436 GEN_CHECK_OFF(PGM, pfnR3BthSyncCR3);
437 GEN_CHECK_OFF(PGM, pfnR3BthInvalidatePage);
438 GEN_CHECK_OFF(PGM, pfnR3BthSyncPage);
439 GEN_CHECK_OFF(PGM, pfnR3BthPrefetchPage);
440 GEN_CHECK_OFF(PGM, pfnR3BthVerifyAccessSyncPage);
441 GEN_CHECK_OFF(PGM, pfnR3BthAssertCR3);
442 GEN_CHECK_OFF(PGM, pfnRCBthTrap0eHandler);
443 GEN_CHECK_OFF(PGM, pfnRCBthInvalidatePage);
444 GEN_CHECK_OFF(PGM, pfnRCBthSyncPage);
445 GEN_CHECK_OFF(PGM, pfnRCBthPrefetchPage);
446 GEN_CHECK_OFF(PGM, pfnRCBthVerifyAccessSyncPage);
447 GEN_CHECK_OFF(PGM, pfnRCBthAssertCR3);
448 GEN_CHECK_OFF(PGM, pRamRangesR3);
449 GEN_CHECK_OFF(PGM, pRamRangesR0);
450 GEN_CHECK_OFF(PGM, pRamRangesRC);
451 GEN_CHECK_OFF(PGM, pRomRangesR3);
452 GEN_CHECK_OFF(PGM, pRomRangesR0);
453 GEN_CHECK_OFF(PGM, pRomRangesRC);
454 GEN_CHECK_OFF(PGM, cbRamSize);
455 GEN_CHECK_OFF(PGM, pTreesR3);
456 GEN_CHECK_OFF(PGM, pTreesR0);
457 GEN_CHECK_OFF(PGM, pTreesRC);
458 GEN_CHECK_OFF(PGM, pMappingsR3);
459 GEN_CHECK_OFF(PGM, pMappingsRC);
460 GEN_CHECK_OFF(PGM, pMappingsR0);
461 GEN_CHECK_OFF(PGM, fMappingsFixed);
462 GEN_CHECK_OFF(PGM, GCPtrMappingFixed);
463 GEN_CHECK_OFF(PGM, cbMappingFixed);
464 GEN_CHECK_OFF(PGM, pInterPD);
465 GEN_CHECK_OFF(PGM, apInterPTs);
466 GEN_CHECK_OFF(PGM, apInterPaePTs);
467 GEN_CHECK_OFF(PGM, apInterPaePDs);
468 GEN_CHECK_OFF(PGM, pInterPaePDPT);
469 GEN_CHECK_OFF(PGM, pInterPaePDPT64);
470 GEN_CHECK_OFF(PGM, pInterPaePML4);
471 GEN_CHECK_OFF(PGM, HCPhysInterPD);
472 GEN_CHECK_OFF(PGM, HCPhysInterPaePDPT);
473 GEN_CHECK_OFF(PGM, HCPhysInterPaePML4);
474 GEN_CHECK_OFF(PGM, pbDynPageMapBaseGC);
475 GEN_CHECK_OFF(PGM, iDynPageMapLast);
476 GEN_CHECK_OFF(PGM, aHCPhysDynPageMapCache);
477 GEN_CHECK_OFF(PGM, GCPhysA20Mask);
478 GEN_CHECK_OFF(PGM, fA20Enabled);
479 GEN_CHECK_OFF(PGM, fSyncFlags);
480 GEN_CHECK_OFF(PGM, CritSect);
481 GEN_CHECK_OFF(PGM, pPoolR3);
482 GEN_CHECK_OFF(PGM, pPoolR0);
483 GEN_CHECK_OFF(PGM, pPoolRC);
484 GEN_CHECK_OFF(PGM, fNoMorePhysWrites);
485 GEN_CHECK_OFF(PGM, fPhysCacheFlushPending);
486 GEN_CHECK_OFF(PGM, pgmphysreadcache);
487 GEN_CHECK_OFF(PGM, pgmphyswritecache);
488 GEN_CHECK_OFF(PGM, ChunkR3Map);
489 GEN_CHECK_OFF(PGM, ChunkR3Map.pTree);
490 GEN_CHECK_OFF(PGM, ChunkR3Map.Tlb);
491 GEN_CHECK_OFF(PGM, ChunkR3Map.c);
492 GEN_CHECK_OFF(PGM, ChunkR3Map.cMax);
493 GEN_CHECK_OFF(PGM, ChunkR3Map.iNow);
494 GEN_CHECK_OFF(PGM, ChunkR3Map.AgeingCountdown);
495 GEN_CHECK_OFF(PGM, PhysTlbHC);
496 GEN_CHECK_OFF(PGM, PhysTlbHC.aEntries[0]);
497 GEN_CHECK_OFF(PGM, PhysTlbHC.aEntries[1]);
498 GEN_CHECK_OFF(PGM, PhysTlbHC.aEntries[1].GCPhys);
499 GEN_CHECK_OFF(PGM, PhysTlbHC.aEntries[1].pMap);
500 GEN_CHECK_OFF(PGM, PhysTlbHC.aEntries[1].pPage);
501 GEN_CHECK_OFF(PGM, PhysTlbHC.aEntries[1].pv);
502 GEN_CHECK_OFF(PGM, HCPhysZeroPg);
503 GEN_CHECK_OFF(PGM, pvZeroPgR3);
504 GEN_CHECK_OFF(PGM, pvZeroPgR0);
505 GEN_CHECK_OFF(PGM, pvZeroPgGC);
506 GEN_CHECK_OFF(PGM, cHandyPages);
507 GEN_CHECK_OFF(PGM, aHandyPages);
508 GEN_CHECK_OFF(PGM, aHandyPages[1]);
509 GEN_CHECK_OFF(PGM, aHandyPages[1].HCPhysGCPhys);
510 GEN_CHECK_OFF(PGM, aHandyPages[1].idPage);
511 GEN_CHECK_OFF(PGM, aHandyPages[1].idSharedPage);
512 GEN_CHECK_OFF(PGM, cAllPages);
513 GEN_CHECK_OFF(PGM, cPrivatePages);
514 GEN_CHECK_OFF(PGM, cSharedPages);
515 GEN_CHECK_OFF(PGM, cZeroPages);
516 GEN_CHECK_OFF(PGM, cGuestModeChanges);
517#ifdef VBOX_WITH_STATISTICS
518 GEN_CHECK_OFF(PGM, pStatTrap0eAttributionR0);
519 GEN_CHECK_OFF(PGM, pStatTrap0eAttributionRC);
520#endif
521
522 GEN_CHECK_SIZE(PGMMAPPING);
523 GEN_CHECK_OFF(PGMMAPPING, pNextR3);
524 GEN_CHECK_OFF(PGMMAPPING, pNextRC);
525 GEN_CHECK_OFF(PGMMAPPING, pNextR0);
526 GEN_CHECK_OFF(PGMMAPPING, GCPtr);
527 GEN_CHECK_OFF(PGMMAPPING, GCPtrLast);
528 GEN_CHECK_OFF(PGMMAPPING, cb);
529 GEN_CHECK_OFF(PGMMAPPING, pfnRelocate);
530 GEN_CHECK_OFF(PGMMAPPING, pvUser);
531 GEN_CHECK_OFF(PGMMAPPING, pszDesc);
532 GEN_CHECK_OFF(PGMMAPPING, cPTs);
533 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].HCPhysPT);
534 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].pPTR3);
535 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].pPTR0);
536 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].pPTRC);
537 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].HCPhysPaePT0);
538 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].HCPhysPaePT1);
539 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].paPaePTsR3);
540 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].paPaePTsRC);
541 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].paPaePTsR0);
542 GEN_CHECK_SIZE(PGMPHYSHANDLER);
543 GEN_CHECK_OFF(PGMPHYSHANDLER, Core);
544 GEN_CHECK_SIZE(((PPGMPHYSHANDLER)0)->Core);
545 GEN_CHECK_OFF(PGMPHYSHANDLER, enmType);
546 GEN_CHECK_OFF(PGMPHYSHANDLER, cPages);
547 GEN_CHECK_OFF(PGMPHYSHANDLER, pfnHandlerR3);
548 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR3);
549 GEN_CHECK_OFF(PGMPHYSHANDLER, pfnHandlerR0);
550 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR0);
551 GEN_CHECK_OFF(PGMPHYSHANDLER, pfnHandlerRC);
552 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserRC);
553 GEN_CHECK_OFF(PGMPHYSHANDLER, pszDesc);
554 GEN_CHECK_SIZE(PGMPHYS2VIRTHANDLER);
555 GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, Core);
556 GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, offVirtHandler);
557 GEN_CHECK_SIZE(PGMVIRTHANDLER);
558 GEN_CHECK_OFF(PGMVIRTHANDLER, Core);
559 GEN_CHECK_OFF(PGMVIRTHANDLER, enmType);
560 GEN_CHECK_OFF(PGMVIRTHANDLER, cb);
561 GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerR3);
562 GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerRC);
563 GEN_CHECK_OFF(PGMVIRTHANDLER, pszDesc);
564 GEN_CHECK_OFF(PGMVIRTHANDLER, cPages);
565 GEN_CHECK_OFF(PGMVIRTHANDLER, aPhysToVirt);
566 GEN_CHECK_SIZE(PGMPAGE);
567 GEN_CHECK_OFF(PGMPAGE, HCPhys);
568 GEN_CHECK_SIZE(PGMRAMRANGE);
569 GEN_CHECK_OFF(PGMRAMRANGE, pNextR3);
570 GEN_CHECK_OFF(PGMRAMRANGE, pNextR0);
571 GEN_CHECK_OFF(PGMRAMRANGE, pNextRC);
572 GEN_CHECK_OFF(PGMRAMRANGE, GCPhys);
573 GEN_CHECK_OFF(PGMRAMRANGE, GCPhysLast);
574 GEN_CHECK_OFF(PGMRAMRANGE, cb);
575 GEN_CHECK_OFF(PGMRAMRANGE, fFlags);
576 GEN_CHECK_OFF(PGMRAMRANGE, pvR3);
577 GEN_CHECK_OFF(PGMRAMRANGE, pszDesc);
578 GEN_CHECK_OFF(PGMRAMRANGE, aPages);
579 GEN_CHECK_OFF(PGMRAMRANGE, aPages[1]);
580 GEN_CHECK_SIZE(PGMROMPAGE);
581 GEN_CHECK_OFF(PGMROMPAGE, Virgin);
582 GEN_CHECK_OFF(PGMROMPAGE, Shadow);
583 GEN_CHECK_OFF(PGMROMPAGE, enmProt);
584 GEN_CHECK_SIZE(PGMROMRANGE);
585 GEN_CHECK_OFF(PGMROMRANGE, pNextR3);
586 GEN_CHECK_OFF(PGMROMRANGE, pNextR0);
587 GEN_CHECK_OFF(PGMROMRANGE, pNextRC);
588 GEN_CHECK_OFF(PGMROMRANGE, GCPhys);
589 GEN_CHECK_OFF(PGMROMRANGE, GCPhysLast);
590 GEN_CHECK_OFF(PGMROMRANGE, cb);
591 GEN_CHECK_OFF(PGMROMRANGE, fFlags);
592 GEN_CHECK_OFF(PGMROMRANGE, pvOriginal);
593 GEN_CHECK_OFF(PGMROMRANGE, pszDesc);
594 GEN_CHECK_OFF(PGMROMRANGE, aPages);
595 GEN_CHECK_OFF(PGMROMRANGE, aPages[1]);
596 GEN_CHECK_SIZE(PGMMMIO2RANGE);
597 GEN_CHECK_OFF(PGMMMIO2RANGE, pDevInsR3);
598 GEN_CHECK_OFF(PGMMMIO2RANGE, pNextR3);
599 GEN_CHECK_OFF(PGMMMIO2RANGE, fMapped);
600 GEN_CHECK_OFF(PGMMMIO2RANGE, fOverlapping);
601 GEN_CHECK_OFF(PGMMMIO2RANGE, iRegion);
602 GEN_CHECK_OFF(PGMMMIO2RANGE, RamRange);
603 GEN_CHECK_SIZE(PGMTREES);
604 GEN_CHECK_OFF(PGMTREES, PhysHandlers);
605 GEN_CHECK_OFF(PGMTREES, VirtHandlers);
606 GEN_CHECK_OFF(PGMTREES, PhysToVirtHandlers);
607 GEN_CHECK_OFF(PGMTREES, HyperVirtHandlers);
608 GEN_CHECK_SIZE(PGMPOOLPAGE);
609 GEN_CHECK_OFF(PGMPOOLPAGE, Core);
610 GEN_CHECK_OFF(PGMPOOLPAGE, GCPhys);
611 GEN_CHECK_OFF(PGMPOOLPAGE, pvPageR3);
612 GEN_CHECK_OFF(PGMPOOLPAGE, enmKind);
613 GEN_CHECK_OFF(PGMPOOLPAGE, bPadding);
614 GEN_CHECK_OFF(PGMPOOLPAGE, idx);
615 GEN_CHECK_OFF(PGMPOOLPAGE, iNext);
616#ifdef PGMPOOL_WITH_USER_TRACKING
617 GEN_CHECK_OFF(PGMPOOLPAGE, iUserHead);
618 GEN_CHECK_OFF(PGMPOOLPAGE, cPresent);
619 GEN_CHECK_OFF(PGMPOOLPAGE, iFirstPresent);
620#endif
621#ifdef PGMPOOL_WITH_MONITORING
622 GEN_CHECK_OFF(PGMPOOLPAGE, cModifications);
623 GEN_CHECK_OFF(PGMPOOLPAGE, iModifiedNext);
624 GEN_CHECK_OFF(PGMPOOLPAGE, iModifiedPrev);
625 GEN_CHECK_OFF(PGMPOOLPAGE, iMonitoredNext);
626 GEN_CHECK_OFF(PGMPOOLPAGE, iMonitoredPrev);
627#endif
628#ifdef PGMPOOL_WITH_CACHE
629 GEN_CHECK_OFF(PGMPOOLPAGE, iAgeNext);
630 GEN_CHECK_OFF(PGMPOOLPAGE, iAgePrev);
631#endif
632 GEN_CHECK_OFF(PGMPOOLPAGE, fZeroed);
633 GEN_CHECK_OFF(PGMPOOLPAGE, fSeenNonGlobal);
634 GEN_CHECK_OFF(PGMPOOLPAGE, fMonitored);
635 GEN_CHECK_OFF(PGMPOOLPAGE, fCached);
636 GEN_CHECK_OFF(PGMPOOLPAGE, fReusedFlushPending);
637 GEN_CHECK_OFF(PGMPOOLPAGE, fCR3Mix);
638 GEN_CHECK_SIZE(PGMPOOL);
639 GEN_CHECK_OFF(PGMPOOL, pVMR3);
640 GEN_CHECK_OFF(PGMPOOL, pVMR0);
641 GEN_CHECK_OFF(PGMPOOL, pVMRC);
642 GEN_CHECK_OFF(PGMPOOL, cMaxPages);
643 GEN_CHECK_OFF(PGMPOOL, cCurPages);
644 GEN_CHECK_OFF(PGMPOOL, iFreeHead);
645 GEN_CHECK_OFF(PGMPOOL, u16Padding);
646#ifdef PGMPOOL_WITH_USER_TRACKING
647 GEN_CHECK_OFF(PGMPOOL, iUserFreeHead);
648 GEN_CHECK_OFF(PGMPOOL, cMaxUsers);
649 GEN_CHECK_OFF(PGMPOOL, cPresent);
650 GEN_CHECK_OFF(PGMPOOL, paUsersR3);
651 GEN_CHECK_OFF(PGMPOOL, paUsersR0);
652 GEN_CHECK_OFF(PGMPOOL, paUsersRC);
653#endif /* PGMPOOL_WITH_USER_TRACKING */
654#ifdef PGMPOOL_WITH_GCPHYS_TRACKING
655 GEN_CHECK_OFF(PGMPOOL, iPhysExtFreeHead);
656 GEN_CHECK_OFF(PGMPOOL, cMaxPhysExts);
657 GEN_CHECK_OFF(PGMPOOL, paPhysExtsR3);
658 GEN_CHECK_OFF(PGMPOOL, paPhysExtsR0);
659 GEN_CHECK_OFF(PGMPOOL, paPhysExtsRC);
660#endif
661#ifdef PGMPOOL_WITH_CACHE
662 GEN_CHECK_OFF(PGMPOOL, aiHash);
663 GEN_CHECK_OFF(PGMPOOL, iAgeHead);
664 GEN_CHECK_OFF(PGMPOOL, iAgeTail);
665 GEN_CHECK_OFF(PGMPOOL, fCacheEnabled);
666#endif
667#ifdef PGMPOOL_WITH_MONITORING
668 GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerRC);
669 GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerR0);
670 GEN_CHECK_OFF(PGMPOOL, pfnAccessHandlerR3);
671 GEN_CHECK_OFF(PGMPOOL, pszAccessHandler);
672 GEN_CHECK_OFF(PGMPOOL, iModifiedHead);
673 GEN_CHECK_OFF(PGMPOOL, cModifiedPages);
674#endif
675 GEN_CHECK_OFF(PGMPOOL, cUsedPages);
676#ifdef VBOX_WITH_STATISTICS
677 GEN_CHECK_OFF(PGMPOOL, cUsedPagesHigh);
678 GEN_CHECK_OFF(PGMPOOL, StatAlloc);
679 GEN_CHECK_OFF(PGMPOOL, StatClearAll);
680#endif
681 GEN_CHECK_OFF(PGMPOOL, HCPhysTree);
682 GEN_CHECK_OFF(PGMPOOL, aPages);
683 GEN_CHECK_OFF(PGMPOOL, aPages[1]);
684 GEN_CHECK_OFF(PGMPOOL, aPages[PGMPOOL_IDX_FIRST - 1]);
685
686 GEN_CHECK_SIZE(REM);
687 GEN_CHECK_OFF(REM, pCtx);
688 GEN_CHECK_OFF(REM, cCanExecuteRaw);
689 GEN_CHECK_OFF(REM, aGCPtrInvalidatedPages);
690 GEN_CHECK_OFF(REM, cHandlerNotifications);
691 GEN_CHECK_OFF(REM, aHandlerNotifications);
692 GEN_CHECK_OFF(REM, paHCVirtToGCPhys);
693 GEN_CHECK_OFF(REM, cPhysRegistrations);
694 GEN_CHECK_OFF(REM, aPhysReg);
695 GEN_CHECK_OFF(REM, rc);
696 GEN_CHECK_OFF(REM, StatsInQEMU);
697 GEN_CHECK_OFF(REM, Env);
698
699 GEN_CHECK_SIZE(SELM);
700 GEN_CHECK_OFF(SELM, offVM);
701 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_CS]);
702 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_DS]);
703 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_CS64]);
704 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS]);
705 GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS_TRAP08]);
706 GEN_CHECK_OFF(SELM, paGdtHC);
707 GEN_CHECK_OFF(SELM, paGdtGC);
708 GEN_CHECK_OFF(SELM, GuestGdtr);
709 GEN_CHECK_OFF(SELM, cbEffGuestGdtLimit);
710 GEN_CHECK_OFF(SELM, HCPtrLdt);
711 GEN_CHECK_OFF(SELM, GCPtrLdt);
712 GEN_CHECK_OFF(SELM, GCPtrGuestLdt);
713 GEN_CHECK_OFF(SELM, cbLdtLimit);
714 GEN_CHECK_OFF(SELM, offLdtHyper);
715 GEN_CHECK_OFF(SELM, Tss);
716 GEN_CHECK_OFF(SELM, TssTrap08);
717 GEN_CHECK_OFF(SELM, GCPtrTss);
718 GEN_CHECK_OFF(SELM, GCPtrGuestTss);
719 GEN_CHECK_OFF(SELM, cbGuestTss);
720 GEN_CHECK_OFF(SELM, fGuestTss32Bit);
721 GEN_CHECK_OFF(SELM, cbMonitoredGuestTss);
722 GEN_CHECK_OFF(SELM, GCSelTss);
723 GEN_CHECK_OFF(SELM, fGDTRangeRegistered);
724 GEN_CHECK_OFF(SELM, StatUpdateFromCPUM);
725
726 GEN_CHECK_SIZE(TM);
727 GEN_CHECK_OFF(TM, offVM);
728 GEN_CHECK_OFF(TM, pvGIPR3);
729 //GEN_CHECK_OFF(TM, pvGIPR0);
730 GEN_CHECK_OFF(TM, pvGIPGC);
731 GEN_CHECK_OFF(TM, fTSCTicking);
732 GEN_CHECK_OFF(TM, fTSCUseRealTSC);
733 GEN_CHECK_OFF(TM, fTSCTiedToExecution);
734 GEN_CHECK_OFF(TM, u64TSCOffset);
735 GEN_CHECK_OFF(TM, u64TSC);
736 GEN_CHECK_OFF(TM, cTSCTicksPerSecond);
737 GEN_CHECK_OFF(TM, fVirtualTicking);
738 GEN_CHECK_OFF(TM, fVirtualWarpDrive);
739 GEN_CHECK_OFF(TM, fVirtualSyncTicking);
740 GEN_CHECK_OFF(TM, fVirtualSyncCatchUp);
741 GEN_CHECK_OFF(TM, u32VirtualWarpDrivePercentage);
742 GEN_CHECK_OFF(TM, u64VirtualOffset);
743 GEN_CHECK_OFF(TM, u64Virtual);
744 GEN_CHECK_OFF(TM, u64VirtualRawPrev);
745 GEN_CHECK_OFF(TM, VirtualGetRawDataR3);
746 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.pu64Prev);
747 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.pfnBad);
748 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.pfnRediscover);
749 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.c1nsSteps);
750 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.cBadPrev);
751 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.cExpired);
752 GEN_CHECK_OFF(TM, VirtualGetRawDataR3.cUpdateRaces);
753 GEN_CHECK_OFF(TM, VirtualGetRawDataR0);
754 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.pu64Prev);
755 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.pfnBad);
756 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.pfnRediscover);
757 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.c1nsSteps);
758 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.cBadPrev);
759 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.cExpired);
760 GEN_CHECK_OFF(TM, VirtualGetRawDataR0.cUpdateRaces);
761 GEN_CHECK_OFF(TM, VirtualGetRawDataGC);
762 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.pu64Prev);
763 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.pfnBad);
764 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.pfnRediscover);
765 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.c1nsSteps);
766 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.cBadPrev);
767 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.cExpired);
768 GEN_CHECK_OFF(TM, VirtualGetRawDataGC.cUpdateRaces);
769 GEN_CHECK_OFF(TM, pfnVirtualGetRawR3);
770 GEN_CHECK_OFF(TM, pfnVirtualGetRawR0);
771 GEN_CHECK_OFF(TM, pfnVirtualGetRawGC);
772 GEN_CHECK_OFF(TM, u64VirtualWarpDriveStart);
773 GEN_CHECK_OFF(TM, u64VirtualSync);
774 GEN_CHECK_OFF(TM, offVirtualSync);
775 GEN_CHECK_OFF(TM, offVirtualSyncGivenUp);
776 GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpPrev);
777 GEN_CHECK_OFF(TM, u32VirtualSyncCatchUpPercentage);
778 GEN_CHECK_OFF(TM, u32VirtualSyncScheduleSlack);
779 GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpStopThreshold);
780 GEN_CHECK_OFF(TM, u64VirtualSyncCatchUpGiveUpThreshold);
781 GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods);
782 GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods[0].u64Start);
783 GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods[0].u32Percentage);
784 GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods[1].u64Start);
785 GEN_CHECK_OFF(TM, aVirtualSyncCatchUpPeriods[1].u32Percentage);
786 GEN_CHECK_OFF(TM, pTimer);
787 GEN_CHECK_OFF(TM, u32TimerMillies);
788 GEN_CHECK_OFF(TM, pFree);
789 GEN_CHECK_OFF(TM, pCreated);
790 GEN_CHECK_OFF(TM, paTimerQueuesR3);
791 GEN_CHECK_OFF(TM, paTimerQueuesR0);
792 GEN_CHECK_OFF(TM, paTimerQueuesGC);
793 GEN_CHECK_OFF(TM, StatDoQueues);
794 GEN_CHECK_OFF(TM, StatTimerCallbackSetFF);
795 GEN_CHECK_SIZE(TMTIMER);
796 GEN_CHECK_OFF(TMTIMER, u64Expire);
797 GEN_CHECK_OFF(TMTIMER, enmClock);
798 GEN_CHECK_OFF(TMTIMER, enmType);
799 GEN_CHECK_OFF(TMTIMER, u.Dev.pfnTimer);
800 GEN_CHECK_OFF(TMTIMER, u.Dev.pDevIns);
801 GEN_CHECK_OFF(TMTIMER, u.Drv.pfnTimer);
802 GEN_CHECK_OFF(TMTIMER, u.Drv.pDrvIns);
803 GEN_CHECK_OFF(TMTIMER, u.Internal.pfnTimer);
804 GEN_CHECK_OFF(TMTIMER, u.Internal.pvUser);
805 GEN_CHECK_OFF(TMTIMER, u.External.pfnTimer);
806 GEN_CHECK_OFF(TMTIMER, u.External.pvUser);
807 GEN_CHECK_OFF(TMTIMER, enmState);
808 GEN_CHECK_OFF(TMTIMER, offScheduleNext);
809 GEN_CHECK_OFF(TMTIMER, offNext);
810 GEN_CHECK_OFF(TMTIMER, offPrev);
811 GEN_CHECK_OFF(TMTIMER, pBigNext);
812 GEN_CHECK_OFF(TMTIMER, pBigPrev);
813 GEN_CHECK_OFF(TMTIMER, pszDesc);
814 GEN_CHECK_OFF(TMTIMER, pVMR0);
815 GEN_CHECK_OFF(TMTIMER, pVMR3);
816 GEN_CHECK_OFF(TMTIMER, pVMGC);
817 GEN_CHECK_SIZE(TMTIMERQUEUE);
818 GEN_CHECK_OFF(TMTIMERQUEUE, offActive);
819 GEN_CHECK_OFF(TMTIMERQUEUE, offSchedule);
820 GEN_CHECK_OFF(TMTIMERQUEUE, enmClock);
821
822 GEN_CHECK_SIZE(TRPM); // has .mac
823 GEN_CHECK_SIZE(VM); // has .mac
824 GEN_CHECK_SIZE(VMM);
825 GEN_CHECK_OFF(VMM, offVM);
826 GEN_CHECK_OFF(VMM, cbCoreCode);
827 GEN_CHECK_OFF(VMM, HCPhysCoreCode);
828 GEN_CHECK_OFF(VMM, pvHCCoreCodeR3);
829 GEN_CHECK_OFF(VMM, pvHCCoreCodeR0);
830 GEN_CHECK_OFF(VMM, pvGCCoreCode);
831 GEN_CHECK_OFF(VMM, enmSwitcher);
832 GEN_CHECK_OFF(VMM, aoffSwitchers);
833 GEN_CHECK_OFF(VMM, aoffSwitchers[1]);
834 GEN_CHECK_OFF(VMM, pfnR0HostToGuest);
835 GEN_CHECK_OFF(VMM, pfnGCGuestToHost);
836 GEN_CHECK_OFF(VMM, pfnGCCallTrampoline);
837 GEN_CHECK_OFF(VMM, pfnCPUMGCResumeGuest);
838 GEN_CHECK_OFF(VMM, pfnCPUMGCResumeGuestV86);
839 GEN_CHECK_OFF(VMM, iLastGCRc);
840 GEN_CHECK_OFF(VMM, pbHCStack);
841 GEN_CHECK_OFF(VMM, pbGCStack);
842 GEN_CHECK_OFF(VMM, pbGCStackBottom);
843 GEN_CHECK_OFF(VMM, pLoggerGC);
844 GEN_CHECK_OFF(VMM, pLoggerHC);
845 GEN_CHECK_OFF(VMM, cbLoggerGC);
846 GEN_CHECK_OFF(VMM, CritSectVMLock);
847 GEN_CHECK_OFF(VMM, pYieldTimer);
848 GEN_CHECK_OFF(VMM, cYieldResumeMillies);
849 GEN_CHECK_OFF(VMM, cYieldEveryMillies);
850 GEN_CHECK_OFF(VMM, enmCallHostOperation);
851 GEN_CHECK_OFF(VMM, rcCallHost);
852 GEN_CHECK_OFF(VMM, u64CallHostArg);
853 GEN_CHECK_OFF(VMM, CallHostR0JmpBuf);
854 GEN_CHECK_OFF(VMM, CallHostR0JmpBuf.SpCheck);
855 GEN_CHECK_OFF(VMM, CallHostR0JmpBuf.SpResume);
856 GEN_CHECK_OFF(VMM, StatRunGC);
857 GEN_CHECK_OFF(VMM, StatGCRetPGMLock);
858
859 GEN_CHECK_SIZE(RTPINGPONG);
860 GEN_CHECK_SIZE(RTCRITSECT);
861 GEN_CHECK_OFF(RTCRITSECT, u32Magic);
862 GEN_CHECK_OFF(RTCRITSECT, cLockers);
863 GEN_CHECK_OFF(RTCRITSECT, NativeThreadOwner);
864 GEN_CHECK_OFF(RTCRITSECT, cNestings);
865 GEN_CHECK_OFF(RTCRITSECT, fFlags);
866 GEN_CHECK_OFF(RTCRITSECT, EventSem);
867 GEN_CHECK_OFF(RTCRITSECT, Strict.ThreadOwner);
868 GEN_CHECK_OFF(RTCRITSECT, Strict.pszEnterFile);
869 GEN_CHECK_OFF(RTCRITSECT, Strict.u32EnterLine);
870 GEN_CHECK_OFF(RTCRITSECT, Strict.uEnterId);
871
872
873 GEN_CHECK_SIZE(CSAM);
874 GEN_CHECK_OFF(CSAM, offVM);
875 GEN_CHECK_OFF(CSAM, pPageTree);
876 GEN_CHECK_OFF(CSAM, aDangerousInstr);
877 GEN_CHECK_OFF(CSAM, aDangerousInstr[1]);
878 GEN_CHECK_OFF(CSAM, aDangerousInstr[CSAM_MAX_DANGR_INSTR - 1]);
879 GEN_CHECK_OFF(CSAM, cDangerousInstr);
880 GEN_CHECK_OFF(CSAM, iDangerousInstr);
881 GEN_CHECK_OFF(CSAM, pPDBitmapGC);
882 GEN_CHECK_OFF(CSAM, pPDHCBitmapGC);
883 GEN_CHECK_OFF(CSAM, pPDBitmapHC);
884 GEN_CHECK_OFF(CSAM, pPDGCBitmapHC);
885 GEN_CHECK_OFF(CSAM, savedstate);
886 GEN_CHECK_OFF(CSAM, savedstate.pSSM);
887 GEN_CHECK_OFF(CSAM, savedstate.cPageRecords);
888 GEN_CHECK_OFF(CSAM, savedstate.cPatchPageRecords);
889 GEN_CHECK_OFF(CSAM, cDirtyPages);
890 GEN_CHECK_OFF(CSAM, pvDirtyBasePage);
891 GEN_CHECK_OFF(CSAM, pvDirtyBasePage[1]);
892 GEN_CHECK_OFF(CSAM, pvDirtyBasePage[CSAM_MAX_DIRTY_PAGES - 1]);
893 GEN_CHECK_OFF(CSAM, pvDirtyFaultPage);
894 GEN_CHECK_OFF(CSAM, pvDirtyFaultPage[1]);
895 GEN_CHECK_OFF(CSAM, pvDirtyFaultPage[CSAM_MAX_DIRTY_PAGES - 1]);
896 GEN_CHECK_OFF(CSAM, pvCallInstruction);
897 GEN_CHECK_OFF(CSAM, iCallInstruction);
898 GEN_CHECK_OFF(CSAM, fScanningStarted);
899 GEN_CHECK_OFF(CSAM, fGatesChecked);
900 GEN_CHECK_OFF(CSAM, StatNrTraps);
901 GEN_CHECK_OFF(CSAM, StatNrPages);
902
903 GEN_CHECK_SIZE(PATM);
904 GEN_CHECK_OFF(PATM, offVM);
905 GEN_CHECK_OFF(PATM, pPatchMemGC);
906 GEN_CHECK_OFF(PATM, pPatchMemHC);
907 GEN_CHECK_OFF(PATM, cbPatchMem);
908 GEN_CHECK_OFF(PATM, offPatchMem);
909 GEN_CHECK_OFF(PATM, fOutOfMemory);
910 GEN_CHECK_OFF(PATM, deltaReloc);
911 GEN_CHECK_OFF(PATM, pGCStateGC);
912 GEN_CHECK_OFF(PATM, pGCStateHC);
913 GEN_CHECK_OFF(PATM, pGCStackGC);
914 GEN_CHECK_OFF(PATM, pGCStackHC);
915 GEN_CHECK_OFF(PATM, pCPUMCtxGC);
916 GEN_CHECK_OFF(PATM, pStatsGC);
917 GEN_CHECK_OFF(PATM, pStatsHC);
918 GEN_CHECK_OFF(PATM, uCurrentPatchIdx);
919 GEN_CHECK_OFF(PATM, ulCallDepth);
920 GEN_CHECK_OFF(PATM, cPageRecords);
921 GEN_CHECK_OFF(PATM, pPatchedInstrGCLowest);
922 GEN_CHECK_OFF(PATM, pPatchedInstrGCHighest);
923 GEN_CHECK_OFF(PATM, PatchLookupTreeHC);
924 GEN_CHECK_OFF(PATM, PatchLookupTreeGC);
925 GEN_CHECK_OFF(PATM, pfnHelperCallGC);
926 GEN_CHECK_OFF(PATM, pfnHelperRetGC);
927 GEN_CHECK_OFF(PATM, pfnHelperJumpGC);
928 GEN_CHECK_OFF(PATM, pfnHelperIretGC);
929 GEN_CHECK_OFF(PATM, pGlobalPatchRec);
930 GEN_CHECK_OFF(PATM, pfnSysEnterGC);
931 GEN_CHECK_OFF(PATM, pfnSysEnterPatchGC);
932 GEN_CHECK_OFF(PATM, uSysEnterPatchIdx);
933 GEN_CHECK_OFF(PATM, pvFaultMonitor);
934 GEN_CHECK_OFF(PATM, mmio);
935 GEN_CHECK_OFF(PATM, mmio.GCPhys);
936 GEN_CHECK_OFF(PATM, mmio.pCachedData);
937 GEN_CHECK_OFF(PATM, savedstate);
938 GEN_CHECK_OFF(PATM, savedstate.pSSM);
939 GEN_CHECK_OFF(PATM, savedstate.cPatches);
940 GEN_CHECK_OFF(PATM, StatNrOpcodeRead);
941 GEN_CHECK_OFF(PATM, StatU32FunctionMaxSlotsUsed);
942
943 GEN_CHECK_SIZE(PATMGCSTATE);
944 GEN_CHECK_OFF(PATMGCSTATE, uVMFlags);
945 GEN_CHECK_OFF(PATMGCSTATE, uPendingAction);
946 GEN_CHECK_OFF(PATMGCSTATE, uPatchCalls);
947 GEN_CHECK_OFF(PATMGCSTATE, uScratch);
948 GEN_CHECK_OFF(PATMGCSTATE, uIretEFlags);
949 GEN_CHECK_OFF(PATMGCSTATE, uIretCS);
950 GEN_CHECK_OFF(PATMGCSTATE, uIretEIP);
951 GEN_CHECK_OFF(PATMGCSTATE, Psp);
952 GEN_CHECK_OFF(PATMGCSTATE, fPIF);
953 GEN_CHECK_OFF(PATMGCSTATE, GCPtrInhibitInterrupts);
954 GEN_CHECK_OFF(PATMGCSTATE, Restore);
955 GEN_CHECK_OFF(PATMGCSTATE, Restore.uEAX);
956 GEN_CHECK_OFF(PATMGCSTATE, Restore.uECX);
957 GEN_CHECK_OFF(PATMGCSTATE, Restore.uEDI);
958 GEN_CHECK_OFF(PATMGCSTATE, Restore.eFlags);
959 GEN_CHECK_OFF(PATMGCSTATE, Restore.uFlags);
960 GEN_CHECK_SIZE(PATMTREES);
961 GEN_CHECK_OFF(PATMTREES, PatchTree);
962 GEN_CHECK_OFF(PATMTREES, PatchTreeByPatchAddr);
963 GEN_CHECK_OFF(PATMTREES, PatchTreeByPage);
964 GEN_CHECK_SIZE(PATMPATCHREC);
965 GEN_CHECK_OFF(PATMPATCHREC, Core);
966 GEN_CHECK_OFF(PATMPATCHREC, CoreOffset);
967 GEN_CHECK_OFF(PATMPATCHREC, patch);
968 GEN_CHECK_SIZE(PATCHINFO);
969 GEN_CHECK_OFF(PATCHINFO, uState);
970 GEN_CHECK_OFF(PATCHINFO, uOldState);
971 GEN_CHECK_OFF(PATCHINFO, uOpMode);
972 GEN_CHECK_OFF(PATCHINFO, pPrivInstrHC);
973 GEN_CHECK_OFF(PATCHINFO, pPrivInstrGC);
974 GEN_CHECK_OFF(PATCHINFO, aPrivInstr);
975 GEN_CHECK_OFF(PATCHINFO, aPrivInstr[1]);
976 GEN_CHECK_OFF(PATCHINFO, aPrivInstr[MAX_INSTR_SIZE - 1]);
977 GEN_CHECK_OFF(PATCHINFO, cbPrivInstr);
978 GEN_CHECK_OFF(PATCHINFO, opcode);
979 GEN_CHECK_OFF(PATCHINFO, cbPatchJump);
980 GEN_CHECK_OFF(PATCHINFO, pPatchJumpDestGC);
981 GEN_CHECK_OFF(PATCHINFO, pPatchBlockOffset);
982 GEN_CHECK_OFF(PATCHINFO, cbPatchBlockSize);
983 GEN_CHECK_OFF(PATCHINFO, uCurPatchOffset);
984 GEN_CHECK_OFF(PATCHINFO, flags);
985 GEN_CHECK_OFF(PATCHINFO, pInstrGCLowest);
986 GEN_CHECK_OFF(PATCHINFO, pInstrGCHighest);
987 GEN_CHECK_OFF(PATCHINFO, FixupTree);
988 GEN_CHECK_OFF(PATCHINFO, nrFixups);
989 GEN_CHECK_OFF(PATCHINFO, JumpTree);
990 GEN_CHECK_OFF(PATCHINFO, nrJumpRecs);
991 GEN_CHECK_OFF(PATCHINFO, Patch2GuestAddrTree);
992 GEN_CHECK_OFF(PATCHINFO, Guest2PatchAddrTree);
993 GEN_CHECK_OFF(PATCHINFO, nrPatch2GuestRecs);
994 GEN_CHECK_OFF(PATCHINFO, cacheRec);
995 GEN_CHECK_OFF(PATCHINFO, cacheRec.pPatchLocStartHC);
996 GEN_CHECK_OFF(PATCHINFO, cacheRec.pPatchLocEndHC);
997 GEN_CHECK_OFF(PATCHINFO, cacheRec.pGuestLoc);
998 GEN_CHECK_OFF(PATCHINFO, cacheRec.opsize);
999 GEN_CHECK_OFF(PATCHINFO, pTempInfo);
1000 GEN_CHECK_OFF(PATCHINFO, cCodeWrites);
1001 GEN_CHECK_OFF(PATCHINFO, cTraps);
1002 GEN_CHECK_OFF(PATCHINFO, cInvalidWrites);
1003 GEN_CHECK_OFF(PATCHINFO, uPatchIdx);
1004 GEN_CHECK_OFF(PATCHINFO, bDirtyOpcode);
1005 GEN_CHECK_SIZE(PATMPATCHPAGE);
1006 GEN_CHECK_OFF(PATMPATCHPAGE, Core);
1007 GEN_CHECK_OFF(PATMPATCHPAGE, pLowestAddrGC);
1008 GEN_CHECK_OFF(PATMPATCHPAGE, pHighestAddrGC);
1009 GEN_CHECK_OFF(PATMPATCHPAGE, cCount);
1010 GEN_CHECK_OFF(PATMPATCHPAGE, cMaxPatches);
1011 GEN_CHECK_OFF(PATMPATCHPAGE, aPatch);
1012
1013 return (0);
1014}
1015
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