VirtualBox

Changeset 103602 in vbox for trunk/src/VBox/ValidationKit


Ignore:
Timestamp:
Feb 29, 2024 2:10:17 AM (13 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
161960
Message:

ValKit/bs3-cpu-instr-2: Added a bunch of tests for binary arithmetic/logical/bit-test-modify instruction (add, sub, cmp, test, and, ...). (This is a little reminiscent of early tstIEMAImpl, but we're severly space limited here, so don't worry about the data source-file size or compile times.) bugref:10376

Location:
trunk/src/VBox/ValidationKit/bootsectors
Files:
6 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ValidationKit/bootsectors/Makefile.kmk

    r102271 r103602  
    385385        bs3-cpu-instr-2.c \
    386386        bs3-cpu-instr-2-asm.asm \
     387        bs3-cpu-instr-2-data16.c16 \
     388        bs3-cpu-instr-2-data64.c64 \
    387389        bs3kit/bs3-cmn-instantiate-x0.c16 \
    388390        bs3kit/bs3-cmn-instantiate.c32 \
    … …  
    393395                $$(bs3-cpu-instr-2_0_OUTDIR)/bs3kit/bs3-cmn-instantiate.o64 \
    394396                $$(bs3-cpu-instr-2_0_OUTDIR)/bs3-cpu-instr-2-asm.o16
     397
     398 BLDPROGS.amd64 += bs3-cpu-instr-2-gen
     399 bs3-cpu-instr-2-gen_TEMPLATE = VBoxAdvBldProg
     400 bs3-cpu-instr-2-gen_SOURCES  = \
     401        bs3-cpu-instr-2-gen.cpp \
     402        bs3-cpu-instr-2-gen-asm.asm
    395403
    396404 #

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

    r103584 r103602  
    4141#include <iprt/asm.h>
    4242#include <iprt/asm-amd64-x86.h>
     43#include "bs3-cpu-instr-2.h"
     44#include "bs3-cpu-instr-2-data.h"
    4345
    4446
    … …  
    6567*********************************************************************************************************************************/
    6668#ifdef BS3_INSTANTIATING_CMN
     69# if ARCH_BITS == 64
     70#  define BS3CPUINSTR2_BINARY_OP_PROTO64(a_Ins) \
     71        /* 8-bit */ \
     72        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _sil_dil); \
     73        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r9b_r8b); \
     74        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _al_r13b); \
     75        /* 16-bit */ \
     76        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r8w_cx); \
     77        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r15w_r10w); \
     78        /* 32-bit */ \
     79        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _eax_r8d); \
     80        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r9d_ecx); \
     81        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r13d_r14d); \
     82        /* 64-bit */ \
     83        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _rax_rbx); \
     84        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r8_rax); \
     85        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _rdx_r10);
     86
     87# define BS3CPUINSTR2CMNBINTEST_ENTRIES_8_64BIT(a_Ins) \
     88        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _sil_dil), X86_GREG_xSI, X86_GREG_xDI   }, \
     89        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r9b_r8b), X86_GREG_x9,  X86_GREG_x8    }, \
     90        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _al_r13b), X86_GREG_xAX, X86_GREG_x13   },
     91# define BS3CPUINSTR2CMNBINTEST_ENTRIES_16_64BIT(a_Ins) \
     92        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r8w_cx),    X86_GREG_x8,  X86_GREG_xCX }, \
     93        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r15w_r10w), X86_GREG_x15, X86_GREG_x10 },
     94# define BS3CPUINSTR2CMNBINTEST_ENTRIES_32_64BIT(a_Ins) \
     95        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _eax_r8d),   X86_GREG_xAX, X86_GREG_x8  }, \
     96        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r9d_ecx),   X86_GREG_x9,  X86_GREG_xCX }, \
     97        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r13d_r14d), X86_GREG_x13, X86_GREG_x14 },
     98# define BS3CPUINSTR2CMNBINTEST_ENTRIES_64(a_Ins) \
     99        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _rax_rbx), X86_GREG_xAX, X86_GREG_xBX   }, \
     100        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _r8_rax),  X86_GREG_x8,  X86_GREG_xAX   }, \
     101        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _rdx_r10), X86_GREG_xDX, X86_GREG_x10   },
     102# else
     103#  define BS3CPUINSTR2_BINARY_OP_PROTO64(a_Ins)
     104# define BS3CPUINSTR2CMNBINTEST_ENTRIES_8_64BIT(aIns)
     105# define BS3CPUINSTR2CMNBINTEST_ENTRIES_16_64BIT(aIns)
     106# define BS3CPUINSTR2CMNBINTEST_ENTRIES_32_64BIT(aIns)
     107# endif
     108# define BS3CPUINSTR2_BINARY_OP_PROTO(a_Ins) \
     109        BS3CPUINSTR2_BINARY_OP_PROTO64(a_Ins) \
     110        /* 8-bit */ \
     111        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _al_dl); \
     112        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _ch_bh); \
     113        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _dl_ah); \
     114        /* 16-bit */ \
     115        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _di_si); \
     116        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _cx_bp); \
     117        /* 32-bit */ \
     118        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _eax_ebx); \
     119        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _ecx_ebp); \
     120        extern FNBS3FAR BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _edx_edi)
     121
     122# define BS3CPUINSTR2CMNBINTEST_ENTRIES_8(a_Ins) \
     123        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _al_dl), X86_GREG_xAX,    X86_GREG_xDX    }, \
     124        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _ch_bh), X86_GREG_xCX+16, X86_GREG_xBX+16 }, \
     125        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _dl_ah), X86_GREG_xDX,    X86_GREG_xAX+16 }, \
     126        BS3CPUINSTR2CMNBINTEST_ENTRIES_8_64BIT(a_Ins)
     127# define BS3CPUINSTR2CMNBINTEST_ENTRIES_16(a_Ins) \
     128        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _di_si), X86_GREG_xDI, X86_GREG_xSI       }, \
     129        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _cx_bp), X86_GREG_xCX, X86_GREG_xBP       }, \
     130        BS3CPUINSTR2CMNBINTEST_ENTRIES_16_64BIT(a_Ins)
     131# define BS3CPUINSTR2CMNBINTEST_ENTRIES_32(a_Ins) \
     132        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _eax_ebx), X86_GREG_xAX, X86_GREG_xBX     }, \
     133        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _ecx_ebp), X86_GREG_xCX, X86_GREG_xBP     }, \
     134        { BS3_CMN_NM(bs3CpuInstr2_ ## a_Ins ## _edx_edi), X86_GREG_xDX, X86_GREG_xDI     }, \
     135        BS3CPUINSTR2CMNBINTEST_ENTRIES_32_64BIT(a_Ins)
     136
     137
     138BS3CPUINSTR2_BINARY_OP_PROTO(and);
     139BS3CPUINSTR2_BINARY_OP_PROTO(or);
     140BS3CPUINSTR2_BINARY_OP_PROTO(xor);
     141BS3CPUINSTR2_BINARY_OP_PROTO(test);
     142
     143BS3CPUINSTR2_BINARY_OP_PROTO(add);
     144BS3CPUINSTR2_BINARY_OP_PROTO(adc);
     145BS3CPUINSTR2_BINARY_OP_PROTO(sub);
     146BS3CPUINSTR2_BINARY_OP_PROTO(sbb);
     147BS3CPUINSTR2_BINARY_OP_PROTO(cmp);
     148
     149BS3CPUINSTR2_BINARY_OP_PROTO(bt);  /* ignore 8-bit protos */
     150BS3CPUINSTR2_BINARY_OP_PROTO(btc);
     151BS3CPUINSTR2_BINARY_OP_PROTO(btr);
     152BS3CPUINSTR2_BINARY_OP_PROTO(bts);
     153
    67154extern FNBS3FAR     BS3_CMN_NM(bs3CpuInstr2_mul_xBX_ud2);
    68155
    … …  
    309396 */
    310397#ifdef BS3_INSTANTIATING_CMN
     398
     399/*
     400 * Basic binary arithmetic tests.
     401 */
     402
     403typedef struct BS3CPUINSTR2CMNBINTEST
     404{
     405    FPFNBS3FAR  pfnWorker;
     406    uint8_t     idxDstReg;
     407    uint8_t     idxSrcReg;
     408} BS3CPUINSTR2CMNBINTEST;
     409typedef BS3CPUINSTR2CMNBINTEST const BS3_FAR_DATA *PCBS3CPUINSTR2CMNBINTEST;
     410
     411
     412static uint16_t const g_auEflStatusBitsVars[] =
     413{
     414    0,
     415    X86_EFL_STATUS_BITS,
     416    X86_EFL_CF,
     417    X86_EFL_PF,
     418    X86_EFL_AF,
     419    X86_EFL_ZF,
     420    X86_EFL_SF,
     421    X86_EFL_OF,
     422    X86_EFL_PF | X86_EFL_AF,
     423};
     424
     425#define BS3CPUINSTR2_COMMON_BINARY_U(a_cBits, a_UIntType, a_szFmt) \
     426static uint8_t \
     427RT_CONCAT(bs3CpuInstr2_CommonBinaryU,a_cBits)(uint8_t bMode, PCBS3CPUINSTR2CMNBINTEST paTests, unsigned cTests, uint16_t fPassthruEfl, \
     428                                              RT_CONCAT(PCBS3CPUINSTR2BIN,a_cBits) paTestData, unsigned cTestData, bool fCarryIn) \
     429{ \
     430    BS3REGCTX       Ctx; \
     431    BS3REGCTX       CtxExpect; \
     432    BS3TRAPFRAME    TrapFrame; \
     433    unsigned        iTest; \
     434    \
     435    /* Ensure the structures are allocated before we sample the stack pointer. */ \
     436    Bs3MemSet(&Ctx, 0, sizeof(Ctx)); \
     437    Bs3MemSet(&TrapFrame, 0, sizeof(TrapFrame)); \
     438    \
     439    /* \
     440     * Create test context. \
     441     */ \
     442    Bs3RegCtxSaveEx(&Ctx, bMode, 512); \
     443    Ctx.rflags.u32 &= ~X86_EFL_RF; \
     444    Bs3MemCpy(&CtxExpect, &Ctx, sizeof(CtxExpect)); \
     445    if (!BS3_MODE_IS_16BIT_SYS(bMode)) \
     446        CtxExpect.rflags.u32 |= X86_EFL_RF; \
     447    \
     448    /* \
     449     * Each test worker. \
     450     */ \
     451    for (iTest = 0; iTest < cTests; iTest++) \
     452    { \
     453        uint8_t const               cbInstr        = ((uint8_t BS3_FAR *)paTests[iTest].pfnWorker)[-1]; /* the function is prefixed by the length */ \
     454        unsigned const              idxDstReg      = paTests[iTest].idxDstReg; \
     455        unsigned const              idxSrcReg      = paTests[iTest].idxSrcReg; \
     456        BS3REG const                SavedDst       =  (&Ctx.rax)[idxDstReg & 15]; \
     457        BS3REG const                SavedSrc       =  (&Ctx.rax)[idxSrcReg & 15]; \
     458        a_UIntType RT_FAR * const   puCtxDst       = &(&Ctx.rax)[idxDstReg & 15].RT_CONCAT(au,a_cBits)[idxDstReg >> 4]; \
     459        a_UIntType RT_FAR * const   puCtxSrc       = &(&Ctx.rax)[idxSrcReg & 15].RT_CONCAT(au,a_cBits)[idxSrcReg >> 4]; \
     460        a_UIntType RT_FAR * const   puCtxExpectDst = &(&CtxExpect.rax)[idxDstReg & 15].RT_CONCAT(au,a_cBits)[idxDstReg >> 4]; \
     461        a_UIntType RT_FAR * const   puCtxExpectSrc = &(&CtxExpect.rax)[idxSrcReg & 15].RT_CONCAT(au,a_cBits)[idxSrcReg >> 4]; \
     462        unsigned                    iTestData; \
     463        /*Bs3TestPrintf("pfnWorker=%p\n", paTests[iTest].pfnWorker);*/ \
     464        \
     465        Bs3RegCtxSetRipCsFromLnkPtr(&Ctx, paTests[iTest].pfnWorker); \
     466        CtxExpect.rip.u = Ctx.rip.u + cbInstr; \
     467        CtxExpect.cs    = Ctx.cs; \
     468        \
     469        /* \
     470         * Loop over the test data and feed it to the worker. \
     471         */\
     472        for (iTestData = 5; iTestData < cTestData; iTestData++) \
     473        { \
     474            unsigned iRecompiler; \
     475            *puCtxDst             = paTestData[iTestData].uSrc1; \
     476            *puCtxSrc             = paTestData[iTestData].uSrc2; \
     477            *puCtxExpectDst       = paTestData[iTestData].uResult; \
     478            *puCtxExpectSrc       = paTestData[iTestData].uSrc2; \
     479            CtxExpect.rflags.u16 &= ~X86_EFL_STATUS_BITS; \
     480            CtxExpect.rflags.u16 |= paTestData[iTestData].fEflOut & X86_EFL_STATUS_BITS; \
     481            \
     482            /* \
     483             * Do input the eight EFLAGS variations three times, so we're sure to trigger \
     484             * native recompilation of the test worker code. \                            \
     485             */ \
     486            for (iRecompiler = 0; iRecompiler < 2; iRecompiler++) \
     487            { \
     488                unsigned iEflVar = 0; \
     489                for (iEflVar = 0; iEflVar < RT_ELEMENTS(g_auEflStatusBitsVars); iEflVar++) \
     490                { \
     491                    Ctx.rflags.u16 &= ~X86_EFL_STATUS_BITS; \
     492                    if (!fCarryIn) \
     493                        Ctx.rflags.u16 |= g_auEflStatusBitsVars[iEflVar]; \
     494                    else \
     495                        Ctx.rflags.u16 |= (g_auEflStatusBitsVars[iEflVar] & ~X86_EFL_CF) \
     496                                       |  (paTestData[iTestData].fEflOut >> BS3CPUINSTR2BIN_EFL_CARRY_IN_BIT) & X86_EFL_CF; \
     497                    if (fPassthruEfl) \
     498                        CtxExpect.rflags.u16 = (CtxExpect.rflags.u16 & ~fPassthruEfl) | (Ctx.rflags.u16 & fPassthruEfl); \
     499                    \
     500                    Bs3TrapSetJmpAndRestore(&Ctx, &TrapFrame); \
     501                    if (TrapFrame.bXcpt != X86_XCPT_UD) \
     502                    { \
     503                        Bs3TestFailedF("Expected #UD got %#x", TrapFrame.bXcpt); \
     504                        Bs3TrapPrintFrame(&TrapFrame); \
     505                    } \
     506                    else if (Bs3TestCheckRegCtxEx(&TrapFrame.Ctx, &CtxExpect, 0 /*cbPcAdjust*/,  0 /*cbSpAdjust*/, \
     507                                                  0 /*fExtraEfl*/, "mode", (iTest << 8) | (iTestData & 0xff))) \
     508                        continue; \
     509                    /*else { Bs3RegCtxPrint(&Ctx); Bs3TrapPrintFrame(&TrapFrame); }*/ \
     510                    Bs3TestPrintf("iTest=%u iData=%u: uSrc1=%" a_szFmt " uSrc2=%" a_szFmt " %s-> %" a_szFmt "\n", \
     511                                  iTest, iTestData, paTestData[iTestData].uSrc1, paTestData[iTestData].uSrc2, \
     512                                  !fCarryIn ? "" : Ctx.rflags.u16 & X86_EFL_CF ? "CF " : "NC ", \
     513                                  paTestData[iTestData].uResult); \
     514                    /*ASMHalt();*/ \
     515                    iRecompiler = ~0U - 1; \
     516                    break; \
     517                } \
     518            } \
     519        } \
     520        \
     521        (&CtxExpect.rax)[idxDstReg & 15].u = (&Ctx.rax)[idxDstReg & 15].u = SavedDst.u; \
     522        (&CtxExpect.rax)[idxSrcReg & 15].u = (&Ctx.rax)[idxSrcReg & 15].u = SavedSrc.u; \
     523    } \
     524    \
     525    return 0; \
     526}
     527
     528BS3CPUINSTR2_COMMON_BINARY_U(8,  uint8_t,  "RX8")
     529BS3CPUINSTR2_COMMON_BINARY_U(16, uint16_t, "RX16")
     530BS3CPUINSTR2_COMMON_BINARY_U(32, uint32_t, "RX32")
     531#if ARCH_BITS == 64
     532BS3CPUINSTR2_COMMON_BINARY_U(64, uint64_t, "RX64")
     533#endif
     534
     535
     536BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_and)(uint8_t bMode)
     537{
     538    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(and) };
     539    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(and) };
     540    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(and) };
     541#if ARCH_BITS == 64
     542    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(and) };
     543#endif
     544    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     545                                g_aBs3CpuInstr2_and_TestDataU8, g_cBs3CpuInstr2_and_TestDataU8, false /*fCarryIn*/);
     546    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     547                                 g_aBs3CpuInstr2_and_TestDataU16, g_cBs3CpuInstr2_and_TestDataU16, false /*fCarryIn*/);
     548    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     549                                 g_aBs3CpuInstr2_and_TestDataU32, g_cBs3CpuInstr2_and_TestDataU32, false /*fCarryIn*/);
     550#if ARCH_BITS == 64
     551    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     552                                 g_aBs3CpuInstr2_and_TestDataU64, g_cBs3CpuInstr2_and_TestDataU64, false /*fCarryIn*/);
     553#endif
     554    return 0;
     555}
     556
     557
     558BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_or)(uint8_t bMode)
     559{
     560    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(or) };
     561    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(or) };
     562    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(or) };
     563#if ARCH_BITS == 64
     564    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(or) };
     565#endif
     566    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     567                                g_aBs3CpuInstr2_or_TestDataU8, g_cBs3CpuInstr2_or_TestDataU8, false /*fCarryIn*/);
     568    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     569                                 g_aBs3CpuInstr2_or_TestDataU16, g_cBs3CpuInstr2_or_TestDataU16, false /*fCarryIn*/);
     570    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     571                                 g_aBs3CpuInstr2_or_TestDataU32, g_cBs3CpuInstr2_or_TestDataU32, false /*fCarryIn*/);
     572#if ARCH_BITS == 64
     573    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     574                                 g_aBs3CpuInstr2_or_TestDataU64, g_cBs3CpuInstr2_or_TestDataU64, false /*fCarryIn*/);
     575#endif
     576    return 0;
     577}
     578
     579
     580BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_xor)(uint8_t bMode)
     581{
     582    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(xor) };
     583    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(xor) };
     584    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(xor) };
     585#if ARCH_BITS == 64
     586    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(xor) };
     587#endif
     588    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     589                                g_aBs3CpuInstr2_xor_TestDataU8, g_cBs3CpuInstr2_xor_TestDataU8, false /*fCarryIn*/);
     590    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     591                                 g_aBs3CpuInstr2_xor_TestDataU16, g_cBs3CpuInstr2_xor_TestDataU16, false /*fCarryIn*/);
     592    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     593                                 g_aBs3CpuInstr2_xor_TestDataU32, g_cBs3CpuInstr2_xor_TestDataU32, false /*fCarryIn*/);
     594#if ARCH_BITS == 64
     595    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     596                                 g_aBs3CpuInstr2_xor_TestDataU64, g_cBs3CpuInstr2_xor_TestDataU64, false /*fCarryIn*/);
     597#endif
     598    return 0;
     599}
     600
     601
     602BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_test)(uint8_t bMode)
     603{
     604    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(test) };
     605    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(test) };
     606    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(test) };
     607#if ARCH_BITS == 64
     608    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(test) };
     609#endif
     610    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     611                                g_aBs3CpuInstr2_test_TestDataU8, g_cBs3CpuInstr2_test_TestDataU8, false /*fCarryIn*/);
     612    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     613                                 g_aBs3CpuInstr2_test_TestDataU16, g_cBs3CpuInstr2_test_TestDataU16, false /*fCarryIn*/);
     614    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     615                                 g_aBs3CpuInstr2_test_TestDataU32, g_cBs3CpuInstr2_test_TestDataU32, false /*fCarryIn*/);
     616#if ARCH_BITS == 64
     617    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     618                                 g_aBs3CpuInstr2_test_TestDataU64, g_cBs3CpuInstr2_test_TestDataU64, false /*fCarryIn*/);
     619#endif
     620    return 0;
     621}
     622
     623
     624BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_add)(uint8_t bMode)
     625{
     626    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(add) };
     627    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(add) };
     628    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(add) };
     629#if ARCH_BITS == 64
     630    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(add) };
     631#endif
     632    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     633                                g_aBs3CpuInstr2_add_TestDataU8, g_cBs3CpuInstr2_add_TestDataU8, false /*fCarryIn*/);
     634    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     635                                 g_aBs3CpuInstr2_add_TestDataU16, g_cBs3CpuInstr2_add_TestDataU16, false /*fCarryIn*/);
     636    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     637                                 g_aBs3CpuInstr2_add_TestDataU32, g_cBs3CpuInstr2_add_TestDataU32, false /*fCarryIn*/);
     638#if ARCH_BITS == 64
     639    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     640                                 g_aBs3CpuInstr2_add_TestDataU64, g_cBs3CpuInstr2_add_TestDataU64, false /*fCarryIn*/);
     641#endif
     642    return 0;
     643}
     644
     645
     646BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_adc)(uint8_t bMode)
     647{
     648    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(adc) };
     649    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(adc) };
     650    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(adc) };
     651#if ARCH_BITS == 64
     652    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(adc) };
     653#endif
     654    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     655                                g_aBs3CpuInstr2_adc_TestDataU8, g_cBs3CpuInstr2_adc_TestDataU8, true /*fCarryIn*/);
     656    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     657                                 g_aBs3CpuInstr2_adc_TestDataU16, g_cBs3CpuInstr2_adc_TestDataU16, true /*fCarryIn*/);
     658    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     659                                 g_aBs3CpuInstr2_adc_TestDataU32, g_cBs3CpuInstr2_adc_TestDataU32, true /*fCarryIn*/);
     660#if ARCH_BITS == 64
     661    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     662                                 g_aBs3CpuInstr2_adc_TestDataU64, g_cBs3CpuInstr2_adc_TestDataU64, true /*fCarryIn*/);
     663#endif
     664    return 0;
     665}
     666
     667
     668BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_sub)(uint8_t bMode)
     669{
     670    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(sub) };
     671    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(sub) };
     672    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(sub) };
     673#if ARCH_BITS == 64
     674    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(sub) };
     675#endif
     676    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     677                                g_aBs3CpuInstr2_sub_TestDataU8, g_cBs3CpuInstr2_sub_TestDataU8, false /*fCarryIn*/);
     678    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     679                                 g_aBs3CpuInstr2_sub_TestDataU16, g_cBs3CpuInstr2_sub_TestDataU16, false /*fCarryIn*/);
     680    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     681                                 g_aBs3CpuInstr2_sub_TestDataU32, g_cBs3CpuInstr2_sub_TestDataU32, false /*fCarryIn*/);
     682#if ARCH_BITS == 64
     683    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     684                                 g_aBs3CpuInstr2_sub_TestDataU64, g_cBs3CpuInstr2_sub_TestDataU64, false /*fCarryIn*/);
     685#endif
     686    return 0;
     687}
     688
     689
     690BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_sbb)(uint8_t bMode)
     691{
     692    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(sbb) };
     693    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(sbb) };
     694    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(sbb) };
     695#if ARCH_BITS == 64
     696    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(sbb) };
     697#endif
     698    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     699                                g_aBs3CpuInstr2_sbb_TestDataU8, g_cBs3CpuInstr2_sbb_TestDataU8, true /*fCarryIn*/);
     700    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     701                                 g_aBs3CpuInstr2_sbb_TestDataU16, g_cBs3CpuInstr2_sbb_TestDataU16, true /*fCarryIn*/);
     702    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     703                                 g_aBs3CpuInstr2_sbb_TestDataU32, g_cBs3CpuInstr2_sbb_TestDataU32, true /*fCarryIn*/);
     704#if ARCH_BITS == 64
     705    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     706                                 g_aBs3CpuInstr2_sbb_TestDataU64, g_cBs3CpuInstr2_sbb_TestDataU64, true /*fCarryIn*/);
     707#endif
     708    return 0;
     709}
     710
     711
     712BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_cmp)(uint8_t bMode)
     713{
     714    static const BS3CPUINSTR2CMNBINTEST s_aTests8[]  = { BS3CPUINSTR2CMNBINTEST_ENTRIES_8(cmp) };
     715    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(cmp) };
     716    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(cmp) };
     717#if ARCH_BITS == 64
     718    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(cmp) };
     719#endif
     720    bs3CpuInstr2_CommonBinaryU8(bMode, s_aTests8, RT_ELEMENTS(s_aTests8), 0 /*fPassthruEfl*/,
     721                                g_aBs3CpuInstr2_cmp_TestDataU8, g_cBs3CpuInstr2_cmp_TestDataU8, false /*fCarryIn*/);
     722    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), 0 /*fPassthruEfl*/,
     723                                 g_aBs3CpuInstr2_cmp_TestDataU16, g_cBs3CpuInstr2_cmp_TestDataU16, false /*fCarryIn*/);
     724    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), 0 /*fPassthruEfl*/,
     725                                 g_aBs3CpuInstr2_cmp_TestDataU32, g_cBs3CpuInstr2_cmp_TestDataU32, false /*fCarryIn*/);
     726#if ARCH_BITS == 64
     727    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), 0 /*fPassthruEfl*/,
     728                                 g_aBs3CpuInstr2_cmp_TestDataU64, g_cBs3CpuInstr2_cmp_TestDataU64, false /*fCarryIn*/);
     729#endif
     730    return 0;
     731}
     732
     733
     734#define BS3CPUINSTR2_BTx_PASSTHRU_EFL (X86_EFL_ZF | X86_EFL_PF | X86_EFL_AF | X86_EFL_SF | X86_EFL_OF)
     735
     736BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_bt)(uint8_t bMode)
     737{
     738    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(bt) };
     739    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(bt) };
     740#if ARCH_BITS == 64
     741    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(bt) };
     742#endif
     743    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     744                                 g_aBs3CpuInstr2_bt_TestDataU16, g_cBs3CpuInstr2_bt_TestDataU16, false /*fCarryIn*/);
     745    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     746                                 g_aBs3CpuInstr2_bt_TestDataU32, g_cBs3CpuInstr2_bt_TestDataU32, false /*fCarryIn*/);
     747#if ARCH_BITS == 64
     748    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     749                                 g_aBs3CpuInstr2_bt_TestDataU64, g_cBs3CpuInstr2_bt_TestDataU64, false /*fCarryIn*/);
     750#endif
     751    return 0;
     752}
     753
     754
     755BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_btc)(uint8_t bMode)
     756{
     757    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(btc) };
     758    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(btc) };
     759#if ARCH_BITS == 64
     760    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(btc) };
     761#endif
     762    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     763                                 g_aBs3CpuInstr2_btc_TestDataU16, g_cBs3CpuInstr2_btc_TestDataU16, false /*fCarryIn*/);
     764    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     765                                 g_aBs3CpuInstr2_btc_TestDataU32, g_cBs3CpuInstr2_btc_TestDataU32, false /*fCarryIn*/);
     766#if ARCH_BITS == 64
     767    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     768                                 g_aBs3CpuInstr2_btc_TestDataU64, g_cBs3CpuInstr2_btc_TestDataU64, false /*fCarryIn*/);
     769#endif
     770    return 0;
     771}
     772
     773
     774BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_btr)(uint8_t bMode)
     775{
     776    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(btr) };
     777    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(btr) };
     778#if ARCH_BITS == 64
     779    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(btr) };
     780#endif
     781    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     782                                 g_aBs3CpuInstr2_btr_TestDataU16, g_cBs3CpuInstr2_btr_TestDataU16, false /*fCarryIn*/);
     783    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     784                                 g_aBs3CpuInstr2_btr_TestDataU32, g_cBs3CpuInstr2_btr_TestDataU32, false /*fCarryIn*/);
     785#if ARCH_BITS == 64
     786    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     787                                 g_aBs3CpuInstr2_btr_TestDataU64, g_cBs3CpuInstr2_btr_TestDataU64, false /*fCarryIn*/);
     788#endif
     789    return 0;
     790}
     791
     792
     793BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_bts)(uint8_t bMode)
     794{
     795    static const BS3CPUINSTR2CMNBINTEST s_aTests16[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_16(bts) };
     796    static const BS3CPUINSTR2CMNBINTEST s_aTests32[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_32(bts) };
     797#if ARCH_BITS == 64
     798    static const BS3CPUINSTR2CMNBINTEST s_aTests64[] = { BS3CPUINSTR2CMNBINTEST_ENTRIES_64(bts) };
     799#endif
     800    bs3CpuInstr2_CommonBinaryU16(bMode, s_aTests16, RT_ELEMENTS(s_aTests16), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     801                                 g_aBs3CpuInstr2_bts_TestDataU16, g_cBs3CpuInstr2_bts_TestDataU16, false /*fCarryIn*/);
     802    bs3CpuInstr2_CommonBinaryU32(bMode, s_aTests32, RT_ELEMENTS(s_aTests32), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     803                                 g_aBs3CpuInstr2_bts_TestDataU32, g_cBs3CpuInstr2_bts_TestDataU32, false /*fCarryIn*/);
     804#if ARCH_BITS == 64
     805    bs3CpuInstr2_CommonBinaryU64(bMode, s_aTests64, RT_ELEMENTS(s_aTests64), BS3CPUINSTR2_BTx_PASSTHRU_EFL,
     806                                 g_aBs3CpuInstr2_bts_TestDataU64, g_cBs3CpuInstr2_bts_TestDataU64, false /*fCarryIn*/);
     807#endif
     808    return 0;
     809}
     810
     811
     812
     813/*
     814 * Multiplication
     815 */
    311816
    312817BS3_DECL_FAR(uint8_t) BS3_CMN_NM(bs3CpuInstr2_mul)(uint8_t bMode)
    … …  
    30743579            for (iValue = 0; iValue < cValues; iValue++)
    30753580            {
    3076                 uint64_t const uExpectRax = fOkay ? paValues[iValue].uDstOut : paValues[iValue].uDstIn;
     3581                //uint64_t const uExpectRax = fOkay ? paValues[iValue].uDstOut : paValues[iValue].uDstIn;
    30773582                uint64_t       uMem, uMemExpect;
    30783583

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

    r103584 r103602  
    5151; ASSUMES the length is between the start of the function and the .again label.
    5252;
    53 %ifndef BS3CPUINSTR2_PROC_BEGIN_CMN_DEFINED
     53%ifndef  BS3CPUINSTR2_PROC_BEGIN_CMN_DEFINED
    5454 %define BS3CPUINSTR2_PROC_BEGIN_CMN_DEFINED
    55  %macro BS3CPUINSTR2_PROC_BEGIN_CMN 1
     55 %macro  BS3CPUINSTR2_PROC_BEGIN_CMN 1
    5656        align   8, db 0cch
    5757        db      BS3_CMN_NM(%1).again - BS3_CMN_NM(%1)
    … …  
    6161
    6262
     63;;
     64; For defining simple instruction test.
     65%ifndef  BS3CPUINSTR2_EMIT_INSTR_UD2_DEFINED
     66 %define BS3CPUINSTR2_EMIT_INSTR_UD2_DEFINED
     67 %macro  BS3CPUINSTR2_EMIT_INSTR_UD2 2+
     68BS3CPUINSTR2_PROC_BEGIN_CMN %1
     69        %2
     70.again:
     71        ud2
     72        jmp     .again
     73BS3_PROC_END_CMN            %1
     74 %endmacro
     75%endif
     76
     77%ifndef  BS3CPUINSTR2_BINARY_OP_DEFINED
     78 %define BS3CPUINSTR2_BINARY_OP_DEFINED
     79 %macro  BS3CPUINSTR2_BINARY_OP 2
     80  %if %2 != 0
     81        ; 8-bit
     82        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _al  %+ _dl,     %1 al, dl
     83        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _ch  %+ _bh,     %1 ch, bh
     84        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _dl  %+ _ah,     %1 dl, ah
     85   %ifdef TMPL_64BIT
     86        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _sil  %+ _dil,   %1 sil, dil
     87        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _r9b  %+ _r8b,   %1 r9b, r8b
     88        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _al   %+ _r13b,  %1 al, r13b
     89   %endif
     90  %endif
     91        ; 16-bit
     92        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _di  %+ _si,     %1 di, si
     93        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _cx  %+ _bp,     %1 cx, bp
     94  %ifdef TMPL_64BIT
     95        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _r8w  %+ _cx,    %1 r8w, cx
     96        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _r15w %+ _r10w,  %1 r15w, r10w
     97  %endif
     98        ; 32-bit
     99        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _eax %+ _ebx,    %1 eax, ebx
     100        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _ecx %+ _ebp,    %1 ecx, ebp
     101        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _edx %+ _edi,    %1 edx, edi
     102  %ifdef TMPL_64BIT
     103        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _eax %+ _r8d,    %1 eax, r8d
     104        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _r9d %+ _ecx,    %1 r9d, ecx
     105        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _r13d %+ _r14d,  %1 r13d, r14d
     106  %endif
     107        ; 64-bit
     108  %ifdef TMPL_64BIT
     109        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _rax %+ _rbx,    %1 rax, rbx
     110        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _r8  %+ _rax,    %1 r8, rax
     111        BS3CPUINSTR2_EMIT_INSTR_UD2 bs3CpuInstr2_ %+ %1 %+ _rdx %+ _r10,    %1 rdx, r10
     112  %endif
     113 %endmacro
     114%endif
     115
     116
    63117;*********************************************************************************************************************************
    64118;*  External Symbols                                                                                                             *
    … …  
    72126;
    73127%ifdef BS3_INSTANTIATING_CMN
     128
     129BS3CPUINSTR2_BINARY_OP and,  1
     130BS3CPUINSTR2_BINARY_OP or,   1
     131BS3CPUINSTR2_BINARY_OP xor,  1
     132BS3CPUINSTR2_BINARY_OP test, 1
     133
     134BS3CPUINSTR2_BINARY_OP add,  1
     135BS3CPUINSTR2_BINARY_OP adc,  1
     136BS3CPUINSTR2_BINARY_OP sub,  1
     137BS3CPUINSTR2_BINARY_OP sbb,  1
     138BS3CPUINSTR2_BINARY_OP cmp,  1
     139
     140BS3CPUINSTR2_BINARY_OP bt,   0
     141BS3CPUINSTR2_BINARY_OP btc,  0
     142BS3CPUINSTR2_BINARY_OP btr,  0
     143BS3CPUINSTR2_BINARY_OP bts,  0
     144
    74145
    75146BS3_PROC_BEGIN_CMN bs3CpuInstr2_mul_xBX_ud2, BS3_PBC_NEAR

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

    r103584 r103602  
    4545*   Internal Functions                                                                                                           *
    4646*********************************************************************************************************************************/
     47BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_and);
     48BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_or);
     49BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_xor);
     50BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_test);
     51BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_add);
     52BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_adc);
     53BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_sub);
     54BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_sbb);
     55BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_cmp);
     56BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_bt);
     57BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_btc);
     58BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_btr);
     59BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_bts);
    4760BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_mul);
    4861BS3TESTMODE_PROTOTYPES_CMN(bs3CpuInstr2_imul);
    … …  
    8194static const BS3TESTMODEENTRY g_aModeTests[] =
    8295{
     96#if 1
     97    BS3TESTMODEENTRY_CMN("and", bs3CpuInstr2_and),
     98    BS3TESTMODEENTRY_CMN("or", bs3CpuInstr2_or),
     99    BS3TESTMODEENTRY_CMN("xor", bs3CpuInstr2_xor),
     100    BS3TESTMODEENTRY_CMN("test", bs3CpuInstr2_test),
     101#endif
     102#if 1
     103    BS3TESTMODEENTRY_CMN("add", bs3CpuInstr2_add),
     104    BS3TESTMODEENTRY_CMN("adc", bs3CpuInstr2_adc),
     105    BS3TESTMODEENTRY_CMN("sub", bs3CpuInstr2_sub),
     106    BS3TESTMODEENTRY_CMN("sbb", bs3CpuInstr2_sbb),
     107    BS3TESTMODEENTRY_CMN("cmp", bs3CpuInstr2_cmp),
     108#endif
     109#if 1
     110    BS3TESTMODEENTRY_CMN("bt", bs3CpuInstr2_bt),
     111    BS3TESTMODEENTRY_CMN("btc", bs3CpuInstr2_btc),
     112    BS3TESTMODEENTRY_CMN("btr", bs3CpuInstr2_btr),
     113    BS3TESTMODEENTRY_CMN("bts", bs3CpuInstr2_bts),
     114#endif
    83115#if 1
    84116    BS3TESTMODEENTRY_CMN("mul", bs3CpuInstr2_mul),

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3kit.h

    r103262 r103602  
    26432643    /** 32-bit view. */
    26442644    uint32_t    au32[2];
     2645    /** 64-bit view. */
     2646    uint64_t    au64[1];
    26452647    /** Unsigned integer, depending on compiler context.
    26462648     * This generally follows ARCH_BITS. */
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