VirtualBox

Ignore:
Timestamp:
Jan 19, 2018 4:00:42 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
120382
Message:

bootsectors/bs3-cpu-instr-2: Added testcase for FSGSBASE instructions.

Location:
trunk/src/VBox/ValidationKit/bootsectors
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-2-template.c

    r69111 r70651  
    3939*********************************************************************************************************************************/
    4040#ifdef BS3_INSTANTIATING_CMN
     41# if ARCH_BITS == 64
     42typedef struct BS3CI2FSGSBASE
     43{
     44    const char *pszDesc;
     45    bool        f64BitOperand;
     46    FPFNBS3FAR  pfnWorker;
     47    uint8_t     offWorkerUd2;
     48    FPFNBS3FAR  pfnVerifyWorker;
     49    uint8_t     offVerifyWorkerUd2;
     50} BS3CI2FSGSBASE;
     51# endif
    4152#endif
    4253
    … …  
    6071extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_repnz_cmpxchg16b_rdi_ud2);
    6172extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_lock_repnz_cmpxchg16b_rdi_ud2);
     73
     74extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrfsbase_rbx_ud2);
     75extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrfsbase_ebx_ud2);
     76extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrfsbase_rbx_rdfsbase_rcx_ud2);
     77extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrfsbase_ebx_rdfsbase_ecx_ud2);
     78
     79extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrgsbase_rbx_ud2);
     80extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrgsbase_ebx_ud2);
     81extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrgsbase_rbx_rdgsbase_rcx_ud2);
     82extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_wrgsbase_ebx_rdgsbase_ecx_ud2);
     83
     84extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_rdfsbase_rbx_ud2);
     85extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_rdfsbase_ebx_ud2);
     86extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_rdgsbase_rbx_ud2);
     87extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_rdgsbase_ebx_ud2);
    6288# endif
    6389#endif
    … …  
    6894*********************************************************************************************************************************/
    6995#ifdef BS3_INSTANTIATING_CMN
    70 
     96# if ARCH_BITS == 64
     97static BS3CI2FSGSBASE const s_aWrFsBaseWorkers[] =
     98{
     99    { "wrfsbase rbx", true,  BS3_CMN_NM(bs3CpuInstr2_wrfsbase_rbx_ud2), 5, BS3_CMN_NM(bs3CpuInstr2_wrfsbase_rbx_rdfsbase_rcx_ud2), 10 },
     100    { "wrfsbase ebx", false, BS3_CMN_NM(bs3CpuInstr2_wrfsbase_ebx_ud2), 4, BS3_CMN_NM(bs3CpuInstr2_wrfsbase_ebx_rdfsbase_ecx_ud2),  8 },
     101};
     102
     103static BS3CI2FSGSBASE const s_aWrGsBaseWorkers[] =
     104{
     105    { "wrgsbase rbx", true,  BS3_CMN_NM(bs3CpuInstr2_wrgsbase_rbx_ud2), 5, BS3_CMN_NM(bs3CpuInstr2_wrgsbase_rbx_rdgsbase_rcx_ud2), 10 },
     106    { "wrgsbase ebx", false, BS3_CMN_NM(bs3CpuInstr2_wrgsbase_ebx_ud2), 4, BS3_CMN_NM(bs3CpuInstr2_wrgsbase_ebx_rdgsbase_ecx_ud2),  8 },
     107};
     108
     109static BS3CI2FSGSBASE const s_aRdFsBaseWorkers[] =
     110{
     111    { "rdfsbase rbx", true,  BS3_CMN_NM(bs3CpuInstr2_rdfsbase_rbx_ud2), 5, BS3_CMN_NM(bs3CpuInstr2_wrfsbase_rbx_rdfsbase_rcx_ud2), 10 },
     112    { "rdfsbase ebx", false, BS3_CMN_NM(bs3CpuInstr2_rdfsbase_ebx_ud2), 4, BS3_CMN_NM(bs3CpuInstr2_wrfsbase_ebx_rdfsbase_ecx_ud2),  8 },
     113};
     114
     115static BS3CI2FSGSBASE const s_aRdGsBaseWorkers[] =
     116{
     117    { "rdgsbase rbx", true,  BS3_CMN_NM(bs3CpuInstr2_rdgsbase_rbx_ud2), 5, BS3_CMN_NM(bs3CpuInstr2_wrgsbase_rbx_rdgsbase_rcx_ud2), 10 },
     118    { "rdgsbase ebx", false, BS3_CMN_NM(bs3CpuInstr2_rdgsbase_ebx_ud2), 4, BS3_CMN_NM(bs3CpuInstr2_wrgsbase_ebx_rdgsbase_ecx_ud2),  8 },
     119};
     120# endif
    71121#endif /* BS3_INSTANTIATING_CMN - global */
    72122
    … …  
    669719    return 0;
    670720}
     721
     722
     723static void bs3CpuInstr2_fsgsbase_ExpectUD(uint8_t bMode, PBS3REGCTX pCtx, PBS3REGCTX pExpectCtx, PBS3TRAPFRAME pTrapFrame)
     724{
     725    pCtx->rbx.u  = 0;
     726    Bs3MemCpy(pExpectCtx, pCtx, sizeof(*pExpectCtx));
     727    Bs3TrapSetJmpAndRestore(pCtx, pTrapFrame);
     728    pExpectCtx->rip.u       = pCtx->rip.u;
     729    pExpectCtx->rflags.u32 |= X86_EFL_RF;
     730    if (   !Bs3TestCheckRegCtxEx(&pTrapFrame->Ctx, pExpectCtx, 0 /*cbPcAdjust*/, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, "lm64",
     731                                 0 /*idTestStep*/)
     732        || pTrapFrame->bXcpt != X86_XCPT_UD)
     733    {
     734        Bs3TestFailedF("Expected #UD, got %#x (%#x)", pTrapFrame->bXcpt, pTrapFrame->uErrCd);
     735        ASMHalt();
     736    }
     737}
     738
     739
     740static bool bs3CpuInstr2_fsgsbase_VerifyWorker(uint8_t bMode, PBS3REGCTX pCtx, PBS3REGCTX pExpectCtx, PBS3TRAPFRAME pTrapFrame,
     741                                               BS3CI2FSGSBASE const *pFsGsBaseWorker, unsigned *puIter)
     742{
     743    bool     fPassed = true;
     744    unsigned iValue  = 0;
     745    static const struct
     746    {
     747        bool      fGP;
     748        uint64_t  u64Base;
     749    } s_aValues64[] =
     750    {
     751        { false, UINT64_C(0x0000000000000000) },
     752        { false, UINT64_C(0x0000000000000001) },
     753        { false, UINT64_C(0x0000000000000010) },
     754        { false, UINT64_C(0x0000000000000123) },
     755        { false, UINT64_C(0x0000000000001234) },
     756        { false, UINT64_C(0x0000000000012345) },
     757        { false, UINT64_C(0x0000000000123456) },
     758        { false, UINT64_C(0x0000000001234567) },
     759        { false, UINT64_C(0x0000000012345678) },
     760        { false, UINT64_C(0x0000000123456789) },
     761        { false, UINT64_C(0x000000123456789a) },
     762        { false, UINT64_C(0x00000123456789ab) },
     763        { false, UINT64_C(0x0000123456789abc) },
     764        { false, UINT64_C(0x00007ffffeefefef) },
     765        { false, UINT64_C(0x00007fffffffffff) },
     766        {  true, UINT64_C(0x0000800000000000) },
     767        {  true, UINT64_C(0x0000800000000000) },
     768        {  true, UINT64_C(0x0000800000000333) },
     769        {  true, UINT64_C(0x0001000000000000) },
     770        {  true, UINT64_C(0x0012000000000000) },
     771        {  true, UINT64_C(0x0123000000000000) },
     772        {  true, UINT64_C(0x1234000000000000) },
     773        {  true, UINT64_C(0xffff300000000000) },
     774        {  true, UINT64_C(0xffff7fffffffffff) },
     775        {  true, UINT64_C(0xffff7fffffffffff) },
     776        { false, UINT64_C(0xffff800000000000) },
     777        { false, UINT64_C(0xffffffffffeefefe) },
     778        { false, UINT64_C(0xffffffffffffffff) },
     779        { false, UINT64_C(0xffffffffffffffff) },
     780        { false, UINT64_C(0x00000000efefefef) },
     781        { false, UINT64_C(0x0000000080204060) },
     782        { false, UINT64_C(0x00000000ddeeffaa) },
     783        { false, UINT64_C(0x00000000fdecdbca) },
     784        { false, UINT64_C(0x000000006098456b) },
     785        { false, UINT64_C(0x0000000098506099) },
     786        { false, UINT64_C(0x00000000206950bc) },
     787        { false, UINT64_C(0x000000009740395d) },
     788        { false, UINT64_C(0x0000000064a9455e) },
     789        { false, UINT64_C(0x00000000d20b6eff) },
     790        { false, UINT64_C(0x0000000085296d46) },
     791        { false, UINT64_C(0x0000000007000039) },
     792        { false, UINT64_C(0x000000000007fe00) },
     793    };
     794
     795    Bs3RegCtxSetRipCsFromCurPtr(pCtx, pFsGsBaseWorker->pfnVerifyWorker);
     796    if (pFsGsBaseWorker->f64BitOperand)
     797    {
     798        for (iValue = 0; iValue < RT_ELEMENTS(s_aValues64); iValue++)
     799        {
     800            bool const fGP = s_aValues64[iValue].fGP;
     801
     802            pCtx->rbx.u  = s_aValues64[iValue].u64Base;
     803            pCtx->rcx.u  = 0;
     804            pCtx->cr4.u |= X86_CR4_FSGSBASE;
     805            Bs3MemCpy(pExpectCtx, pCtx, sizeof(*pExpectCtx));
     806            Bs3TrapSetJmpAndRestore(pCtx, pTrapFrame);
     807            pExpectCtx->rip.u       = pCtx->rip.u + (!fGP ? pFsGsBaseWorker->offVerifyWorkerUd2 : 0);
     808            pExpectCtx->rcx.u       = !fGP ? s_aValues64[iValue].u64Base : 0;
     809            pExpectCtx->rflags.u32 |= X86_EFL_RF;
     810            if (  !Bs3TestCheckRegCtxEx(&pTrapFrame->Ctx, pExpectCtx, 0 /*cbPcAdjust*/, 0 /*cbSpAdjust*/,
     811                                        0 /*fExtraEfl*/,    "lm64", 0 /*idTestStep*/)
     812                || (fGP && pTrapFrame->bXcpt != X86_XCPT_GP))
     813            {
     814                if (fGP && pTrapFrame->bXcpt != X86_XCPT_GP)
     815                    Bs3TestFailedF("Expected #GP, got %#x (%#x)", pTrapFrame->bXcpt, pTrapFrame->uErrCd);
     816                fPassed = false;
     817                break;
     818            }
     819        }
     820    }
     821    else
     822    {
     823        for (iValue = 0; iValue < RT_ELEMENTS(s_aValues64); iValue++)
     824        {
     825            pCtx->rbx.u  =  s_aValues64[iValue].u64Base;
     826            pCtx->rcx.u  = ~s_aValues64[iValue].u64Base;
     827            pCtx->cr4.u |= X86_CR4_FSGSBASE;
     828            Bs3MemCpy(pExpectCtx, pCtx, sizeof(*pExpectCtx));
     829            Bs3TrapSetJmpAndRestore(pCtx, pTrapFrame);
     830            pExpectCtx->rip.u       = pCtx->rip.u + pFsGsBaseWorker->offVerifyWorkerUd2;
     831            pExpectCtx->rcx.u       = s_aValues64[iValue].u64Base & UINT64_C(0x00000000ffffffff);
     832            pExpectCtx->rflags.u32 |= X86_EFL_RF;
     833            if (!Bs3TestCheckRegCtxEx(&pTrapFrame->Ctx, pExpectCtx, 0 /*cbPcAdjust*/, 0 /*cbSpAdjust*/,
     834                                      0 /*fExtraEfl*/, "lm64", 0 /*idTestStep*/))
     835            {
     836                fPassed = false;
     837                break;
     838            }
     839        }
     840    }
     841
     842    *puIter = iValue;
     843    return fPassed;
     844}
     845
     846
     847static void bs3CpuInstr2_rdfsbase_rdgsbase_Common(uint8_t bMode, bool fSupportsFsGsBase,
     848                                                  BS3CI2FSGSBASE const *paFsGsBaseWorkers, unsigned cFsGsBaseWorkers)
     849{
     850    BS3REGCTX         Ctx;
     851    BS3REGCTX         ExpectCtx;
     852    BS3TRAPFRAME      TrapFrame;
     853    unsigned          iWorker;
     854    unsigned          iIter;
     855
     856    /* Ensure the structures are allocated before we sample the stack pointer. */
     857    Bs3MemSet(&Ctx, 0, sizeof(Ctx));
     858    Bs3MemSet(&ExpectCtx, 0, sizeof(ExpectCtx));
     859    Bs3MemSet(&TrapFrame, 0, sizeof(TrapFrame));
     860
     861    /*
     862     * Create test context.
     863     */
     864    Bs3RegCtxSaveEx(&Ctx, bMode, 512);
     865
     866    for (iWorker = 0; iWorker < cFsGsBaseWorkers; iWorker++)
     867    {
     868        Bs3RegCtxSetRipCsFromCurPtr(&Ctx, paFsGsBaseWorkers[iWorker].pfnWorker);
     869        if (fSupportsFsGsBase)
     870        {
     871            /* CR4.FSGSBASE disabled -> #UD. */
     872            Ctx.cr4.u &= ~X86_CR4_FSGSBASE;
     873            bs3CpuInstr2_fsgsbase_ExpectUD(bMode, &Ctx, &ExpectCtx, &TrapFrame);
     874
     875            /* Read null base address. */
     876            Ctx.rbx.u  = 0xa0000;
     877            Ctx.cr4.u |= X86_CR4_FSGSBASE;
     878            Bs3MemCpy(&ExpectCtx, &Ctx, sizeof(ExpectCtx));
     879            Bs3TrapSetJmpAndRestore(&Ctx, &TrapFrame);
     880            ExpectCtx.rip.u       = Ctx.rip.u + paFsGsBaseWorkers[iWorker].offWorkerUd2;
     881            ExpectCtx.rbx.u       = 0;
     882            ExpectCtx.rflags.u32 |= X86_EFL_RF;
     883            if (!Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &ExpectCtx, 0 /*cbPcAdjust*/, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, "lm64",
     884                                      0 /*idTestStep*/))
     885            {
     886                ASMHalt();
     887            }
     888
     889            /* Write and read back the address. */
     890            if (!bs3CpuInstr2_fsgsbase_VerifyWorker(bMode, &Ctx, &ExpectCtx, &TrapFrame, &paFsGsBaseWorkers[iWorker], &iIter))
     891            {
     892                Bs3TestFailedF("^^^ %s: iWorker=%u iIter=%u\n", paFsGsBaseWorkers[iWorker].pszDesc, iWorker, iIter);
     893                ASMHalt();
     894            }
     895
     896            /* Clean used GPRs. */
     897            Ctx.rbx.u = 0;
     898            Ctx.rcx.u = 0;
     899        }
     900        else
     901        {
     902            /* Unsupported by CPUID -> #UD. */
     903            Bs3TestPrintf("Note! FSGSBASE is not supported by the CPU!\n");
     904            bs3CpuInstr2_fsgsbase_ExpectUD(bMode, &Ctx, &ExpectCtx, &TrapFrame);
     905        }
     906    }
     907}
     908
     909
     910static void bs3CpuInstr2_wrfsbase_wrgsbase_Common(uint8_t bMode, bool fSupportsFsGsBase,
     911                                                  BS3CI2FSGSBASE const *paFsGsBaseWorkers, unsigned cFsGsBaseWorkers)
     912{
     913    BS3REGCTX         Ctx;
     914    BS3REGCTX         ExpectCtx;
     915    BS3TRAPFRAME      TrapFrame;
     916    unsigned          iWorker;
     917    unsigned          iIter;
     918
     919    /* Ensure the structures are allocated before we sample the stack pointer. */
     920    Bs3MemSet(&Ctx, 0, sizeof(Ctx));
     921    Bs3MemSet(&ExpectCtx, 0, sizeof(ExpectCtx));
     922    Bs3MemSet(&TrapFrame, 0, sizeof(TrapFrame));
     923
     924    /*
     925     * Create test context.
     926     */
     927    Bs3RegCtxSaveEx(&Ctx, bMode, 512);
     928
     929    for (iWorker = 0; iWorker < cFsGsBaseWorkers; iWorker++)
     930    {
     931        Bs3RegCtxSetRipCsFromCurPtr(&Ctx, paFsGsBaseWorkers[iWorker].pfnWorker);
     932        if (fSupportsFsGsBase)
     933        {
     934            /* CR4.FSGSBASE disabled -> #UD. */
     935            Ctx.cr4.u &= ~X86_CR4_FSGSBASE;
     936            bs3CpuInstr2_fsgsbase_ExpectUD(bMode, &Ctx, &ExpectCtx, &TrapFrame);
     937
     938            /* Write the base address. */
     939            Ctx.rbx.u  = 0xa0000;
     940            Ctx.cr4.u |= X86_CR4_FSGSBASE;
     941            Bs3MemCpy(&ExpectCtx, &Ctx, sizeof(ExpectCtx));
     942            Bs3TrapSetJmpAndRestore(&Ctx, &TrapFrame);
     943            ExpectCtx.rip.u       = Ctx.rip.u + paFsGsBaseWorkers[iWorker].offWorkerUd2;
     944            ExpectCtx.rflags.u32 |= X86_EFL_RF;
     945            if (!Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &ExpectCtx, 0 /*cbPcAdjust*/, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, "lm64",
     946                                      0 /*idTestStep*/))
     947            {
     948                ASMHalt();
     949            }
     950
     951            /* Write and read back the address. */
     952            if (!bs3CpuInstr2_fsgsbase_VerifyWorker(bMode, &Ctx, &ExpectCtx, &TrapFrame, &paFsGsBaseWorkers[iWorker], &iIter))
     953            {
     954                Bs3TestFailedF("^^^ %s: iWorker=%u iIter=%u\n", paFsGsBaseWorkers[iWorker].pszDesc, iWorker, iIter);
     955                ASMHalt();
     956            }
     957
     958            /* Clean used GPRs. */
     959            Ctx.rbx.u = 0;
     960            Ctx.rcx.u = 0;
     961        }
     962        else
     963        {
     964            /* Unsupported by CPUID -> #UD. */
     965            Bs3TestPrintf("Note! FSGSBASE is not supported by the CPU!\n");
     966            bs3CpuInstr2_fsgsbase_ExpectUD(bMode, &Ctx, &ExpectCtx, &TrapFrame);
     967        }
     968    }
     969}
     970
     971
     972BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_wrfsbase)(uint8_t bMode)
     973{
     974    bool const fSupportFsGsBase = RT_BOOL(ASMCpuId_EBX(7) & X86_CPUID_STEXT_FEATURE_EBX_FSGSBASE);
     975    bs3CpuInstr2_wrfsbase_wrgsbase_Common(bMode, fSupportFsGsBase, s_aWrFsBaseWorkers, RT_ELEMENTS(s_aWrFsBaseWorkers));
     976    return 0;
     977}
     978
     979
     980BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_wrgsbase)(uint8_t bMode)
     981{
     982    bool const fSupportFsGsBase = RT_BOOL(ASMCpuId_EBX(7) & X86_CPUID_STEXT_FEATURE_EBX_FSGSBASE);
     983    bs3CpuInstr2_wrfsbase_wrgsbase_Common(bMode, fSupportFsGsBase, s_aWrGsBaseWorkers, RT_ELEMENTS(s_aWrGsBaseWorkers));
     984    return 0;
     985}
     986
     987
     988BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_rdfsbase)(uint8_t bMode)
     989{
     990    bool const fSupportFsGsBase = RT_BOOL(ASMCpuId_EBX(7) & X86_CPUID_STEXT_FEATURE_EBX_FSGSBASE);
     991    bs3CpuInstr2_rdfsbase_rdgsbase_Common(bMode, fSupportFsGsBase, s_aRdFsBaseWorkers, RT_ELEMENTS(s_aRdFsBaseWorkers));
     992    return 0;
     993}
     994
     995
     996BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_rdgsbase)(uint8_t bMode)
     997{
     998    bool const fSupportFsGsBase = RT_BOOL(ASMCpuId_EBX(7) & X86_CPUID_STEXT_FEATURE_EBX_FSGSBASE);
     999    bs3CpuInstr2_rdfsbase_rdgsbase_Common(bMode, fSupportFsGsBase, s_aRdGsBaseWorkers, RT_ELEMENTS(s_aRdGsBaseWorkers));
     1000    return 0;
     1001}
    6711002# endif /* ARCH_BITS == 64 */
    6721003

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-2-template.mac

    r69222 r70651  
    158158BS3_PROC_END_CMN   bs3CpuInstr2_lock_repnz_cmpxchg16b_rdi_ud2
    159159
     160
     161BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrfsbase_rbx_ud2, BS3_PBC_NEAR
     162        wrfsbase rbx
     163.again:
     164        ud2
     165        jmp     .again
     166AssertCompile(.again - BS3_LAST_LABEL == 5)
     167BS3_PROC_END_CMN   bs3CpuInstr2_wrfsbase_rbx_ud2
     168
     169
     170BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrfsbase_ebx_ud2, BS3_PBC_NEAR
     171        wrfsbase ebx
     172.again:
     173        ud2
     174        jmp     .again
     175AssertCompile(.again - BS3_LAST_LABEL == 4)
     176BS3_PROC_END_CMN   bs3CpuInstr2_wrfsbase_ebx_ud2
     177
     178
     179BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrgsbase_rbx_ud2, BS3_PBC_NEAR
     180        wrgsbase rbx
     181.again:
     182        ud2
     183        jmp     .again
     184AssertCompile(.again - BS3_LAST_LABEL == 5)
     185BS3_PROC_END_CMN   bs3CpuInstr2_wrgsbase_rbx_ud2
     186
     187
     188BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrgsbase_ebx_ud2, BS3_PBC_NEAR
     189        wrgsbase ebx
     190.again:
     191        ud2
     192        jmp     .again
     193AssertCompile(.again - BS3_LAST_LABEL == 4)
     194BS3_PROC_END_CMN   bs3CpuInstr2_wrgsbase_ebx_ud2
     195
     196
     197BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrfsbase_rbx_rdfsbase_rcx_ud2, BS3_PBC_NEAR
     198        wrfsbase rbx
     199        rdfsbase rcx
     200.again:
     201        ud2
     202        jmp     .again
     203AssertCompile(.again - BS3_LAST_LABEL == 10)
     204BS3_PROC_END_CMN   bs3CpuInstr2_wrfsbase_rbx_rdfsbase_rcx_ud2
     205
     206
     207BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrfsbase_ebx_rdfsbase_ecx_ud2, BS3_PBC_NEAR
     208        wrfsbase ebx
     209        rdfsbase ecx
     210.again:
     211        ud2
     212        jmp     .again
     213AssertCompile(.again - BS3_LAST_LABEL == 8)
     214BS3_PROC_END_CMN   bs3CpuInstr2_wrfsbase_ebx_rdfsbase_ecx_ud2
     215
     216
     217BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrgsbase_rbx_rdgsbase_rcx_ud2, BS3_PBC_NEAR
     218        wrgsbase rbx
     219        rdgsbase rcx
     220.again:
     221        ud2
     222        jmp     .again
     223AssertCompile(.again - BS3_LAST_LABEL == 10)
     224BS3_PROC_END_CMN   bs3CpuInstr2_wrgsbase_rbx_rdgsbase_rcx_ud2
     225
     226
     227BS3_PROC_BEGIN_CMN bs3CpuInstr2_wrgsbase_ebx_rdgsbase_ecx_ud2, BS3_PBC_NEAR
     228        wrgsbase ebx
     229        rdgsbase ecx
     230.again:
     231        ud2
     232        jmp     .again
     233AssertCompile(.again - BS3_LAST_LABEL == 8)
     234BS3_PROC_END_CMN   bs3CpuInstr2_wrfgbase_ebx_rdgsbase_ecx_ud2
     235
     236
     237BS3_PROC_BEGIN_CMN bs3CpuInstr2_rdfsbase_rbx_ud2, BS3_PBC_NEAR
     238        rdfsbase rbx
     239.again:
     240        ud2
     241        jmp     .again
     242AssertCompile(.again - BS3_LAST_LABEL == 5)
     243BS3_PROC_END_CMN   bs3CpuInstr2_rdfsbase_rbx_ud2
     244
     245
     246BS3_PROC_BEGIN_CMN bs3CpuInstr2_rdfsbase_ebx_ud2, BS3_PBC_NEAR
     247        rdfsbase ebx
     248.again:
     249        ud2
     250        jmp     .again
     251AssertCompile(.again - BS3_LAST_LABEL == 4)
     252BS3_PROC_END_CMN   bs3CpuInstr2_rdfsbase_ebx_ud2
     253
     254
     255BS3_PROC_BEGIN_CMN bs3CpuInstr2_rdgsbase_rbx_ud2, BS3_PBC_NEAR
     256        rdgsbase rbx
     257.again:
     258        ud2
     259        jmp     .again
     260AssertCompile(.again - BS3_LAST_LABEL == 5)
     261BS3_PROC_END_CMN   bs3CpuInstr2_rdgsbase_rbx_ud2
     262
     263
     264BS3_PROC_BEGIN_CMN bs3CpuInstr2_rdgsbase_ebx_ud2, BS3_PBC_NEAR
     265        rdgsbase ebx
     266.again:
     267        ud2
     268        jmp     .again
     269AssertCompile(.again - BS3_LAST_LABEL == 4)
     270BS3_PROC_END_CMN   bs3CpuInstr2_rdgsbase_ebx_ud2
     271
     272
    160273;; @todo figure out this fudge. sigh.
    161274times (348) db 0cch ; fudge to avoid 'rderr' during boot.

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-2.c

    r69111 r70651  
    4040BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_idiv);
    4141BS3TESTMODE_PROTOTYPES_CMN_64(bs3CpuInstr2_cmpxchg16b);
     42BS3TESTMODE_PROTOTYPES_CMN_64(bs3CpuInstr2_wrfsbase);
     43BS3TESTMODE_PROTOTYPES_CMN_64(bs3CpuInstr2_wrgsbase);
     44BS3TESTMODE_PROTOTYPES_CMN_64(bs3CpuInstr2_rdfsbase);
     45BS3TESTMODE_PROTOTYPES_CMN_64(bs3CpuInstr2_rdgsbase);
    4246
    4347
    … …  
    5256    BS3TESTMODEENTRY_CMN("idiv", bs3CpuInstr2_idiv),
    5357    BS3TESTMODEENTRY_CMN_64("cmpxchg16b", bs3CpuInstr2_cmpxchg16b),
     58    BS3TESTMODEENTRY_CMN_64("wrfsbase", bs3CpuInstr2_wrfsbase),
     59    BS3TESTMODEENTRY_CMN_64("wrgsbase", bs3CpuInstr2_wrgsbase),
     60    BS3TESTMODEENTRY_CMN_64("rdfsbase", bs3CpuInstr2_rdfsbase),
     61    BS3TESTMODEENTRY_CMN_64("rdgsbase", bs3CpuInstr2_rdgsbase),
    5462};
    5563
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