%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/virtualbox/dtrace/testcase/amd64/
Upload File :
Create Path :
Current File : //lib/virtualbox/dtrace/testcase/amd64/vbox-vm-struct-test.d

#pragma D option quiet
int g_cErrors;

dtrace:::BEGIN
{
    g_cErrors = 0;
}

dtrace:::BEGIN
/sizeof(X86CPUIDFEATECX) != 4/
{
    printf("error: sizeof(X86CPUIDFEATECX) should be 4, not %u\n", sizeof(X86CPUIDFEATECX));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUM) != 624/
{
    printf("error: sizeof(CPUM) should be 624, not %u\n", sizeof(CPUM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, offCPUMCPU0) != 0/
{
    printf("error: offsetof(CPUM, offCPUMCPU0) should be 0, not %u\n", offsetof(CPUM, offCPUMCPU0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, fHostUseFlags) != 4/
{
    printf("error: offsetof(CPUM, fHostUseFlags) should be 4, not %u\n", offsetof(CPUM, fHostUseFlags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, CR4) != 8/
{
    printf("error: offsetof(CPUM, CR4) should be 8, not %u\n", offsetof(CPUM, CR4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, aGuestCpuIdPatmStd) != 248/
{
    printf("error: offsetof(CPUM, aGuestCpuIdPatmStd) should be 248, not %u\n", offsetof(CPUM, aGuestCpuIdPatmStd));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, aGuestCpuIdPatmExt) != 344/
{
    printf("error: offsetof(CPUM, aGuestCpuIdPatmExt) should be 344, not %u\n", offsetof(CPUM, aGuestCpuIdPatmExt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, aGuestCpuIdPatmCentaur) != 504/
{
    printf("error: offsetof(CPUM, aGuestCpuIdPatmCentaur) should be 504, not %u\n", offsetof(CPUM, aGuestCpuIdPatmCentaur));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCPU) != 3328/
{
    printf("error: sizeof(CPUMCPU) should be 3328, not %u\n", sizeof(CPUMCPU));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, Hyper) != 2112/
{
    printf("error: offsetof(CPUMCPU, Hyper) should be 2112, not %u\n", offsetof(CPUMCPU, Hyper));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, Host) != 1792/
{
    printf("error: offsetof(CPUMCPU, Host) should be 1792, not %u\n", offsetof(CPUMCPU, Host));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, Guest) != 0/
{
    printf("error: offsetof(CPUMCPU, Guest) should be 0, not %u\n", offsetof(CPUMCPU, Guest));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, GuestMsrs) != 1216/
{
    printf("error: offsetof(CPUMCPU, GuestMsrs) should be 1216, not %u\n", offsetof(CPUMCPU, GuestMsrs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fUseFlags) != 1728/
{
    printf("error: offsetof(CPUMCPU, fUseFlags) should be 1728, not %u\n", offsetof(CPUMCPU, fUseFlags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fChanged) != 1732/
{
    printf("error: offsetof(CPUMCPU, fChanged) should be 1732, not %u\n", offsetof(CPUMCPU, fChanged));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, offCPUM) != 1736/
{
    printf("error: offsetof(CPUMCPU, offCPUM) should be 1736, not %u\n", offsetof(CPUMCPU, offCPUM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, u32RetCode) != 1740/
{
    printf("error: offsetof(CPUMCPU, u32RetCode) should be 1740, not %u\n", offsetof(CPUMCPU, u32RetCode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, pvApicBase) != 1744/
{
    printf("error: offsetof(CPUMCPU, pvApicBase) should be 1744, not %u\n", offsetof(CPUMCPU, pvApicBase));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fApicDisVectors) != 1752/
{
    printf("error: offsetof(CPUMCPU, fApicDisVectors) should be 1752, not %u\n", offsetof(CPUMCPU, fApicDisVectors));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fX2Apic) != 1756/
{
    printf("error: offsetof(CPUMCPU, fX2Apic) should be 1756, not %u\n", offsetof(CPUMCPU, fX2Apic));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fRawEntered) != 1757/
{
    printf("error: offsetof(CPUMCPU, fRawEntered) should be 1757, not %u\n", offsetof(CPUMCPU, fRawEntered));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fRemEntered) != 1758/
{
    printf("error: offsetof(CPUMCPU, fRemEntered) should be 1758, not %u\n", offsetof(CPUMCPU, fRemEntered));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMHOSTCTX) != 320/
{
    printf("error: sizeof(CPUMHOSTCTX) should be 320, not %u\n", sizeof(CPUMHOSTCTX));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, pXStateR3) != 296/
{
    printf("error: offsetof(CPUMHOSTCTX, pXStateR3) should be 296, not %u\n", offsetof(CPUMHOSTCTX, pXStateR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, pXStateR0) != 288/
{
    printf("error: offsetof(CPUMHOSTCTX, pXStateR0) should be 288, not %u\n", offsetof(CPUMHOSTCTX, pXStateR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, pXStateRC) != 284/
{
    printf("error: offsetof(CPUMHOSTCTX, pXStateRC) should be 284, not %u\n", offsetof(CPUMHOSTCTX, pXStateRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rbx) != 0/
{
    printf("error: offsetof(CPUMHOSTCTX, rbx) should be 0, not %u\n", offsetof(CPUMHOSTCTX, rbx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rdi) != 8/
{
    printf("error: offsetof(CPUMHOSTCTX, rdi) should be 8, not %u\n", offsetof(CPUMHOSTCTX, rdi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rsi) != 16/
{
    printf("error: offsetof(CPUMHOSTCTX, rsi) should be 16, not %u\n", offsetof(CPUMHOSTCTX, rsi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rbp) != 24/
{
    printf("error: offsetof(CPUMHOSTCTX, rbp) should be 24, not %u\n", offsetof(CPUMHOSTCTX, rbp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rsp) != 32/
{
    printf("error: offsetof(CPUMHOSTCTX, rsp) should be 32, not %u\n", offsetof(CPUMHOSTCTX, rsp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r10) != 40/
{
    printf("error: offsetof(CPUMHOSTCTX, r10) should be 40, not %u\n", offsetof(CPUMHOSTCTX, r10));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r11) != 48/
{
    printf("error: offsetof(CPUMHOSTCTX, r11) should be 48, not %u\n", offsetof(CPUMHOSTCTX, r11));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r12) != 56/
{
    printf("error: offsetof(CPUMHOSTCTX, r12) should be 56, not %u\n", offsetof(CPUMHOSTCTX, r12));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r13) != 64/
{
    printf("error: offsetof(CPUMHOSTCTX, r13) should be 64, not %u\n", offsetof(CPUMHOSTCTX, r13));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r14) != 72/
{
    printf("error: offsetof(CPUMHOSTCTX, r14) should be 72, not %u\n", offsetof(CPUMHOSTCTX, r14));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r15) != 80/
{
    printf("error: offsetof(CPUMHOSTCTX, r15) should be 80, not %u\n", offsetof(CPUMHOSTCTX, r15));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rflags) != 88/
{
    printf("error: offsetof(CPUMHOSTCTX, rflags) should be 88, not %u\n", offsetof(CPUMHOSTCTX, rflags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, ss) != 96/
{
    printf("error: offsetof(CPUMHOSTCTX, ss) should be 96, not %u\n", offsetof(CPUMHOSTCTX, ss));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, gs) != 100/
{
    printf("error: offsetof(CPUMHOSTCTX, gs) should be 100, not %u\n", offsetof(CPUMHOSTCTX, gs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, fs) != 104/
{
    printf("error: offsetof(CPUMHOSTCTX, fs) should be 104, not %u\n", offsetof(CPUMHOSTCTX, fs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, es) != 108/
{
    printf("error: offsetof(CPUMHOSTCTX, es) should be 108, not %u\n", offsetof(CPUMHOSTCTX, es));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, ds) != 112/
{
    printf("error: offsetof(CPUMHOSTCTX, ds) should be 112, not %u\n", offsetof(CPUMHOSTCTX, ds));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cs) != 116/
{
    printf("error: offsetof(CPUMHOSTCTX, cs) should be 116, not %u\n", offsetof(CPUMHOSTCTX, cs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr0) != 120/
{
    printf("error: offsetof(CPUMHOSTCTX, cr0) should be 120, not %u\n", offsetof(CPUMHOSTCTX, cr0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr3) != 128/
{
    printf("error: offsetof(CPUMHOSTCTX, cr3) should be 128, not %u\n", offsetof(CPUMHOSTCTX, cr3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr4) != 136/
{
    printf("error: offsetof(CPUMHOSTCTX, cr4) should be 136, not %u\n", offsetof(CPUMHOSTCTX, cr4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr8) != 144/
{
    printf("error: offsetof(CPUMHOSTCTX, cr8) should be 144, not %u\n", offsetof(CPUMHOSTCTX, cr8));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr0) != 152/
{
    printf("error: offsetof(CPUMHOSTCTX, dr0) should be 152, not %u\n", offsetof(CPUMHOSTCTX, dr0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr1) != 160/
{
    printf("error: offsetof(CPUMHOSTCTX, dr1) should be 160, not %u\n", offsetof(CPUMHOSTCTX, dr1));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr2) != 168/
{
    printf("error: offsetof(CPUMHOSTCTX, dr2) should be 168, not %u\n", offsetof(CPUMHOSTCTX, dr2));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr3) != 176/
{
    printf("error: offsetof(CPUMHOSTCTX, dr3) should be 176, not %u\n", offsetof(CPUMHOSTCTX, dr3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr6) != 184/
{
    printf("error: offsetof(CPUMHOSTCTX, dr6) should be 184, not %u\n", offsetof(CPUMHOSTCTX, dr6));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr7) != 192/
{
    printf("error: offsetof(CPUMHOSTCTX, dr7) should be 192, not %u\n", offsetof(CPUMHOSTCTX, dr7));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, gdtr) != 200/
{
    printf("error: offsetof(CPUMHOSTCTX, gdtr) should be 200, not %u\n", offsetof(CPUMHOSTCTX, gdtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, idtr) != 212/
{
    printf("error: offsetof(CPUMHOSTCTX, idtr) should be 212, not %u\n", offsetof(CPUMHOSTCTX, idtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, ldtr) != 224/
{
    printf("error: offsetof(CPUMHOSTCTX, ldtr) should be 224, not %u\n", offsetof(CPUMHOSTCTX, ldtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, tr) != 228/
{
    printf("error: offsetof(CPUMHOSTCTX, tr) should be 228, not %u\n", offsetof(CPUMHOSTCTX, tr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, SysEnter) != 232/
{
    printf("error: offsetof(CPUMHOSTCTX, SysEnter) should be 232, not %u\n", offsetof(CPUMHOSTCTX, SysEnter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, FSbase) != 256/
{
    printf("error: offsetof(CPUMHOSTCTX, FSbase) should be 256, not %u\n", offsetof(CPUMHOSTCTX, FSbase));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, GSbase) != 264/
{
    printf("error: offsetof(CPUMHOSTCTX, GSbase) should be 264, not %u\n", offsetof(CPUMHOSTCTX, GSbase));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, efer) != 272/
{
    printf("error: offsetof(CPUMHOSTCTX, efer) should be 272, not %u\n", offsetof(CPUMHOSTCTX, efer));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCTX) != 1216/
{
    printf("error: sizeof(CPUMCTX) should be 1216, not %u\n", sizeof(CPUMCTX));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt) != 736/
{
    printf("error: offsetof(CPUMCTX, hwvirt) should be 736, not %u\n", offsetof(CPUMCTX, hwvirt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.uMsrHSavePa) != 736/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.uMsrHSavePa) should be 736, not %u\n", offsetof(CPUMCTX, hwvirt.svm.uMsrHSavePa));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.GCPhysVmcb) != 744/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.GCPhysVmcb) should be 744, not %u\n", offsetof(CPUMCTX, hwvirt.svm.GCPhysVmcb));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pVmcbR0) != 752/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pVmcbR0) should be 752, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pVmcbR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pVmcbR3) != 760/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pVmcbR3) should be 760, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pVmcbR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.HostState) != 768/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.HostState) should be 768, not %u\n", offsetof(CPUMCTX, hwvirt.svm.HostState));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.uPrevPauseTick) != 952/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.uPrevPauseTick) should be 952, not %u\n", offsetof(CPUMCTX, hwvirt.svm.uPrevPauseTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.cPauseFilter) != 960/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.cPauseFilter) should be 960, not %u\n", offsetof(CPUMCTX, hwvirt.svm.cPauseFilter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.cPauseFilterThreshold) != 962/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.cPauseFilterThreshold) should be 962, not %u\n", offsetof(CPUMCTX, hwvirt.svm.cPauseFilterThreshold));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.fInterceptEvents) != 964/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.fInterceptEvents) should be 964, not %u\n", offsetof(CPUMCTX, hwvirt.svm.fInterceptEvents));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR0) != 968/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR0) should be 968, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR3) != 976/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR3) should be 976, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR0) != 984/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR0) should be 984, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR3) != 992/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR3) should be 992, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.HCPhysVmcb) != 1000/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.HCPhysVmcb) should be 1000, not %u\n", offsetof(CPUMCTX, hwvirt.svm.HCPhysVmcb));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmxon) != 736/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmxon) should be 736, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmxon));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmcs) != 744/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmcs) should be 744, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmcs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.enmDiag) != 760/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.enmDiag) should be 760, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.enmDiag));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.enmAbort) != 764/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.enmAbort) should be 764, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.enmAbort));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uAbortAux) != 768/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uAbortAux) should be 768, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uAbortAux));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fInVmxRootMode) != 772/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fInVmxRootMode) should be 772, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fInVmxRootMode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode) != 773/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode) should be 773, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fInterceptEvents) != 774/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fInterceptEvents) should be 774, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fInterceptEvents));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret) != 775/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret) should be 775, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pVmcsR0) != 776/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pVmcsR0) should be 776, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pVmcsR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pVmcsR3) != 784/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pVmcsR3) should be 784, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pVmcsR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR0) != 792/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR0) should be 792, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR3) != 800/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR3) should be 800, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0) != 808/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0) should be 808, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3) != 816/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3) should be 816, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0) != 824/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0) should be 824, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3) != 832/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3) should be 832, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0) != 840/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0) should be 840, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3) != 848/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3) should be 848, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR0) != 856/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR0) should be 856, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR3) != 864/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR3) should be 864, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pAutoMsrAreaR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0) != 872/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0) should be 872, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3) != 880/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3) should be 880, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR0) != 888/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR0) should be 888, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR3) != 896/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR3) should be 896, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick) != 904/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick) should be 904, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uPrevPauseTick) != 912/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uPrevPauseTick) should be 912, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uPrevPauseTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uVmentryTick) != 920/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uVmentryTick) should be 920, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uVmentryTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.offVirtApicWrite) != 928/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.offVirtApicWrite) should be 928, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.offVirtApicWrite));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking) != 930/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking) should be 930, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.Msrs) != 936/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.Msrs) should be 936, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.Msrs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.enmHwvirt) != 1160/
{
    printf("error: offsetof(CPUMCTX, hwvirt.enmHwvirt) should be 1160, not %u\n", offsetof(CPUMCTX, hwvirt.enmHwvirt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.fGif) != 1164/
{
    printf("error: offsetof(CPUMCTX, hwvirt.fGif) should be 1164, not %u\n", offsetof(CPUMCTX, hwvirt.fGif));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.fLocalForcedActions) != 1168/
{
    printf("error: offsetof(CPUMCTX, hwvirt.fLocalForcedActions) should be 1168, not %u\n", offsetof(CPUMCTX, hwvirt.fLocalForcedActions));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, pXStateR0) != 576/
{
    printf("error: offsetof(CPUMCTX, pXStateR0) should be 576, not %u\n", offsetof(CPUMCTX, pXStateR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, pXStateR3) != 584/
{
    printf("error: offsetof(CPUMCTX, pXStateR3) should be 584, not %u\n", offsetof(CPUMCTX, pXStateR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, pXStateRC) != 592/
{
    printf("error: offsetof(CPUMCTX, pXStateRC) should be 592, not %u\n", offsetof(CPUMCTX, pXStateRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rdi) != 56/
{
    printf("error: offsetof(CPUMCTX, rdi) should be 56, not %u\n", offsetof(CPUMCTX, rdi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rsi) != 48/
{
    printf("error: offsetof(CPUMCTX, rsi) should be 48, not %u\n", offsetof(CPUMCTX, rsi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rbp) != 40/
{
    printf("error: offsetof(CPUMCTX, rbp) should be 40, not %u\n", offsetof(CPUMCTX, rbp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rax) != 0/
{
    printf("error: offsetof(CPUMCTX, rax) should be 0, not %u\n", offsetof(CPUMCTX, rax));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rbx) != 24/
{
    printf("error: offsetof(CPUMCTX, rbx) should be 24, not %u\n", offsetof(CPUMCTX, rbx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rdx) != 16/
{
    printf("error: offsetof(CPUMCTX, rdx) should be 16, not %u\n", offsetof(CPUMCTX, rdx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rcx) != 8/
{
    printf("error: offsetof(CPUMCTX, rcx) should be 8, not %u\n", offsetof(CPUMCTX, rcx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rsp) != 32/
{
    printf("error: offsetof(CPUMCTX, rsp) should be 32, not %u\n", offsetof(CPUMCTX, rsp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, es) != 128/
{
    printf("error: offsetof(CPUMCTX, es) should be 128, not %u\n", offsetof(CPUMCTX, es));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cs) != 152/
{
    printf("error: offsetof(CPUMCTX, cs) should be 152, not %u\n", offsetof(CPUMCTX, cs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ss) != 176/
{
    printf("error: offsetof(CPUMCTX, ss) should be 176, not %u\n", offsetof(CPUMCTX, ss));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ds) != 200/
{
    printf("error: offsetof(CPUMCTX, ds) should be 200, not %u\n", offsetof(CPUMCTX, ds));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, fs) != 224/
{
    printf("error: offsetof(CPUMCTX, fs) should be 224, not %u\n", offsetof(CPUMCTX, fs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, gs) != 248/
{
    printf("error: offsetof(CPUMCTX, gs) should be 248, not %u\n", offsetof(CPUMCTX, gs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rflags) != 280/
{
    printf("error: offsetof(CPUMCTX, rflags) should be 280, not %u\n", offsetof(CPUMCTX, rflags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rip) != 272/
{
    printf("error: offsetof(CPUMCTX, rip) should be 272, not %u\n", offsetof(CPUMCTX, rip));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r8) != 64/
{
    printf("error: offsetof(CPUMCTX, r8) should be 64, not %u\n", offsetof(CPUMCTX, r8));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r9) != 72/
{
    printf("error: offsetof(CPUMCTX, r9) should be 72, not %u\n", offsetof(CPUMCTX, r9));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r10) != 80/
{
    printf("error: offsetof(CPUMCTX, r10) should be 80, not %u\n", offsetof(CPUMCTX, r10));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r11) != 88/
{
    printf("error: offsetof(CPUMCTX, r11) should be 88, not %u\n", offsetof(CPUMCTX, r11));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r12) != 96/
{
    printf("error: offsetof(CPUMCTX, r12) should be 96, not %u\n", offsetof(CPUMCTX, r12));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r13) != 104/
{
    printf("error: offsetof(CPUMCTX, r13) should be 104, not %u\n", offsetof(CPUMCTX, r13));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r14) != 112/
{
    printf("error: offsetof(CPUMCTX, r14) should be 112, not %u\n", offsetof(CPUMCTX, r14));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r15) != 120/
{
    printf("error: offsetof(CPUMCTX, r15) should be 120, not %u\n", offsetof(CPUMCTX, r15));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr0) != 288/
{
    printf("error: offsetof(CPUMCTX, cr0) should be 288, not %u\n", offsetof(CPUMCTX, cr0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr2) != 296/
{
    printf("error: offsetof(CPUMCTX, cr2) should be 296, not %u\n", offsetof(CPUMCTX, cr2));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr3) != 304/
{
    printf("error: offsetof(CPUMCTX, cr3) should be 304, not %u\n", offsetof(CPUMCTX, cr3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr4) != 312/
{
    printf("error: offsetof(CPUMCTX, cr4) should be 312, not %u\n", offsetof(CPUMCTX, cr4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, dr) != 320/
{
    printf("error: offsetof(CPUMCTX, dr) should be 320, not %u\n", offsetof(CPUMCTX, dr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, gdtr) != 390/
{
    printf("error: offsetof(CPUMCTX, gdtr) should be 390, not %u\n", offsetof(CPUMCTX, gdtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, idtr) != 406/
{
    printf("error: offsetof(CPUMCTX, idtr) should be 406, not %u\n", offsetof(CPUMCTX, idtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ldtr) != 416/
{
    printf("error: offsetof(CPUMCTX, ldtr) should be 416, not %u\n", offsetof(CPUMCTX, ldtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, tr) != 440/
{
    printf("error: offsetof(CPUMCTX, tr) should be 440, not %u\n", offsetof(CPUMCTX, tr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, SysEnter) != 464/
{
    printf("error: offsetof(CPUMCTX, SysEnter) should be 464, not %u\n", offsetof(CPUMCTX, SysEnter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrEFER) != 488/
{
    printf("error: offsetof(CPUMCTX, msrEFER) should be 488, not %u\n", offsetof(CPUMCTX, msrEFER));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrSTAR) != 496/
{
    printf("error: offsetof(CPUMCTX, msrSTAR) should be 496, not %u\n", offsetof(CPUMCTX, msrSTAR));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrPAT) != 504/
{
    printf("error: offsetof(CPUMCTX, msrPAT) should be 504, not %u\n", offsetof(CPUMCTX, msrPAT));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrLSTAR) != 512/
{
    printf("error: offsetof(CPUMCTX, msrLSTAR) should be 512, not %u\n", offsetof(CPUMCTX, msrLSTAR));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrCSTAR) != 520/
{
    printf("error: offsetof(CPUMCTX, msrCSTAR) should be 520, not %u\n", offsetof(CPUMCTX, msrCSTAR));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrSFMASK) != 528/
{
    printf("error: offsetof(CPUMCTX, msrSFMASK) should be 528, not %u\n", offsetof(CPUMCTX, msrSFMASK));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrKERNELGSBASE) != 536/
{
    printf("error: offsetof(CPUMCTX, msrKERNELGSBASE) should be 536, not %u\n", offsetof(CPUMCTX, msrKERNELGSBASE));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ldtr) != 416/
{
    printf("error: offsetof(CPUMCTX, ldtr) should be 416, not %u\n", offsetof(CPUMCTX, ldtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, tr) != 440/
{
    printf("error: offsetof(CPUMCTX, tr) should be 440, not %u\n", offsetof(CPUMCTX, tr));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCTXMSRS) != 512/
{
    printf("error: sizeof(CPUMCTXMSRS) should be 512, not %u\n", sizeof(CPUMCTXMSRS));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCTXCORE) != 288/
{
    printf("error: sizeof(CPUMCTXCORE) should be 288, not %u\n", sizeof(CPUMCTXCORE));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(APIC) != 96/
{
    printf("error: sizeof(APIC) should be 96, not %u\n", sizeof(APIC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pApicDevR0) != 0/
{
    printf("error: offsetof(APIC, pApicDevR0) should be 0, not %u\n", offsetof(APIC, pApicDevR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pApicDevR3) != 8/
{
    printf("error: offsetof(APIC, pApicDevR3) should be 8, not %u\n", offsetof(APIC, pApicDevR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pApicDevRC) != 16/
{
    printf("error: offsetof(APIC, pApicDevRC) should be 16, not %u\n", offsetof(APIC, pApicDevRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pvApicPibR0) != 48/
{
    printf("error: offsetof(APIC, pvApicPibR0) should be 48, not %u\n", offsetof(APIC, pvApicPibR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pvApicPibR3) != 56/
{
    printf("error: offsetof(APIC, pvApicPibR3) should be 56, not %u\n", offsetof(APIC, pvApicPibR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pvApicPibRC) != 64/
{
    printf("error: offsetof(APIC, pvApicPibRC) should be 64, not %u\n", offsetof(APIC, pvApicPibRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, cbApicPib) != 72/
{
    printf("error: offsetof(APIC, cbApicPib) should be 72, not %u\n", offsetof(APIC, cbApicPib));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, enmMaxMode) != 88/
{
    printf("error: offsetof(APIC, enmMaxMode) should be 88, not %u\n", offsetof(APIC, enmMaxMode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPageR0) != 24/
{
    printf("error: offsetof(APICCPU, pvApicPageR0) should be 24, not %u\n", offsetof(APICCPU, pvApicPageR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPageR3) != 32/
{
    printf("error: offsetof(APICCPU, pvApicPageR3) should be 32, not %u\n", offsetof(APICCPU, pvApicPageR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPageRC) != 40/
{
    printf("error: offsetof(APICCPU, pvApicPageRC) should be 40, not %u\n", offsetof(APICCPU, pvApicPageRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPageRC) != 40/
{
    printf("error: offsetof(APICCPU, pvApicPageRC) should be 40, not %u\n", offsetof(APICCPU, pvApicPageRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, cbApicPage) != 48/
{
    printf("error: offsetof(APICCPU, cbApicPage) should be 48, not %u\n", offsetof(APICCPU, cbApicPage));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPibR0) != 72/
{
    printf("error: offsetof(APICCPU, pvApicPibR0) should be 72, not %u\n", offsetof(APICCPU, pvApicPibR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPibR3) != 80/
{
    printf("error: offsetof(APICCPU, pvApicPibR3) should be 80, not %u\n", offsetof(APICCPU, pvApicPibR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPibRC) != 88/
{
    printf("error: offsetof(APICCPU, pvApicPibRC) should be 88, not %u\n", offsetof(APICCPU, pvApicPibRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, ApicPibLevel) != 96/
{
    printf("error: offsetof(APICCPU, ApicPibLevel) should be 96, not %u\n", offsetof(APICCPU, ApicPibLevel));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pTimerR0) != 1256/
{
    printf("error: offsetof(APICCPU, pTimerR0) should be 1256, not %u\n", offsetof(APICCPU, pTimerR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pTimerR3) != 1264/
{
    printf("error: offsetof(APICCPU, pTimerR3) should be 1264, not %u\n", offsetof(APICCPU, pTimerR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pTimerRC) != 1272/
{
    printf("error: offsetof(APICCPU, pTimerRC) should be 1272, not %u\n", offsetof(APICCPU, pTimerRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, TimerCritSect) != 1280/
{
    printf("error: offsetof(APICCPU, TimerCritSect) should be 1280, not %u\n", offsetof(APICCPU, TimerCritSect));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(VM) != 196608/
{
    printf("error: sizeof(VM) should be 196608, not %u\n", sizeof(VM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, enmVMState) != 0/
{
    printf("error: offsetof(VM, enmVMState) should be 0, not %u\n", offsetof(VM, enmVMState));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fGlobalForcedActions) != 4/
{
    printf("error: offsetof(VM, fGlobalForcedActions) should be 4, not %u\n", offsetof(VM, fGlobalForcedActions));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, paVMPagesR3) != 8/
{
    printf("error: offsetof(VM, paVMPagesR3) should be 8, not %u\n", offsetof(VM, paVMPagesR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pSession) != 16/
{
    printf("error: offsetof(VM, pSession) should be 16, not %u\n", offsetof(VM, pSession));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pUVM) != 24/
{
    printf("error: offsetof(VM, pUVM) should be 24, not %u\n", offsetof(VM, pUVM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pVMR3) != 32/
{
    printf("error: offsetof(VM, pVMR3) should be 32, not %u\n", offsetof(VM, pVMR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pVMR0) != 40/
{
    printf("error: offsetof(VM, pVMR0) should be 40, not %u\n", offsetof(VM, pVMR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pVMRC) != 48/
{
    printf("error: offsetof(VM, pVMRC) should be 48, not %u\n", offsetof(VM, pVMRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hSelf) != 52/
{
    printf("error: offsetof(VM, hSelf) should be 52, not %u\n", offsetof(VM, hSelf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cCpus) != 56/
{
    printf("error: offsetof(VM, cCpus) should be 56, not %u\n", offsetof(VM, cCpus));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, uCpuExecutionCap) != 60/
{
    printf("error: offsetof(VM, uCpuExecutionCap) should be 60, not %u\n", offsetof(VM, uCpuExecutionCap));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cbSelf) != 64/
{
    printf("error: offsetof(VM, cbSelf) should be 64, not %u\n", offsetof(VM, cbSelf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pfnVMMRCToHostAsm) != 72/
{
    printf("error: offsetof(VM, pfnVMMRCToHostAsm) should be 72, not %u\n", offsetof(VM, pfnVMMRCToHostAsm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pfnVMMRCToHostAsmNoReturn) != 76/
{
    printf("error: offsetof(VM, pfnVMMRCToHostAsmNoReturn) should be 76, not %u\n", offsetof(VM, pfnVMMRCToHostAsmNoReturn));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, bMainExecutionEngine) != 80/
{
    printf("error: offsetof(VM, bMainExecutionEngine) should be 80, not %u\n", offsetof(VM, bMainExecutionEngine));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fRecompileUser) != 81/
{
    printf("error: offsetof(VM, fRecompileUser) should be 81, not %u\n", offsetof(VM, fRecompileUser));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fRecompileSupervisor) != 82/
{
    printf("error: offsetof(VM, fRecompileSupervisor) should be 82, not %u\n", offsetof(VM, fRecompileSupervisor));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fPATMEnabled) != 84/
{
    printf("error: offsetof(VM, fPATMEnabled) should be 84, not %u\n", offsetof(VM, fPATMEnabled));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fCSAMEnabled) != 85/
{
    printf("error: offsetof(VM, fCSAMEnabled) should be 85, not %u\n", offsetof(VM, fCSAMEnabled));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fHMEnabled) != 86/
{
    printf("error: offsetof(VM, fHMEnabled) should be 86, not %u\n", offsetof(VM, fHMEnabled));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fFaultTolerantMaster) != 88/
{
    printf("error: offsetof(VM, fFaultTolerantMaster) should be 88, not %u\n", offsetof(VM, fFaultTolerantMaster));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fUseLargePages) != 89/
{
    printf("error: offsetof(VM, fUseLargePages) should be 89, not %u\n", offsetof(VM, fUseLargePages));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hTraceBufRC) != 92/
{
    printf("error: offsetof(VM, hTraceBufRC) should be 92, not %u\n", offsetof(VM, hTraceBufRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hTraceBufR3) != 96/
{
    printf("error: offsetof(VM, hTraceBufR3) should be 96, not %u\n", offsetof(VM, hTraceBufR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hTraceBufR0) != 104/
{
    printf("error: offsetof(VM, hTraceBufR0) should be 104, not %u\n", offsetof(VM, hTraceBufR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatTotalQemuToGC) != 112/
{
    printf("error: offsetof(VM, StatTotalQemuToGC) should be 112, not %u\n", offsetof(VM, StatTotalQemuToGC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatTotalGCToQemu) != 152/
{
    printf("error: offsetof(VM, StatTotalGCToQemu) should be 152, not %u\n", offsetof(VM, StatTotalGCToQemu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatTotalInGC) != 192/
{
    printf("error: offsetof(VM, StatTotalInGC) should be 192, not %u\n", offsetof(VM, StatTotalInGC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatTotalInQemu) != 232/
{
    printf("error: offsetof(VM, StatTotalInQemu) should be 232, not %u\n", offsetof(VM, StatTotalInQemu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherToGC) != 272/
{
    printf("error: offsetof(VM, StatSwitcherToGC) should be 272, not %u\n", offsetof(VM, StatSwitcherToGC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherToHC) != 312/
{
    printf("error: offsetof(VM, StatSwitcherToHC) should be 312, not %u\n", offsetof(VM, StatSwitcherToHC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherSaveRegs) != 352/
{
    printf("error: offsetof(VM, StatSwitcherSaveRegs) should be 352, not %u\n", offsetof(VM, StatSwitcherSaveRegs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherSysEnter) != 392/
{
    printf("error: offsetof(VM, StatSwitcherSysEnter) should be 392, not %u\n", offsetof(VM, StatSwitcherSysEnter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherDebug) != 432/
{
    printf("error: offsetof(VM, StatSwitcherDebug) should be 432, not %u\n", offsetof(VM, StatSwitcherDebug));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherCR0) != 472/
{
    printf("error: offsetof(VM, StatSwitcherCR0) should be 472, not %u\n", offsetof(VM, StatSwitcherCR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherCR4) != 512/
{
    printf("error: offsetof(VM, StatSwitcherCR4) should be 512, not %u\n", offsetof(VM, StatSwitcherCR4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherJmpCR3) != 552/
{
    printf("error: offsetof(VM, StatSwitcherJmpCR3) should be 552, not %u\n", offsetof(VM, StatSwitcherJmpCR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherRstrRegs) != 592/
{
    printf("error: offsetof(VM, StatSwitcherRstrRegs) should be 592, not %u\n", offsetof(VM, StatSwitcherRstrRegs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherLgdt) != 632/
{
    printf("error: offsetof(VM, StatSwitcherLgdt) should be 632, not %u\n", offsetof(VM, StatSwitcherLgdt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherLidt) != 672/
{
    printf("error: offsetof(VM, StatSwitcherLidt) should be 672, not %u\n", offsetof(VM, StatSwitcherLidt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherLldt) != 712/
{
    printf("error: offsetof(VM, StatSwitcherLldt) should be 712, not %u\n", offsetof(VM, StatSwitcherLldt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, StatSwitcherTSS) != 752/
{
    printf("error: offsetof(VM, StatSwitcherTSS) should be 752, not %u\n", offsetof(VM, StatSwitcherTSS));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cpum) != 832/
{
    printf("error: offsetof(VM, cpum) should be 832, not %u\n", offsetof(VM, cpum));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, vmm) != 2368/
{
    printf("error: offsetof(VM, vmm) should be 2368, not %u\n", offsetof(VM, vmm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pgm) != 3968/
{
    printf("error: offsetof(VM, pgm) should be 3968, not %u\n", offsetof(VM, pgm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hm) != 18240/
{
    printf("error: offsetof(VM, hm) should be 18240, not %u\n", offsetof(VM, hm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, trpm) != 23680/
{
    printf("error: offsetof(VM, trpm) should be 23680, not %u\n", offsetof(VM, trpm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, selm) != 28928/
{
    printf("error: offsetof(VM, selm) should be 28928, not %u\n", offsetof(VM, selm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, mm) != 29696/
{
    printf("error: offsetof(VM, mm) should be 29696, not %u\n", offsetof(VM, mm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pdm) != 29888/
{
    printf("error: offsetof(VM, pdm) should be 29888, not %u\n", offsetof(VM, pdm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, iom) != 31808/
{
    printf("error: offsetof(VM, iom) should be 31808, not %u\n", offsetof(VM, iom));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, patm) != 38656/
{
    printf("error: offsetof(VM, patm) should be 38656, not %u\n", offsetof(VM, patm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, csam) != 39424/
{
    printf("error: offsetof(VM, csam) should be 39424, not %u\n", offsetof(VM, csam));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, em) != 32704/
{
    printf("error: offsetof(VM, em) should be 32704, not %u\n", offsetof(VM, em));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, tm) != 33088/
{
    printf("error: offsetof(VM, tm) should be 33088, not %u\n", offsetof(VM, tm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, dbgf) != 35584/
{
    printf("error: offsetof(VM, dbgf) should be 35584, not %u\n", offsetof(VM, dbgf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, ssm) != 38016/
{
    printf("error: offsetof(VM, ssm) should be 38016, not %u\n", offsetof(VM, ssm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, ftm) != 38144/
{
    printf("error: offsetof(VM, ftm) should be 38144, not %u\n", offsetof(VM, ftm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, rem) != 40512/
{
    printf("error: offsetof(VM, rem) should be 40512, not %u\n", offsetof(VM, rem));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, gim) != 110400/
{
    printf("error: offsetof(VM, gim) should be 110400, not %u\n", offsetof(VM, gim));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, vm) != 110976/
{
    printf("error: offsetof(VM, vm) should be 110976, not %u\n", offsetof(VM, vm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cfgm) != 111008/
{
    printf("error: offsetof(VM, cfgm) should be 111008, not %u\n", offsetof(VM, cfgm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, apic) != 110848/
{
    printf("error: offsetof(VM, apic) should be 110848, not %u\n", offsetof(VM, apic));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, aCpus) != 114688/
{
    printf("error: offsetof(VM, aCpus) should be 114688, not %u\n", offsetof(VM, aCpus));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(VMCPU) != 81920/
{
    printf("error: sizeof(VMCPU) should be 81920, not %u\n", sizeof(VMCPU));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, fLocalForcedActions) != 0/
{
    printf("error: offsetof(VMCPU, fLocalForcedActions) should be 0, not %u\n", offsetof(VMCPU, fLocalForcedActions));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, enmState) != 8/
{
    printf("error: offsetof(VMCPU, enmState) should be 8, not %u\n", offsetof(VMCPU, enmState));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pUVCpu) != 18584/
{
    printf("error: offsetof(VMCPU, pUVCpu) should be 18584, not %u\n", offsetof(VMCPU, pUVCpu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pVMR3) != 18568/
{
    printf("error: offsetof(VMCPU, pVMR3) should be 18568, not %u\n", offsetof(VMCPU, pVMR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pVMR0) != 18576/
{
    printf("error: offsetof(VMCPU, pVMR0) should be 18576, not %u\n", offsetof(VMCPU, pVMR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pVMRC) != 18564/
{
    printf("error: offsetof(VMCPU, pVMRC) should be 18564, not %u\n", offsetof(VMCPU, pVMRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, idCpu) != 18560/
{
    printf("error: offsetof(VMCPU, idCpu) should be 18560, not %u\n", offsetof(VMCPU, idCpu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, hNativeThread) != 18592/
{
    printf("error: offsetof(VMCPU, hNativeThread) should be 18592, not %u\n", offsetof(VMCPU, hNativeThread));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, hNativeThreadR0) != 18600/
{
    printf("error: offsetof(VMCPU, hNativeThreadR0) should be 18600, not %u\n", offsetof(VMCPU, hNativeThreadR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, idHostCpu) != 12/
{
    printf("error: offsetof(VMCPU, idHostCpu) should be 12, not %u\n", offsetof(VMCPU, idHostCpu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, fTraceGroups) != 29760/
{
    printf("error: offsetof(VMCPU, fTraceGroups) should be 29760, not %u\n", offsetof(VMCPU, fTraceGroups));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, uAdHoc) != 29764/
{
    printf("error: offsetof(VMCPU, uAdHoc) should be 29764, not %u\n", offsetof(VMCPU, uAdHoc));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, aStatAdHoc) != 29768/
{
    printf("error: offsetof(VMCPU, aStatAdHoc) should be 29768, not %u\n", offsetof(VMCPU, aStatAdHoc));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, hm) != 18624/
{
    printf("error: offsetof(VMCPU, hm) should be 18624, not %u\n", offsetof(VMCPU, hm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, em) != 40960/
{
    printf("error: offsetof(VMCPU, em) should be 40960, not %u\n", offsetof(VMCPU, em));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, iem) != 64/
{
    printf("error: offsetof(VMCPU, iem) should be 64, not %u\n", offsetof(VMCPU, iem));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, trpm) != 25024/
{
    printf("error: offsetof(VMCPU, trpm) should be 25024, not %u\n", offsetof(VMCPU, trpm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, tm) != 25152/
{
    printf("error: offsetof(VMCPU, tm) should be 25152, not %u\n", offsetof(VMCPU, tm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, vmm) != 25536/
{
    printf("error: offsetof(VMCPU, vmm) should be 25536, not %u\n", offsetof(VMCPU, vmm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pdm) != 26432/
{
    printf("error: offsetof(VMCPU, pdm) should be 26432, not %u\n", offsetof(VMCPU, pdm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, iom) != 26688/
{
    printf("error: offsetof(VMCPU, iom) should be 26688, not %u\n", offsetof(VMCPU, iom));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, dbgf) != 27200/
{
    printf("error: offsetof(VMCPU, dbgf) should be 27200, not %u\n", offsetof(VMCPU, dbgf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, gim) != 27456/
{
    printf("error: offsetof(VMCPU, gim) should be 27456, not %u\n", offsetof(VMCPU, gim));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, apic) != 27968/
{
    printf("error: offsetof(VMCPU, apic) should be 27968, not %u\n", offsetof(VMCPU, apic));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pgm) != 32768/
{
    printf("error: offsetof(VMCPU, pgm) should be 32768, not %u\n", offsetof(VMCPU, pgm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, cpum) != 36864/
{
    printf("error: offsetof(VMCPU, cpum) should be 36864, not %u\n", offsetof(VMCPU, cpum));
    g_cErrors++;
}

dtrace:::BEGIN
/g_cErrors != 0/
{
    printf("%u errors!\n", g_cErrors);
    exit(1);
}

dtrace:::BEGIN
{
    printf("Success!\n");
    exit(0);
}

Zerion Mini Shell 1.0