VirtualBox

Changeset 108763 in vbox for trunk/src


Ignore:
Timestamp:
Mar 27, 2025 10:22:31 AM (3 weeks ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
168190
Message:

VMM/NEMR3Native-win-armv8.cpp: Cleanup the state import export methods to use a table driven style where possible to keep them shorter and more in line with the other ARMv8 NEM backends, bugref:10392

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMR3/NEMR3Native-win-armv8.cpp

    r108761 r108763  
    278278
    279279
     280#define WHV_REGNM(a_Suffix) WHvArm64Register ## a_Suffix
     281/** The general registers. */
     282static const struct
     283{
     284    WHV_REGISTER_NAME    enmWHvReg;
     285    uint32_t             fCpumExtrn;
     286    uintptr_t            offCpumCtx;
     287} s_aCpumRegs[] =
     288{
     289#define CPUM_GREG_EMIT_X0_X3(a_Idx)  { WHV_REGNM(X ## a_Idx), CPUMCTX_EXTRN_X ## a_Idx, RT_UOFFSETOF(CPUMCTX, aGRegs[a_Idx].x) }
     290#define CPUM_GREG_EMIT_X4_X28(a_Idx) { WHV_REGNM(X ## a_Idx), CPUMCTX_EXTRN_X4_X28,     RT_UOFFSETOF(CPUMCTX, aGRegs[a_Idx].x) }
     291    CPUM_GREG_EMIT_X0_X3(0),
     292    CPUM_GREG_EMIT_X0_X3(1),
     293    CPUM_GREG_EMIT_X0_X3(2),
     294    CPUM_GREG_EMIT_X0_X3(3),
     295    CPUM_GREG_EMIT_X4_X28(4),
     296    CPUM_GREG_EMIT_X4_X28(5),
     297    CPUM_GREG_EMIT_X4_X28(6),
     298    CPUM_GREG_EMIT_X4_X28(7),
     299    CPUM_GREG_EMIT_X4_X28(8),
     300    CPUM_GREG_EMIT_X4_X28(9),
     301    CPUM_GREG_EMIT_X4_X28(10),
     302    CPUM_GREG_EMIT_X4_X28(11),
     303    CPUM_GREG_EMIT_X4_X28(12),
     304    CPUM_GREG_EMIT_X4_X28(13),
     305    CPUM_GREG_EMIT_X4_X28(14),
     306    CPUM_GREG_EMIT_X4_X28(15),
     307    CPUM_GREG_EMIT_X4_X28(16),
     308    CPUM_GREG_EMIT_X4_X28(17),
     309    CPUM_GREG_EMIT_X4_X28(18),
     310    CPUM_GREG_EMIT_X4_X28(19),
     311    CPUM_GREG_EMIT_X4_X28(20),
     312    CPUM_GREG_EMIT_X4_X28(21),
     313    CPUM_GREG_EMIT_X4_X28(22),
     314    CPUM_GREG_EMIT_X4_X28(23),
     315    CPUM_GREG_EMIT_X4_X28(24),
     316    CPUM_GREG_EMIT_X4_X28(25),
     317    CPUM_GREG_EMIT_X4_X28(26),
     318    CPUM_GREG_EMIT_X4_X28(27),
     319    CPUM_GREG_EMIT_X4_X28(28),
     320    { WHV_REGNM(Fp),   CPUMCTX_EXTRN_FP,   RT_UOFFSETOF(CPUMCTX, aGRegs[29].x) },
     321    { WHV_REGNM(Lr),   CPUMCTX_EXTRN_LR,   RT_UOFFSETOF(CPUMCTX, aGRegs[30].x) },
     322    { WHV_REGNM(Pc),   CPUMCTX_EXTRN_PC,   RT_UOFFSETOF(CPUMCTX, Pc.u64)       },
     323    { WHV_REGNM(Fpcr), CPUMCTX_EXTRN_FPCR, RT_UOFFSETOF(CPUMCTX, fpcr)         },
     324    { WHV_REGNM(Fpsr), CPUMCTX_EXTRN_FPSR, RT_UOFFSETOF(CPUMCTX, fpsr)         }
     325#undef CPUM_GREG_EMIT_X0_X3
     326#undef CPUM_GREG_EMIT_X4_X28
     327};
     328/** SIMD/FP registers. */
     329static const struct
     330{
     331    WHV_REGISTER_NAME   enmWHvReg;
     332    uintptr_t           offCpumCtx;
     333} s_aCpumFpRegs[] =
     334{
     335#define CPUM_VREG_EMIT(a_Idx)  {  WHV_REGNM(Q ## a_Idx), RT_UOFFSETOF(CPUMCTX, aVRegs[a_Idx].v) }
     336    CPUM_VREG_EMIT(0),
     337    CPUM_VREG_EMIT(1),
     338    CPUM_VREG_EMIT(2),
     339    CPUM_VREG_EMIT(3),
     340    CPUM_VREG_EMIT(4),
     341    CPUM_VREG_EMIT(5),
     342    CPUM_VREG_EMIT(6),
     343    CPUM_VREG_EMIT(7),
     344    CPUM_VREG_EMIT(8),
     345    CPUM_VREG_EMIT(9),
     346    CPUM_VREG_EMIT(10),
     347    CPUM_VREG_EMIT(11),
     348    CPUM_VREG_EMIT(12),
     349    CPUM_VREG_EMIT(13),
     350    CPUM_VREG_EMIT(14),
     351    CPUM_VREG_EMIT(15),
     352    CPUM_VREG_EMIT(16),
     353    CPUM_VREG_EMIT(17),
     354    CPUM_VREG_EMIT(18),
     355    CPUM_VREG_EMIT(19),
     356    CPUM_VREG_EMIT(20),
     357    CPUM_VREG_EMIT(21),
     358    CPUM_VREG_EMIT(22),
     359    CPUM_VREG_EMIT(23),
     360    CPUM_VREG_EMIT(24),
     361    CPUM_VREG_EMIT(25),
     362    CPUM_VREG_EMIT(26),
     363    CPUM_VREG_EMIT(27),
     364    CPUM_VREG_EMIT(28),
     365    CPUM_VREG_EMIT(29),
     366    CPUM_VREG_EMIT(30),
     367    CPUM_VREG_EMIT(31)
     368#undef CPUM_VREG_EMIT
     369};
     370/** PAuth key system registers. */
     371static const struct
     372{
     373    WHV_REGISTER_NAME   enmWHvReg;
     374    uintptr_t           offCpumCtx;
     375} s_aCpumPAuthKeyRegs[] =
     376{
     377    { WHV_REGNM(ApdAKeyLoEl1), RT_UOFFSETOF(CPUMCTX, Apda.Low.u64)  },
     378    { WHV_REGNM(ApdAKeyHiEl1), RT_UOFFSETOF(CPUMCTX, Apda.High.u64) },
     379    { WHV_REGNM(ApdBKeyLoEl1), RT_UOFFSETOF(CPUMCTX, Apdb.Low.u64)  },
     380    { WHV_REGNM(ApdBKeyHiEl1), RT_UOFFSETOF(CPUMCTX, Apdb.High.u64) },
     381    { WHV_REGNM(ApgAKeyLoEl1), RT_UOFFSETOF(CPUMCTX, Apga.Low.u64)  },
     382    { WHV_REGNM(ApgAKeyHiEl1), RT_UOFFSETOF(CPUMCTX, Apga.High.u64) },
     383    { WHV_REGNM(ApiAKeyLoEl1), RT_UOFFSETOF(CPUMCTX, Apia.Low.u64)  },
     384    { WHV_REGNM(ApiAKeyHiEl1), RT_UOFFSETOF(CPUMCTX, Apia.High.u64) },
     385    { WHV_REGNM(ApiBKeyLoEl1), RT_UOFFSETOF(CPUMCTX, Apib.Low.u64)  },
     386    { WHV_REGNM(ApiBKeyHiEl1), RT_UOFFSETOF(CPUMCTX, Apib.High.u64) }
     387};
     388/** System registers. */
     389static const struct
     390{
     391    WHV_REGISTER_NAME   enmWHvReg;
     392    uint32_t            fCpumExtrn;
     393    uintptr_t           offCpumCtx;
     394} s_aCpumSysRegs[] =
     395{
     396    { WHV_REGNM(SpEl0),            CPUMCTX_EXTRN_SP,               RT_UOFFSETOF(CPUMCTX, aSpReg[0].u64)    },
     397    { WHV_REGNM(SpEl1),            CPUMCTX_EXTRN_SP,               RT_UOFFSETOF(CPUMCTX, aSpReg[1].u64)    },
     398    { WHV_REGNM(SpsrEl1),          CPUMCTX_EXTRN_SPSR,             RT_UOFFSETOF(CPUMCTX, Spsr.u64)         },
     399    { WHV_REGNM(ElrEl1),           CPUMCTX_EXTRN_ELR,              RT_UOFFSETOF(CPUMCTX, Elr.u64)          },
     400    { WHV_REGNM(SctlrEl1),         CPUMCTX_EXTRN_SCTLR_TCR_TTBR,   RT_UOFFSETOF(CPUMCTX, Sctlr.u64)        },
     401    { WHV_REGNM(TcrEl1),           CPUMCTX_EXTRN_SCTLR_TCR_TTBR,   RT_UOFFSETOF(CPUMCTX, Tcr.u64)          },
     402    { WHV_REGNM(Ttbr0El1),         CPUMCTX_EXTRN_SCTLR_TCR_TTBR,   RT_UOFFSETOF(CPUMCTX, Ttbr0.u64)        },
     403    { WHV_REGNM(Ttbr1El1),         CPUMCTX_EXTRN_SCTLR_TCR_TTBR,   RT_UOFFSETOF(CPUMCTX, Ttbr1.u64)        },
     404    { WHV_REGNM(VbarEl1),          CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, VBar.u64)         },
     405    { WHV_REGNM(CntkctlEl1),       CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, CntKCtl.u64)      },
     406    { WHV_REGNM(ContextidrEl1),    CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, ContextIdr.u64)   },
     407    { WHV_REGNM(CpacrEl1),         CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Cpacr.u64)        },
     408    { WHV_REGNM(CsselrEl1),        CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Csselr.u64)       },
     409    { WHV_REGNM(EsrEl1),           CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Esr.u64)          },
     410    { WHV_REGNM(FarEl1),           CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Far.u64)          },
     411    { WHV_REGNM(MairEl1),          CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Mair.u64)         },
     412    { WHV_REGNM(ParEl1),           CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Par.u64)          },
     413    { WHV_REGNM(TpidrroEl0),       CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, TpIdrRoEl0.u64)   },
     414    { WHV_REGNM(TpidrEl0),         CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, aTpIdr[0].u64)    },
     415    { WHV_REGNM(TpidrEl1),         CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, aTpIdr[1].u64)    },
     416    { My_WHvArm64RegisterActlrEl1, CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Actlr.u64)        }
     417#if 0 /* Not available in Hyper-V */
     418    { WHV_REGNM(),                 CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Afsr0.u64)        },
     419    { WHV_REGNM(),                 CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Afsr1.u64)        },
     420    { WHV_REGNM(),                 CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, Amair.u64)        },
     421    { WHV_REGNM(),                 CPUMCTX_EXTRN_SYSREG_MISC,      RT_UOFFSETOF(CPUMCTX, MDccInt.u64)      }
     422#endif
     423};
     424
     425
    280426/*********************************************************************************************************************************
    281427*   Internal Functions                                                                                                           *
    … …  
    401547#define NEM_LOG_REL_CAP_SUB(a_szField, a_Value)             NEM_LOG_REL_CAP_SUB_EX(a_szField, "%d", a_Value)
    402548
    403     /*
    404      * Is the hypervisor present with the desired capability?
    405      *
    406      * In build 17083 this translates into:
    407      *      - CPUID[0x00000001].HVP is set
    408      *      - CPUID[0x40000000] == "Microsoft Hv"
    409      *      - CPUID[0x40000001].eax == "Hv#1"
    410      *      - CPUID[0x40000003].ebx[12] is set.
    411      *      - VidGetExoPartitionProperty(INVALID_HANDLE_VALUE, 0x60000, &Ignored) returns
    412      *        a non-zero value.
    413      */
    414     /**
    415      * @todo Someone at Microsoft please explain weird API design:
    416      *   1. Pointless CapabilityCode duplication int the output;
    417      *   2. No output size.
    418      */
    419549    WHV_CAPABILITY Caps;
    420550    RT_ZERO(Caps);
    … …  
    12761406        } while (0)
    12771407
    1278     /* GPRs */
    1279     if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
    1280     {
    1281         if (fWhat & CPUMCTX_EXTRN_X0)
    1282             ADD_REG64(WHvArm64RegisterX0, pVCpu->cpum.GstCtx.aGRegs[0]);
    1283         if (fWhat & CPUMCTX_EXTRN_X1)
    1284             ADD_REG64(WHvArm64RegisterX1, pVCpu->cpum.GstCtx.aGRegs[1]);
    1285         if (fWhat & CPUMCTX_EXTRN_X2)
    1286             ADD_REG64(WHvArm64RegisterX2, pVCpu->cpum.GstCtx.aGRegs[2]);
    1287         if (fWhat & CPUMCTX_EXTRN_X3)
    1288             ADD_REG64(WHvArm64RegisterX3, pVCpu->cpum.GstCtx.aGRegs[3]);
    1289         if (fWhat & CPUMCTX_EXTRN_X4_X28)
    1290         {
    1291             ADD_REG64(WHvArm64RegisterX4,  pVCpu->cpum.GstCtx.aGRegs[4]);
    1292             ADD_REG64(WHvArm64RegisterX5,  pVCpu->cpum.GstCtx.aGRegs[5]);
    1293             ADD_REG64(WHvArm64RegisterX6,  pVCpu->cpum.GstCtx.aGRegs[6]);
    1294             ADD_REG64(WHvArm64RegisterX7,  pVCpu->cpum.GstCtx.aGRegs[7]);
    1295             ADD_REG64(WHvArm64RegisterX8,  pVCpu->cpum.GstCtx.aGRegs[8]);
    1296             ADD_REG64(WHvArm64RegisterX9,  pVCpu->cpum.GstCtx.aGRegs[9]);
    1297             ADD_REG64(WHvArm64RegisterX10, pVCpu->cpum.GstCtx.aGRegs[10]);
    1298             ADD_REG64(WHvArm64RegisterX11, pVCpu->cpum.GstCtx.aGRegs[11]);
    1299             ADD_REG64(WHvArm64RegisterX12, pVCpu->cpum.GstCtx.aGRegs[12]);
    1300             ADD_REG64(WHvArm64RegisterX13, pVCpu->cpum.GstCtx.aGRegs[13]);
    1301             ADD_REG64(WHvArm64RegisterX14, pVCpu->cpum.GstCtx.aGRegs[14]);
    1302             ADD_REG64(WHvArm64RegisterX15, pVCpu->cpum.GstCtx.aGRegs[15]);
    1303             ADD_REG64(WHvArm64RegisterX16, pVCpu->cpum.GstCtx.aGRegs[16]);
    1304             ADD_REG64(WHvArm64RegisterX17, pVCpu->cpum.GstCtx.aGRegs[17]);
    1305             ADD_REG64(WHvArm64RegisterX18, pVCpu->cpum.GstCtx.aGRegs[18]);
    1306             ADD_REG64(WHvArm64RegisterX19, pVCpu->cpum.GstCtx.aGRegs[19]);
    1307             ADD_REG64(WHvArm64RegisterX20, pVCpu->cpum.GstCtx.aGRegs[20]);
    1308             ADD_REG64(WHvArm64RegisterX21, pVCpu->cpum.GstCtx.aGRegs[21]);
    1309             ADD_REG64(WHvArm64RegisterX22, pVCpu->cpum.GstCtx.aGRegs[22]);
    1310             ADD_REG64(WHvArm64RegisterX23, pVCpu->cpum.GstCtx.aGRegs[23]);
    1311             ADD_REG64(WHvArm64RegisterX24, pVCpu->cpum.GstCtx.aGRegs[24]);
    1312             ADD_REG64(WHvArm64RegisterX25, pVCpu->cpum.GstCtx.aGRegs[25]);
    1313             ADD_REG64(WHvArm64RegisterX26, pVCpu->cpum.GstCtx.aGRegs[26]);
    1314             ADD_REG64(WHvArm64RegisterX27, pVCpu->cpum.GstCtx.aGRegs[27]);
    1315             ADD_REG64(WHvArm64RegisterX28, pVCpu->cpum.GstCtx.aGRegs[28]);
    1316         }
    1317         if (fWhat & CPUMCTX_EXTRN_LR)
    1318             ADD_REG64(WHvArm64RegisterLr, pVCpu->cpum.GstCtx.aGRegs[30]);
    1319         if (fWhat & CPUMCTX_EXTRN_FP)
    1320             ADD_REG64(WHvArm64RegisterFp, pVCpu->cpum.GstCtx.aGRegs[29]);
    1321     }
    1322 
    1323     /* RIP & Flags */
    1324     if (fWhat & CPUMCTX_EXTRN_PC)
    1325         ADD_SYSREG64(WHvArm64RegisterPc, pVCpu->cpum.GstCtx.Pc);
     1408    if (   (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_GPRS_MASK | CPUMCTX_EXTRN_PC | CPUMCTX_EXTRN_FPCR | CPUMCTX_EXTRN_FPSR))
     1409        !=                              (CPUMCTX_EXTRN_GPRS_MASK | CPUMCTX_EXTRN_PC | CPUMCTX_EXTRN_FPCR | CPUMCTX_EXTRN_FPSR))
     1410    {
     1411        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumRegs); i++)
     1412        {
     1413            if (!(s_aCpumRegs[i].fCpumExtrn & pVCpu->cpum.GstCtx.fExtrn))
     1414            {
     1415                const CPUMCTXGREG *pReg = (const CPUMCTXGREG *)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumRegs[i].offCpumCtx);
     1416                ADD_REG64(s_aCpumRegs[i].enmWHvReg, *pReg);
     1417            }
     1418        }
     1419    }
     1420
     1421    if (fWhat & CPUMCTX_EXTRN_V0_V31)
     1422    {
     1423        /* SIMD/FP registers. */
     1424        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumFpRegs); i++)
     1425        {
     1426            PCCPUMCTXVREG pVReg = (PCCPUMCTXVREG)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumFpRegs[i].offCpumCtx);
     1427            ADD_REG128(s_aCpumFpRegs[i].enmWHvReg, *pVReg);
     1428        }
     1429    }
     1430
     1431    if (fWhat & CPUMCTX_EXTRN_SYSREG_DEBUG)
     1432    {
     1433        for (uint32_t i = 0; i < pVM->nem.s.cBreakpoints; i++)
     1434        {
     1435            ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbcr0El1 + i), pVCpu->cpum.GstCtx.aBp[i].Ctrl);
     1436            ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbvr0El1 + i), pVCpu->cpum.GstCtx.aBp[i].Value);
     1437        }
     1438
     1439        for (uint32_t i = 0; i < pVM->nem.s.cWatchpoints; i++)
     1440        {
     1441            ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwcr0El1 + i), pVCpu->cpum.GstCtx.aWp[i].Ctrl);
     1442            ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwvr0El1 + i), pVCpu->cpum.GstCtx.aWp[i].Value);
     1443        }
     1444
     1445        ADD_SYSREG64(WHvArm64RegisterMdscrEl1, pVCpu->cpum.GstCtx.Mdscr);
     1446    }
     1447
     1448    if (fWhat & CPUMCTX_EXTRN_SYSREG_PAUTH_KEYS)
     1449    {
     1450        /* PAuth registers. */
     1451        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumPAuthKeyRegs); i++)
     1452        {
     1453            const CPUMCTXSYSREG *pReg = (const CPUMCTXSYSREG *)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumPAuthKeyRegs[i].offCpumCtx);
     1454            ADD_SYSREG64(s_aCpumPAuthKeyRegs[i].enmWHvReg, *pReg);
     1455        }
     1456    }
     1457
     1458    if (   (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_SPSR | CPUMCTX_EXTRN_ELR | CPUMCTX_EXTRN_SP | CPUMCTX_EXTRN_SCTLR_TCR_TTBR | CPUMCTX_EXTRN_SYSREG_MISC))
     1459        !=                              (CPUMCTX_EXTRN_SPSR | CPUMCTX_EXTRN_ELR | CPUMCTX_EXTRN_SP | CPUMCTX_EXTRN_SCTLR_TCR_TTBR | CPUMCTX_EXTRN_SYSREG_MISC))
     1460    {
     1461        /* System registers. */
     1462        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumSysRegs); i++)
     1463        {
     1464            if (!(s_aCpumSysRegs[i].fCpumExtrn & pVCpu->cpum.GstCtx.fExtrn))
     1465            {
     1466                const CPUMCTXSYSREG *pReg = (const CPUMCTXSYSREG *)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumSysRegs[i].offCpumCtx);
     1467                ADD_SYSREG64(s_aCpumSysRegs[i].enmWHvReg, *pReg);
     1468            }
     1469        }
     1470    }
     1471
    13261472    if (fWhat & CPUMCTX_EXTRN_PSTATE)
    13271473        ADD_REG64_RAW(WHvArm64RegisterPstate, pVCpu->cpum.GstCtx.fPState);
    1328     if (fWhat & CPUMCTX_EXTRN_SPSR)
    1329         ADD_SYSREG64(WHvArm64RegisterSpsrEl1, pVCpu->cpum.GstCtx.Spsr);
    1330     if (fWhat & CPUMCTX_EXTRN_ELR)
    1331         ADD_SYSREG64(WHvArm64RegisterElrEl1, pVCpu->cpum.GstCtx.Elr);
    1332     if (fWhat & CPUMCTX_EXTRN_SP)
    1333     {
    1334         ADD_SYSREG64(WHvArm64RegisterSpEl0, pVCpu->cpum.GstCtx.aSpReg[0]);
    1335         ADD_SYSREG64(WHvArm64RegisterSpEl1, pVCpu->cpum.GstCtx.aSpReg[1]);
    1336     }
    1337     if (fWhat & CPUMCTX_EXTRN_SCTLR_TCR_TTBR)
    1338     {
    1339         ADD_SYSREG64(WHvArm64RegisterSctlrEl1, pVCpu->cpum.GstCtx.Sctlr);
    1340         ADD_SYSREG64(WHvArm64RegisterTcrEl1,   pVCpu->cpum.GstCtx.Tcr);
    1341         ADD_SYSREG64(WHvArm64RegisterTtbr0El1, pVCpu->cpum.GstCtx.Ttbr0);
    1342         ADD_SYSREG64(WHvArm64RegisterTtbr1El1, pVCpu->cpum.GstCtx.Ttbr1);
    1343     }
    1344 
    1345     /* Vector state. */
    1346     if (fWhat & CPUMCTX_EXTRN_V0_V31)
    1347     {
    1348         ADD_REG128(WHvArm64RegisterQ0,  pVCpu->cpum.GstCtx.aVRegs[0]);
    1349         ADD_REG128(WHvArm64RegisterQ1,  pVCpu->cpum.GstCtx.aVRegs[1]);
    1350         ADD_REG128(WHvArm64RegisterQ2,  pVCpu->cpum.GstCtx.aVRegs[2]);
    1351         ADD_REG128(WHvArm64RegisterQ3,  pVCpu->cpum.GstCtx.aVRegs[3]);
    1352         ADD_REG128(WHvArm64RegisterQ4,  pVCpu->cpum.GstCtx.aVRegs[4]);
    1353         ADD_REG128(WHvArm64RegisterQ5,  pVCpu->cpum.GstCtx.aVRegs[5]);
    1354         ADD_REG128(WHvArm64RegisterQ6,  pVCpu->cpum.GstCtx.aVRegs[6]);
    1355         ADD_REG128(WHvArm64RegisterQ7,  pVCpu->cpum.GstCtx.aVRegs[7]);
    1356         ADD_REG128(WHvArm64RegisterQ8,  pVCpu->cpum.GstCtx.aVRegs[8]);
    1357         ADD_REG128(WHvArm64RegisterQ9,  pVCpu->cpum.GstCtx.aVRegs[9]);
    1358         ADD_REG128(WHvArm64RegisterQ10, pVCpu->cpum.GstCtx.aVRegs[10]);
    1359         ADD_REG128(WHvArm64RegisterQ11, pVCpu->cpum.GstCtx.aVRegs[11]);
    1360         ADD_REG128(WHvArm64RegisterQ12, pVCpu->cpum.GstCtx.aVRegs[12]);
    1361         ADD_REG128(WHvArm64RegisterQ13, pVCpu->cpum.GstCtx.aVRegs[13]);
    1362         ADD_REG128(WHvArm64RegisterQ14, pVCpu->cpum.GstCtx.aVRegs[14]);
    1363         ADD_REG128(WHvArm64RegisterQ15, pVCpu->cpum.GstCtx.aVRegs[15]);
    1364         ADD_REG128(WHvArm64RegisterQ16, pVCpu->cpum.GstCtx.aVRegs[16]);
    1365         ADD_REG128(WHvArm64RegisterQ17, pVCpu->cpum.GstCtx.aVRegs[17]);
    1366         ADD_REG128(WHvArm64RegisterQ18, pVCpu->cpum.GstCtx.aVRegs[18]);
    1367         ADD_REG128(WHvArm64RegisterQ19, pVCpu->cpum.GstCtx.aVRegs[19]);
    1368         ADD_REG128(WHvArm64RegisterQ20, pVCpu->cpum.GstCtx.aVRegs[20]);
    1369         ADD_REG128(WHvArm64RegisterQ21, pVCpu->cpum.GstCtx.aVRegs[21]);
    1370         ADD_REG128(WHvArm64RegisterQ22, pVCpu->cpum.GstCtx.aVRegs[22]);
    1371         ADD_REG128(WHvArm64RegisterQ23, pVCpu->cpum.GstCtx.aVRegs[23]);
    1372         ADD_REG128(WHvArm64RegisterQ24, pVCpu->cpum.GstCtx.aVRegs[24]);
    1373         ADD_REG128(WHvArm64RegisterQ25, pVCpu->cpum.GstCtx.aVRegs[25]);
    1374         ADD_REG128(WHvArm64RegisterQ26, pVCpu->cpum.GstCtx.aVRegs[26]);
    1375         ADD_REG128(WHvArm64RegisterQ27, pVCpu->cpum.GstCtx.aVRegs[27]);
    1376         ADD_REG128(WHvArm64RegisterQ28, pVCpu->cpum.GstCtx.aVRegs[28]);
    1377         ADD_REG128(WHvArm64RegisterQ29, pVCpu->cpum.GstCtx.aVRegs[29]);
    1378         ADD_REG128(WHvArm64RegisterQ30, pVCpu->cpum.GstCtx.aVRegs[30]);
    1379         ADD_REG128(WHvArm64RegisterQ31, pVCpu->cpum.GstCtx.aVRegs[31]);
    1380     }
    1381 
    1382     if (fWhat & CPUMCTX_EXTRN_FPCR)
    1383         ADD_REG64_RAW(WHvArm64RegisterFpcr, pVCpu->cpum.GstCtx.fpcr);
    1384     if (fWhat & CPUMCTX_EXTRN_FPSR)
    1385         ADD_REG64_RAW(WHvArm64RegisterFpsr, pVCpu->cpum.GstCtx.fpsr);
    1386 
    1387     /* System registers. */
    1388     if (fWhat & CPUMCTX_EXTRN_SYSREG_MISC)
    1389     {
    1390         ADD_SYSREG64(WHvArm64RegisterVbarEl1,       pVCpu->cpum.GstCtx.VBar);
    1391         ADD_SYSREG64(WHvArm64RegisterEsrEl1,        pVCpu->cpum.GstCtx.Esr);
    1392         ADD_SYSREG64(WHvArm64RegisterFarEl1,        pVCpu->cpum.GstCtx.Far);
    1393         ADD_SYSREG64(WHvArm64RegisterCntkctlEl1,    pVCpu->cpum.GstCtx.CntKCtl);
    1394         ADD_SYSREG64(WHvArm64RegisterContextidrEl1, pVCpu->cpum.GstCtx.ContextIdr);
    1395         ADD_SYSREG64(WHvArm64RegisterCpacrEl1,      pVCpu->cpum.GstCtx.Cpacr);
    1396         ADD_SYSREG64(WHvArm64RegisterCsselrEl1,     pVCpu->cpum.GstCtx.Csselr);
    1397         ADD_SYSREG64(WHvArm64RegisterMairEl1,       pVCpu->cpum.GstCtx.Mair);
    1398         ADD_SYSREG64(WHvArm64RegisterParEl1,        pVCpu->cpum.GstCtx.Par);
    1399         ADD_SYSREG64(WHvArm64RegisterTpidrroEl0,    pVCpu->cpum.GstCtx.TpIdrRoEl0);
    1400         ADD_SYSREG64(WHvArm64RegisterTpidrEl0,      pVCpu->cpum.GstCtx.aTpIdr[0]);
    1401         ADD_SYSREG64(WHvArm64RegisterTpidrEl1,      pVCpu->cpum.GstCtx.aTpIdr[1]);
    1402         ADD_SYSREG64(My_WHvArm64RegisterActlrEl1,   pVCpu->cpum.GstCtx.Actlr);
    1403     }
    1404 
    1405     if (fWhat & CPUMCTX_EXTRN_SYSREG_DEBUG)
    1406     {
    1407         for (uint32_t i = 0; i < pVM->nem.s.cBreakpoints; i++)
    1408         {
    1409             ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbcr0El1 + i), pVCpu->cpum.GstCtx.aBp[i].Ctrl);
    1410             ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbvr0El1 + i), pVCpu->cpum.GstCtx.aBp[i].Value);
    1411         }
    1412 
    1413         for (uint32_t i = 0; i < pVM->nem.s.cWatchpoints; i++)
    1414         {
    1415             ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwcr0El1 + i), pVCpu->cpum.GstCtx.aWp[i].Ctrl);
    1416             ADD_SYSREG64((WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwvr0El1 + i), pVCpu->cpum.GstCtx.aWp[i].Value);
    1417         }
    1418 
    1419         ADD_SYSREG64(WHvArm64RegisterMdscrEl1, pVCpu->cpum.GstCtx.Mdscr);
    1420     }
    1421 
    1422     if (fWhat & CPUMCTX_EXTRN_SYSREG_PAUTH_KEYS)
    1423     {
    1424         ADD_SYSREG64(WHvArm64RegisterApdAKeyHiEl1, pVCpu->cpum.GstCtx.Apda.High);
    1425         ADD_SYSREG64(WHvArm64RegisterApdAKeyLoEl1, pVCpu->cpum.GstCtx.Apda.Low);
    1426         ADD_SYSREG64(WHvArm64RegisterApdBKeyHiEl1, pVCpu->cpum.GstCtx.Apdb.High);
    1427         ADD_SYSREG64(WHvArm64RegisterApdBKeyLoEl1, pVCpu->cpum.GstCtx.Apdb.Low);
    1428         ADD_SYSREG64(WHvArm64RegisterApgAKeyHiEl1, pVCpu->cpum.GstCtx.Apga.High);
    1429         ADD_SYSREG64(WHvArm64RegisterApgAKeyLoEl1, pVCpu->cpum.GstCtx.Apga.Low);
    1430         ADD_SYSREG64(WHvArm64RegisterApiAKeyHiEl1, pVCpu->cpum.GstCtx.Apia.High);
    1431         ADD_SYSREG64(WHvArm64RegisterApiAKeyLoEl1, pVCpu->cpum.GstCtx.Apia.Low);
    1432         ADD_SYSREG64(WHvArm64RegisterApiBKeyHiEl1, pVCpu->cpum.GstCtx.Apib.High);
    1433         ADD_SYSREG64(WHvArm64RegisterApiBKeyLoEl1, pVCpu->cpum.GstCtx.Apib.Low);
    1434     }
    14351474
    14361475#undef ADD_REG64
    … …  
    14661505    uintptr_t iReg = 0;
    14671506
    1468     /* GPRs */
    1469     if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
    1470     {
    1471         if (fWhat & CPUMCTX_EXTRN_X0)
    1472             aenmNames[iReg++] = WHvArm64RegisterX0;
    1473         if (fWhat & CPUMCTX_EXTRN_X1)
    1474             aenmNames[iReg++] = WHvArm64RegisterX1;
    1475         if (fWhat & CPUMCTX_EXTRN_X2)
    1476             aenmNames[iReg++] = WHvArm64RegisterX2;
    1477         if (fWhat & CPUMCTX_EXTRN_X3)
    1478             aenmNames[iReg++] = WHvArm64RegisterX3;
    1479         if (fWhat & CPUMCTX_EXTRN_X4_X28)
    1480         {
    1481             aenmNames[iReg++] = WHvArm64RegisterX4;
    1482             aenmNames[iReg++] = WHvArm64RegisterX5;
    1483             aenmNames[iReg++] = WHvArm64RegisterX6;
    1484             aenmNames[iReg++] = WHvArm64RegisterX7;
    1485             aenmNames[iReg++] = WHvArm64RegisterX8;
    1486             aenmNames[iReg++] = WHvArm64RegisterX9;
    1487             aenmNames[iReg++] = WHvArm64RegisterX10;
    1488             aenmNames[iReg++] = WHvArm64RegisterX11;
    1489             aenmNames[iReg++] = WHvArm64RegisterX12;
    1490             aenmNames[iReg++] = WHvArm64RegisterX13;
    1491             aenmNames[iReg++] = WHvArm64RegisterX14;
    1492             aenmNames[iReg++] = WHvArm64RegisterX15;
    1493             aenmNames[iReg++] = WHvArm64RegisterX16;
    1494             aenmNames[iReg++] = WHvArm64RegisterX17;
    1495             aenmNames[iReg++] = WHvArm64RegisterX18;
    1496             aenmNames[iReg++] = WHvArm64RegisterX19;
    1497             aenmNames[iReg++] = WHvArm64RegisterX20;
    1498             aenmNames[iReg++] = WHvArm64RegisterX21;
    1499             aenmNames[iReg++] = WHvArm64RegisterX22;
    1500             aenmNames[iReg++] = WHvArm64RegisterX23;
    1501             aenmNames[iReg++] = WHvArm64RegisterX24;
    1502             aenmNames[iReg++] = WHvArm64RegisterX25;
    1503             aenmNames[iReg++] = WHvArm64RegisterX26;
    1504             aenmNames[iReg++] = WHvArm64RegisterX27;
    1505             aenmNames[iReg++] = WHvArm64RegisterX28;
    1506         }
    1507         if (fWhat & CPUMCTX_EXTRN_LR)
    1508             aenmNames[iReg++] = WHvArm64RegisterLr;
    1509         if (fWhat & CPUMCTX_EXTRN_FP)
    1510             aenmNames[iReg++] = WHvArm64RegisterFp;
    1511     }
    1512 
    1513     /* PC & Flags */
    1514     if (fWhat & CPUMCTX_EXTRN_PC)
    1515         aenmNames[iReg++] = WHvArm64RegisterPc;
     1507    if (   (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_GPRS_MASK | CPUMCTX_EXTRN_PC | CPUMCTX_EXTRN_FPCR | CPUMCTX_EXTRN_FPSR))
     1508        !=                              (CPUMCTX_EXTRN_GPRS_MASK | CPUMCTX_EXTRN_PC | CPUMCTX_EXTRN_FPCR | CPUMCTX_EXTRN_FPSR))
     1509    {
     1510        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumRegs); i++)
     1511        {
     1512            if (!(s_aCpumRegs[i].fCpumExtrn & pVCpu->cpum.GstCtx.fExtrn))
     1513                aenmNames[iReg++] = s_aCpumRegs[i].enmWHvReg;
     1514        }
     1515    }
     1516
     1517    if (fWhat & CPUMCTX_EXTRN_V0_V31)
     1518    {
     1519        /* SIMD/FP registers. */
     1520        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumFpRegs); i++)
     1521        {
     1522            aenmNames[iReg++] = s_aCpumFpRegs[i].enmWHvReg;
     1523        }
     1524    }
     1525
     1526    if (fWhat & CPUMCTX_EXTRN_SYSREG_DEBUG)
     1527    {
     1528        for (uint32_t i = 0; i < pVM->nem.s.cBreakpoints; i++)
     1529        {
     1530            aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbcr0El1 + i);
     1531            aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbvr0El1 + i);
     1532        }
     1533
     1534        for (uint32_t i = 0; i < pVM->nem.s.cWatchpoints; i++)
     1535        {
     1536            aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwcr0El1 + i);
     1537            aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwvr0El1 + i);
     1538        }
     1539
     1540        aenmNames[iReg++] = WHvArm64RegisterMdscrEl1;
     1541    }
     1542
     1543    if (fWhat & CPUMCTX_EXTRN_SYSREG_PAUTH_KEYS)
     1544    {
     1545        /* PAuth registers. */
     1546        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumPAuthKeyRegs); i++)
     1547        {
     1548            aenmNames[iReg++] = s_aCpumPAuthKeyRegs[i].enmWHvReg;
     1549        }
     1550    }
     1551
     1552    if (   (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_SPSR | CPUMCTX_EXTRN_ELR | CPUMCTX_EXTRN_SP | CPUMCTX_EXTRN_SCTLR_TCR_TTBR | CPUMCTX_EXTRN_SYSREG_MISC))
     1553        !=                              (CPUMCTX_EXTRN_SPSR | CPUMCTX_EXTRN_ELR | CPUMCTX_EXTRN_SP | CPUMCTX_EXTRN_SCTLR_TCR_TTBR | CPUMCTX_EXTRN_SYSREG_MISC))
     1554    {
     1555        /* System registers. */
     1556        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumSysRegs); i++)
     1557        {
     1558            if (!(s_aCpumSysRegs[i].fCpumExtrn & pVCpu->cpum.GstCtx.fExtrn))
     1559                aenmNames[iReg++] = s_aCpumSysRegs[i].enmWHvReg;
     1560        }
     1561    }
     1562
    15161563    if (fWhat & CPUMCTX_EXTRN_PSTATE)
    15171564        aenmNames[iReg++] = WHvArm64RegisterPstate;
    1518     if (fWhat & CPUMCTX_EXTRN_SPSR)
    1519         aenmNames[iReg++] = WHvArm64RegisterSpsrEl1;
    1520     if (fWhat & CPUMCTX_EXTRN_ELR)
    1521         aenmNames[iReg++] = WHvArm64RegisterElrEl1;
    1522     if (fWhat & CPUMCTX_EXTRN_SP)
    1523     {
    1524         aenmNames[iReg++] = WHvArm64RegisterSpEl0;
    1525         aenmNames[iReg++] = WHvArm64RegisterSpEl1;
    1526     }
    1527     if (fWhat & CPUMCTX_EXTRN_SCTLR_TCR_TTBR)
    1528     {
    1529         aenmNames[iReg++] = WHvArm64RegisterSctlrEl1;
    1530         aenmNames[iReg++] = WHvArm64RegisterTcrEl1;
    1531         aenmNames[iReg++] = WHvArm64RegisterTtbr0El1;
    1532         aenmNames[iReg++] = WHvArm64RegisterTtbr1El1;
    1533     }
    1534 
    1535     /* Vector state. */
    1536     if (fWhat & CPUMCTX_EXTRN_V0_V31)
    1537     {
    1538         aenmNames[iReg++] = WHvArm64RegisterQ0;
    1539         aenmNames[iReg++] = WHvArm64RegisterQ1;
    1540         aenmNames[iReg++] = WHvArm64RegisterQ2;
    1541         aenmNames[iReg++] = WHvArm64RegisterQ3;
    1542         aenmNames[iReg++] = WHvArm64RegisterQ4;
    1543         aenmNames[iReg++] = WHvArm64RegisterQ5;
    1544         aenmNames[iReg++] = WHvArm64RegisterQ6;
    1545         aenmNames[iReg++] = WHvArm64RegisterQ7;
    1546         aenmNames[iReg++] = WHvArm64RegisterQ8;
    1547         aenmNames[iReg++] = WHvArm64RegisterQ9;
    1548         aenmNames[iReg++] = WHvArm64RegisterQ10;
    1549         aenmNames[iReg++] = WHvArm64RegisterQ11;
    1550         aenmNames[iReg++] = WHvArm64RegisterQ12;
    1551         aenmNames[iReg++] = WHvArm64RegisterQ13;
    1552         aenmNames[iReg++] = WHvArm64RegisterQ14;
    1553         aenmNames[iReg++] = WHvArm64RegisterQ15;
    1554 
    1555         aenmNames[iReg++] = WHvArm64RegisterQ16;
    1556         aenmNames[iReg++] = WHvArm64RegisterQ17;
    1557         aenmNames[iReg++] = WHvArm64RegisterQ18;
    1558         aenmNames[iReg++] = WHvArm64RegisterQ19;
    1559         aenmNames[iReg++] = WHvArm64RegisterQ20;
    1560         aenmNames[iReg++] = WHvArm64RegisterQ21;
    1561         aenmNames[iReg++] = WHvArm64RegisterQ22;
    1562         aenmNames[iReg++] = WHvArm64RegisterQ23;
    1563         aenmNames[iReg++] = WHvArm64RegisterQ24;
    1564         aenmNames[iReg++] = WHvArm64RegisterQ25;
    1565         aenmNames[iReg++] = WHvArm64RegisterQ26;
    1566         aenmNames[iReg++] = WHvArm64RegisterQ27;
    1567         aenmNames[iReg++] = WHvArm64RegisterQ28;
    1568         aenmNames[iReg++] = WHvArm64RegisterQ29;
    1569         aenmNames[iReg++] = WHvArm64RegisterQ30;
    1570         aenmNames[iReg++] = WHvArm64RegisterQ31;
    1571     }
    1572     if (fWhat & CPUMCTX_EXTRN_FPCR)
    1573         aenmNames[iReg++] = WHvArm64RegisterFpcr;
    1574     if (fWhat & CPUMCTX_EXTRN_FPSR)
    1575         aenmNames[iReg++] = WHvArm64RegisterFpsr;
    1576 
    1577     /* System registers. */
    1578     if (fWhat & CPUMCTX_EXTRN_SYSREG_MISC)
    1579     {
    1580         aenmNames[iReg++] = WHvArm64RegisterVbarEl1;
    1581         aenmNames[iReg++] = WHvArm64RegisterEsrEl1;
    1582         aenmNames[iReg++] = WHvArm64RegisterFarEl1;
    1583         aenmNames[iReg++] = WHvArm64RegisterCntkctlEl1;
    1584         aenmNames[iReg++] = WHvArm64RegisterContextidrEl1;
    1585         aenmNames[iReg++] = WHvArm64RegisterCpacrEl1;
    1586         aenmNames[iReg++] = WHvArm64RegisterCsselrEl1;
    1587         aenmNames[iReg++] = WHvArm64RegisterMairEl1;
    1588         aenmNames[iReg++] = WHvArm64RegisterParEl1;
    1589         aenmNames[iReg++] = WHvArm64RegisterTpidrroEl0;
    1590         aenmNames[iReg++] = WHvArm64RegisterTpidrEl0;
    1591         aenmNames[iReg++] = WHvArm64RegisterTpidrEl1;
    1592         aenmNames[iReg++] = My_WHvArm64RegisterActlrEl1;
    1593     }
    1594 
    1595     if (fWhat & CPUMCTX_EXTRN_SYSREG_DEBUG)
    1596     {
    1597         /* Hyper-V doesn't allow syncing debug break-/watchpoint registers which aren't there. */
    1598         for (uint32_t i = 0; i < pVM->nem.s.cBreakpoints; i++)
    1599         {
    1600             aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbcr0El1 + i);
    1601             aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbvr0El1 + i);
    1602         }
    1603 
    1604         for (uint32_t i = 0; i < pVM->nem.s.cWatchpoints; i++)
    1605         {
    1606             aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwcr0El1 + i);
    1607             aenmNames[iReg++] = (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwvr0El1 + i);
    1608         }
    1609 
    1610         aenmNames[iReg++] = WHvArm64RegisterMdscrEl1;
    1611     }
    1612 
    1613     if (fWhat & CPUMCTX_EXTRN_SYSREG_PAUTH_KEYS)
    1614     {
    1615         aenmNames[iReg++] = WHvArm64RegisterApdAKeyHiEl1;
    1616         aenmNames[iReg++] = WHvArm64RegisterApdAKeyLoEl1;
    1617         aenmNames[iReg++] = WHvArm64RegisterApdBKeyHiEl1;
    1618         aenmNames[iReg++] = WHvArm64RegisterApdBKeyLoEl1;
    1619         aenmNames[iReg++] = WHvArm64RegisterApgAKeyHiEl1;
    1620         aenmNames[iReg++] = WHvArm64RegisterApgAKeyLoEl1;
    1621         aenmNames[iReg++] = WHvArm64RegisterApiAKeyHiEl1;
    1622         aenmNames[iReg++] = WHvArm64RegisterApiAKeyLoEl1;
    1623         aenmNames[iReg++] = WHvArm64RegisterApiBKeyHiEl1;
    1624         aenmNames[iReg++] = WHvArm64RegisterApiBKeyLoEl1;
    1625     }
    16261565
    16271566    size_t const cRegs = iReg;
    … …  
    16441583#define GET_REG64(a_DstVar, a_enmName) do { \
    16451584            Assert(aenmNames[iReg] == (a_enmName)); \
    1646             (a_DstVar).x = aValues[iReg].Reg64; \
     1585            (a_DstVar)->x = aValues[iReg].Reg64; \
    16471586            iReg++; \
    16481587        } while (0)
    16491588#define GET_REG64_RAW(a_DstVar, a_enmName) do { \
    16501589            Assert(aenmNames[iReg] == (a_enmName)); \
    1651             (a_DstVar) = aValues[iReg].Reg64; \
     1590            *(a_DstVar) = aValues[iReg].Reg64; \
    16521591            iReg++; \
    16531592        } while (0)
    16541593#define GET_SYSREG64(a_DstVar, a_enmName) do { \
    16551594            Assert(aenmNames[iReg] == (a_enmName)); \
    1656             (a_DstVar).u64 = aValues[iReg].Reg64; \
     1595            (a_DstVar)->u64 = aValues[iReg].Reg64; \
    16571596            iReg++; \
    16581597        } while (0)
    16591598#define GET_REG128(a_DstVar, a_enmName) do { \
    16601599            Assert(aenmNames[iReg] == a_enmName); \
    1661             (a_DstVar).au64[0] = aValues[iReg].Reg128.Low64; \
    1662             (a_DstVar).au64[1] = aValues[iReg].Reg128.High64; \
     1600            (a_DstVar)->au64[0] = aValues[iReg].Reg128.Low64; \
     1601            (a_DstVar)->au64[1] = aValues[iReg].Reg128.High64; \
    16631602            iReg++; \
    16641603        } while (0)
    16651604
    1666     /* GPRs */
    1667     if (fWhat & CPUMCTX_EXTRN_GPRS_MASK)
    1668     {
    1669         if (fWhat & CPUMCTX_EXTRN_X0)
    1670             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[0], WHvArm64RegisterX0);
    1671         if (fWhat & CPUMCTX_EXTRN_X1)
    1672             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[1], WHvArm64RegisterX1);
    1673         if (fWhat & CPUMCTX_EXTRN_X2)
    1674             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[2], WHvArm64RegisterX2);
    1675         if (fWhat & CPUMCTX_EXTRN_X3)
    1676             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[3], WHvArm64RegisterX3);
    1677         if (fWhat & CPUMCTX_EXTRN_X4_X28)
    1678         {
    1679             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[4],  WHvArm64RegisterX4);
    1680             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[5],  WHvArm64RegisterX5);
    1681             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[6],  WHvArm64RegisterX6);
    1682             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[7],  WHvArm64RegisterX7);
    1683             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[8],  WHvArm64RegisterX8);
    1684             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[9],  WHvArm64RegisterX9);
    1685             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[10], WHvArm64RegisterX10);
    1686             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[11], WHvArm64RegisterX11);
    1687             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[12], WHvArm64RegisterX12);
    1688             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[13], WHvArm64RegisterX13);
    1689             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[14], WHvArm64RegisterX14);
    1690             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[15], WHvArm64RegisterX15);
    1691             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[16], WHvArm64RegisterX16);
    1692             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[17], WHvArm64RegisterX17);
    1693             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[18], WHvArm64RegisterX18);
    1694             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[19], WHvArm64RegisterX19);
    1695             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[20], WHvArm64RegisterX20);
    1696             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[21], WHvArm64RegisterX21);
    1697             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[22], WHvArm64RegisterX22);
    1698             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[23], WHvArm64RegisterX23);
    1699             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[24], WHvArm64RegisterX24);
    1700             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[25], WHvArm64RegisterX25);
    1701             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[26], WHvArm64RegisterX26);
    1702             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[27], WHvArm64RegisterX27);
    1703             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[28], WHvArm64RegisterX28);
    1704         }
    1705         if (fWhat & CPUMCTX_EXTRN_LR)
    1706             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[30], WHvArm64RegisterLr);
    1707         if (fWhat & CPUMCTX_EXTRN_FP)
    1708             GET_REG64(pVCpu->cpum.GstCtx.aGRegs[29], WHvArm64RegisterFp);
    1709     }
    1710 
    1711     /* RIP & Flags */
    1712     if (fWhat & CPUMCTX_EXTRN_PC)
    1713         GET_REG64_RAW(pVCpu->cpum.GstCtx.Pc.u64, WHvArm64RegisterPc);
     1605    if (   (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_GPRS_MASK | CPUMCTX_EXTRN_PC | CPUMCTX_EXTRN_FPCR | CPUMCTX_EXTRN_FPSR))
     1606        !=                              (CPUMCTX_EXTRN_GPRS_MASK | CPUMCTX_EXTRN_PC | CPUMCTX_EXTRN_FPCR | CPUMCTX_EXTRN_FPSR))
     1607    {
     1608        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumRegs); i++)
     1609        {
     1610            if (!(s_aCpumRegs[i].fCpumExtrn & pVCpu->cpum.GstCtx.fExtrn))
     1611            {
     1612                CPUMCTXGREG *pReg = (CPUMCTXGREG *)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumRegs[i].offCpumCtx);
     1613                GET_REG64(pReg, s_aCpumRegs[i].enmWHvReg);
     1614            }
     1615        }
     1616    }
     1617
     1618    if (fWhat & CPUMCTX_EXTRN_V0_V31)
     1619    {
     1620        /* SIMD/FP registers. */
     1621        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumFpRegs); i++)
     1622        {
     1623            PCPUMCTXVREG pVReg = (PCPUMCTXVREG)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumFpRegs[i].offCpumCtx);
     1624            GET_REG128(pVReg, s_aCpumFpRegs[i].enmWHvReg);
     1625        }
     1626    }
     1627
     1628    if (fWhat & CPUMCTX_EXTRN_SYSREG_DEBUG)
     1629    {
     1630        for (uint32_t i = 0; i < pVM->nem.s.cBreakpoints; i++)
     1631        {
     1632            GET_SYSREG64(&pVCpu->cpum.GstCtx.aBp[i].Ctrl,  (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbcr0El1 + i));
     1633            GET_SYSREG64(&pVCpu->cpum.GstCtx.aBp[i].Value, (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbvr0El1 + i));
     1634        }
     1635
     1636        for (uint32_t i = 0; i < pVM->nem.s.cWatchpoints; i++)
     1637        {
     1638            GET_SYSREG64(&pVCpu->cpum.GstCtx.aWp[i].Ctrl,  (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwcr0El1 + i));
     1639            GET_SYSREG64(&pVCpu->cpum.GstCtx.aWp[i].Value, (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwvr0El1 + i));
     1640        }
     1641
     1642        GET_SYSREG64(&pVCpu->cpum.GstCtx.Mdscr, WHvArm64RegisterMdscrEl1);
     1643    }
     1644
     1645    if (fWhat & CPUMCTX_EXTRN_SYSREG_PAUTH_KEYS)
     1646    {
     1647        /* PAuth registers. */
     1648        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumPAuthKeyRegs); i++)
     1649        {
     1650            CPUMCTXSYSREG *pReg = (CPUMCTXSYSREG *)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumPAuthKeyRegs[i].offCpumCtx);
     1651            GET_SYSREG64(pReg, s_aCpumPAuthKeyRegs[i].enmWHvReg);
     1652        }
     1653    }
     1654
     1655    if (   (pVCpu->cpum.GstCtx.fExtrn & (CPUMCTX_EXTRN_SPSR | CPUMCTX_EXTRN_ELR | CPUMCTX_EXTRN_SP | CPUMCTX_EXTRN_SCTLR_TCR_TTBR | CPUMCTX_EXTRN_SYSREG_MISC))
     1656        !=                              (CPUMCTX_EXTRN_SPSR | CPUMCTX_EXTRN_ELR | CPUMCTX_EXTRN_SP | CPUMCTX_EXTRN_SCTLR_TCR_TTBR | CPUMCTX_EXTRN_SYSREG_MISC))
     1657    {
     1658        /* System registers. */
     1659        for (uint32_t i = 0; i < RT_ELEMENTS(s_aCpumSysRegs); i++)
     1660        {
     1661            if (!(s_aCpumSysRegs[i].fCpumExtrn & pVCpu->cpum.GstCtx.fExtrn))
     1662            {
     1663                CPUMCTXSYSREG *pReg = (CPUMCTXSYSREG *)((uint8_t *)&pVCpu->cpum.GstCtx + s_aCpumSysRegs[i].offCpumCtx);
     1664                GET_SYSREG64(pReg, s_aCpumSysRegs[i].enmWHvReg);
     1665            }
     1666        }
     1667    }
     1668
    17141669    if (fWhat & CPUMCTX_EXTRN_PSTATE)
    1715         GET_REG64_RAW(pVCpu->cpum.GstCtx.fPState, WHvArm64RegisterPstate);
    1716     if (fWhat & CPUMCTX_EXTRN_SPSR)
    1717         GET_SYSREG64(pVCpu->cpum.GstCtx.Spsr, WHvArm64RegisterSpsrEl1);
    1718     if (fWhat & CPUMCTX_EXTRN_ELR)
    1719         GET_SYSREG64(pVCpu->cpum.GstCtx.Elr, WHvArm64RegisterElrEl1);
    1720     if (fWhat & CPUMCTX_EXTRN_SP)
    1721     {
    1722         GET_SYSREG64(pVCpu->cpum.GstCtx.aSpReg[0], WHvArm64RegisterSpEl0);
    1723         GET_SYSREG64(pVCpu->cpum.GstCtx.aSpReg[1], WHvArm64RegisterSpEl1);
    1724     }
    1725     if (fWhat & CPUMCTX_EXTRN_SCTLR_TCR_TTBR)
    1726     {
    1727         GET_SYSREG64(pVCpu->cpum.GstCtx.Sctlr, WHvArm64RegisterSctlrEl1);
    1728         GET_SYSREG64(pVCpu->cpum.GstCtx.Tcr, WHvArm64RegisterTcrEl1);
    1729         GET_SYSREG64(pVCpu->cpum.GstCtx.Ttbr0, WHvArm64RegisterTtbr0El1);
    1730         GET_SYSREG64(pVCpu->cpum.GstCtx.Ttbr1, WHvArm64RegisterTtbr1El1);
    1731     }
    1732 
    1733     /* Vector state. */
    1734     if (fWhat & CPUMCTX_EXTRN_V0_V31)
    1735     {
    1736         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[0],  WHvArm64RegisterQ0);
    1737         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[1],  WHvArm64RegisterQ1);
    1738         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[2],  WHvArm64RegisterQ2);
    1739         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[3],  WHvArm64RegisterQ3);
    1740         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[4],  WHvArm64RegisterQ4);
    1741         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[5],  WHvArm64RegisterQ5);
    1742         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[6],  WHvArm64RegisterQ6);
    1743         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[7],  WHvArm64RegisterQ7);
    1744         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[8],  WHvArm64RegisterQ8);
    1745         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[9],  WHvArm64RegisterQ9);
    1746         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[10], WHvArm64RegisterQ10);
    1747         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[11], WHvArm64RegisterQ11);
    1748         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[12], WHvArm64RegisterQ12);
    1749         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[13], WHvArm64RegisterQ13);
    1750         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[14], WHvArm64RegisterQ14);
    1751         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[15], WHvArm64RegisterQ15);
    1752 
    1753         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[16], WHvArm64RegisterQ16);
    1754         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[17], WHvArm64RegisterQ17);
    1755         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[18], WHvArm64RegisterQ18);
    1756         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[19], WHvArm64RegisterQ19);
    1757         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[20], WHvArm64RegisterQ20);
    1758         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[21], WHvArm64RegisterQ21);
    1759         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[22], WHvArm64RegisterQ22);
    1760         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[23], WHvArm64RegisterQ23);
    1761         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[24], WHvArm64RegisterQ24);
    1762         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[25], WHvArm64RegisterQ25);
    1763         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[26], WHvArm64RegisterQ26);
    1764         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[27], WHvArm64RegisterQ27);
    1765         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[28], WHvArm64RegisterQ28);
    1766         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[29], WHvArm64RegisterQ29);
    1767         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[30], WHvArm64RegisterQ30);
    1768         GET_REG128(pVCpu->cpum.GstCtx.aVRegs[31], WHvArm64RegisterQ31);
    1769     }
    1770     if (fWhat & CPUMCTX_EXTRN_FPCR)
    1771         GET_REG64_RAW(pVCpu->cpum.GstCtx.fpcr, WHvArm64RegisterFpcr);
    1772     if (fWhat & CPUMCTX_EXTRN_FPSR)
    1773         GET_REG64_RAW(pVCpu->cpum.GstCtx.fpsr, WHvArm64RegisterFpsr);
    1774 
    1775     /* System registers. */
    1776     if (fWhat & CPUMCTX_EXTRN_SYSREG_MISC)
    1777     {
    1778         GET_SYSREG64(pVCpu->cpum.GstCtx.VBar,       WHvArm64RegisterVbarEl1);
    1779         GET_SYSREG64(pVCpu->cpum.GstCtx.Esr,        WHvArm64RegisterEsrEl1);
    1780         GET_SYSREG64(pVCpu->cpum.GstCtx.Far,        WHvArm64RegisterFarEl1);
    1781         GET_SYSREG64(pVCpu->cpum.GstCtx.CntKCtl,    WHvArm64RegisterCntkctlEl1);
    1782         GET_SYSREG64(pVCpu->cpum.GstCtx.ContextIdr, WHvArm64RegisterContextidrEl1);
    1783         GET_SYSREG64(pVCpu->cpum.GstCtx.Cpacr,      WHvArm64RegisterCpacrEl1);
    1784         GET_SYSREG64(pVCpu->cpum.GstCtx.Csselr,     WHvArm64RegisterCsselrEl1);
    1785         GET_SYSREG64(pVCpu->cpum.GstCtx.Mair,       WHvArm64RegisterMairEl1);
    1786         GET_SYSREG64(pVCpu->cpum.GstCtx.Par,        WHvArm64RegisterParEl1);
    1787         GET_SYSREG64(pVCpu->cpum.GstCtx.TpIdrRoEl0, WHvArm64RegisterTpidrroEl0);
    1788         GET_SYSREG64(pVCpu->cpum.GstCtx.aTpIdr[0],  WHvArm64RegisterTpidrEl0);
    1789         GET_SYSREG64(pVCpu->cpum.GstCtx.aTpIdr[1],  WHvArm64RegisterTpidrEl1);
    1790         GET_SYSREG64(pVCpu->cpum.GstCtx.Actlr,      My_WHvArm64RegisterActlrEl1);
    1791     }
    1792 
    1793     if (fWhat & CPUMCTX_EXTRN_SYSREG_DEBUG)
    1794     {
    1795         for (uint32_t i = 0; i < pVM->nem.s.cBreakpoints; i++)
    1796         {
    1797             GET_SYSREG64(pVCpu->cpum.GstCtx.aBp[i].Ctrl, (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbcr0El1 + i));
    1798             GET_SYSREG64(pVCpu->cpum.GstCtx.aBp[i].Value, (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgbvr0El1 + i));
    1799         }
    1800 
    1801         for (uint32_t i = 0; i < pVM->nem.s.cWatchpoints; i++)
    1802         {
    1803             GET_SYSREG64(pVCpu->cpum.GstCtx.aWp[i].Ctrl, (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwcr0El1 + i));
    1804             GET_SYSREG64(pVCpu->cpum.GstCtx.aWp[i].Value, (WHV_REGISTER_NAME)((uint32_t)WHvArm64RegisterDbgwvr0El1 + i));
    1805         }
    1806 
    1807         GET_SYSREG64(pVCpu->cpum.GstCtx.Mdscr, WHvArm64RegisterMdscrEl1);
    1808     }
    1809 
    1810     if (fWhat & CPUMCTX_EXTRN_SYSREG_PAUTH_KEYS)
    1811     {
    1812         GET_SYSREG64(pVCpu->cpum.GstCtx.Apda.High, WHvArm64RegisterApdAKeyHiEl1);
    1813         GET_SYSREG64(pVCpu->cpum.GstCtx.Apda.Low,  WHvArm64RegisterApdAKeyLoEl1);
    1814         GET_SYSREG64(pVCpu->cpum.GstCtx.Apdb.High, WHvArm64RegisterApdBKeyHiEl1);
    1815         GET_SYSREG64(pVCpu->cpum.GstCtx.Apdb.Low,  WHvArm64RegisterApdBKeyLoEl1);
    1816         GET_SYSREG64(pVCpu->cpum.GstCtx.Apga.High, WHvArm64RegisterApgAKeyHiEl1);
    1817         GET_SYSREG64(pVCpu->cpum.GstCtx.Apga.Low,  WHvArm64RegisterApgAKeyLoEl1);
    1818         GET_SYSREG64(pVCpu->cpum.GstCtx.Apia.High, WHvArm64RegisterApiAKeyHiEl1);
    1819         GET_SYSREG64(pVCpu->cpum.GstCtx.Apia.Low,  WHvArm64RegisterApiAKeyLoEl1);
    1820         GET_SYSREG64(pVCpu->cpum.GstCtx.Apib.High, WHvArm64RegisterApiBKeyHiEl1);
    1821         GET_SYSREG64(pVCpu->cpum.GstCtx.Apib.Low,  WHvArm64RegisterApiBKeyLoEl1);
    1822     }
     1670        GET_REG64_RAW(&pVCpu->cpum.GstCtx.fPState, WHvArm64RegisterPstate);
    18231671
    18241672    /* Almost done, just update extrn flags. */
Note: See TracChangeset for help on using the changeset viewer.

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