Changeset 96340 in vbox for trunk/src/VBox/VMM/testcase
- Timestamp:
- Aug 19, 2022 3:19:02 PM (2 years ago)
- Location:
- trunk/src/VBox/VMM/testcase
- Files:
-
- 2 added
- 5 edited
-
Makefile.kmk (modified) (1 diff)
-
tstIEMAImpl.cpp (modified) (5 diffs)
-
tstIEMAImpl.h (modified) (3 diffs)
-
tstIEMAImplDataSseBinary-addsd_u128_r64.bin (added)
-
tstIEMAImplDataSseBinary-addss_u128_r32.bin (added)
-
tstIEMAImplDataSseBinary.S (modified) (2 diffs)
-
tstIEMAImplDataSseBinary.asm (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/VMM/testcase/Makefile.kmk
r96336 r96340 244 244 tstIEMAImplDataSseBinary-minpd_u128.bin \ 245 245 tstIEMAImplDataSseBinary-divpd_u128.bin \ 246 tstIEMAImplDataSseBinary-maxpd_u128.bin 246 tstIEMAImplDataSseBinary-maxpd_u128.bin \ 247 tstIEMAImplDataSseBinary-addss_u128_r32.bin \ 248 tstIEMAImplDataSseBinary-addsd_u128_r64.bin 247 249 248 250 tstIEMAImpl_TEMPLATE = VBOXR3TSTEXE -
trunk/src/VBox/VMM/testcase/tstIEMAImpl.cpp
r96336 r96340 4695 4695 if (RT_FAILURE(rc)) 4696 4696 { 4697 RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryR 32[iFn].pszName, rc);4697 RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryR64[iFn].pszName, rc); 4698 4698 return RTEXITCODE_FAILURE; 4699 4699 } … … 4783 4783 if (RT_FAILURE(rc)) 4784 4784 { 4785 RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryR 32[iFn].pszName, rc);4785 RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryR64[iFn].pszName, rc); 4786 4786 return RTEXITCODE_FAILURE; 4787 4787 } … … 4835 4835 } 4836 4836 pfn = g_aSseBinaryR64[iFn].pfnNative; 4837 } 4838 } 4839 } 4840 4841 4842 /* 4843 * Binary SSE operations on packed single precision floating point values. 4844 */ 4845 TYPEDEF_SUBTEST_TYPE(SSE_BINARY_U128_R32_T, SSE_BINARY_U128_R32_TEST_T, PFNIEMAIMPLFPSSEF2U128R32); 4846 4847 static const SSE_BINARY_U128_R32_T g_aSseBinaryU128R32[] = 4848 { 4849 ENTRY_BIN(addss_u128_r32), 4850 }; 4851 4852 #ifdef TSTIEMAIMPL_WITH_GENERATOR 4853 static RTEXITCODE SseBinaryU128R32Generate(const char *pszDataFileFmt, uint32_t cTests) 4854 { 4855 cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */ 4856 4857 static struct { RTFLOAT32U aVal1[4], Val2; } const s_aSpecials[] = 4858 { 4859 { { RTFLOAT32U_INIT_ZERO(0), RTFLOAT32U_INIT_ZERO(0), RTFLOAT32U_INIT_ZERO(0), RTFLOAT32U_INIT_ZERO(0), }, RTFLOAT32U_INIT_C(0, 8388607, RTFLOAT32U_EXP_MAX - 1) }, 4860 /** @todo More specials. */ 4861 }; 4862 4863 X86FXSTATE State; 4864 RT_ZERO(State); 4865 uint32_t cMinNormalPairs = (cTests - 144) / 4; 4866 for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R32); iFn++) 4867 { 4868 PFNIEMAIMPLFPSSEF2U128R32 const pfn = g_aSseBinaryU128R32[iFn].pfnNative ? g_aSseBinaryU128R32[iFn].pfnNative : g_aSseBinaryU128R32[iFn].pfn; 4869 4870 PRTSTREAM pStrmOut = NULL; 4871 int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryU128R32[iFn].pszName); 4872 if (RT_FAILURE(rc)) 4873 { 4874 RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryU128R32[iFn].pszName, rc); 4875 return RTEXITCODE_FAILURE; 4876 } 4877 4878 uint32_t cNormalInputPairs = 0; 4879 for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1) 4880 { 4881 SSE_BINARY_U128_R32_TEST_T TestData; RT_ZERO(TestData); 4882 4883 TestData.InVal1.ar32[0] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0]; 4884 TestData.InVal1.ar32[1] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1]; 4885 TestData.InVal1.ar32[2] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[2]; 4886 TestData.InVal1.ar32[3] = iTest < cTests ? RandR32Src(iTest) : s_aSpecials[iTest - cTests].aVal1[3]; 4887 4888 TestData.r32Val2 = iTest < cTests ? RandR32Src2(iTest) : s_aSpecials[iTest - cTests].Val2; 4889 4890 if ( RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[0]) 4891 && RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[1]) 4892 && RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[2]) 4893 && RTFLOAT32U_IS_NORMAL(&TestData.InVal1.ar32[3]) 4894 && RTFLOAT32U_IS_NORMAL(&TestData.r32Val2)) 4895 cNormalInputPairs++; 4896 else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests) 4897 { 4898 iTest -= 1; 4899 continue; 4900 } 4901 4902 uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS; 4903 for (uint16_t iRounding = 0; iRounding < 4; iRounding++) 4904 for (uint8_t iDaz = 0; iDaz < 2; iDaz++) 4905 for (uint8_t iFz = 0; iFz < 2; iFz++) 4906 { 4907 State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK) 4908 | (iRounding << X86_MXCSR_RC_SHIFT) 4909 | (iDaz ? X86_MXCSR_DAZ : 0) 4910 | (iFz ? X86_MXCSR_FZ : 0) 4911 | X86_MXCSR_XCPT_MASK; 4912 IEMSSERESULT ResM; RT_ZERO(ResM); 4913 pfn(&State, &ResM, &TestData.InVal1, &TestData.r32Val2); 4914 TestData.fMxcsrIn = State.MXCSR; 4915 TestData.fMxcsrOut = ResM.MXCSR; 4916 TestData.OutVal = ResM.uResult; 4917 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 4918 4919 State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK; 4920 IEMSSERESULT ResU; RT_ZERO(ResU); 4921 pfn(&State, &ResU, &TestData.InVal1, &TestData.r32Val2); 4922 TestData.fMxcsrIn = State.MXCSR; 4923 TestData.fMxcsrOut = ResU.MXCSR; 4924 TestData.OutVal = ResU.uResult; 4925 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 4926 4927 uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS; 4928 if (fXcpt) 4929 { 4930 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt; 4931 IEMSSERESULT Res1; RT_ZERO(Res1); 4932 pfn(&State, &Res1, &TestData.InVal1, &TestData.r32Val2); 4933 TestData.fMxcsrIn = State.MXCSR; 4934 TestData.fMxcsrOut = Res1.MXCSR; 4935 TestData.OutVal = Res1.uResult; 4936 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 4937 4938 if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS)) 4939 { 4940 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS; 4941 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT); 4942 IEMSSERESULT Res2; RT_ZERO(Res2); 4943 pfn(&State, &Res2, &TestData.InVal1, &TestData.r32Val2); 4944 TestData.fMxcsrIn = State.MXCSR; 4945 TestData.fMxcsrOut = Res2.MXCSR; 4946 TestData.OutVal = Res2.uResult; 4947 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 4948 } 4949 if (!RT_IS_POWER_OF_TWO(fXcpt)) 4950 for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1) 4951 if (fUnmasked & fXcpt) 4952 { 4953 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT); 4954 IEMSSERESULT Res3; RT_ZERO(Res3); 4955 pfn(&State, &Res3, &TestData.InVal1, &TestData.r32Val2); 4956 TestData.fMxcsrIn = State.MXCSR; 4957 TestData.fMxcsrOut = Res3.MXCSR; 4958 TestData.OutVal = Res3.uResult; 4959 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 4960 } 4961 } 4962 } 4963 } 4964 rc = RTStrmClose(pStrmOut); 4965 if (RT_FAILURE(rc)) 4966 { 4967 RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryU128R32[iFn].pszName, rc); 4968 return RTEXITCODE_FAILURE; 4969 } 4970 } 4971 4972 return RTEXITCODE_SUCCESS; 4973 } 4974 #endif 4975 4976 static void SseBinaryU128R32Test(void) 4977 { 4978 X86FXSTATE State; 4979 RT_ZERO(State); 4980 for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R32); iFn++) 4981 { 4982 if (!SubTestAndCheckIfEnabled(g_aSseBinaryU128R32[iFn].pszName)) 4983 continue; 4984 4985 uint32_t const cTests = *g_aSseBinaryU128R32[iFn].pcTests; 4986 SSE_BINARY_U128_R32_TEST_T const * const paTests = g_aSseBinaryU128R32[iFn].paTests; 4987 PFNIEMAIMPLFPSSEF2U128R32 pfn = g_aSseBinaryU128R32[iFn].pfn; 4988 uint32_t const cVars = COUNT_VARIATIONS(g_aSseBinaryU128R32[iFn]); 4989 if (!cTests) RTTestSkipped(g_hTest, "no tests"); 4990 for (uint32_t iVar = 0; iVar < cVars; iVar++) 4991 { 4992 for (uint32_t iTest = 0; iTest < cTests / sizeof(SSE_BINARY_TEST_T); iTest++) 4993 { 4994 IEMSSERESULT Res; RT_ZERO(Res); 4995 4996 State.MXCSR = paTests[iTest].fMxcsrIn; 4997 pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].r32Val2); 4998 bool fValsIdentical = RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[0], &paTests[iTest].OutVal.ar32[0]) 4999 && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[1], &paTests[iTest].OutVal.ar32[1]) 5000 && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[2], &paTests[iTest].OutVal.ar32[2]) 5001 && RTFLOAT32U_ARE_IDENTICAL(&Res.uResult.ar32[3], &paTests[iTest].OutVal.ar32[3]); 5002 if ( Res.MXCSR != paTests[iTest].fMxcsrOut 5003 || !fValsIdentical) 5004 RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s'%s'%s in2=%s\n" 5005 "%s -> mxcsr=%#08x %s'%s'%s'%s\n" 5006 "%s expected %#08x %s'%s'%s'%s%s%s (%s)\n", 5007 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn, 5008 FormatR32(&paTests[iTest].InVal1.ar32[0]), FormatR32(&paTests[iTest].InVal1.ar32[1]), 5009 FormatR32(&paTests[iTest].InVal1.ar32[2]), FormatR32(&paTests[iTest].InVal1.ar32[3]), 5010 FormatR32(&paTests[iTest].r32Val2), 5011 iVar ? " " : "", Res.MXCSR, 5012 FormatR32(&Res.uResult.ar32[0]), FormatR32(&Res.uResult.ar32[1]), 5013 FormatR32(&Res.uResult.ar32[2]), FormatR32(&Res.uResult.ar32[3]), 5014 iVar ? " " : "", paTests[iTest].fMxcsrOut, 5015 FormatR32(&paTests[iTest].OutVal.ar32[0]), FormatR32(&paTests[iTest].OutVal.ar32[1]), 5016 FormatR32(&paTests[iTest].OutVal.ar32[2]), FormatR32(&paTests[iTest].OutVal.ar32[3]), 5017 MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut), 5018 !fValsIdentical ? " - val" : "", 5019 FormatMxcsr(paTests[iTest].fMxcsrIn) ); 5020 } 5021 } 5022 } 5023 } 5024 5025 5026 /* 5027 * Binary SSE operations on packed single precision floating point values (xxxsd xmm1, r/m64). 5028 */ 5029 TYPEDEF_SUBTEST_TYPE(SSE_BINARY_U128_R64_T, SSE_BINARY_U128_R64_TEST_T, PFNIEMAIMPLFPSSEF2U128R64); 5030 5031 static const SSE_BINARY_U128_R64_T g_aSseBinaryU128R64[] = 5032 { 5033 ENTRY_BIN(addsd_u128_r64), 5034 }; 5035 5036 #ifdef TSTIEMAIMPL_WITH_GENERATOR 5037 static RTEXITCODE SseBinaryU128R64Generate(const char *pszDataFileFmt, uint32_t cTests) 5038 { 5039 cTests = RT_MAX(192, cTests); /* there are 144 standard input variations */ 5040 5041 static struct { RTFLOAT64U aVal1[2], Val2; } const s_aSpecials[] = 5042 { 5043 { { RTFLOAT64U_INIT_ZERO(0), RTFLOAT64U_INIT_ZERO(0) }, RTFLOAT64U_INIT_C(0, 8388607, RTFLOAT64U_EXP_MAX - 1) }, 5044 /** @todo More specials. */ 5045 }; 5046 5047 X86FXSTATE State; 5048 RT_ZERO(State); 5049 uint32_t cMinNormalPairs = (cTests - 144) / 4; 5050 for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R64); iFn++) 5051 { 5052 PFNIEMAIMPLFPSSEF2U128R64 const pfn = g_aSseBinaryU128R64[iFn].pfnNative ? g_aSseBinaryU128R64[iFn].pfnNative : g_aSseBinaryU128R64[iFn].pfn; 5053 5054 PRTSTREAM pStrmOut = NULL; 5055 int rc = RTStrmOpenF("wb", &pStrmOut, pszDataFileFmt, g_aSseBinaryU128R64[iFn].pszName); 5056 if (RT_FAILURE(rc)) 5057 { 5058 RTMsgError("Failed to open data file for %s for writing: %Rrc", g_aSseBinaryU128R64[iFn].pszName, rc); 5059 return RTEXITCODE_FAILURE; 5060 } 5061 5062 uint32_t cNormalInputPairs = 0; 5063 for (uint32_t iTest = 0; iTest < cTests + RT_ELEMENTS(s_aSpecials); iTest += 1) 5064 { 5065 SSE_BINARY_U128_R64_TEST_T TestData; RT_ZERO(TestData); 5066 5067 TestData.InVal1.ar64[0] = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[0]; 5068 TestData.InVal1.ar64[1] = iTest < cTests ? RandR64Src(iTest) : s_aSpecials[iTest - cTests].aVal1[1]; 5069 TestData.r64Val2 = iTest < cTests ? RandR64Src2(iTest) : s_aSpecials[iTest - cTests].Val2; 5070 5071 if ( RTFLOAT64U_IS_NORMAL(&TestData.InVal1.ar64[0]) && RTFLOAT64U_IS_NORMAL(&TestData.InVal1.ar64[1]) 5072 && RTFLOAT64U_IS_NORMAL(&TestData.r64Val2)) 5073 cNormalInputPairs++; 5074 else if (cNormalInputPairs < cMinNormalPairs && iTest + cMinNormalPairs >= cTests && iTest < cTests) 5075 { 5076 iTest -= 1; 5077 continue; 5078 } 5079 5080 uint32_t const fMxcsr = RandMxcsr() & X86_MXCSR_XCPT_FLAGS; 5081 for (uint16_t iRounding = 0; iRounding < 4; iRounding++) 5082 for (uint8_t iDaz = 0; iDaz < 2; iDaz++) 5083 for (uint8_t iFz = 0; iFz < 2; iFz++) 5084 { 5085 State.MXCSR = (fMxcsr & ~X86_MXCSR_RC_MASK) 5086 | (iRounding << X86_MXCSR_RC_SHIFT) 5087 | (iDaz ? X86_MXCSR_DAZ : 0) 5088 | (iFz ? X86_MXCSR_FZ : 0) 5089 | X86_MXCSR_XCPT_MASK; 5090 IEMSSERESULT ResM; RT_ZERO(ResM); 5091 pfn(&State, &ResM, &TestData.InVal1, &TestData.r64Val2); 5092 TestData.fMxcsrIn = State.MXCSR; 5093 TestData.fMxcsrOut = ResM.MXCSR; 5094 TestData.OutVal = ResM.uResult; 5095 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 5096 5097 State.MXCSR = State.MXCSR & ~X86_MXCSR_XCPT_MASK; 5098 IEMSSERESULT ResU; RT_ZERO(ResU); 5099 pfn(&State, &ResU, &TestData.InVal1, &TestData.r64Val2); 5100 TestData.fMxcsrIn = State.MXCSR; 5101 TestData.fMxcsrOut = ResU.MXCSR; 5102 TestData.OutVal = ResU.uResult; 5103 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 5104 5105 uint16_t fXcpt = (ResM.MXCSR | ResU.MXCSR) & X86_MXCSR_XCPT_FLAGS; 5106 if (fXcpt) 5107 { 5108 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | fXcpt; 5109 IEMSSERESULT Res1; RT_ZERO(Res1); 5110 pfn(&State, &Res1, &TestData.InVal1, &TestData.r64Val2); 5111 TestData.fMxcsrIn = State.MXCSR; 5112 TestData.fMxcsrOut = Res1.MXCSR; 5113 TestData.OutVal = Res1.uResult; 5114 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 5115 5116 if (((Res1.MXCSR & X86_MXCSR_XCPT_FLAGS) & fXcpt) != (Res1.MXCSR & X86_MXCSR_XCPT_FLAGS)) 5117 { 5118 fXcpt |= Res1.MXCSR & X86_MXCSR_XCPT_FLAGS; 5119 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | (fXcpt << X86_MXCSR_XCPT_MASK_SHIFT); 5120 IEMSSERESULT Res2; RT_ZERO(Res2); 5121 pfn(&State, &Res2, &TestData.InVal1, &TestData.r64Val2); 5122 TestData.fMxcsrIn = State.MXCSR; 5123 TestData.fMxcsrOut = Res2.MXCSR; 5124 TestData.OutVal = Res2.uResult; 5125 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 5126 } 5127 if (!RT_IS_POWER_OF_TWO(fXcpt)) 5128 for (uint16_t fUnmasked = 1; fUnmasked <= X86_MXCSR_PE; fUnmasked <<= 1) 5129 if (fUnmasked & fXcpt) 5130 { 5131 State.MXCSR = (State.MXCSR & ~X86_MXCSR_XCPT_MASK) | ((fXcpt & ~fUnmasked) << X86_MXCSR_XCPT_MASK_SHIFT); 5132 IEMSSERESULT Res3; RT_ZERO(Res3); 5133 pfn(&State, &Res3, &TestData.InVal1, &TestData.r64Val2); 5134 TestData.fMxcsrIn = State.MXCSR; 5135 TestData.fMxcsrOut = Res3.MXCSR; 5136 TestData.OutVal = Res3.uResult; 5137 RTStrmWrite(pStrmOut, &TestData, sizeof(TestData)); 5138 } 5139 } 5140 } 5141 } 5142 rc = RTStrmClose(pStrmOut); 5143 if (RT_FAILURE(rc)) 5144 { 5145 RTMsgError("Failed to close data file for %s: %Rrc", g_aSseBinaryU128R64[iFn].pszName, rc); 5146 return RTEXITCODE_FAILURE; 5147 } 5148 } 5149 5150 return RTEXITCODE_SUCCESS; 5151 } 5152 #endif 5153 5154 5155 static void SseBinaryU128R64Test(void) 5156 { 5157 X86FXSTATE State; 5158 RT_ZERO(State); 5159 for (size_t iFn = 0; iFn < RT_ELEMENTS(g_aSseBinaryU128R64); iFn++) 5160 { 5161 if (!SubTestAndCheckIfEnabled(g_aSseBinaryU128R64[iFn].pszName)) 5162 continue; 5163 5164 uint32_t const cTests = *g_aSseBinaryU128R64[iFn].pcTests; 5165 SSE_BINARY_U128_R64_TEST_T const * const paTests = g_aSseBinaryU128R64[iFn].paTests; 5166 PFNIEMAIMPLFPSSEF2U128R64 pfn = g_aSseBinaryU128R64[iFn].pfn; 5167 uint32_t const cVars = COUNT_VARIATIONS(g_aSseBinaryU128R64[iFn]); 5168 if (!cTests) RTTestSkipped(g_hTest, "no tests"); 5169 for (uint32_t iVar = 0; iVar < cVars / sizeof(SSE_BINARY_U128_R64_T); iVar++) 5170 { 5171 for (uint32_t iTest = 0; iTest < cTests; iTest++) 5172 { 5173 IEMSSERESULT Res; RT_ZERO(Res); 5174 5175 State.MXCSR = paTests[iTest].fMxcsrIn; 5176 pfn(&State, &Res, &paTests[iTest].InVal1, &paTests[iTest].r64Val2); 5177 if ( Res.MXCSR != paTests[iTest].fMxcsrOut 5178 || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0]) 5179 || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1])) 5180 RTTestFailed(g_hTest, "#%04u%s: mxcsr=%#08x in1=%s'%s in2=%s\n" 5181 "%s -> mxcsr=%#08x %s'%s\n" 5182 "%s expected %#08x %s'%s%s%s (%s)\n", 5183 iTest, iVar ? "/n" : "", paTests[iTest].fMxcsrIn, 5184 FormatR64(&paTests[iTest].InVal1.ar64[0]), FormatR64(&paTests[iTest].InVal1.ar64[1]), 5185 FormatR64(&paTests[iTest].r64Val2), 5186 iVar ? " " : "", Res.MXCSR, 5187 FormatR64(&Res.uResult.ar64[0]), FormatR64(&Res.uResult.ar64[1]), 5188 iVar ? " " : "", paTests[iTest].fMxcsrOut, 5189 FormatR64(&paTests[iTest].OutVal.ar64[0]), FormatR64(&paTests[iTest].OutVal.ar64[1]), 5190 MxcsrDiff(Res.MXCSR, paTests[iTest].fMxcsrOut), 5191 ( !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[0], &paTests[iTest].OutVal.ar64[0]) 5192 || !RTFLOAT64U_ARE_IDENTICAL(&Res.uResult.ar64[1], &paTests[iTest].OutVal.ar64[1])) 5193 ? " - val" : "", 5194 FormatMxcsr(paTests[iTest].fMxcsrIn) ); 5195 } 4837 5196 } 4838 5197 } … … 5178 5537 if (rcExit == RTEXITCODE_SUCCESS) 5179 5538 rcExit = SseBinaryR64Generate(pszDataFileFmt, cTests); 5539 if (rcExit == RTEXITCODE_SUCCESS) 5540 rcExit = SseBinaryU128R32Generate(pszDataFileFmt, cTests); 5541 if (rcExit == RTEXITCODE_SUCCESS) 5542 rcExit = SseBinaryU128R64Generate(pszDataFileFmt, cTests); 5180 5543 if (rcExit != RTEXITCODE_SUCCESS) 5181 5544 return rcExit; … … 5275 5638 SseBinaryR32Test(); 5276 5639 SseBinaryR64Test(); 5640 SseBinaryU128R32Test(); 5641 SseBinaryU128R64Test(); 5277 5642 } 5278 5643 } -
trunk/src/VBox/VMM/testcase/tstIEMAImpl.h
r96336 r96340 354 354 X86XMMREG OutVal; 355 355 } SSE_BINARY_TEST_T; 356 357 typedef struct SSE_BINARY_U128_R32_TEST_T 358 { 359 uint32_t fMxcsrIn; 360 uint32_t fMxcsrOut; 361 uint32_t au32Padding[2]; 362 X86XMMREG OutVal; 363 X86XMMREG InVal1; 364 RTFLOAT32U r32Val2; 365 } SSE_BINARY_U128_R32_TEST_T; 366 367 typedef struct SSE_BINARY_U128_R64_TEST_T 368 { 369 uint32_t fMxcsrIn; 370 uint32_t fMxcsrOut; 371 uint32_t au32Padding[2]; 372 X86XMMREG OutVal; 373 X86XMMREG InVal1; 374 RTFLOAT64U r64Val2; 375 } SSE_BINARY_U128_R64_TEST_T; 356 376 357 377 /** @} */ … … 736 756 TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary, SSE_BINARY_TEST_T, maxps_u128 ); 737 757 758 TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary, SSE_BINARY_U128_R32_TEST_T, addss_u128_r32 ); 759 738 760 TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary, SSE_BINARY_TEST_T, addpd_u128 ); 739 761 TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary, SSE_BINARY_TEST_T, mulpd_u128 ); … … 743 765 TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary, SSE_BINARY_TEST_T, maxpd_u128 ); 744 766 767 TSTIEM_DECLARE_TEST_ARRAY_BIN(SseBinary, SSE_BINARY_U128_R64_TEST_T, addsd_u128_r64 ); 768 745 769 #endif /* !VMM_INCLUDED_SRC_testcase_tstIEMAImpl_h */ 746 770 -
trunk/src/VBox/VMM/testcase/tstIEMAImplDataSseBinary.S
r96336 r96340 64 64 IEM_TEST_DATA(maxps_u128, "tstIEMAImplDataSseBinary-maxps_u128.bin") 65 65 66 IEM_TEST_DATA(addss_u128_r32, "tstIEMAImplDataSseBinary-addss_u128_r32.bin") 67 66 68 IEM_TEST_DATA(addpd_u128, "tstIEMAImplDataSseBinary-addpd_u128.bin") 67 69 IEM_TEST_DATA(mulpd_u128, "tstIEMAImplDataSseBinary-mulpd_u128.bin") … … 70 72 IEM_TEST_DATA(divpd_u128, "tstIEMAImplDataSseBinary-divpd_u128.bin") 71 73 IEM_TEST_DATA(maxpd_u128, "tstIEMAImplDataSseBinary-maxpd_u128.bin") 74 75 IEM_TEST_DATA(addsd_u128_r64, "tstIEMAImplDataSseBinary-addsd_u128_r64.bin") -
trunk/src/VBox/VMM/testcase/tstIEMAImplDataSseBinary.asm
r96336 r96340 55 55 IEM_TEST_DATA maxps_u128, "tstIEMAImplDataSseBinary-maxps_u128.bin" 56 56 57 IEM_TEST_DATA addss_u128_r32, "tstIEMAImplDataSseBinary-addss_u128_r32.bin" 58 57 59 IEM_TEST_DATA addpd_u128, "tstIEMAImplDataSseBinary-addpd_u128.bin" 58 60 IEM_TEST_DATA mulpd_u128, "tstIEMAImplDataSseBinary-mulpd_u128.bin" … … 61 63 IEM_TEST_DATA divpd_u128, "tstIEMAImplDataSseBinary-divpd_u128.bin" 62 64 IEM_TEST_DATA maxpd_u128, "tstIEMAImplDataSseBinary-maxpd_u128.bin" 65 66 IEM_TEST_DATA addsd_u128_r64, "tstIEMAImplDataSseBinary-addsd_u128_r64.bin"
Note:
See TracChangeset
for help on using the changeset viewer.
