VirtualBox

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

Last change on this file since 1 was 1, checked in by vboxsync, 55 years ago

import

File size: 17.8 KB
Line 
1/** @file
2 *
3 * tstVMMStructGC - Generate structure member and size checks from the GC
4 * perspective. This is built using the VBOXGC template
5 * but linked into a host ring-3 executable, rather hacky.
6 */
7
8/*
9 * Copyright (C) 2006 InnoTek Systemberatung GmbH
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.215389.xyz. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License as published by the Free Software Foundation,
15 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
16 * distribution. VirtualBox OSE is distributed in the hope that it will
17 * be useful, but WITHOUT ANY WARRANTY of any kind.
18 *
19 * If you received this file as part of a commercial VirtualBox
20 * distribution, then only the terms of your commercial VirtualBox
21 * license agreement apply instead of the previous paragraph.
22 */
23
24
25/*
26 * Sanity checks.
27 */
28#ifndef IN_GC
29# error Incorrect template!
30#endif
31#if defined(IN_RING3) || defined(IN_RING0)
32# error Incorrect template!
33#endif
34
35
36/*******************************************************************************
37* Header Files *
38*******************************************************************************/
39#include <VBox/cfgm.h>
40#include <VBox/cpum.h>
41#include <VBox/mm.h>
42#include <VBox/pgm.h>
43#include <VBox/selm.h>
44#include <VBox/trpm.h>
45#include <VBox/vmm.h>
46#include <VBox/stam.h>
47#include "PDMInternal.h"
48#include <VBox/pdm.h>
49#include "CFGMInternal.h"
50#include "CPUMInternal.h"
51#include "MMInternal.h"
52#include "PGMInternal.h"
53#include "SELMInternal.h"
54#include "TRPMInternal.h"
55#include "TMInternal.h"
56#include "IOMInternal.h"
57#include "REMInternal.h"
58#include "HWACCMInternal.h"
59#ifdef VBOX_WITH_PATM
60# include "PATMInternal.h"
61#endif
62#include "VMMInternal.h"
63#include "DBGFInternal.h"
64#include "STAMInternal.h"
65#ifdef VBOX_WITH_CSAM
66# include "CSAMInternal.h"
67#endif
68#include "EMInternal.h"
69#include "REMInternal.h"
70#ifdef VBOX_WITH_RRM
71# include "RRMInternal.h"
72#endif
73#include <VBox/vm.h>
74#include <VBox/param.h>
75#include <VBox/x86.h>
76
77/* we don't use iprt here because we're pretending to be in GC! */
78#include <stdio.h>
79
80#define GEN_CHECK_SIZE(s) printf(" CHECK_SIZE(%s, %d);\n", #s, sizeof(s))
81#define GEN_CHECK_OFF(s, m) printf(" CHECK_OFF(%s, %d, %s);\n", #s, RT_OFFSETOF(s, m), #m)
82
83int main()
84{
85 GEN_CHECK_SIZE(CFGM);
86
87 GEN_CHECK_SIZE(CPUM); // has .mac
88 GEN_CHECK_SIZE(CPUMHOSTCTX);
89 GEN_CHECK_SIZE(CPUMCTX);
90 GEN_CHECK_SIZE(CPUMCTXCORE);
91
92 GEN_CHECK_SIZE(DBGF);
93 GEN_CHECK_OFF(DBGF, offVM);
94 GEN_CHECK_OFF(DBGF, fAttached);
95 GEN_CHECK_OFF(DBGF, fStoppedInHyper);
96 GEN_CHECK_OFF(DBGF, PingPong);
97 GEN_CHECK_OFF(DBGF, DbgEvent);
98 GEN_CHECK_OFF(DBGF, enmVMMCmd);
99 GEN_CHECK_OFF(DBGF, VMMCmdData);
100 GEN_CHECK_OFF(DBGF, pInfoFirst);
101 GEN_CHECK_OFF(DBGF, InfoCritSect);
102 GEN_CHECK_OFF(DBGF, SymbolTree);
103 GEN_CHECK_OFF(DBGF, pSymbolSpace);
104 GEN_CHECK_OFF(DBGF, fSymInited);
105 GEN_CHECK_OFF(DBGF, cHwBreakpoints);
106 GEN_CHECK_OFF(DBGF, cBreakpoints);
107 GEN_CHECK_OFF(DBGF, aHwBreakpoints);
108 GEN_CHECK_OFF(DBGF, aBreakpoints);
109 GEN_CHECK_OFF(DBGF, iActiveBp);
110 GEN_CHECK_OFF(DBGF, fSingleSteppingRaw);
111 GEN_CHECK_SIZE(DBGFEVENT);
112
113 GEN_CHECK_SIZE(EM);
114 GEN_CHECK_OFF(EM, offVM);
115 GEN_CHECK_OFF(EM, pCtx);
116 GEN_CHECK_OFF(EM, enmState);
117 GEN_CHECK_OFF(EM, fForceRAW);
118 GEN_CHECK_OFF(EM, u.achPaddingFatalLongJump);
119 GEN_CHECK_OFF(EM, StatForcedActions);
120 GEN_CHECK_OFF(EM, StatTotalClis);
121 GEN_CHECK_OFF(EM, pStatsHC);
122 GEN_CHECK_OFF(EM, pStatsGC);
123 GEN_CHECK_OFF(EM, pCliStatTree);
124
125 GEN_CHECK_SIZE(IOM);
126
127 GEN_CHECK_SIZE(MM);
128 GEN_CHECK_OFF(MM, offVM);
129 GEN_CHECK_OFF(MM, offHyperNextStatic);
130 GEN_CHECK_OFF(MM, cbHyperArea);
131 GEN_CHECK_OFF(MM, fPGMInitialized);
132 GEN_CHECK_OFF(MM, offLookupHyper);
133 GEN_CHECK_OFF(MM, pHyperHeapHC);
134 GEN_CHECK_OFF(MM, pHyperHeapGC);
135 GEN_CHECK_OFF(MM, pLockedMem);
136 GEN_CHECK_OFF(MM, pPagePool);
137 GEN_CHECK_OFF(MM, pPagePoolLow);
138 GEN_CHECK_OFF(MM, pvDummyPage);
139 GEN_CHECK_OFF(MM, HCPhysDummyPage);
140 GEN_CHECK_OFF(MM, cbRAMSize);
141 GEN_CHECK_OFF(MM, pvRamBaseHC);
142 GEN_CHECK_OFF(MM, cbRamBase);
143 GEN_CHECK_OFF(MM, pHeap);
144 GEN_CHECK_SIZE(MMHYPERSTAT);
145 GEN_CHECK_SIZE(MMHYPERCHUNK);
146 GEN_CHECK_SIZE(MMHYPERCHUNKFREE);
147 GEN_CHECK_SIZE(MMHYPERHEAP);
148 GEN_CHECK_OFF(MMHYPERHEAP, u32Magic);
149 GEN_CHECK_OFF(MMHYPERHEAP, cbHeap);
150 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapHC);
151 GEN_CHECK_OFF(MMHYPERHEAP, pbHeapGC);
152 GEN_CHECK_OFF(MMHYPERHEAP, pVMHC);
153 GEN_CHECK_OFF(MMHYPERHEAP, pVMGC);
154 GEN_CHECK_OFF(MMHYPERHEAP, cbFree);
155 GEN_CHECK_OFF(MMHYPERHEAP, offFreeHead);
156 GEN_CHECK_OFF(MMHYPERHEAP, offFreeTail);
157 GEN_CHECK_OFF(MMHYPERHEAP, offPageAligned);
158 GEN_CHECK_OFF(MMHYPERHEAP, HyperHeapStatTree);
159 GEN_CHECK_SIZE(MMLOOKUPHYPER);
160 GEN_CHECK_OFF(MMLOOKUPHYPER, offNext);
161 GEN_CHECK_OFF(MMLOOKUPHYPER, off);
162 GEN_CHECK_OFF(MMLOOKUPHYPER, cb);
163 GEN_CHECK_OFF(MMLOOKUPHYPER, enmType);
164 GEN_CHECK_OFF(MMLOOKUPHYPER, u.Locked.pvHC);
165 GEN_CHECK_OFF(MMLOOKUPHYPER, u.Locked.pLockedMem);
166 GEN_CHECK_OFF(MMLOOKUPHYPER, u.HCPhys.pvHC);
167 GEN_CHECK_OFF(MMLOOKUPHYPER, u.HCPhys.HCPhys);
168 GEN_CHECK_OFF(MMLOOKUPHYPER, u.GCPhys.GCPhys);
169 GEN_CHECK_OFF(MMLOOKUPHYPER, pszDesc);
170
171 GEN_CHECK_SIZE(PDM);
172 GEN_CHECK_OFF(PDM, offVM);
173 GEN_CHECK_OFF(PDM, pModules);
174 GEN_CHECK_OFF(PDM, pDevs);
175 GEN_CHECK_OFF(PDM, pDevInstances);
176 GEN_CHECK_OFF(PDM, pDrvs);
177 GEN_CHECK_OFF(PDM, pCritSects);
178 GEN_CHECK_OFF(PDM, aPciBuses);
179 GEN_CHECK_OFF(PDM, Pic);
180 GEN_CHECK_OFF(PDM, Apic);
181 GEN_CHECK_OFF(PDM, IoApic);
182 GEN_CHECK_OFF(PDM, pDmac);
183 GEN_CHECK_OFF(PDM, pRtc);
184 GEN_CHECK_OFF(PDM, pDevHlpQueueGC);
185 GEN_CHECK_OFF(PDM, pDevHlpQueueHC);
186 GEN_CHECK_OFF(PDM, cQueuedCritSectLeaves);
187 GEN_CHECK_OFF(PDM, apQueuedCritSectsLeaves);
188 GEN_CHECK_OFF(PDM, pQueuesTimer);
189 GEN_CHECK_OFF(PDM, pQueuesForced);
190 GEN_CHECK_OFF(PDM, pQueueFlushGC);
191 GEN_CHECK_OFF(PDM, pQueueFlushHC);
192 GEN_CHECK_OFF(PDM, cPollers);
193 GEN_CHECK_OFF(PDM, apfnPollers);
194 GEN_CHECK_OFF(PDM, aDrvInsPollers);
195 GEN_CHECK_OFF(PDM, pTimerPollers);
196#ifdef VBOX_WITH_PDM_LOCK
197 GEN_CHECK_OFF(PDM, CritSect);
198#endif
199 GEN_CHECK_OFF(PDM, StatQueuedCritSectLeaves);
200
201 GEN_CHECK_SIZE(PGM);
202 GEN_CHECK_OFF(PGM, offVM);
203 GEN_CHECK_OFF(PGM, paDynPageMap32BitPTEsGC);
204 GEN_CHECK_OFF(PGM, paDynPageMapPaePTEsGC);
205 GEN_CHECK_OFF(PGM, enmHostMode);
206 GEN_CHECK_OFF(PGM, enmShadowMode);
207 GEN_CHECK_OFF(PGM, enmGuestMode);
208 GEN_CHECK_OFF(PGM, GCPhysCR3);
209 GEN_CHECK_OFF(PGM, GCPtrCR3Mapping);
210 GEN_CHECK_OFF(PGM, GCPhysGstCR3Monitored);
211 GEN_CHECK_OFF(PGM, pGuestPDHC);
212 GEN_CHECK_OFF(PGM, pGuestPDGC);
213 GEN_CHECK_OFF(PGM, pGstPaePDPTRHC);
214 GEN_CHECK_OFF(PGM, pGstPaePDPTRGC);
215 GEN_CHECK_OFF(PGM, apGstPaePDsHC);
216 GEN_CHECK_OFF(PGM, apGstPaePDsGC);
217 GEN_CHECK_OFF(PGM, aGCPhysGstPaePDs);
218 GEN_CHECK_OFF(PGM, aGCPhysGstPaePDsMonitored);
219 GEN_CHECK_OFF(PGM, pHC32BitPD);
220 GEN_CHECK_OFF(PGM, pGC32BitPD);
221 GEN_CHECK_OFF(PGM, HCPhys32BitPD);
222 GEN_CHECK_OFF(PGM, apHCPaePDs);
223 GEN_CHECK_OFF(PGM, apGCPaePDs);
224 GEN_CHECK_OFF(PGM, aHCPhysPaePDs);
225 GEN_CHECK_OFF(PGM, pHCPaePDPTR);
226 GEN_CHECK_OFF(PGM, pGCPaePDPTR);
227 GEN_CHECK_OFF(PGM, HCPhysPaePDPTR);
228 GEN_CHECK_OFF(PGM, pHCPaePML4);
229 GEN_CHECK_OFF(PGM, pGCPaePML4);
230 GEN_CHECK_OFF(PGM, HCPhysPaePML4);
231 GEN_CHECK_OFF(PGM, pfnR3ShwRelocate);
232 GEN_CHECK_OFF(PGM, pfnR3ShwExit);
233 GEN_CHECK_OFF(PGM, pfnR3ShwGetPage);
234 GEN_CHECK_OFF(PGM, pfnR3ShwModifyPage);
235 GEN_CHECK_OFF(PGM, pfnR3ShwGetPDEByIndex);
236 GEN_CHECK_OFF(PGM, pfnR3ShwSetPDEByIndex);
237 GEN_CHECK_OFF(PGM, pfnR3ShwModifyPDEByIndex);
238 GEN_CHECK_OFF(PGM, pfnGCShwGetPage);
239 GEN_CHECK_OFF(PGM, pfnGCShwModifyPage);
240 GEN_CHECK_OFF(PGM, pfnGCShwGetPDEByIndex);
241 GEN_CHECK_OFF(PGM, pfnGCShwSetPDEByIndex);
242 GEN_CHECK_OFF(PGM, pfnGCShwModifyPDEByIndex);
243 GEN_CHECK_OFF(PGM, pfnR3GstRelocate);
244 GEN_CHECK_OFF(PGM, pfnR3GstExit);
245 GEN_CHECK_OFF(PGM, pfnR3GstMonitorCR3);
246 GEN_CHECK_OFF(PGM, pfnR3GstUnmonitorCR3);
247 GEN_CHECK_OFF(PGM, pfnR3GstMapCR3);
248 GEN_CHECK_OFF(PGM, pfnR3GstUnmapCR3);
249 GEN_CHECK_OFF(PGM, pfnR3GstGetPage);
250 GEN_CHECK_OFF(PGM, pfnR3GstModifyPage);
251 GEN_CHECK_OFF(PGM, pfnR3GstGetPDE);
252 GEN_CHECK_OFF(PGM, pfnGCGstGetPage);
253 GEN_CHECK_OFF(PGM, pfnGCGstModifyPage);
254 GEN_CHECK_OFF(PGM, pfnGCGstGetPDE);
255 GEN_CHECK_OFF(PGM, pfnR3BthRelocate);
256 GEN_CHECK_OFF(PGM, pfnR3BthSyncCR3);
257 GEN_CHECK_OFF(PGM, pfnR3BthTrap0eHandler);
258 GEN_CHECK_OFF(PGM, pfnR3BthInvalidatePage);
259 GEN_CHECK_OFF(PGM, pfnR3BthSyncPage);
260 GEN_CHECK_OFF(PGM, pfnR3BthPrefetchPage);
261 GEN_CHECK_OFF(PGM, pfnR3BthVerifyAccessSyncPage);
262 GEN_CHECK_OFF(PGM, pfnR3BthAssertCR3);
263 GEN_CHECK_OFF(PGM, pfnGCBthTrap0eHandler);
264 GEN_CHECK_OFF(PGM, pfnGCBthInvalidatePage);
265 GEN_CHECK_OFF(PGM, pfnGCBthSyncPage);
266 GEN_CHECK_OFF(PGM, pfnGCBthPrefetchPage);
267 GEN_CHECK_OFF(PGM, pfnGCBthVerifyAccessSyncPage);
268 GEN_CHECK_OFF(PGM, pfnGCBthAssertCR3);
269 GEN_CHECK_OFF(PGM, pRamRangesHC);
270 GEN_CHECK_OFF(PGM, pRamRangesGC);
271 GEN_CHECK_OFF(PGM, cbRamSize);
272 GEN_CHECK_OFF(PGM, pTreesHC);
273 GEN_CHECK_OFF(PGM, pTreesGC);
274 GEN_CHECK_OFF(PGM, pMappingsHC);
275 GEN_CHECK_OFF(PGM, pMappingsGC);
276 GEN_CHECK_OFF(PGM, fMappingsFixed);
277 GEN_CHECK_OFF(PGM, GCPtrMappingFixed);
278 GEN_CHECK_OFF(PGM, cbMappingFixed);
279 GEN_CHECK_OFF(PGM, pInterPD);
280 GEN_CHECK_OFF(PGM, apInterPTs);
281 GEN_CHECK_OFF(PGM, apInterPaePTs);
282 GEN_CHECK_OFF(PGM, apInterPaePDs);
283 GEN_CHECK_OFF(PGM, pInterPaePDPTR);
284 GEN_CHECK_OFF(PGM, pInterPaePDPTR64);
285 GEN_CHECK_OFF(PGM, pInterPaePML4);
286 GEN_CHECK_OFF(PGM, HCPhysInterPD);
287 GEN_CHECK_OFF(PGM, HCPhysInterPaePDPTR);
288 GEN_CHECK_OFF(PGM, HCPhysInterPaePML4);
289 GEN_CHECK_OFF(PGM, pbDynPageMapBaseGC);
290 GEN_CHECK_OFF(PGM, iDynPageMapLast);
291 GEN_CHECK_OFF(PGM, aHCPhysDynPageMapCache);
292 GEN_CHECK_OFF(PGM, GCPhysA20Mask);
293 GEN_CHECK_OFF(PGM, fA20Enabled);
294 GEN_CHECK_OFF(PGM, fSyncFlags);
295 GEN_CHECK_OFF(PGM, CritSect);
296#ifdef PGM_PD_CACHING_ENABLED
297 GEN_CHECK_OFF(PGM, pdcache);
298#endif
299 GEN_CHECK_OFF(PGM, pgmphysreadcache);
300 GEN_CHECK_OFF(PGM, pgmphyswritecache);
301 GEN_CHECK_SIZE(PGMMAPPING);
302 GEN_CHECK_OFF(PGMMAPPING, pNextHC);
303 GEN_CHECK_OFF(PGMMAPPING, pNextGC);
304 GEN_CHECK_OFF(PGMMAPPING, GCPtr);
305 GEN_CHECK_OFF(PGMMAPPING, GCPtrLast);
306 GEN_CHECK_OFF(PGMMAPPING, cb);
307 GEN_CHECK_OFF(PGMMAPPING, pfnRelocate);
308 GEN_CHECK_OFF(PGMMAPPING, pvUser);
309 GEN_CHECK_OFF(PGMMAPPING, pszDesc);
310 GEN_CHECK_OFF(PGMMAPPING, cPTs);
311 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].HCPhysPT);
312 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].pPTHC);
313 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].pPTGC);
314 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].HCPhysPaePT0);
315 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].HCPhysPaePT1);
316 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].paPaePTsHC);
317 GEN_CHECK_OFF(PGMMAPPING, aPTs[1].paPaePTsGC);
318 GEN_CHECK_SIZE(PGMPHYSHANDLER);
319 GEN_CHECK_OFF(PGMPHYSHANDLER, Core);
320 GEN_CHECK_OFF(PGMPHYSHANDLER, enmType);
321 GEN_CHECK_OFF(PGMPHYSHANDLER, cPages);
322 GEN_CHECK_OFF(PGMPHYSHANDLER, pfnHandlerR3);
323 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR3);
324 GEN_CHECK_OFF(PGMPHYSHANDLER, pfnHandlerR0);
325 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserR0);
326 GEN_CHECK_OFF(PGMPHYSHANDLER, pfnHandlerGC);
327 GEN_CHECK_OFF(PGMPHYSHANDLER, pvUserGC);
328 GEN_CHECK_OFF(PGMPHYSHANDLER, pszDesc);
329 GEN_CHECK_SIZE(PGMPHYS2VIRTHANDLER);
330 GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, Core);
331 GEN_CHECK_OFF(PGMPHYS2VIRTHANDLER, offVirtHandler);
332 GEN_CHECK_SIZE(PGMVIRTHANDLER);
333 GEN_CHECK_OFF(PGMVIRTHANDLER, Core);
334 GEN_CHECK_OFF(PGMVIRTHANDLER, enmType);
335 GEN_CHECK_OFF(PGMVIRTHANDLER, GCPtr);
336 GEN_CHECK_OFF(PGMVIRTHANDLER, GCPtrLast);
337 GEN_CHECK_OFF(PGMVIRTHANDLER, cb);
338 GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerHC);
339 GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerGC);
340 GEN_CHECK_OFF(PGMVIRTHANDLER, pszDesc);
341 GEN_CHECK_OFF(PGMVIRTHANDLER, cPages);
342 GEN_CHECK_OFF(PGMVIRTHANDLER, aPhysToVirt);
343 GEN_CHECK_SIZE(PGMRAMRANGE);
344 GEN_CHECK_OFF(PGMRAMRANGE, pNextHC);
345 GEN_CHECK_OFF(PGMRAMRANGE, pNextGC);
346 GEN_CHECK_OFF(PGMRAMRANGE, GCPhys);
347 GEN_CHECK_OFF(PGMRAMRANGE, GCPhysLast);
348 GEN_CHECK_OFF(PGMRAMRANGE, cb);
349 GEN_CHECK_OFF(PGMRAMRANGE, pvHC);
350 GEN_CHECK_OFF(PGMRAMRANGE, aHCPhys);
351 GEN_CHECK_SIZE(PGMTREES);
352 GEN_CHECK_OFF(PGMTREES, PhysHandlers);
353 GEN_CHECK_OFF(PGMTREES, VirtHandlers);
354 GEN_CHECK_OFF(PGMTREES, PhysToVirtHandlers);
355 GEN_CHECK_OFF(PGMTREES, auPadding);
356
357 GEN_CHECK_SIZE(REM);
358
359 GEN_CHECK_SIZE(SELM);
360 GEN_CHECK_OFF(SELM, offVM);
361 GEN_CHECK_OFF(SELM, SelCS);
362 GEN_CHECK_OFF(SELM, SelDS);
363 GEN_CHECK_OFF(SELM, SelCS64);
364 GEN_CHECK_OFF(SELM, SelTSS);
365 GEN_CHECK_OFF(SELM, SelTSSTrap08);
366 GEN_CHECK_OFF(SELM, paGdtHC);
367 GEN_CHECK_OFF(SELM, paGdtGC);
368 GEN_CHECK_OFF(SELM, GuestGdtr);
369 GEN_CHECK_OFF(SELM, cbEffGuestGdtLimit);
370 GEN_CHECK_OFF(SELM, HCPtrLdt);
371 GEN_CHECK_OFF(SELM, GCPtrLdt);
372 GEN_CHECK_OFF(SELM, GCPtrGuestLdt);
373 GEN_CHECK_OFF(SELM, cbLdtLimit);
374 GEN_CHECK_OFF(SELM, offLdtHyper);
375 GEN_CHECK_OFF(SELM, Tss);
376 GEN_CHECK_OFF(SELM, TssTrap08);
377 GEN_CHECK_OFF(SELM, TssTrap0a);
378 GEN_CHECK_OFF(SELM, GCPtrTss);
379 GEN_CHECK_OFF(SELM, GCPtrGuestTss);
380 GEN_CHECK_OFF(SELM, cbGuestTss);
381 GEN_CHECK_OFF(SELM, fGuestTss32Bit);
382 GEN_CHECK_OFF(SELM, cbMonitoredGuestTss);
383 GEN_CHECK_OFF(SELM, GCSelTss);
384 GEN_CHECK_OFF(SELM, fGDTRangeRegistered);
385 GEN_CHECK_OFF(SELM, StatUpdateFromCPUM);
386
387 GEN_CHECK_SIZE(STAM);
388
389 GEN_CHECK_SIZE(TM);
390 GEN_CHECK_OFF(TM, offVM);
391 GEN_CHECK_OFF(TM, pvGIPR3);
392 //GEN_CHECK_OFF(TM, pvGIPR0);
393 GEN_CHECK_OFF(TM, pvGIPGC);
394 GEN_CHECK_OFF(TM, fTSCTicking);
395 GEN_CHECK_OFF(TM, u64TSCOffset);
396 GEN_CHECK_OFF(TM, u64TSC);
397 GEN_CHECK_OFF(TM, cTSCTicksPerSecond);
398 GEN_CHECK_OFF(TM, uReserved);
399 GEN_CHECK_OFF(TM, fVirtualTicking);
400 GEN_CHECK_OFF(TM, u64VirtualOffset);
401 GEN_CHECK_OFF(TM, u64Virtual);
402 GEN_CHECK_OFF(TM, u64VirtualSync);
403 GEN_CHECK_OFF(TM, u32VirtualSyncCatchupPrecentage);
404 GEN_CHECK_OFF(TM, u32VirtualSyncCatchupStopThreashold);
405 GEN_CHECK_OFF(TM, u64VirtualSyncCatchupStartTreashold);
406 GEN_CHECK_OFF(TM, u64VirtualSyncCatchupGiveUpTreashold);
407 GEN_CHECK_OFF(TM, pTimer);
408 GEN_CHECK_OFF(TM, u32TimerMillies);
409 GEN_CHECK_OFF(TM, pFree);
410 GEN_CHECK_OFF(TM, pCreated);
411 GEN_CHECK_OFF(TM, paTimerQueuesR3);
412 GEN_CHECK_OFF(TM, paTimerQueuesR0);
413 GEN_CHECK_OFF(TM, paTimerQueuesGC);
414 GEN_CHECK_OFF(TM, StatDoQueues);
415 GEN_CHECK_SIZE(TMTIMER);
416 GEN_CHECK_OFF(TMTIMER, u64Expire);
417 GEN_CHECK_OFF(TMTIMER, enmClock);
418 GEN_CHECK_OFF(TMTIMER, enmType);
419 GEN_CHECK_OFF(TMTIMER, u.Dev.pfnTimer);
420 GEN_CHECK_OFF(TMTIMER, u.Dev.pDevIns);
421 GEN_CHECK_OFF(TMTIMER, u.Drv.pfnTimer);
422 GEN_CHECK_OFF(TMTIMER, u.Drv.pDrvIns);
423 GEN_CHECK_OFF(TMTIMER, u.Internal.pfnTimer);
424 GEN_CHECK_OFF(TMTIMER, u.Internal.pvUser);
425 GEN_CHECK_OFF(TMTIMER, u.External.pfnTimer);
426 GEN_CHECK_OFF(TMTIMER, u.External.pvUser);
427 GEN_CHECK_OFF(TMTIMER, enmState);
428 GEN_CHECK_OFF(TMTIMER, offScheduleNext);
429 GEN_CHECK_OFF(TMTIMER, offNext);
430 GEN_CHECK_OFF(TMTIMER, offPrev);
431 GEN_CHECK_OFF(TMTIMER, pBigNext);
432 GEN_CHECK_OFF(TMTIMER, pBigPrev);
433 GEN_CHECK_OFF(TMTIMER, pszDesc);
434 GEN_CHECK_OFF(TMTIMER, pVMR0);
435 GEN_CHECK_OFF(TMTIMER, pVMR3);
436 GEN_CHECK_OFF(TMTIMER, pVMGC);
437 GEN_CHECK_SIZE(TMTIMERQUEUE);
438 GEN_CHECK_OFF(TMTIMERQUEUE, offActive);
439 GEN_CHECK_OFF(TMTIMERQUEUE, offSchedule);
440 GEN_CHECK_OFF(TMTIMERQUEUE, enmClock);
441
442 GEN_CHECK_SIZE(TRPM); // has .mac
443 GEN_CHECK_SIZE(VM); // has .mac
444 GEN_CHECK_SIZE(VMM);
445 GEN_CHECK_OFF(VMM, offVM);
446 GEN_CHECK_OFF(VMM, cbCoreCode);
447 GEN_CHECK_OFF(VMM, HCPhysCoreCode);
448 GEN_CHECK_OFF(VMM, pvHCCoreCodeR3);
449 GEN_CHECK_OFF(VMM, pvHCCoreCodeR0);
450 GEN_CHECK_OFF(VMM, pvGCCoreCode);
451 GEN_CHECK_OFF(VMM, enmSwitcher);
452 GEN_CHECK_OFF(VMM, aoffSwitchers);
453 GEN_CHECK_OFF(VMM, aoffSwitchers[1]);
454 GEN_CHECK_OFF(VMM, pfnR0HostToGuest);
455 GEN_CHECK_OFF(VMM, pfnGCGuestToHost);
456 GEN_CHECK_OFF(VMM, pfnGCCallTrampoline);
457 GEN_CHECK_OFF(VMM, pfnCPUMGCResumeGuest);
458 GEN_CHECK_OFF(VMM, pfnCPUMGCResumeGuestV86);
459 GEN_CHECK_OFF(VMM, iLastGCRc);
460 GEN_CHECK_OFF(VMM, pbHCStack);
461 GEN_CHECK_OFF(VMM, pbGCStack);
462 GEN_CHECK_OFF(VMM, pbGCStackBottom);
463 GEN_CHECK_OFF(VMM, pLoggerGC);
464 GEN_CHECK_OFF(VMM, pLoggerHC);
465 GEN_CHECK_OFF(VMM, cbLoggerGC);
466 GEN_CHECK_OFF(VMM, CritSectVMLock);
467 GEN_CHECK_OFF(VMM, pYieldTimer);
468 GEN_CHECK_OFF(VMM, cYieldResumeMillies);
469 GEN_CHECK_OFF(VMM, cYieldEveryMillies);
470 GEN_CHECK_OFF(VMM, StatRunGC);
471
472 GEN_CHECK_SIZE(RTPINGPONG);
473 GEN_CHECK_SIZE(RTCRITSECT);
474 GEN_CHECK_OFF(RTCRITSECT, u32Magic);
475 GEN_CHECK_OFF(RTCRITSECT, cLockers);
476 GEN_CHECK_OFF(RTCRITSECT, NativeThreadOwner);
477 GEN_CHECK_OFF(RTCRITSECT, cNestings);
478 GEN_CHECK_OFF(RTCRITSECT, fFlags);
479 GEN_CHECK_OFF(RTCRITSECT, EventSem);
480 GEN_CHECK_OFF(RTCRITSECT, Strict.ThreadOwner);
481 GEN_CHECK_OFF(RTCRITSECT, Strict.pszEnterFile);
482 GEN_CHECK_OFF(RTCRITSECT, Strict.u32EnterLine);
483 GEN_CHECK_OFF(RTCRITSECT, Strict.uEnterId);
484
485 return 0;
486}
487
488
489
Note: See TracBrowser for help on using the repository browser.

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