VirtualBox

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


Ignore:
Timestamp:
Oct 28, 2024 3:47:44 AM (3 months ago)
Author:
vboxsync
Message:

ValidationKit/bootsectors: Implement SISD FP testcases for cvtsi2ss; bugref:10658; jiraref:VBP-1206

Bs3ExtCtxSetReg:

  • fix bs3CpuInstrXGetRegisterName() for arbitrary FSxReg
  • use RTUINT256U in place of ad hoc casts
  • use a mostly-static context struct for Bs3ExtCtxSetReg() args
  • fix Bs3ExtCtxSetReg() on 64-bit GPRs in non-64-bit execution modes
  • add a debug flag to print Bs3ExtCtxSetReg() actions

ValKit bs3-cpu-instr-4 test worker:

  • add ability to mark an instruction test as always faulting

ValKit bs3-cpu-instr-4 test setup:

  • fix some macros needing more parentheses
  • fix integer macros & move them where they belong

ValKit:

  • implement cvtsi2ss tests
  • improve test-function emitter comments
Location:
trunk/src/VBox/ValidationKit/bootsectors
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-3.c32

    r106620 r106733  
    1489414894    PBS3EXTCTX                  pExtCtxOut;
    1489514895    PBS3EXTCTX                  pExtCtx = bs3CpuInstr3AllocExtCtxs(&pExtCtxOut);
     14896    BS3SETREGCTX                pSetRegCtx;
     14897
    1489614898    if (!pExtCtx)
    1489714899        return 0;
     14900
     14901    pSetRegCtx.pExtCtx = pExtCtx;
     14902    pSetRegCtx.pCtx = &Ctx;
     14903    pSetRegCtx.fZeroYMMHi = false;
     14904    pSetRegCtx.bMode = bMode;
    1489814905
    1489914906    /* Ensure the structures are allocated before we sample the stack pointer. */
    … …  
    1497014977                             */
    1497114978                            /* initial value of destination register */
    14972                             Bs3ExtCtxSetReg(pExtCtx, paTests[iTest].iMmDst, (void *)&paValues[iVal].uDstInit, SET_YmmHi);
     14979                            Bs3ExtCtxSetReg(&pSetRegCtx, paTests[iTest].iMmDst, &paValues[iVal].uDstInit);
    1497314980
    1497414981                            /* offsets register */
    14975                             Bs3ExtCtxSetReg(pExtCtx, paTests[iTest].iMmOff, (void *)&paValues[iVal].uOffsets, SET_YmmHi);
     14982                            Bs3ExtCtxSetReg(&pSetRegCtx, paTests[iTest].iMmOff, &paValues[iVal].uOffsets);
    1497614983
    1497714984                            /* initial value of mask register */
    14978                             Bs3ExtCtxSetReg(pExtCtx, paTests[iTest].iMmMsk, (void *)&paValues[iVal].uMask, SET_YmmHi);
     14985                            Bs3ExtCtxSetReg(&pSetRegCtx, paTests[iTest].iMmMsk, &paValues[iVal].uMask);
    1497914986
    1498014987                            /* Memory pointer. */
    1498114988                            puMemOp = fPf ? (PRTUINT256U)&pbBuf[X86_PAGE_SIZE * 2 + 256] : (PRTUINT256U)&pbBuf[X86_PAGE_SIZE];
    1498214989                            puMemOp = (PRTUINT256U)(((uint8_t BS3_FAR *)puMemOp) - paTests[iTest].cMemOpOffset);
    14983                             Bs3ExtCtxSetReg(pExtCtx, BS3_FSxREG(paTests[iTest].iGpMem), (void *)puMemOp, (void *)&Ctx);
     14990                            Bs3ExtCtxSetReg(&pSetRegCtx, BS3_FSxREG(paTests[iTest].iGpMem), (void *)puMemOp);
    1498414991
    1498514992                            /*
    … …  
    1500115008                            {
    1500215009                                RTUINT256U zip = RTUINT256_INIT_C(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000);
    15003                                 Bs3ExtCtxSetReg(pExtCtx, paTests[iTest].iMmDst, (void *)&paValues[iVal].uDstOut, SET_YmmHi);
    15004                                 Bs3ExtCtxSetReg(pExtCtx, paTests[iTest].iMmMsk, (void *)&zip, SET_YmmHi);
     15010                                Bs3ExtCtxSetReg(&pSetRegCtx, paTests[iTest].iMmDst, &paValues[iVal].uDstOut);
     15011                                Bs3ExtCtxSetReg(&pSetRegCtx, paTests[iTest].iMmMsk, &zip);
    1500515012                            }
    1500615013
    1500715014                            if (bXcptExpect == X86_XCPT_PF)
    15008                                 Bs3ExtCtxSetReg(pExtCtx, paTests[iTest].iMmMsk, (void *)&paValues[iVal].uMaskPf, SET_YmmHi);
     15015                                Bs3ExtCtxSetReg(&pSetRegCtx, paTests[iTest].iMmMsk, &paValues[iVal].uMaskPf);
    1500915016
    1501015017#if defined(DEBUG_aeichner) /** @todo Necessary kludge on a i7-1068NG7. */

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

    r106721 r106733  
    874874;; cvtpi2ps
    875875;
    876 ; SSE-128, int32 -> fp32 (packed:2; from MMX register)
     876; SSE-128, fp32 <- int32 (packed:2; from MMX register)
    877877EMIT_INSTR_PLUS_ICEBP       cvtpi2ps, XMM1, MM1
    878878EMIT_INSTR_PLUS_ICEBP       cvtpi2ps, XMM1, FSxBX
    … …  
    883883;; cvtps2pi
    884884;
    885 ; SSE-128, fp32 -> int32 (packed:2; to MMX register)
     885; SSE-128, int32 <- fp32 (packed:2; to MMX register)
    886886EMIT_INSTR_PLUS_ICEBP       cvtps2pi, MM1, XMM1
    887887EMIT_INSTR_PLUS_ICEBP       cvtps2pi, MM1, FSxBX
    … …  
    891891;; cvttps2pi
    892892;
    893 ; SSE-128, fp32 -> int32 (packed:2; truncated; to MMX register)
     893; SSE-128, int32 <- fp32 (packed:2; truncated; to MMX register)
    894894EMIT_INSTR_PLUS_ICEBP       cvttps2pi, MM1, XMM1
    895895EMIT_INSTR_PLUS_ICEBP       cvttps2pi, MM1, FSxBX
    … …  
    899899;; cvtsi2ss
    900900;
    901 ; SSE-128, int32 -> fp32 (single)
     901; SSE-128, fp32 <- int32 (single)
    902902EMIT_INSTR_PLUS_ICEBP       cvtsi2ss,  XMM1, EAX
    903903EMIT_INSTR_PLUS_ICEBP       cvtsi2ss,  XMM1, FSxBX_D
    904904EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2ss,  XMM8, R8D
    905905EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2ss,  XMM8, FSxBX_D
    906 ; SSE-128, int64 -> fp32 (single)
     906; SSE-128, fp32 <- int64 (single)
    907907EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2ss,  XMM1, RAX
    908908EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2ss,  XMM1, FSxBX_Q
    909909EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2ss,  XMM8, R8
    910910EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2ss,  XMM8, FSxBX_Q
    911 ; AVX-128, int32 -> fp32 (single)
     911; AVX-128, fp32 <- int32 (single)
    912912EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM2, EAX
    913913EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM2, FSxBX_D
    914914EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM9, R8D
    915915EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM9, FSxBX_D
    916 ; AVX-128, int64 -> fp32 (single)
     916; AVX-128, fp32 <- int64 (single)
    917917EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM2, RAX       ;; @todo this assembles in 16/32 mode; SDM says VEX.W1 ignored in non-64 bit
    918918EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM2, FSxBX_Q   ;; @todo this assembles in 16/32 mode; SDM says VEX.W1 ignored in non-64 bit
    919919EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM9, R8
    920920EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM9, FSxBX_Q
    921 ; AVX-128, int32 -> fp32, same-reg (single)
     921; AVX-128, fp32 <- int32, same-reg (single)
    922922EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM1, EAX
    923923EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM1, FSxBX_D
    924924EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM8, R8D
    925925EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM8, FSxBX_D
    926 ; AVX-128, int64 -> fp32, same-reg (single)
     926; AVX-128, fp32 <- int64, same-reg (single)
    927927EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM1, RAX       ;; @todo this assembles in 16/32 mode, but should it...?
    928928EMIT_INSTR_PLUS_ICEBP       vcvtsi2ss, XMM1, XMM1, FSxBX_Q   ;; @todo this assembles in 16/32 mode, but should it...?
    … …  
    930930EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2ss, XMM8, XMM8, FSxBX_Q
    931931; @todo test with VEX.L=1 (as if asking for YMM)?  SDM says 'unpredictable behavior'...
    932 ; @todo same-reg int32 -> fp32 (SDM says W1 ignored in 32-bit modes) (see above)
     932; @todo same-reg fp32 <- int32 (SDM says W1 ignored in 32-bit modes) (see above)
    933933
    934934;
    935935;; cvtss2si
    936936;
    937 ; SSE-128, fp32 -> int32
     937; SSE-128, int32 <- fp32
    938938EMIT_INSTR_PLUS_ICEBP       cvtss2si,  EAX, XMM1
    939939EMIT_INSTR_PLUS_ICEBP       cvtss2si,  EAX, FSxBX
    940940EMIT_INSTR_PLUS_ICEBP_C64   cvtss2si,  R8D, XMM8
    941941EMIT_INSTR_PLUS_ICEBP_C64   cvtss2si,  R8D, FSxBX
    942 ; SSE-128, fp32 -> int64
     942; SSE-128, int64 <- fp32
    943943EMIT_INSTR_PLUS_ICEBP_C64   cvtss2si,  RAX, XMM1
    944944EMIT_INSTR_PLUS_ICEBP_C64   cvtss2si,  RAX, FSxBX
    945945EMIT_INSTR_PLUS_ICEBP_C64   cvtss2si,  R8,  XMM8
    946946EMIT_INSTR_PLUS_ICEBP_C64   cvtss2si,  R8,  FSxBX
    947 ; AVX-128, fp32 -> int32
     947; AVX-128, int32 <- fp32
    948948EMIT_INSTR_PLUS_ICEBP       vcvtss2si, EAX, XMM1
    949949EMIT_INSTR_PLUS_ICEBP       vcvtss2si, EAX, FSxBX
    950950EMIT_INSTR_PLUS_ICEBP_C64   vcvtss2si, R8D, XMM8
    951951EMIT_INSTR_PLUS_ICEBP_C64   vcvtss2si, R8D, FSxBX
    952 ; AVX-128, fp32 -> int64
     952; AVX-128, int64 <- fp32
    953953EMIT_INSTR_PLUS_ICEBP       vcvtss2si, RAX, XMM1
    954954EMIT_INSTR_PLUS_ICEBP       vcvtss2si, RAX, FSxBX
    … …  
    961961;; cvttss2si
    962962;
    963 ; SSE-128, fp32 -> int32 (single; truncated)
     963; SSE-128, int32 <- fp32 (single; truncated)
    964964EMIT_INSTR_PLUS_ICEBP       cvttss2si,  EAX,  XMM1
    965965EMIT_INSTR_PLUS_ICEBP       cvttss2si,  EAX,  FSxBX
    966966EMIT_INSTR_PLUS_ICEBP_C64   cvttss2si,  R8D,  XMM8
    967967EMIT_INSTR_PLUS_ICEBP_C64   cvttss2si,  R8D,  FSxBX
    968 ; SSE-128, fp32 -> int64 (single; truncated)
     968; SSE-128, int64 <- fp32 (single; truncated)
    969969EMIT_INSTR_PLUS_ICEBP_C64   cvttss2si,  RAX,  XMM1
    970970EMIT_INSTR_PLUS_ICEBP_C64   cvttss2si,  RAX,  FSxBX
    971971EMIT_INSTR_PLUS_ICEBP_C64   cvttss2si,  R8,   XMM8
    972972EMIT_INSTR_PLUS_ICEBP_C64   cvttss2si,  R8,   FSxBX
    973 ; AVX-128, fp32 -> int32 (single; truncated)
     973; AVX-128, int32 <- fp32 (single; truncated)
    974974EMIT_INSTR_PLUS_ICEBP       vcvttss2si, EAX,  XMM1
    975975EMIT_INSTR_PLUS_ICEBP       vcvttss2si, EAX,  FSxBX
    976976EMIT_INSTR_PLUS_ICEBP_C64   vcvttss2si, R8D,  XMM8
    977977EMIT_INSTR_PLUS_ICEBP_C64   vcvttss2si, R8D,  FSxBX
    978 ; AVX-128, fp32 -> int64 (single; truncated)
     978; AVX-128, int64 <- fp32 (single; truncated)
    979979EMIT_INSTR_PLUS_ICEBP       vcvttss2si, RAX,  XMM1
    980980EMIT_INSTR_PLUS_ICEBP       vcvttss2si, RAX,  FSxBX
    … …  
    987987;; cvtpi2pd
    988988;
    989 ; SSE-128, int32 -> fp64 (packed:2; from MMX register)
     989; SSE-128, fp64 <- int32 (packed:2; from MMX register)
    990990EMIT_INSTR_PLUS_ICEBP       cvtpi2pd, XMM1, MM1
    991991EMIT_INSTR_PLUS_ICEBP       cvtpi2pd, XMM1, FSxBX
    … …  
    997997;; cvtpd2pi
    998998;
    999 ; SSE-128, fp64 -> int32 (packed:2; to MMX register)
     999; SSE-128, int32 <- fp64 (packed:2; to MMX register)
    10001000EMIT_INSTR_PLUS_ICEBP       cvtpd2pi, MM1, XMM1
    10011001EMIT_INSTR_PLUS_ICEBP       cvtpd2pi, MM1, FSxBX
    … …  
    10061006;; cvttpd2pi
    10071007;
    1008 ; SSE-128, fp64 -> int32 (packed:2; truncated; to MMX register)
     1008; SSE-128, int32 <- fp64 (packed:2; truncated; to MMX register)
    10091009EMIT_INSTR_PLUS_ICEBP       cvttpd2pi, MM1, XMM1
    10101010EMIT_INSTR_PLUS_ICEBP       cvttpd2pi, MM1, FSxBX
    … …  
    10151015;; cvtsi2sd
    10161016;
    1017 ; SSE-128, int32 -> fp64 (single)
     1017; SSE-128, fp64 <- int32 (single)
    10181018EMIT_INSTR_PLUS_ICEBP       cvtsi2sd,  XMM1, EAX
    10191019EMIT_INSTR_PLUS_ICEBP       cvtsi2sd,  XMM1, FSxBX_D
    10201020EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2sd,  XMM8, R8D
    10211021EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2sd,  XMM8, FSxBX_D
    1022 ; SSE-128, int64 -> fp64 (single)
     1022; SSE-128, fp64 <- int64 (single)
    10231023EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2sd,  XMM1, RAX
    10241024EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2sd,  XMM1, FSxBX_Q
    10251025EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2sd,  XMM8, R8
    10261026EMIT_INSTR_PLUS_ICEBP_C64   cvtsi2sd,  XMM8, FSxBX_Q
    1027 ; AVX-128, int32 -> fp64 (single)
     1027; AVX-128, fp64 <- int32 (single)
    10281028EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM2, EAX
    10291029EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM2, FSxBX_D
    10301030EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2sd, XMM8, XMM9, EAX
    10311031EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2sd, XMM8, XMM9, FSxBX_D
    1032 ; AVX-128, int64 -> fp64 (single)
     1032; AVX-128, fp64 <- int64 (single)
    10331033EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM2, RAX
    10341034EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM2, FSxBX_Q
    10351035EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2sd, XMM8, XMM9, RAX
    10361036EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2sd, XMM8, XMM9, FSxBX_Q
    1037 ; AVX-128, int32 -> fp64, same-reg (single)
     1037; AVX-128, fp64 <- int32, same-reg (single)
    10381038EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM1, EAX
    10391039EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM1, FSxBX_D
    10401040EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2sd, XMM8, XMM8, EAX
    10411041EMIT_INSTR_PLUS_ICEBP_C64   vcvtsi2sd, XMM8, XMM8, FSxBX_D
    1042 ; AVX-128, int64 -> fp64, same-reg (single)
     1042; AVX-128, fp64 <- int64, same-reg (single)
    10431043EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM1, RAX
    10441044EMIT_INSTR_PLUS_ICEBP       vcvtsi2sd, XMM1, XMM1, FSxBX_Q
    … …  
    10511051;; cvtsd2si
    10521052;
    1053 ; SSE-128, fp64 -> int32 (single)
     1053; SSE-128, int32 <- fp64 (single)
    10541054EMIT_INSTR_PLUS_ICEBP       cvtsd2si,  EAX, XMM1
    10551055EMIT_INSTR_PLUS_ICEBP       cvtsd2si,  EAX, FSxBX
    10561056EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2si,  R8D, XMM8
    10571057EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2si,  R8D, FSxBX
    1058 ; SSE-128, fp64 -> int64 (single)
     1058; SSE-128, int64 <- fp64 (single)
    10591059EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2si,  RAX, XMM1
    10601060EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2si,  RAX, FSxBX
    10611061EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2si,  R8,  XMM8
    10621062EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2si,  R8,  FSxBX
    1063 ; AVX-128, fp64 -> int32 (single)
     1063; AVX-128, int32 <- fp64 (single)
    10641064EMIT_INSTR_PLUS_ICEBP       vcvtsd2si, EAX, XMM1
    10651065EMIT_INSTR_PLUS_ICEBP       vcvtsd2si, EAX, FSxBX
    10661066EMIT_INSTR_PLUS_ICEBP_C64   vcvtsd2si, R8D, XMM8
    10671067EMIT_INSTR_PLUS_ICEBP_C64   vcvtsd2si, R8D, FSxBX
    1068 ; AVX-128, fp64 -> int64 (single)
     1068; AVX-128, int64 <- fp64 (single)
    10691069EMIT_INSTR_PLUS_ICEBP       vcvtsd2si, RAX, XMM1   ;; @todo this assembles in 16/32 mode; SDM says VEX.W1 ignored in non-64 bit
    10701070EMIT_INSTR_PLUS_ICEBP       vcvtsd2si, RAX, FSxBX  ;; @todo this assembles in 16/32 mode; SDM says VEX.W1 ignored in non-64 bit
    … …  
    10721072EMIT_INSTR_PLUS_ICEBP_C64   vcvtsd2si, R8,  FSxBX
    10731073; @todo test with VEX.L=1 (as if asking for YMM)?  SDM says 'unpredictable behavior'...
    1074 ; @todo same-reg int32 -> fp32 (SDM says W1 ignored in 32-bit modes) (see above)
     1074; @todo same-reg fp32 <- int32 (SDM says W1 ignored in 32-bit modes) (see above)
    10751075
    10761076;
    10771077;; cvttsd2si
    10781078;
    1079 ; SSE-128, fp64 -> int32 (single; truncated)
     1079; SSE-128, int32 <- fp64 (single; truncated)
    10801080EMIT_INSTR_PLUS_ICEBP       cvttsd2si,  EAX, XMM1
    10811081EMIT_INSTR_PLUS_ICEBP       cvttsd2si,  EAX, FSxBX
    10821082EMIT_INSTR_PLUS_ICEBP_C64   cvttsd2si,  R8D, XMM8
    10831083EMIT_INSTR_PLUS_ICEBP_C64   cvttsd2si,  R8D, FSxBX
    1084 ; SSE-128, fp64 -> int64 (single; truncated)
     1084; SSE-128, int64 <- fp64 (single; truncated)
    10851085EMIT_INSTR_PLUS_ICEBP_C64   cvttsd2si,  RAX, XMM1
    10861086EMIT_INSTR_PLUS_ICEBP_C64   cvttsd2si,  RAX, FSxBX
    10871087EMIT_INSTR_PLUS_ICEBP_C64   cvttsd2si,  R8,  XMM8
    10881088EMIT_INSTR_PLUS_ICEBP_C64   cvttsd2si,  R8,  FSxBX
    1089 ; AVX-128, fp64 -> int32 (single; truncated)
     1089; AVX-128, int32 <- fp64 (single; truncated)
    10901090EMIT_INSTR_PLUS_ICEBP       vcvttsd2si, EAX, XMM1
    10911091EMIT_INSTR_PLUS_ICEBP       vcvttsd2si, EAX, FSxBX
    10921092EMIT_INSTR_PLUS_ICEBP_C64   vcvttsd2si, R8D, XMM8
    10931093EMIT_INSTR_PLUS_ICEBP_C64   vcvttsd2si, R8D, FSxBX
    1094 ; AVX-128, fp64 -> int64 (single; truncated)
     1094; AVX-128, int64 <- fp64 (single; truncated)
    10951095EMIT_INSTR_PLUS_ICEBP       vcvttsd2si, RAX, XMM1
    10961096EMIT_INSTR_PLUS_ICEBP       vcvttsd2si, RAX, FSxBX
    … …  
    11031103;; cvtdq2ps
    11041104;
    1105 ; SSE-128, int32 -> fp32 (packed:4)
     1105; SSE-128, fp32 <- int32 (packed:4)
    11061106EMIT_INSTR_PLUS_ICEBP       cvtdq2ps,  XMM1, XMM2
    11071107EMIT_INSTR_PLUS_ICEBP       cvtdq2ps,  XMM1, FSxBX
    11081108EMIT_INSTR_PLUS_ICEBP_C64   cvtdq2ps,  XMM8, XMM9
    11091109EMIT_INSTR_PLUS_ICEBP_C64   cvtdq2ps,  XMM8, FSxBX
    1110 ; AVX-128, int32 -> fp32 (packed:4)
     1110; AVX-128, fp32 <- int32 (packed:4)
    11111111EMIT_INSTR_PLUS_ICEBP       vcvtdq2ps, XMM1, XMM2
    11121112EMIT_INSTR_PLUS_ICEBP       vcvtdq2ps, XMM1, FSxBX
    11131113EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2ps, XMM8, XMM9
    11141114EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2ps, XMM8, FSxBX
    1115 ; AVX-256, int32 -> fp32 (packed:8)
     1115; AVX-256, fp32 <- int32 (packed:8)
    11161116EMIT_INSTR_PLUS_ICEBP       vcvtdq2ps, YMM1, YMM2
    11171117EMIT_INSTR_PLUS_ICEBP       vcvtdq2ps, YMM1, FSxBX
    11181118EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2ps, YMM8, YMM9
    11191119EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2ps, YMM8, FSxBX
    1120 ; SSE-128, int32 -> fp32, same-reg (packed:4)
     1120; SSE-128, fp32 <- int32, same-reg (packed:4)
    11211121EMIT_INSTR_PLUS_ICEBP       cvtdq2ps,  XMM1, XMM1
    11221122EMIT_INSTR_PLUS_ICEBP_C64   cvtdq2ps,  XMM8, XMM8
    1123 ; AVX-128, int32 -> fp32, same-reg (packed:4)
     1123; AVX-128, fp32 <- int32, same-reg (packed:4)
    11241124EMIT_INSTR_PLUS_ICEBP       vcvtdq2ps, XMM1, XMM1
    11251125EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2ps, XMM8, XMM8
    1126 ; AVX-256, int32 -> fp32, same-reg (packed:8)
     1126; AVX-256, fp32 <- int32, same-reg (packed:8)
    11271127EMIT_INSTR_PLUS_ICEBP       vcvtdq2ps, YMM1, YMM1
    11281128EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2ps, YMM8, YMM8
    … …  
    11311131;; cvtps2dq
    11321132;
    1133 ; SSE-128, fp32 -> int32 (packed:4)
     1133; SSE-128, int32 <- fp32 (packed:4)
    11341134EMIT_INSTR_PLUS_ICEBP       cvtps2dq,  XMM1, XMM2
    11351135EMIT_INSTR_PLUS_ICEBP       cvtps2dq,  XMM1, FSxBX
    11361136EMIT_INSTR_PLUS_ICEBP_C64   cvtps2dq,  XMM8, XMM9
    11371137EMIT_INSTR_PLUS_ICEBP_C64   cvtps2dq,  XMM8, FSxBX
    1138 ; AVX-128, fp32 -> int32 (packed:4)
     1138; AVX-128, int32 <- fp32 (packed:4)
    11391139EMIT_INSTR_PLUS_ICEBP       vcvtps2dq, XMM1, XMM2
    11401140EMIT_INSTR_PLUS_ICEBP       vcvtps2dq, XMM1, FSxBX
    11411141EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2dq, XMM8, XMM9
    11421142EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2dq, XMM8, FSxBX
    1143 ; AVX-256, fp32 -> int32 (packed:8)
     1143; AVX-256, int32 <- fp32 (packed:8)
    11441144EMIT_INSTR_PLUS_ICEBP       vcvtps2dq, YMM1, YMM2
    11451145EMIT_INSTR_PLUS_ICEBP       vcvtps2dq, YMM1, FSxBX
    11461146EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2dq, YMM8, YMM9
    11471147EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2dq, YMM8, FSxBX
    1148 ; SSE-128, fp32 -> int32, same-reg (packed:4)
     1148; SSE-128, int32 <- fp32, same-reg (packed:4)
    11491149EMIT_INSTR_PLUS_ICEBP       cvtps2dq,  XMM1, XMM1
    11501150EMIT_INSTR_PLUS_ICEBP_C64   cvtps2dq,  XMM8, XMM8
    1151 ; AVX-128, fp32 -> int32, same-reg (packed:4)
     1151; AVX-128, int32 <- fp32, same-reg (packed:4)
    11521152EMIT_INSTR_PLUS_ICEBP       vcvtps2dq, XMM1, XMM1
    11531153EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2dq, XMM8, XMM8
    1154 ; AVX-256, fp32 -> int32, same-reg (packed:8)
     1154; AVX-256, int32 <- fp32, same-reg (packed:8)
    11551155EMIT_INSTR_PLUS_ICEBP       vcvtps2dq, YMM1, YMM1
    11561156EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2dq, YMM8, YMM8
    … …  
    11591159;; cvttps2dq
    11601160;
    1161 ; SSE-128, fp32 -> int32 (packed:4; truncated)
     1161; SSE-128, int32 <- fp32 (packed:4; truncated)
    11621162EMIT_INSTR_PLUS_ICEBP       cvttps2dq,  XMM1, XMM2
    11631163EMIT_INSTR_PLUS_ICEBP       cvttps2dq,  XMM1, FSxBX_O
    11641164EMIT_INSTR_PLUS_ICEBP_C64   cvttps2dq,  XMM8, XMM9
    11651165EMIT_INSTR_PLUS_ICEBP_C64   cvttps2dq,  XMM8, FSxBX_O
    1166 ; AVX-128, fp32 -> int32 (packed:4; truncated)
     1166; AVX-128, int32 <- fp32 (packed:4; truncated)
    11671167EMIT_INSTR_PLUS_ICEBP       vcvttps2dq, XMM1, XMM2
    11681168EMIT_INSTR_PLUS_ICEBP       vcvttps2dq, XMM1, FSxBX_O
    11691169EMIT_INSTR_PLUS_ICEBP_C64   vcvttps2dq, XMM8, XMM9
    11701170EMIT_INSTR_PLUS_ICEBP_C64   vcvttps2dq, XMM8, FSxBX_O
    1171 ; AVX-256, fp32 -> int32 (packed:8; truncated)
     1171; AVX-256, int32 <- fp32 (packed:8; truncated)
    11721172EMIT_INSTR_PLUS_ICEBP       vcvttps2dq, YMM1, YMM2
    11731173EMIT_INSTR_PLUS_ICEBP       vcvttps2dq, YMM1, FSxBX_Y
    11741174EMIT_INSTR_PLUS_ICEBP_C64   vcvttps2dq, YMM8, YMM9
    11751175EMIT_INSTR_PLUS_ICEBP_C64   vcvttps2dq, YMM8, FSxBX_Y
    1176 ; AVX-128, fp32 -> int32, same-reg (packed:4; truncated)
     1176; AVX-128, int32 <- fp32, same-reg (packed:4; truncated)
    11771177EMIT_INSTR_PLUS_ICEBP       cvttps2dq,  XMM1, XMM1
    11781178EMIT_INSTR_PLUS_ICEBP_C64   cvttps2dq,  XMM8, XMM8
    1179 ; AVX-128, fp32 -> int32, same-reg (packed:4; truncated)
     1179; AVX-128, int32 <- fp32, same-reg (packed:4; truncated)
    11801180EMIT_INSTR_PLUS_ICEBP       vcvttps2dq, XMM1, XMM1
    11811181EMIT_INSTR_PLUS_ICEBP_C64   vcvttps2dq, XMM8, XMM8
    1182 ; AVX-256, fp32 -> int32, same-reg (packed:8; truncated)
     1182; AVX-256, int32 <- fp32, same-reg (packed:8; truncated)
    11831183EMIT_INSTR_PLUS_ICEBP       vcvttps2dq, YMM1, YMM1
    11841184EMIT_INSTR_PLUS_ICEBP_C64   vcvttps2dq, YMM8, YMM8
    … …  
    11871187;; cvtdq2pd
    11881188;
    1189 ; SSE-128, int32 -> fp64 (packed:2)
     1189; SSE-128, fp64 <- int32 (packed:2)
    11901190EMIT_INSTR_PLUS_ICEBP       cvtdq2pd,  XMM1, XMM2
    11911191EMIT_INSTR_PLUS_ICEBP       cvtdq2pd,  XMM1, FSxBX
    11921192EMIT_INSTR_PLUS_ICEBP_C64   cvtdq2pd,  XMM8, XMM9
    11931193EMIT_INSTR_PLUS_ICEBP_C64   cvtdq2pd,  XMM8, FSxBX
    1194 ; AVX-128, int32 -> fp64 (packed:2)
     1194; AVX-128, fp64 <- int32 (packed:2)
    11951195EMIT_INSTR_PLUS_ICEBP       vcvtdq2pd, XMM1, XMM2
    11961196EMIT_INSTR_PLUS_ICEBP       vcvtdq2pd, XMM1, FSxBX
    11971197EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2pd, XMM8, XMM9
    11981198EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2pd, XMM8, FSxBX
    1199 ; AVX-256, int32 -> fp64 (packed:4)
     1199; AVX-256, fp64 <- int32 (packed:4)
    12001200EMIT_INSTR_PLUS_ICEBP       vcvtdq2pd, YMM1, XMM2
    12011201EMIT_INSTR_PLUS_ICEBP       vcvtdq2pd, YMM1, FSxBX
    12021202EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2pd, YMM8, XMM9
    12031203EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2pd, YMM8, FSxBX
    1204 ; SSE-128, int32 -> fp64, same-reg (packed:2)
     1204; SSE-128, fp64 <- int32, same-reg (packed:2)
    12051205EMIT_INSTR_PLUS_ICEBP       cvtdq2pd,  XMM1, XMM1
    12061206EMIT_INSTR_PLUS_ICEBP_C64   cvtdq2pd,  XMM8, XMM8
    1207 ; AVX-128, int32 -> fp64, same-reg (packed:2)
     1207; AVX-128, fp64 <- int32, same-reg (packed:2)
    12081208EMIT_INSTR_PLUS_ICEBP       vcvtdq2pd, XMM1, XMM1
    12091209EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2pd, XMM8, XMM8
    1210 ; AVX-256, int32 -> fp64, same-reg (packed:4)
     1210; AVX-256, fp64 <- int32, same-reg (packed:4)
    12111211EMIT_INSTR_PLUS_ICEBP       vcvtdq2pd, YMM1, XMM1
    12121212EMIT_INSTR_PLUS_ICEBP_C64   vcvtdq2pd, YMM8, XMM8
    … …  
    12151215;; cvtpd2dq
    12161216;
    1217 ; SSE-128, fp64 -> int32 (packed:2)
     1217; SSE-128, int32 <- fp64 (packed:2)
    12181218EMIT_INSTR_PLUS_ICEBP       cvtpd2dq,  XMM1, XMM2
    12191219EMIT_INSTR_PLUS_ICEBP       cvtpd2dq,  XMM1, FSxBX
    12201220EMIT_INSTR_PLUS_ICEBP_C64   cvtpd2dq,  XMM8, XMM9
    12211221EMIT_INSTR_PLUS_ICEBP_C64   cvtpd2dq,  XMM8, FSxBX
    1222 ; AVX-128, fp64 -> int32 (packed:2)
     1222; AVX-128, int32 <- fp64 (packed:2)
    12231223EMIT_INSTR_PLUS_ICEBP       vcvtpd2dq, XMM1, XMM2
    12241224EMIT_INSTR_PLUS_ICEBP       vcvtpd2dq, XMM1, FSxBX
    12251225EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2dq, XMM8, XMM9
    12261226EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2dq, XMM8, FSxBX
    1227 ; AVX-256, fp64 -> int32 (packed:4)
     1227; AVX-256, int32 <- fp64 (packed:4)
    12281228EMIT_INSTR_PLUS_ICEBP       vcvtpd2dq, XMM1, YMM2
    12291229EMIT_INSTR_PLUS_ICEBP       vcvtpd2dq, YMM1, FSxBX
    12301230EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2dq, XMM8, YMM9
    12311231EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2dq, YMM8, FSxBX
    1232 ; SSE-128, fp64 -> int32, same-reg (packed:2)
     1232; SSE-128, int32 <- fp64, same-reg (packed:2)
    12331233EMIT_INSTR_PLUS_ICEBP       cvtpd2dq,  XMM1, XMM1
    12341234EMIT_INSTR_PLUS_ICEBP_C64   cvtpd2dq,  XMM8, XMM8
    1235 ; AVX-128, fp64 -> int32, same-reg (packed:2)
     1235; AVX-128, int32 <- fp64, same-reg (packed:2)
    12361236EMIT_INSTR_PLUS_ICEBP       vcvtpd2dq, XMM1, XMM1
    12371237EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2dq, XMM8, XMM8
    1238 ; AVX-256, fp64 -> int32, same-reg (packed:4)
     1238; AVX-256, int32 <- fp64, same-reg (packed:4)
    12391239EMIT_INSTR_PLUS_ICEBP       vcvtpd2dq, XMM1, YMM1
    12401240EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2dq, XMM8, YMM8
    … …  
    12431243;; cvttpd2dq
    12441244;
    1245 ; SSE-128, fp64 -> int32 (packed:2; truncated)
     1245; SSE-128, int32 <- fp64 (packed:2; truncated)
    12461246EMIT_INSTR_PLUS_ICEBP       cvttpd2dq,  XMM1, XMM2
    12471247EMIT_INSTR_PLUS_ICEBP       cvttpd2dq,  XMM1, FSxBX_O
    12481248EMIT_INSTR_PLUS_ICEBP_C64   cvttpd2dq,  XMM8, XMM9
    12491249EMIT_INSTR_PLUS_ICEBP_C64   cvttpd2dq,  XMM8, FSxBX_O
    1250 ; AVX-128, fp64 -> int32 (packed:2; truncated)
     1250; AVX-128, int32 <- fp64 (packed:2; truncated)
    12511251EMIT_INSTR_PLUS_ICEBP       vcvttpd2dq, XMM1, XMM2
    12521252EMIT_INSTR_PLUS_ICEBP       vcvttpd2dq, XMM1, FSxBX_O
    12531253EMIT_INSTR_PLUS_ICEBP_C64   vcvttpd2dq, XMM8, XMM9
    12541254EMIT_INSTR_PLUS_ICEBP_C64   vcvttpd2dq, XMM8, FSxBX_O
    1255 ; AVX-256, fp64 -> int32 (packed:4; truncated)
     1255; AVX-256, int32 <- fp64 (packed:4; truncated)
    12561256EMIT_INSTR_PLUS_ICEBP       vcvttpd2dq, XMM1, YMM2
    12571257EMIT_INSTR_PLUS_ICEBP       vcvttpd2dq, XMM1, FSxBX_Y
    12581258EMIT_INSTR_PLUS_ICEBP_C64   vcvttpd2dq, XMM8, YMM9
    12591259EMIT_INSTR_PLUS_ICEBP_C64   vcvttpd2dq, XMM8, FSxBX_Y
    1260 ; AVX-128, fp64 -> int32, same-reg (packed:2; truncated)
     1260; AVX-128, int32 <- fp64, same-reg (packed:2; truncated)
    12611261EMIT_INSTR_PLUS_ICEBP       cvttpd2dq,  XMM1, XMM1
    12621262EMIT_INSTR_PLUS_ICEBP_C64   cvttpd2dq,  XMM8, XMM8
    1263 ; AVX-128, fp64 -> int32, same-reg (packed:2; truncated)
     1263; AVX-128, int32 <- fp64, same-reg (packed:2; truncated)
    12641264EMIT_INSTR_PLUS_ICEBP       vcvttpd2dq, XMM1, XMM1
    12651265EMIT_INSTR_PLUS_ICEBP_C64   vcvttpd2dq, XMM8, XMM8
    1266 ; AVX-256, fp64 -> int32, same-reg (packed:4; truncated)
     1266; AVX-256, int32 <- fp64, same-reg (packed:4; truncated)
    12671267EMIT_INSTR_PLUS_ICEBP       vcvttpd2dq, XMM1, YMM1
    12681268EMIT_INSTR_PLUS_ICEBP_C64   vcvttpd2dq, XMM8, YMM8
    … …  
    12711271;; cvtpd2ps
    12721272;
    1273 ; SSE-128, fp64 -> fp32 (packed:2)
     1273; SSE-128, fp32 <- fp64 (packed:2)
    12741274EMIT_INSTR_PLUS_ICEBP       cvtpd2ps,  XMM1, XMM2
    12751275EMIT_INSTR_PLUS_ICEBP       cvtpd2ps,  XMM1, FSxBX
    12761276EMIT_INSTR_PLUS_ICEBP_C64   cvtpd2ps,  XMM8, XMM9
    12771277EMIT_INSTR_PLUS_ICEBP_C64   cvtpd2ps,  XMM8, FSxBX
    1278 ; AVX-128, fp64 -> fp32 (packed:2)
     1278; AVX-128, fp32 <- fp64 (packed:2)
    12791279EMIT_INSTR_PLUS_ICEBP       vcvtpd2ps, XMM1, XMM2
    12801280EMIT_INSTR_PLUS_ICEBP       vcvtpd2ps, XMM1, FSxBX_O
    12811281EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2ps, XMM8, XMM9
    12821282EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2ps, XMM8, FSxBX_O
    1283 ; AVX-256, fp64 -> fp32 (packed:4)
     1283; AVX-256, fp32 <- fp64 (packed:4)
    12841284EMIT_INSTR_PLUS_ICEBP       vcvtpd2ps, XMM1, YMM2
    12851285EMIT_INSTR_PLUS_ICEBP       vcvtpd2ps, XMM1, FSxBX_Y
    12861286EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2ps, XMM8, YMM9
    12871287EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2ps, XMM8, FSxBX_Y
    1288 ; SSE-128, fp64 -> fp32, same-reg (packed:2)
     1288; SSE-128, fp32 <- fp64, same-reg (packed:2)
    12891289EMIT_INSTR_PLUS_ICEBP       cvtpd2ps,  XMM1, XMM1
    12901290EMIT_INSTR_PLUS_ICEBP_C64   cvtpd2ps,  XMM8, XMM8
    1291 ; AVX-128, fp64 -> fp32, same-reg (packed:2)
     1291; AVX-128, fp32 <- fp64, same-reg (packed:2)
    12921292EMIT_INSTR_PLUS_ICEBP       vcvtpd2ps, XMM1, XMM1
    12931293EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2ps, XMM8, XMM8
    1294 ; AVX-256, fp64 -> fp32, same-reg (packed:4)
     1294; AVX-256, fp32 <- fp64, same-reg (packed:4)
    12951295EMIT_INSTR_PLUS_ICEBP       vcvtpd2ps, XMM1, YMM1
    12961296EMIT_INSTR_PLUS_ICEBP_C64   vcvtpd2ps, XMM8, YMM8
    … …  
    12991299;; cvtps2pd
    13001300;
    1301 ; SSE-128, fp32 -> fp64 (packed:2)
     1301; SSE-128, fp64 <- fp32 (packed:2)
    13021302EMIT_INSTR_PLUS_ICEBP       cvtps2pd,  XMM1, XMM2
    13031303EMIT_INSTR_PLUS_ICEBP       cvtps2pd,  XMM1, FSxBX
    13041304EMIT_INSTR_PLUS_ICEBP_C64   cvtps2pd,  XMM8, XMM9
    13051305EMIT_INSTR_PLUS_ICEBP_C64   cvtps2pd,  XMM8, FSxBX
    1306 ; AVX-128, fp32 -> fp64 (packed:2)
     1306; AVX-128, fp64 <- fp32 (packed:2)
    13071307EMIT_INSTR_PLUS_ICEBP       vcvtps2pd, XMM1, XMM2
    13081308EMIT_INSTR_PLUS_ICEBP       vcvtps2pd, XMM1, FSxBX
    13091309EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2pd, XMM8, XMM9
    13101310EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2pd, XMM8, FSxBX
    1311 ; AVX-256, fp32 -> fp64 (packed:4)
     1311; AVX-256, fp64 <- fp32 (packed:4)
    13121312EMIT_INSTR_PLUS_ICEBP       vcvtps2pd, YMM1, XMM2
    13131313EMIT_INSTR_PLUS_ICEBP       vcvtps2pd, YMM1, FSxBX_O
    13141314EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2pd, YMM8, XMM9
    13151315EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2pd, YMM8, FSxBX_O
    1316 ; SSE-128, fp32 -> fp64, same-reg (packed:2)
     1316; SSE-128, fp64 <- fp32, same-reg (packed:2)
    13171317EMIT_INSTR_PLUS_ICEBP       cvtps2pd,  XMM1, XMM1
    13181318EMIT_INSTR_PLUS_ICEBP_C64   cvtps2pd,  XMM8, XMM8
    1319 ; AVX-128, fp32 -> fp64, same-reg (packed:2)
     1319; AVX-128, fp64 <- fp32, same-reg (packed:2)
    13201320EMIT_INSTR_PLUS_ICEBP       vcvtps2pd, XMM1, XMM1
    13211321EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2pd, XMM8, XMM8
    1322 ; AVX-256, fp32 -> fp64, same-reg (packed:4)
     1322; AVX-256, fp64 <- fp32, same-reg (packed:4)
    13231323EMIT_INSTR_PLUS_ICEBP       vcvtps2pd, YMM1, XMM1
    13241324EMIT_INSTR_PLUS_ICEBP_C64   vcvtps2pd, YMM8, XMM8
    … …  
    13271327;; cvtsd2ss
    13281328;
    1329 ; SSE-128, fp64 -> fp32 (single)
     1329; SSE-128, fp32 <- fp64 (single)
    13301330EMIT_INSTR_PLUS_ICEBP       cvtsd2ss,  XMM1, XMM2
    13311331EMIT_INSTR_PLUS_ICEBP       cvtsd2ss,  XMM1, FSxBX
    13321332EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2ss,  XMM8, XMM9
    13331333EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2ss,  XMM8, FSxBX
    1334 ; AVX-128, fp64 -> fp32 (single)
     1334; AVX-128, fp32 <- fp64 (single)
    13351335EMIT_INSTR_PLUS_ICEBP       vcvtsd2ss, XMM1, XMM2, XMM3
    13361336EMIT_INSTR_PLUS_ICEBP       vcvtsd2ss, XMM1, XMM2, FSxBX
    13371337EMIT_INSTR_PLUS_ICEBP_C64   vcvtsd2ss, XMM8, XMM9, XMM10
    13381338EMIT_INSTR_PLUS_ICEBP_C64   vcvtsd2ss, XMM8, XMM9, FSxBX
    1339 ; SSE-128, fp64 -> fp32, same-reg (single)
     1339; SSE-128, fp32 <- fp64, same-reg (single)
    13401340EMIT_INSTR_PLUS_ICEBP       cvtsd2ss,  XMM1, XMM1
    13411341EMIT_INSTR_PLUS_ICEBP_C64   cvtsd2ss,  XMM8, XMM8
    1342 ; AVX-128, fp64 -> fp32, same-reg (single)
     1342; AVX-128, fp32 <- fp64, same-reg (single)
    13431343EMIT_INSTR_PLUS_ICEBP       vcvtsd2ss, XMM1, XMM1, XMM1
    13441344EMIT_INSTR_PLUS_ICEBP_C64   vcvtsd2ss, XMM1, XMM1, XMM8
    … …  
    13531353;; cvtss2sd
    13541354;
    1355 ; SSE-128, fp32 -> fp64 (single)
     1355; SSE-128, fp64 <- fp32 (single)
    13561356EMIT_INSTR_PLUS_ICEBP       cvtss2sd,  XMM1, XMM2
    13571357EMIT_INSTR_PLUS_ICEBP       cvtss2sd,  XMM1, FSxBX
    13581358EMIT_INSTR_PLUS_ICEBP_C64   cvtss2sd,  XMM8, XMM9
    13591359EMIT_INSTR_PLUS_ICEBP_C64   cvtss2sd,  XMM8, FSxBX
    1360 ; AVX-128, fp32 -> fp64 (single)
     1360; AVX-128, fp64 <- fp32 (single)
    13611361EMIT_INSTR_PLUS_ICEBP       vcvtss2sd, XMM1, XMM2, XMM3
    13621362EMIT_INSTR_PLUS_ICEBP       vcvtss2sd, XMM1, XMM2, FSxBX
    13631363EMIT_INSTR_PLUS_ICEBP_C64   vcvtss2sd, XMM8, XMM9, XMM10
    13641364EMIT_INSTR_PLUS_ICEBP_C64   vcvtss2sd, XMM8, XMM9, FSxBX
    1365 ; SSE-128, fp32 -> fp64, same-reg (single)
     1365; SSE-128, fp64 <- fp32, same-reg (single)
    13661366EMIT_INSTR_PLUS_ICEBP       cvtss2sd,  XMM1, XMM1
    13671367EMIT_INSTR_PLUS_ICEBP_C64   cvtss2sd,  XMM8, XMM8
    1368 ; AVX-128, fp32 -> fp64, same-reg (single)
     1368; AVX-128, fp64 <- fp32, same-reg (single)
    13691369EMIT_INSTR_PLUS_ICEBP       vcvtss2sd, XMM1, XMM1, XMM1
    13701370EMIT_INSTR_PLUS_ICEBP_C64   vcvtss2sd, XMM1, XMM1, XMM8

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-4.c32

    r106721 r106733  
    281281#define FP32_ROW_UNUSED                     FP32_1(0),       FP32_RAND_x7_V0
    282282#define FP32_x6_UNUSED                      FP32_RAND_x6_V7
     283
     284
     285/*
     286 * Macros to store integer values into floating point boxes, allowing testing
     287 * of instructions which convert between types.
     288 */
     289#define FP32_INT_SIGN_PART(a_uInt32) ((((uint32_t)(a_uInt32)) >> 31) & 1)
     290#define FP32_INT_EXPN_PART(a_uInt32) ((((uint32_t)(a_uInt32)) >> 23) & 0xFF)
     291#define FP32_INT_FRAC_PART(a_uInt32) (((uint32_t)(a_uInt32)) & 0x7FFFFF)
     292#define FP32_INT(a_uInt32) RTFLOAT32U_INIT(FP32_INT_SIGN_PART(a_uInt32), FP32_INT_FRAC_PART(a_uInt32), FP32_INT_EXPN_PART(a_uInt32))
     293#define FP32_INT_C(a_uInt32) FP32_INT(UINT32_C(a_uInt32))
     294#define FP32_INT64(a_uInt64) FP32_INT((a_uInt64) & 0xFFFFFFFF), FP32_INT((a_uInt64) >> 32)
     295#define FP32_INT64_C(a_uInt64) FP32_INT64(UINT64_C(a_uInt64))
     296
     297#define FP64_INT_SIGN_PART(a_uInt64) ((((uint64_t)(a_uInt64)) >> 63) & 1)
     298#define FP64_INT_EXPN_PART(a_uInt64) ((((uint64_t)(a_uInt64)) >> 52) & 0x7FF)
     299#define FP64_INT_FRAC_PART(a_uInt64) (((uint64_t)(a_uInt64)) & 0xFFFFFFFFFFFFF)
     300#define FP64_INT(a_uInt64) RTFLOAT64U_INIT(FP64_INT_SIGN_PART(a_uInt64), FP64_INT_FRAC_PART(a_uInt64), FP64_INT_EXPN_PART(a_uInt64))
     301#define FP64_INT_C(a_uInt64) FP64_INT(UINT64_C(a_uInt64))
     302#define FP64_INT32(a_uInt32_1, a_uInt32_2) FP64_INT(((uint64_t)(a_uInt32_1)) | (((uint64_t)(a_uInt32_2)) << 32))
     303#define FP64_INT32_C(a_uInt32_1, a_uInt32_2) FP64_INT32(UINT32_C(a_uInt32_1), UINT32_C(a_uInt32_2))
    283304
    284305/*
    … …  
    25522573{
    25532574    FPFNBS3FAR          pfnWorker;           /**< Test function worker. */
    2554     uint8_t             bAvxMisalignXcpt;    /**< AVX misalignment exception. */
     2575    uint8_t             bAltXcpt;            /**< AVX misalignment exception, or always-expected exception. */
    25552576    uint8_t             enmRm;               /**< R/M type. */
    25562577    uint8_t             enmType;             /**< CPU instruction type (see T_XXX). */
    … …  
    25622583} BS3CPUINSTR4_TEST1_T;
    25632584
     2585#define BS3_XCPT_ALWAYS 0x80
     2586#define BS3_XCPT_UD     (X86_XCPT_UD | BS3_XCPT_ALWAYS)
     2587
    25642588typedef struct BS3CPUINSTR4_TEST1_MODE_T
    25652589{
    … …  
    25762600#define PASS_s_aValues            PASS_s_aArray(s_aValues)
    25772601#define PASS_s_aValuesSR          PASS_s_aArray(s_aValuesSR)
     2602#define PASS_s_aValues32          PASS_s_aArray(s_aValues32)
     2603#define PASS_s_aValues64          PASS_s_aArray(s_aValues64)
    25782604
    25792605typedef struct BS3CPUINSTR4_TEST1_CTX_T
    … …  
    26612687    bool             fFpXcptExpected;
    26622688    uint8_t          cbBytesExecuted;
     2689    BS3SETREGCTX     pSetRegCtx;
    26632690
    26642691    uint32_t uSpecifiedMask, uExpectedMask, uImpliedMask, uCombinedMask, uMaskedMask, uUnmaskedMask, uThisMask;
    … …  
    28302857        {
    28312858            Bs3MemSet(puMemOpAlias, 0xcc, cbMemOp);
     2859//Bs3TestPrintf("memory operand (Dst); set %d bytes of dst to 0xCC\n", cbMemOp);
    28322860            if (fNonFpOK)
    28332861                MemOpExpect.ymm = pValues->uDstOut.ymm;
    28342862            else
    28352863                Bs3MemSet(&MemOpExpect, 0xcc, sizeof(MemOpExpect));
     2864//Bs3TestPrintf("success expected; set %d bytes of expect to YMM value\n", sizeof(MemOpExpect));
    28362865        }
     2866
     2867        pSetRegCtx.pExtCtx = pExtCtx;
     2868        pSetRegCtx.pCtx = pCtx;
     2869        pSetRegCtx.fZeroYMMHi = fSseInstr;
     2870        pSetRegCtx.bMode = bMode;
    28372871
    28382872        /* Source #1 (/ destination for SSE). */
    … …  
    28402874        {
    28412875            Bs3MemCpy(puMemOpAlias, &pValues->uSrc1, cbMemOp);
     2876//Bs3TestPrintf("memory operand (Src1); set %d bytes of src1 & expected to specified value\n", cbMemOp);
    28422877            if (pTest->iRegDst >= FSxDI)
    28432878                BS3_ASSERT(fSseInstr);
    … …  
    28452880                MemOpExpect.ymm = pValues->uSrc1.ymm;
    28462881        }
    2847         else Bs3ExtCtxSetReg(pExtCtx, pTest->iRegSrc1, (void*)&pValues->uSrc1, (void *)fSseInstr);
     2882        else Bs3ExtCtxSetReg(&pSetRegCtx, pTest->iRegSrc1, (void*)&pValues->uSrc1);
    28482883
    28492884        /* Source #2. */
    … …  
    28522887            BS3_ASSERT(pTest->iRegDst < FSxDI && pTest->iRegSrc1 < FSxDI);
    28532888            Bs3MemCpy(puMemOpAlias, &pValues->uSrc2, cbMemOp);
     2889//Bs3TestPrintf("memory operand (Src2); set %d bytes of src2 & expected to specified value\n", cbMemOp);
    28542890            MemOpExpect.ymm = pValues->uSrc2.ymm;
    28552891        }
    2856         else Bs3ExtCtxSetReg(pExtCtx, pTest->iRegSrc2, (void*)&pValues->uSrc2, (void *)fSseInstr);
     2892        else Bs3ExtCtxSetReg(&pSetRegCtx, pTest->iRegSrc2, (void*)&pValues->uSrc2);
    28572893
    28582894        /* Memory pointer. */
    … …  
    28842920        cErrors = Bs3TestSubErrorCount();
    28852921        if (fNonFpOK && !fFpXcptExpected && pTest->iRegDst < FSxDI)
    2886             Bs3ExtCtxSetReg(pExtCtx, pTest->iRegDst, (void*)&pValues->uDstOut, (void *)fSseInstr);
     2922{
     2923//Bs3TestPrintf("after successful execution\n");
     2924            Bs3ExtCtxSetReg(&pSetRegCtx, pTest->iRegDst, (void*)&pValues->uDstOut);
     2925}
    28872926#if     defined(DEBUG_aeichner) /** @todo Necessary kludge on a i7-1068NG7. */
    28882927        if (   pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE
    … …  
    30523091                    uint8_t          *puMemOpAlias  = &g_pbBufAlias[(uintptr_t)puMemOp - (uintptr_t)pbBuf];
    30533092                    uint8_t           bXcptExpect   = !g_afTypeSupports[pTest->enmType] ? X86_XCPT_UD
     3093                                                    : pTest->bAltXcpt & BS3_XCPT_ALWAYS && pTest->bAltXcpt != 255 ? pTest->bAltXcpt & ~BS3_XCPT_ALWAYS
    30543094                                                    : fSseInstr ? paConfigs[iCfg].bXcptSse
    30553095                                                    : BS3_MODE_IS_RM_OR_V86(bMode) ? X86_XCPT_UD : paConfigs[iCfg].bXcptAvx;
    … …  
    30713111                        if (bRing != 3)
    30723112                            bXcptExpect = X86_XCPT_DB;
    3073                         else if (fAvxInstr)
    3074                             bXcptExpect = pTest->bAvxMisalignXcpt; /* they generally don't raise #AC */
     3113                        else if (fAvxInstr && pTest->bAltXcpt != 255)
     3114                            bXcptExpect = pTest->bAltXcpt; /* they generally don't raise #AC */
    30753115                    }
    30763116
    … …  
    1631316353
    1631416354
    16315 #define FP32_INT_SIGN_PART(a_uInt32) ((((uint32_t)a_uInt32) >> 31) & 1)
    16316 #define FP32_INT_EXPN_PART(a_uInt32) ((((uint32_t)a_uInt32) >> 23) & 0xFF)
    16317 #define FP32_INT_FRAC_PART(a_uInt32) (((uint32_t)a_uInt32) & 0x7FFFFF)
    16318 #define FP32_INT(a_uInt32) RTFLOAT32U_INIT(FP32_INT_SIGN_PART(a_uInt32), FP32_INT_FRAC_PART(a_uInt32), FP32_INT_EXPN_PART(a_uInt32))
    16319 
    16320 #define FP64_INT_SIGN_PART(a_uInt64) ((((uint64_t)a_uInt64) >> 63) & 1)
    16321 #define FP64_INT_EXPN_PART(a_uInt64) ((((uint64_t)a_uInt64) >> 52) & 0x7FF)
    16322 #define FP64_INT_FRAC_PART(a_uInt64) (((uint64_t)a_uInt64) & 0xFFFFFFFFFFFFF)
    16323 #define FP64_INT(a_uInt64) RTFLOAT64U_INIT(FP64_INT_SIGN_PART(a_uInt64), FP64_INT_FRAC_PART(a_uInt64), FP64_INT_EXPN_PART(a_uInt64))
    16324 
    1632516355/*
    1632616356 * CVTPI2PS.
    … …  
    1633416364     */
    1633516365    /* 0*/{ { /*init dst */ { FP32_RAND_V1(0), FP32_RAND_V3(1), FP32_RAND_x6_V0 } },
    16336             { /* src  mm */ { FP32_INT(0),     FP32_INT(0),     FP32_RAND_x6_V2 } },
     16366            { /* src  mm */ { FP32_INT_C(0),   FP32_INT_C(0),   FP32_RAND_x6_V2 } },
    1633716367            { /* =>  xmm */ { FP32_0(0),       FP32_0(0),       FP32_RAND_x6_V0 } },
    1633816368              /*mxcsr:in */ 0,
    … …  
    1634316373     */
    1634416374    /* 1*/{ { /*init dst */ { FP32_NORM_V0(0),         FP32_NORM_V4(0),         FP32_RAND_x6_V3 } },
    16345             { /* src  mm */ { FP32_INT(123456789),     FP32_INT(-123456789),    FP32_RAND_x6_V4 } },
     16375            { /* src  mm */ { FP32_INT_C(123456789),   FP32_INT_C(-123456789),  FP32_RAND_x6_V4 } },
    1634616376            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_V(1,0x6b79a3,0x99), FP32_RAND_x6_V3 } },
    1634716377                              /*123456792.0*/          /*-123456792.0*/
    … …  
    1635016380              /*256:out  */ -1 },
    1635116381          { { /*init dst */ { FP32_NORM_V1(0),         FP32_NORM_V7(0),         FP32_RAND_x6_V5 } },
    16352             { /* src  mm */ { FP32_INT(-47),           FP32_INT(42),            FP32_RAND_x6_V1 } },
     16382            { /* src  mm */ { FP32_INT_C(-47),         FP32_INT_C(42),          FP32_RAND_x6_V1 } },
    1635316383            { /* =>  xmm */ { FP32_V(1,0x3c0000,0x84), FP32_V(0,0x280000,0x84), FP32_RAND_x6_V5 } },
    1635416384                              /*-47.0*/                /*42.0*/
    … …  
    1636416394              /*256:out  */ -1 },
    1636516395          { { /*init dst */ { FP32_NORM_V0(0),         FP32_NORM_V4(0),         FP32_RAND_x6_V7 } },
    16366             { /* src  mm */ { FP32_INT(123456789),     FP32_INT(-123456789),    FP32_RAND_x6_V7 } },
     16396            { /* src  mm */ { FP32_INT_C(123456789),   FP32_INT_C(-123456789),  FP32_RAND_x6_V7 } },
    1636716397            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_V(1,0x6b79a3,0x99), FP32_RAND_x6_V7 } },
    1636816398                              /*123456792.0*/          /*-123456792.0*/
    … …  
    1637116401              /*256:out  */ -1 },
    1637216402          { { /*init dst */ { FP32_NORM_V0(0),         FP32_NORM_V4(0),         FP32_RAND_x6_V6 } },
    16373             { /* src  mm */ { FP32_INT(123456789),     FP32_INT(-123456789),    FP32_RAND_x6_V4 } },
     16403            { /* src  mm */ { FP32_INT_C(123456789),   FP32_INT_C(-123456789),  FP32_RAND_x6_V4 } },
    1637416404            { /* =>  xmm */ { FP32_V(0,0x6b79a2,0x99), FP32_V(1,0x6b79a3,0x99), FP32_RAND_x6_V6 } },
    1637516405                              /*123456784.0*/          /*-123456792.0*/
    … …  
    1637816408              /*256:out  */ -1 },
    1637916409          { { /*init dst */ { FP32_NORM_V0(0),         FP32_NORM_V4(0),         FP32_RAND_x6_V2 } },
    16380             { /* src  mm */ { FP32_INT(123456789),     FP32_INT(-123456789),    FP32_RAND_x6_V1 } },
     16410            { /* src  mm */ { FP32_INT_C(123456789),   FP32_INT_C(-123456789),  FP32_RAND_x6_V1 } },
    1638116411            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_V(1,0x6b79a2,0x99), FP32_RAND_x6_V2 } },
    1638216412                              /*123456792.0*/          /*-123456784.0*/
    … …  
    1638516415              /*256:out  */ -1 },
    1638616416          { { /*init dst */ { FP32_NORM_V0(0),         FP32_NORM_V4(0),         FP32_RAND_x6_V0 } },
    16387             { /* src  mm */ { FP32_INT(123456789),     FP32_INT(-123456789),    FP32_RAND_x6_V5 } },
     16417            { /* src  mm */ { FP32_INT_C(123456789),   FP32_INT_C(-123456789),  FP32_RAND_x6_V5 } },
    1638816418            { /* =>  xmm */ { FP32_V(0,0x6b79a2,0x99), FP32_V(1,0x6b79a2,0x99), FP32_RAND_x6_V0 } },
    1638916419                              /*123456784.0*/          /*-123456784.0*/
    … …  
    1643216462     */
    1643316463    /* 0*/{ { /* unused  */ { FP32_ROW_UNUSED } },
    16434             { /* src xmm */ { FP32_0(0),       FP32_0(1),       FP32_RAND_x6_V1 } },
    16435             { /* =>   mm */ { FP32_INT(0),     FP32_INT(0),    FP32_x6_UNUSED  } },
     16464            { /* src xmm */ { FP32_0(0),     FP32_0(1),     FP32_RAND_x6_V1 } },
     16465            { /* =>   mm */ { FP32_INT_C(0), FP32_INT_C(0), FP32_x6_UNUSED  } },
    1643616466              /*mxcsr:in */ 0,
    1643716467              /*128:out  */ 0,
    … …  
    1645116481    /* 2*/{ { /* unused  */ { FP32_ROW_UNUSED } },
    1645216482            { /* src xmm */ { FP32_V(0,0x712000,0x8f), FP32_V(1,0x712000,0x8f), FP32_RAND_x6_V0 } },
    16453             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16483            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1645416484              /*mxcsr:in */ 0,
    1645516485              /*128:out  */ 0,
    … …  
    1645816488            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1645916489                              /*123456.1*/             /*-123456.1*/
    16460             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16490            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1646116491              /*mxcsr:in */ 0,
    1646216492              /*128:out  */ X86_MXCSR_PE,
    … …  
    1646516495            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1646616496                              /*123456.1*/             /*-123456.1*/
    16467             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123457),       FP32_x6_UNUSED  } },
     16497            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123457),     FP32_x6_UNUSED  } },
    1646816498              /*mxcsr:in */ X86_MXCSR_RC_DOWN,
    1646916499              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_RC_DOWN,
    … …  
    1647216502            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1647316503                              /*123456.1*/             /*-123456.1*/
    16474             { /* =>   mm */ { FP32_INT(123457),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16504            { /* =>   mm */ { FP32_INT_C(123457),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1647516505              /*mxcsr:in */ X86_MXCSR_RC_UP,
    1647616506              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_RC_UP,
    … …  
    1647916509            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1648016510                              /*123456.1*/             /*-123456.1*/
    16481             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16511            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1648216512              /*mxcsr:in */ X86_MXCSR_RC_ZERO,
    1648316513              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_RC_ZERO,
    … …  
    1648616516            { /* src xmm */ { FP32_V(1,0x666666,0x7e), FP32_V(0,0x666666,0x7e), FP32_RAND_x6_V2 } },
    1648716517                              /*-0.9*/                 /*0.9*/
    16488             { /* =>   mm */ { FP32_INT(-1),            FP32_INT(1),             FP32_x6_UNUSED  } },
     16518            { /* =>   mm */ { FP32_INT_C(-1),          FP32_INT_C(1),           FP32_x6_UNUSED  } },
    1648916519              /*mxcsr:in */ X86_MXCSR_FZ,
    1649016520              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_FZ,
    … …  
    1649216522          { { /* unused  */ { FP32_ROW_UNUSED } },
    1649316523            { /* src xmm */ { FP32_NORM_SAFE_INT_MAX(1), FP32_NORM_SAFE_INT_MAX(0), FP32_RAND_x6_V2 } },
    16494             { /* =>   mm */ { FP32_INT(-16777215),       FP32_INT(16777215),        FP32_x6_UNUSED  } },
     16524            { /* =>   mm */ { FP32_INT_C(-16777215),     FP32_INT_C(16777215),      FP32_x6_UNUSED  } },
    1649516525              /*mxcsr:in */ 0,
    1649616526              /*128:out  */ 0,
    … …  
    1650116531    /* 9*/{ { /* unused  */ { FP32_ROW_UNUSED } },
    1650216532            { /* src xmm */ { FP32_DENORM_MAX(0), FP32_DENORM_MIN(1), FP32_RAND_x6_V2 } },
    16503             { /* =>   mm */ { FP32_INT(0),        FP32_INT(0),        FP32_x6_UNUSED  } },
     16533            { /* =>   mm */ { FP32_INT_C(0),      FP32_INT_C(0),      FP32_x6_UNUSED  } },
    1650416534              /*mxcsr:in */ 0,
    1650516535              /*128:out  */ X86_MXCSR_PE,
    … …  
    1650716537          { { /* unused  */ { FP32_ROW_UNUSED } },
    1650816538            { /* src xmm */ { FP32_DENORM_MIN(0), FP32_DENORM_MAX(1), FP32_RAND_x6_V2 } },
    16509             { /* =>   mm */ { FP32_INT(0),        FP32_INT(0),        FP32_x6_UNUSED  } },
     16539            { /* =>   mm */ { FP32_INT_C(0),      FP32_INT_C(0),      FP32_x6_UNUSED  } },
    1651016540              /*mxcsr:in */ X86_MXCSR_DAZ,
    1651116541              /*128:out  */ X86_MXCSR_DAZ,
    … …  
    1657316603     */
    1657416604    /* 0*/{ { /* unused  */ { FP32_ROW_UNUSED } },
    16575             { /* src xmm */ { FP32_0(0),       FP32_0(1),       FP32_RAND_x6_V1 } },
    16576             { /* =>   mm */ { FP32_INT(0),     FP32_INT(0),    FP32_x6_UNUSED  } },
     16605            { /* src xmm */ { FP32_0(0),     FP32_0(1),     FP32_RAND_x6_V1 } },
     16606            { /* =>   mm */ { FP32_INT_C(0), FP32_INT_C(0), FP32_x6_UNUSED  } },
    1657716607              /*mxcsr:in */ 0,
    1657816608              /*128:out  */ 0,
    … …  
    1659216622    /* 2*/{ { /* unused  */ { FP32_ROW_UNUSED } },
    1659316623            { /* src xmm */ { FP32_V(0,0x712000,0x8f), FP32_V(1,0x712000,0x8f), FP32_RAND_x6_V0 } },
    16594             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16624            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1659516625              /*mxcsr:in */ 0,
    1659616626              /*128:out  */ 0,
    … …  
    1659916629            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1660016630                              /*123456.1*/             /*-123456.1*/
    16601             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16631            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1660216632              /*mxcsr:in */ 0,
    1660316633              /*128:out  */ X86_MXCSR_PE,
    … …  
    1660616636            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1660716637                              /*123456.1*/             /*-123456.1*/
    16608             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16638            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1660916639              /*mxcsr:in */ X86_MXCSR_RC_DOWN,
    1661016640              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_RC_DOWN,
    … …  
    1661316643            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1661416644                              /*123456.1*/             /*-123456.1*/
    16615             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16645            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1661616646              /*mxcsr:in */ X86_MXCSR_RC_UP,
    1661716647              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_RC_UP,
    … …  
    1662016650            { /* src xmm */ { FP32_V(0,0x71200d,0x8f), FP32_V(1,0x71200d,0x8f), FP32_RAND_x6_V2 } },
    1662116651                              /*123456.1*/             /*-123456.1*/
    16622             { /* =>   mm */ { FP32_INT(123456),        FP32_INT(-123456),       FP32_x6_UNUSED  } },
     16652            { /* =>   mm */ { FP32_INT_C(123456),      FP32_INT_C(-123456),     FP32_x6_UNUSED  } },
    1662316653              /*mxcsr:in */ X86_MXCSR_RC_ZERO,
    1662416654              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_RC_ZERO,
    … …  
    1662716657            { /* src xmm */ { FP32_V(1,0x666666,0x7e), FP32_V(0,0x666666,0x7e), FP32_RAND_x6_V2 } },
    1662816658                              /*-0.9*/                 /*0.9*/
    16629             { /* =>   mm */ { FP32_INT(0),             FP32_INT(0),             FP32_x6_UNUSED  } },
     16659            { /* =>   mm */ { FP32_INT_C(0),           FP32_INT_C(0),           FP32_x6_UNUSED  } },
    1663016660              /*mxcsr:in */ X86_MXCSR_FZ,
    1663116661              /*128:out  */ X86_MXCSR_PE | X86_MXCSR_FZ,
    … …  
    1663316663          { { /* unused  */ { FP32_ROW_UNUSED } },
    1663416664            { /* src xmm */ { FP32_NORM_SAFE_INT_MAX(1), FP32_NORM_SAFE_INT_MAX(0), FP32_RAND_x6_V2 } },
    16635             { /* =>   mm */ { FP32_INT(-16777215),       FP32_INT(16777215),        FP32_x6_UNUSED  } },
     16665            { /* =>   mm */ { FP32_INT_C(-16777215),     FP32_INT_C(16777215),      FP32_x6_UNUSED  } },
    1663616666              /*mxcsr:in */ 0,
    1663716667              /*128:out  */ 0,
    … …  
    1664216672    /* 9*/{ { /* unused  */ { FP32_ROW_UNUSED } },
    1664316673            { /* src xmm */ { FP32_DENORM_MAX(0), FP32_DENORM_MIN(1), FP32_RAND_x6_V2 } },
    16644             { /* =>   mm */ { FP32_INT(0),        FP32_INT(0),        FP32_x6_UNUSED  } },
     16674            { /* =>   mm */ { FP32_INT_C(0),      FP32_INT_C(0),      FP32_x6_UNUSED  } },
    1664516675              /*mxcsr:in */ 0,
    1664616676              /*128:out  */ X86_MXCSR_PE,
    … …  
    1664816678          { { /* unused  */ { FP32_ROW_UNUSED } },
    1664916679            { /* src xmm */ { FP32_DENORM_MIN(0), FP32_DENORM_MAX(1), FP32_RAND_x6_V2 } },
    16650             { /* =>   mm */ { FP32_INT(0),        FP32_INT(0),        FP32_x6_UNUSED  } },
     16680            { /* =>   mm */ { FP32_INT_C(0),      FP32_INT_C(0),      FP32_x6_UNUSED  } },
    1665116681              /*mxcsr:in */ X86_MXCSR_DAZ,
    1665216682              /*128:out  */ X86_MXCSR_DAZ,
    … …  
    1669416724        { bs3CpuInstr4_cvttps2pi_MM1_XMM1_icebp_c64,  255, RM_REG, T_SSE, MM1, XMM1,  NOREG, PASS_s_aValues },
    1669516725        { bs3CpuInstr4_cvttps2pi_MM1_XMM8_icebp_c64,  255, RM_REG, T_SSE, MM1, XMM8,  NOREG, PASS_s_aValues },
     16726    };
     16727
     16728    static BS3CPUINSTR4_TEST1_MODE_T const s_aTests[3] = BS3CPUINSTR4_TEST1_MODES_INIT(s_aTests16, s_aTests32, s_aTests64);
     16729    unsigned const                         iTest       = BS3CPUINSTR4_TEST_MODES_INDEX(bMode);
     16730    return bs3CpuInstr4_WorkerTestType1(bMode, s_aTests[iTest].paTests, s_aTests[iTest].cTests,
     16731                                        g_aXcptConfig5, RT_ELEMENTS(g_aXcptConfig5));
     16732}
     16733
     16734
     16735/*
     16736 * CVTSI2SS.
     16737 */
     16738BS3_DECL_FAR(uint8_t) bs3CpuInstr4_cvtsi2ss(uint8_t bMode)
     16739{
     16740    static BS3CPUINSTR4_TEST1_VALUES_PS_T const s_aValues32[] =
     16741    {
     16742    /*
     16743     * Zero.
     16744     */
     16745    /* 0*/{ { /* src r32 */ { FP32_INT_C(0),   FP32_RAND_x7_V0 } },
     16746            { /* src xmm */ { FP32_RAND_V1(0), FP32_RAND_x7_V2 } },
     16747            { /* =>  xmm */ { FP32_0(0),       FP32_RAND_x7_V2 } },
     16748              /*mxcsr:in */ 0,
     16749              /*128:out  */ 0,
     16750              /*256:out  */ -1 },
     16751    /*
     16752     * Normals & Precision.
     16753     */
     16754    /* 1*/{ { /* src r32 */ { FP32_INT_C(123456789),   FP32_RAND_x7_V4 } },
     16755            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16756            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_RAND_x7_V3 } },
     16757                              /*123456792.0*/
     16758              /*mxcsr:in */ 0,
     16759              /*128:out  */ X86_MXCSR_PE,
     16760              /*256:out  */ -1 },
     16761          { { /* src r32 */ { FP32_INT_C(-123456789),  FP32_RAND_x7_V4 } },
     16762            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16763            { /* =>  xmm */ { FP32_V(1,0x6b79a3,0x99), FP32_RAND_x7_V3 } },
     16764                              /*-123456792.0*/
     16765              /*mxcsr:in */ 0,
     16766              /*128:out  */ X86_MXCSR_PE,
     16767              /*256:out  */ -1 },
     16768          { { /* src r32 */ { FP32_INT_C(-47),         FP32_RAND_x7_V4 } },
     16769            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16770            { /* =>  xmm */ { FP32_V(1,0x3c0000,0x84), FP32_RAND_x7_V3 } },
     16771                              /*-47.0*/
     16772              /*mxcsr:in */ 0,
     16773              /*128:out  */ 0,
     16774              /*256:out  */ -1 },
     16775          { { /* src r32 */ { FP32_INT(INT32_MAX), FP32_RAND_x7_V4 } },
     16776            { /* src xmm */ { FP32_NORM_V0(0),     FP32_RAND_x7_V3 } },
     16777            { /* =>  xmm */ { FP32_V(0,0,0x9e),    FP32_RAND_x7_V3 } },
     16778                              /*2147483648.0*/
     16779              /*mxcsr:in */ 0,
     16780              /*128:out  */ X86_MXCSR_PE,
     16781              /*256:out  */ -1 },
     16782          { { /* src r32 */ { FP32_INT(-INT32_MAX), FP32_RAND_x7_V4 } },
     16783            { /* src xmm */ { FP32_NORM_V0(0),      FP32_RAND_x7_V3 } },
     16784            { /* =>  xmm */ { FP32_V(1,0,0x9e),     FP32_RAND_x7_V3 } },
     16785                              /*-2147483648.0*/
     16786              /*mxcsr:in */ 0,
     16787              /*128:out  */ X86_MXCSR_PE,
     16788              /*256:out  */ -1 },
     16789          { { /* src r32 */ { FP32_INT_C(123456789),   FP32_RAND_x7_V4 } },
     16790            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16791            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_RAND_x7_V3 } },
     16792                              /*123456792.0*/
     16793              /*mxcsr:in */ X86_MXCSR_FZ | X86_MXCSR_DAZ,
     16794              /*128:out  */ X86_MXCSR_FZ | X86_MXCSR_DAZ | X86_MXCSR_PE,
     16795              /*256:out  */ -1 },
     16796          { { /* src r32 */ { FP32_INT_C(123456789),   FP32_RAND_x7_V4 } },
     16797            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16798            { /* =>  xmm */ { FP32_V(0,0x6b79a2,0x99), FP32_RAND_x7_V3 } },
     16799                              /*123456784.0*/
     16800              /*mxcsr:in */ X86_MXCSR_RC_DOWN,
     16801              /*128:out  */ X86_MXCSR_RC_DOWN | X86_MXCSR_PE,
     16802              /*256:out  */ -1 },
     16803          { { /* src r32 */ { FP32_INT_C(-123456789),  FP32_RAND_x7_V4 } },
     16804            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16805            { /* =>  xmm */ { FP32_V(1,0x6b79a3,0x99), FP32_RAND_x7_V3 } },
     16806                              /*-123456792.0*/
     16807              /*mxcsr:in */ X86_MXCSR_RC_DOWN,
     16808              /*128:out  */ X86_MXCSR_RC_DOWN | X86_MXCSR_PE,
     16809              /*256:out  */ -1 },
     16810          { { /* src r32 */ { FP32_INT_C(123456789),   FP32_RAND_x7_V4 } },
     16811            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16812            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_RAND_x7_V3 } },
     16813                              /*123456792.0*/
     16814              /*mxcsr:in */ X86_MXCSR_RC_UP,
     16815              /*128:out  */ X86_MXCSR_RC_UP | X86_MXCSR_PE,
     16816              /*256:out  */ -1 },
     16817          { { /* src r32 */ { FP32_INT_C(-123456789),  FP32_RAND_x7_V4 } },
     16818            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16819            { /* =>  xmm */ { FP32_V(1,0x6b79a2,0x99), FP32_RAND_x7_V3 } },
     16820                              /*-123456784.0*/
     16821              /*mxcsr:in */ X86_MXCSR_RC_UP,
     16822              /*128:out  */ X86_MXCSR_RC_UP | X86_MXCSR_PE,
     16823              /*256:out  */ -1 },
     16824          { { /* src r32 */ { FP32_INT_C(123456789),   FP32_RAND_x7_V4 } },
     16825            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16826            { /* =>  xmm */ { FP32_V(0,0x6b79a2,0x99), FP32_RAND_x7_V3 } },
     16827                              /*123456784.0*/
     16828              /*mxcsr:in */ X86_MXCSR_RC_ZERO,
     16829              /*128:out  */ X86_MXCSR_RC_ZERO | X86_MXCSR_PE,
     16830              /*256:out  */ -1 },
     16831          { { /* src r32 */ { FP32_INT_C(-123456789),  FP32_RAND_x7_V4 } },
     16832            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16833            { /* =>  xmm */ { FP32_V(1,0x6b79a2,0x99), FP32_RAND_x7_V3 } },
     16834                              /*-123456784.0*/
     16835              /*mxcsr:in */ X86_MXCSR_RC_ZERO,
     16836              /*128:out  */ X86_MXCSR_RC_ZERO | X86_MXCSR_PE,
     16837              /*256:out  */ -1 },
     16838    };
     16839
     16840    static BS3CPUINSTR4_TEST1_VALUES_PS_T const s_aValues64[] =
     16841    {
     16842    /*
     16843     * Zero.
     16844     */
     16845    /* 0*/{ { /* src r64 */ { FP32_INT64_C(0), FP32_RAND_x6_V0 } },
     16846            { /* src xmm */ { FP32_RAND_V1(0), FP32_RAND_x7_V2 } },
     16847            { /* =>  xmm */ { FP32_0(0),       FP32_RAND_x7_V2 } },
     16848              /*mxcsr:in */ 0,
     16849              /*128:out  */ 0,
     16850              /*256:out  */ -1 },
     16851    /*
     16852     * Normals & Precision.
     16853     */
     16854    /* 1*/{ { /* src r64 */ { FP32_INT64_C(123456789), FP32_RAND_x6_V4 } },
     16855            { /* src xmm */ { FP32_NORM_V0(0),         FP32_RAND_x7_V3 } },
     16856            { /* =>  xmm */ { FP32_V(0,0x6b79a3,0x99), FP32_RAND_x7_V3 } },
     16857                              /*123456792.0*/
     16858              /*mxcsr:in */ 0,
     16859              /*128:out  */ X86_MXCSR_PE,
     16860              /*256:out  */ -1 },
     16861          { { /* src r64 */ { FP32_INT64_C(8526495043095935640), FP32_RAND_x6_V4 } },
     16862                                          /*0x76543210FEDCBA98*/
     16863            { /* src xmm */ { FP32_NORM_V0(0),                   FP32_RAND_x7_V3 } },
     16864            { /* =>  xmm */ { FP32_V(0,0x6ca864,0xbd),           FP32_RAND_x7_V3 } },
     16865                              /* 8526494970100580352.0 = 0x7654320000000000 */
     16866              /*mxcsr:in */ 0,
     16867              /*128:out  */ X86_MXCSR_PE,
     16868              /*256:out  */ -1 },
     16869          { { /* src r64 */ { FP32_INT64_C(-8526495043095935640), FP32_RAND_x6_V4 } },
     16870                                          /*-0x76543210FEDCBA98*/
     16871            { /* src xmm */ { FP32_NORM_V0(0),                    FP32_RAND_x7_V3 } },
     16872            { /* =>  xmm */ { FP32_V(1,0x6ca864,0xbd),            FP32_RAND_x7_V3 } },
     16873                              /* -8526494970100580352.0 = -0x7654320000000000 */
     16874              /*mxcsr:in */ 0,
     16875              /*128:out  */ X86_MXCSR_PE,
     16876              /*256:out  */ -1 },
     16877          { { /* src r64 */ { FP32_INT64_C(-2), FP32_RAND_x6_V4 } },
     16878            { /* src xmm */ { FP32_NORM_V0(0),  FP32_RAND_x7_V3 } },
     16879            { /* =>  xmm */ { FP32_2(1),        FP32_RAND_x7_V3 } },
     16880              /*mxcsr:in */ 0,
     16881              /*128:out  */ 0,
     16882              /*256:out  */ -1 },
     16883          { { /* src r64 */ { FP32_INT64(INT64_MAX), FP32_RAND_x6_V4 } },
     16884            { /* src xmm */ { FP32_NORM_V0(0),       FP32_RAND_x7_V3 } },
     16885            { /* =>  xmm */ { FP32_V(0,0x0,0xbe),    FP32_RAND_x7_V3 } },
     16886                              /* 9223372036854775808.0; exactly INT64_MAX, so why PE (i7-10700)?? */
     16887              /*mxcsr:in */ X86_MXCSR_XCPT_MASK,
     16888              /*128:out  */ X86_MXCSR_XCPT_MASK | X86_MXCSR_PE,
     16889              /*256:out  */ -1 },
     16890          { { /* src r64 */ { FP32_INT64(-INT64_MAX), FP32_RAND_x6_V4 } },
     16891            { /* src xmm */ { FP32_NORM_V0(0),        FP32_RAND_x7_V3 } },
     16892            { /* =>  xmm */ { FP32_V(1,0x0,0xbe),     FP32_RAND_x7_V3 } },
     16893                              /* -9223372036854775808.0; exactly -INT64_MAX, so why PE (i7-10700)?? */
     16894              /*mxcsr:in */ X86_MXCSR_XCPT_MASK,
     16895              /*128:out  */ X86_MXCSR_XCPT_MASK | X86_MXCSR_PE,
     16896              /*256:out  */ -1 },
     16897
     16898          { { /* src r64 */ { FP32_INT64_C(8526495043095935640), FP32_RAND_x6_V4 } },
     16899                                          /*0x76543210FEDCBA98*/
     16900            { /* src xmm */ { FP32_NORM_V0(0),                   FP32_RAND_x7_V3 } },
     16901            { /* =>  xmm */ { FP32_V(0,0x6ca864,0xbd),           FP32_RAND_x7_V3 } },
     16902                              /* 8526494970100580352.0 = 0x7654320000000000 */
     16903              /*mxcsr:in */ X86_MXCSR_FZ | X86_MXCSR_DAZ,
     16904              /*128:out  */ X86_MXCSR_FZ | X86_MXCSR_DAZ | X86_MXCSR_PE,
     16905              /*256:out  */ -1 },
     16906          { { /* src r64 */ { FP32_INT64_C(8526495043095935640), FP32_RAND_x6_V4 } },
     16907                                          /*0x76543210FEDCBA98*/
     16908            { /* src xmm */ { FP32_NORM_V0(0),                   FP32_RAND_x7_V3 } },
     16909            { /* =>  xmm */ { FP32_V(0,0x6ca864,0xbd),           FP32_RAND_x7_V3 } },
     16910                              /* 8526494970100580352.0 = 0x7654320000000000 */
     16911              /*mxcsr:in */ X86_MXCSR_RC_DOWN,
     16912              /*128:out  */ X86_MXCSR_RC_DOWN | X86_MXCSR_PE,
     16913              /*256:out  */ -1 },
     16914          { { /* src r64 */ { FP32_INT64_C(-8526495043095935640), FP32_RAND_x6_V4 } },
     16915                                          /*-0x76543210FEDCBA98*/
     16916            { /* src xmm */ { FP32_NORM_V0(0),                    FP32_RAND_x7_V3 } },
     16917            { /* =>  xmm */ { FP32_V(1,0x6ca865,0xbd),            FP32_RAND_x7_V3 } },
     16918                              /* -8526495519856394240.0 = -0x7654328000000000 */
     16919              /*mxcsr:in */ X86_MXCSR_RC_DOWN,
     16920              /*128:out  */ X86_MXCSR_RC_DOWN | X86_MXCSR_PE,
     16921              /*256:out  */ -1 },
     16922          { { /* src r64 */ { FP32_INT64_C(8526495043095935640), FP32_RAND_x6_V4 } },
     16923                                          /*0x76543210FEDCBA98*/
     16924            { /* src xmm */ { FP32_NORM_V0(0),                   FP32_RAND_x7_V3 } },
     16925            { /* =>  xmm */ { FP32_V(0,0x6ca865,0xbd),           FP32_RAND_x7_V3 } },
     16926                              /* 8526495519856394240.0 = 0x7654328000000000 */
     16927              /*mxcsr:in */ X86_MXCSR_RC_UP,
     16928              /*128:out  */ X86_MXCSR_RC_UP | X86_MXCSR_PE,
     16929              /*256:out  */ -1 },
     16930          { { /* src r64 */ { FP32_INT64_C(-8526495043095935640), FP32_RAND_x6_V4 } },
     16931                                          /*-0x76543210FEDCBA98*/
     16932            { /* src xmm */ { FP32_NORM_V0(0),                    FP32_RAND_x7_V3 } },
     16933            { /* =>  xmm */ { FP32_V(1,0x6ca864,0xbd),            FP32_RAND_x7_V3 } },
     16934                              /* -8526494970100580352.0 = -0x7654320000000000 */
     16935              /*mxcsr:in */ X86_MXCSR_RC_UP,
     16936              /*128:out  */ X86_MXCSR_RC_UP | X86_MXCSR_PE,
     16937              /*256:out  */ -1 },
     16938          { { /* src r64 */ { FP32_INT64_C(8526495043095935640), FP32_RAND_x6_V4 } },
     16939                                          /*0x76543210FEDCBA98*/
     16940            { /* src xmm */ { FP32_NORM_V0(0),                   FP32_RAND_x7_V3 } },
     16941            { /* =>  xmm */ { FP32_V(0,0x6ca864,0xbd),           FP32_RAND_x7_V3 } },
     16942                              /* 8526494970100580352.0 = 0x7654320000000000 */
     16943              /*mxcsr:in */ X86_MXCSR_RC_ZERO,
     16944              /*128:out  */ X86_MXCSR_RC_ZERO | X86_MXCSR_PE,
     16945              /*256:out  */ -1 },
     16946          { { /* src r64 */ { FP32_INT64_C(-8526495043095935640), FP32_RAND_x6_V4 } },
     16947                                          /*-0x76543210FEDCBA98*/
     16948            { /* src xmm */ { FP32_NORM_V0(0),                    FP32_RAND_x7_V3 } },
     16949            { /* =>  xmm */ { FP32_V(1,0x6ca864,0xbd),            FP32_RAND_x7_V3 } },
     16950                              /* -8526494970100580352.0 = -0x7654320000000000 */
     16951              /*mxcsr:in */ X86_MXCSR_RC_ZERO,
     16952              /*128:out  */ X86_MXCSR_RC_ZERO | X86_MXCSR_PE,
     16953              /*256:out  */ -1 },
     16954    };
     16955    /*
     16956     * Infinity, Overflow, Underflow, Denormal, Invalid not possible.
     16957     */
     16958
     16959    static BS3CPUINSTR4_TEST1_T const s_aTests16[] =
     16960    {
     16961        { bs3CpuInstr4_cvtsi2ss_XMM1_EAX_icebp_c16,           255,         RM_REG, T_SSE,     XMM1, XMM1, EAX,   PASS_s_aValues32 },
     16962        { bs3CpuInstr4_cvtsi2ss_XMM1_FSxBX_D_icebp_c16,       255,         RM_MEM, T_SSE,     XMM1, XMM1, FSxBX, PASS_s_aValues32 },
     16963
     16964        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_EAX_icebp_c16,     255,         RM_REG, T_AVX_128, XMM1, XMM2, EAX,   PASS_s_aValues32 },
     16965        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_FSxBX_D_icebp_c16, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM2, FSxBX, PASS_s_aValues32 },
     16966
     16967        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_RAX_icebp_c16,     BS3_XCPT_UD, RM_REG, T_AVX_128, XMM1, XMM2, RAX,   PASS_s_aValues64 },
     16968        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_FSxBX_Q_icebp_c16, BS3_XCPT_UD, RM_MEM, T_AVX_128, XMM1, XMM2, FSxBX, PASS_s_aValues64 },
     16969
     16970        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_EAX_icebp_c16,     255,         RM_REG, T_AVX_128, XMM1, XMM1, EAX,   PASS_s_aValues32 },
     16971        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_FSxBX_D_icebp_c16, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM1, FSxBX, PASS_s_aValues32 },
     16972
     16973        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_RAX_icebp_c16,     BS3_XCPT_UD, RM_REG, T_AVX_128, XMM1, XMM1, RAX,   PASS_s_aValues64 },
     16974        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_FSxBX_Q_icebp_c16, BS3_XCPT_UD, RM_MEM, T_AVX_128, XMM1, XMM1, FSxBX, PASS_s_aValues64 },
     16975    };
     16976    static BS3CPUINSTR4_TEST1_T const s_aTests32[] =
     16977    {
     16978        { bs3CpuInstr4_cvtsi2ss_XMM1_EAX_icebp_c32,           255,         RM_REG, T_SSE,     XMM1, XMM1, EAX,   PASS_s_aValues32 },
     16979        { bs3CpuInstr4_cvtsi2ss_XMM1_FSxBX_D_icebp_c32,       255,         RM_MEM, T_SSE,     XMM1, XMM1, FSxBX, PASS_s_aValues32 },
     16980
     16981        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_EAX_icebp_c32,     255,         RM_REG, T_AVX_128, XMM1, XMM2, EAX,   PASS_s_aValues32 },
     16982        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_FSxBX_D_icebp_c32, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM2, FSxBX, PASS_s_aValues32 },
     16983
     16984        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_RAX_icebp_c32,     BS3_XCPT_UD, RM_REG, T_AVX_128, XMM1, XMM2, RAX,   PASS_s_aValues64 },
     16985        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_FSxBX_Q_icebp_c32, BS3_XCPT_UD, RM_MEM, T_AVX_128, XMM1, XMM2, FSxBX, PASS_s_aValues64 },
     16986
     16987        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_EAX_icebp_c32,     255,         RM_REG, T_AVX_128, XMM1, XMM1, EAX,   PASS_s_aValues32 },
     16988        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_FSxBX_D_icebp_c32, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM1, FSxBX, PASS_s_aValues32 },
     16989        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_RAX_icebp_c32,     BS3_XCPT_UD, RM_REG, T_AVX_128, XMM1, XMM1, RAX,   PASS_s_aValues64 },
     16990        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_FSxBX_Q_icebp_c32, BS3_XCPT_UD, RM_MEM, T_AVX_128, XMM1, XMM1, FSxBX, PASS_s_aValues64 },
     16991    };
     16992    static BS3CPUINSTR4_TEST1_T const s_aTests64[] =
     16993    {
     16994        { bs3CpuInstr4_cvtsi2ss_XMM1_EAX_icebp_c64,           255,         RM_REG, T_SSE,     XMM1, XMM1, EAX,   PASS_s_aValues32 },
     16995        { bs3CpuInstr4_cvtsi2ss_XMM1_FSxBX_D_icebp_c64,       255,         RM_MEM, T_SSE,     XMM1, XMM1, FSxBX, PASS_s_aValues32 },
     16996        { bs3CpuInstr4_cvtsi2ss_XMM8_R8D_icebp_c64,           255,         RM_REG, T_SSE,     XMM8, XMM8, R8D,   PASS_s_aValues32 },
     16997        { bs3CpuInstr4_cvtsi2ss_XMM8_FSxBX_D_icebp_c64,       255,         RM_MEM, T_SSE,     XMM8, XMM8, FSxBX, PASS_s_aValues32 },
     16998
     16999        { bs3CpuInstr4_cvtsi2ss_XMM1_RAX_icebp_c64,           255,         RM_REG, T_SSE,     XMM1, XMM1, RAX,   PASS_s_aValues64 },
     17000        { bs3CpuInstr4_cvtsi2ss_XMM1_FSxBX_Q_icebp_c64,       255,         RM_MEM, T_SSE,     XMM1, XMM1, FSxBX, PASS_s_aValues64 },
     17001        { bs3CpuInstr4_cvtsi2ss_XMM8_R8_icebp_c64,            255,         RM_REG, T_SSE,     XMM8, XMM8, R8,    PASS_s_aValues64 },
     17002        { bs3CpuInstr4_cvtsi2ss_XMM8_FSxBX_Q_icebp_c64,       255,         RM_MEM, T_SSE,     XMM8, XMM8, FSxBX, PASS_s_aValues64 },
     17003
     17004        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_EAX_icebp_c64,     255,         RM_REG, T_AVX_128, XMM1, XMM2, EAX,   PASS_s_aValues32 },
     17005        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_FSxBX_D_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM2, FSxBX, PASS_s_aValues32 },
     17006        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM9_R8D_icebp_c64,     255,         RM_REG, T_AVX_128, XMM8, XMM9, R8D,   PASS_s_aValues32 },
     17007        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM9_FSxBX_D_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM8, XMM9, FSxBX, PASS_s_aValues32 },
     17008
     17009        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_RAX_icebp_c64,     255,         RM_REG, T_AVX_128, XMM1, XMM2, RAX,   PASS_s_aValues64 },
     17010        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM2_FSxBX_Q_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM2, FSxBX, PASS_s_aValues64 },
     17011        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM9_R8_icebp_c64,      255,         RM_REG, T_AVX_128, XMM8, XMM9, R8,    PASS_s_aValues64 },
     17012        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM9_FSxBX_Q_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM8, XMM9, FSxBX, PASS_s_aValues64 },
     17013
     17014        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_EAX_icebp_c64,     255,         RM_REG, T_AVX_128, XMM1, XMM1, EAX,   PASS_s_aValues32 },
     17015        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_FSxBX_D_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM1, FSxBX, PASS_s_aValues32 },
     17016        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM8_R8D_icebp_c64,     255,         RM_REG, T_AVX_128, XMM8, XMM8, R8D,   PASS_s_aValues32 },
     17017        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM8_FSxBX_D_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM8, XMM8, FSxBX, PASS_s_aValues32 },
     17018
     17019        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_RAX_icebp_c64,     255,         RM_REG, T_AVX_128, XMM1, XMM1, RAX,   PASS_s_aValues64 },
     17020        { bs3CpuInstr4_vcvtsi2ss_XMM1_XMM1_FSxBX_Q_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM1, XMM1, FSxBX, PASS_s_aValues64 },
     17021        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM8_R8_icebp_c64,      255,         RM_REG, T_AVX_128, XMM8, XMM8, R8,    PASS_s_aValues64 },
     17022        { bs3CpuInstr4_vcvtsi2ss_XMM8_XMM8_FSxBX_Q_icebp_c64, X86_XCPT_AC, RM_MEM, T_AVX_128, XMM8, XMM8, FSxBX, PASS_s_aValues64 },
    1669617023    };
    1669717024
    … …  
    1676317090        { "cvtps2pi",       bs3CpuInstr4_cvtps2pi,   0 },
    1676417091        { "cvttps2pi",      bs3CpuInstr4_cvttps2pi,  0 },
     17092        { "cvtsi2ss",       bs3CpuInstr4_cvtsi2ss,   0 },
    1676517093#endif
    1676617094    };

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-x-regs.c32

    r106721 r106733  
    7070/** These values are used in uint8_t fields; the TODO values are *intended* to break compilation. */
    7171
    72 #define          BS3_REGISTER_FAMILY_AVX512_TODO       0x1000
    73 #define          BS3_REGISTER_FAMILY_APX_TODO          0x2000
    74 #define          BS3_REGISTER_FAMILY_OTHER_TODO        0x3000
     72#define          BS3_REGISTER_FAMILY_AVX512_TODO 0x1000
     73#define          BS3_REGISTER_FAMILY_APX_TODO    0x2000
     74#define          BS3_REGISTER_FAMILY_OTHER_TODO  0x3000
    7575
    7676#define          BS3_REGISTER_FAMILY_MASK        0xE0
    7777#define          BS3_REGISTER_REGISTER_MASK      0x1F
     78#define          BS3_REGISTER_MASK               (BS3_REGISTER_FAMILY_MASK | BS3_REGISTER_REGISTER_MASK)
    7879
    7980#define          BS3_REGISTER_FAMILY_8BIT_L      0x00
    … …  
    381382#define          BS3_FSxREG(reg)                 (((reg) == FSxBX || (reg) == FSxDI) ? reg : ((reg) & BS3_REGISTER_REGISTER_MASK) | BS3_REGISTER_FLAG_MEMREF)
    382383
    383 #define BS3_REGISTER_NAME_MAXSIZE sizeof("(avail)")
     384#define BS3_REGISTER_NAME_MAXSIZE sizeof("FSx(avail)")
    384385
    385386/**
    … …  
    391392 * @param    uReg    The register identity value.
    392393 */
    393 static size_t bs3CpuInstrXGetRegisterName(char BS3_FAR *pszBuf, size_t cchBuf, uint8_t uReg)
     394static size_t bs3CpuInstrXGetRegisterName(char BS3_FAR *pszBuf, size_t cchBuf, uint16_t uReg)
    394395{
    395396    const uint8_t uRegNum = uReg & BS3_REGISTER_REGISTER_MASK;
    … …  
    404405                                                                       "NOREG", "(avail)", "FSxDI", "FSxBX" };
    405406    BS3_ASSERT(cchBuf >= BS3_REGISTER_NAME_MAXSIZE);
     407
     408    if (uReg & BS3_REGISTER_FLAG_MEMREF)
     409    {
     410        char pszRegName[BS3_REGISTER_NAME_MAXSIZE];
     411
     412        bs3CpuInstrXGetRegisterName(pszRegName, BS3_REGISTER_NAME_MAXSIZE, uReg & BS3_REGISTER_MASK);
     413        return Bs3StrPrintf(pszBuf, cchBuf, "FSx%s", pszRegName);
     414    }
    406415
    407416    switch (uRegSet) {
    … …  
    440449/**
    441450 * Set a register within a testing context.  Intended to support a broad
    442  * range of register types; this prototype so far only supports MMX, XMM,
    443  * YMM, and hypothetically-but-not-yet-linked, general purpose registers
    444  * other than their 8-bit sub-aliases.
    445  *
    446  * @returns  Nothing much of any interest (so far).
    447  * @param    pExtCtx     The testing context to modify.
     451 * range of register types; currently supports MMX, XMM, YMM, and general
     452 * purpose registers (except 8-bit sub-registers); and setting up FS:xGPR
     453 * for memory reference operations.
     454 *
     455 * Other regs known to this subsystem are either so far unused by
     456 * VirtualBox (ZMM, k[0-7], GPRs >15); or not used by tests which call
     457 * this (8-bit sub-registers, segment registers, xIP, xFL).
     458 *
     459 * @param    pSetRegCtx  Arguments to this function (see below).
    448460 * @param    uReg        The register identity value to modify within that context.
    449  * @param    pValue      Pointer to the data to store there.
    450  * @param    pExtra      For BS3_REGISTER_FAMILY_XMM: flag whether to zero YMM-hi.
    451  *                       For GPR references: pointer to general purpose register context.
     461 * @param    pu256Val    Pointer to the data to store there.
     462 * @returns  bool        Whether the store succeeded (currently ignored by callers).
    452463 */
    453 #define CLR_YmmHi (void *)true
    454 #define SET_YmmHi (void *)false
    455 
    456 static bool Bs3ExtCtxSetReg(PBS3EXTCTX pExtCtx, uint16_t uReg, void * pValue, void * pExtra)
     464
     465typedef struct BS3SETREGCTX
    457466{
    458     uint8_t    uRegNum = uReg & BS3_REGISTER_REGISTER_MASK;
    459     uint8_t    uRegSet = uReg & BS3_REGISTER_FAMILY_MASK;
    460     char       pszRegName[BS3_REGISTER_NAME_MAXSIZE];
    461     PBS3REGCTX pCtx = (PBS3REGCTX)pExtra;  /* for BS3_REGISTER_FAMILY_MEMREF, all GPR families */
    462     bool       fZeroYMMHi = (bool)pExtra;  /* for BS3_REGISTER_FAMILY_XMM    */
     467    /** Pointer to test context. */
     468    PBS3EXTCTX   pExtCtx;
     469    /** Pointer to register context; for BS3_REGISTER_FAMILY_MEMREF, all GPR families */
     470    PBS3REGCTX   pCtx;
     471    /** Whether to zero YMM-high bits when setting XMM; for BS3_REGISTER_FAMILY_XMM */
     472    bool         fZeroYMMHi;
     473    /** Current execution mode; for BS3_REGISTER_FAMILY_64BIT */
     474    uint8_t      bMode;
     475} BS3SETREGCTX;
     476typedef BS3SETREGCTX BS3_FAR *PBS3SETREGCTX;
     477
     478static bool Bs3ExtCtxSetReg_int(PBS3SETREGCTX pSetRegCtx, uint16_t uReg, PCRTUINT256U pu256Val)
     479{
     480    uint8_t     uRegNum = uReg & BS3_REGISTER_REGISTER_MASK;
     481    uint8_t     uRegSet = uReg & BS3_REGISTER_FAMILY_MASK;
     482    char        pszRegName[BS3_REGISTER_NAME_MAXSIZE];
    463483
    464484    if (uReg & BS3_REGISTER_FLAG_MEMREF || uReg == FSxBX || uReg == FSxDI)
    465485    {
     486        if (uRegSet <= BS3_REGISTER_FAMILY_64BIT)
     487            uRegNum &= BS3_REGISTER_REGISTER_MASK;
     488        else if (uReg == FSxBX)
     489            uRegNum = BX;
     490        else if (uReg == FSxDI)
     491            uRegNum = DI;
     492        else
     493            uRegNum = 255; /* Fall through to error handling below to complain about 'FSxZMM31' or whatever */
    466494        uRegSet = BS3_REGISTER_FAMILY_MEMREF;
    467         if (uReg == FSxBX) uRegNum = BX;
    468         if (uReg == FSxDI) uRegNum = DI;
    469         uRegNum &= BS3_REGISTER_REGISTER_MASK;
    470495    }
    471496
    … …  
    475500        {
    476501            case BS3_REGISTER_FAMILY_16BIT:
    477                 return Bs3RegCtxSetGpr(pCtx, uRegNum, *((uint16_t *)pValue), 2);
     502                return Bs3RegCtxSetGpr(pSetRegCtx->pCtx, uRegNum, pu256Val->au16[0], 2);
    478503            case BS3_REGISTER_FAMILY_32BIT:
    479                 return Bs3RegCtxSetGpr(pCtx, uRegNum, *((uint32_t *)pValue), 4);
     504                return Bs3RegCtxSetGpr(pSetRegCtx->pCtx, uRegNum, pu256Val->au32[0], 4);
    480505            case BS3_REGISTER_FAMILY_64BIT:
    481                 return Bs3RegCtxSetGpr(pCtx, uRegNum, *((uint64_t *)pValue), 8);
     506                return Bs3RegCtxSetGpr(pSetRegCtx->pCtx, uRegNum, pu256Val->au64[0], BS3_MODE_IS_64BIT_CODE(pSetRegCtx->bMode) ? 8 : 4);
    482507            case BS3_REGISTER_FAMILY_XMM:
    483                 if (fZeroYMMHi)
    484                     return Bs3ExtCtxSetXmm(pExtCtx, uRegNum, pValue);
     508                if (pSetRegCtx->fZeroYMMHi)
     509                    return Bs3ExtCtxSetXmm(pSetRegCtx->pExtCtx, uRegNum, &pu256Val->au128[0]);
    485510                else
    486                     return Bs3ExtCtxSetYmm(pExtCtx, uRegNum, pValue, 16);
     511                    return Bs3ExtCtxSetYmm(pSetRegCtx->pExtCtx, uRegNum, pu256Val, 16);
    487512            case BS3_REGISTER_FAMILY_YMM:
    488                 return Bs3ExtCtxSetYmm(pExtCtx, uRegNum, pValue, 32);
     513                return Bs3ExtCtxSetYmm(pSetRegCtx->pExtCtx, uRegNum, pu256Val, 32);
    489514            case BS3_REGISTER_FAMILY_MEMREF:
    490                 Bs3RegCtxSetGrpSegFromCurPtr(pCtx, (&pCtx->rax) + uRegNum, &pCtx->fs, pValue);
     515                Bs3RegCtxSetGrpSegFromCurPtr(pSetRegCtx->pCtx, (&pSetRegCtx->pCtx->rax) + uRegNum, &pSetRegCtx->pCtx->fs, (void *)pu256Val);
    491516                return true;
    492517            case BS3_REGISTER_FAMILY_OTHER:
    493518                if (BS3_REGISTER_IS_MMX(uReg))
    494                     return Bs3ExtCtxSetMm(pExtCtx, uRegNum, *((uint64_t *)pValue), BS3EXTCTXTOPMM_SET);
     519                    return Bs3ExtCtxSetMm(pSetRegCtx->pExtCtx, uRegNum, pu256Val->au64[0], BS3EXTCTXTOPMM_SET);
    495520                break;
    496521            case BS3_REGISTER_FAMILY_8BIT_L:
    … …  
    503528    if (uReg == NOREG)
    504529        return true;
    505     /* FSxDI, FSxBX presumed handled by the callers, though that may change */
    506530
    507531    bs3CpuInstrXGetRegisterName(pszRegName, BS3_REGISTER_NAME_MAXSIZE, uReg);
    508532    return Bs3TestFailedF("Bs3ExtCtxSetReg() todo: handle register '%s' (%02X)", pszRegName, uReg);
    509533}
     534
     535static bool g_fSetRegVerbose = false;
     536
     537static bool Bs3ExtCtxSetReg(PBS3SETREGCTX pSetRegCtx, uint16_t uReg, PCRTUINT256U pu256Val)
     538{
     539    bool fRet = Bs3ExtCtxSetReg_int(pSetRegCtx, uReg, pu256Val);
     540
     541    if (g_fSetRegVerbose)
     542    {
     543        char pszRegName[BS3_REGISTER_NAME_MAXSIZE];
     544        char pszValBuf[80] = "(not decoded)";
     545
     546        switch (uReg & BS3_REGISTER_FAMILY_MASK)
     547        {
     548            case BS3_REGISTER_FAMILY_16BIT:
     549                Bs3StrPrintf(pszValBuf, 80, "%#06RX16", pu256Val->au16[0]);
     550                break;
     551            case BS3_REGISTER_FAMILY_32BIT:
     552                Bs3StrPrintf(pszValBuf, 80, "%#10RX32", pu256Val->au32[0]);
     553                break;
     554            case BS3_REGISTER_FAMILY_64BIT:
     555                Bs3StrPrintf(pszValBuf, 80, "%#18RX64", pu256Val->au64[0]);
     556                break;
     557            case BS3_REGISTER_FAMILY_XMM:
     558                Bs3StrPrintf(pszValBuf, 80, "%#18RX64:%#18RX64", pu256Val->au64[1], pu256Val->au64[0]);
     559                break;
     560            case BS3_REGISTER_FAMILY_YMM:
     561                Bs3StrPrintf(pszValBuf, 80, "%#18RX64:%#18RX64:%#18RX64:%#18RX64", pu256Val->au64[3], pu256Val->au64[2], pu256Val->au64[1], pu256Val->au64[0]);
     562                break;
     563            case BS3_REGISTER_FAMILY_OTHER:
     564                if (BS3_REGISTER_IS_MMX(uReg))
     565                    Bs3StrPrintf(pszValBuf, 80, "%#18RX64", pu256Val->au64[0]);
     566                break;
     567            default:
     568                break;
     569        }
     570        bs3CpuInstrXGetRegisterName(pszRegName, BS3_REGISTER_NAME_MAXSIZE, uReg);
     571        Bs3TestPrintf("Bs3ExtCtxSetReg '%s' to '%s'; %s\n", pszRegName, pszValBuf, fRet ? "worked" : "failed");
     572    }
     573    return fRet;
     574}
Note: See TracChangeset for help on using the changeset viewer.

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