From 0887ccd6094955a669251dc6961a0838ded80929 Mon Sep 17 00:00:00 2001 From: Jacek Blaszczynski Date: Sat, 27 Jan 2018 22:18:05 +0100 Subject: [PATCH 1/2] Implement scalar Sse2 hardware intrinsics --- src/jit/emitxarch.cpp | 3 +- src/jit/hwintrinsiccodegenxarch.cpp | 160 ++++++++- src/jit/hwintrinsiclistxarch.h | 45 +++ src/jit/hwintrinsicxarch.cpp | 91 +++++ src/jit/lsraxarch.cpp | 5 + .../X86/Sse2/TestTableSse2.cs | 311 +++++++++++++++++- 6 files changed, 601 insertions(+), 14 deletions(-) diff --git a/src/jit/emitxarch.cpp b/src/jit/emitxarch.cpp index b9f318fc46f3..d1a5f0847145 100644 --- a/src/jit/emitxarch.cpp +++ b/src/jit/emitxarch.cpp @@ -215,6 +215,7 @@ bool emitter::IsDstSrcSrcAVXInstruction(instruction ins) case INS_movhps: case INS_movlpd: case INS_movlps: + case INS_movsdsse2: case INS_movss: case INS_rcpss: case INS_roundsd: @@ -267,7 +268,7 @@ bool emitter::Is4ByteSSE4Instruction(instruction ins) bool emitter::TakesVexPrefix(instruction ins) { // special case vzeroupper as it requires 2-byte VEX prefix - // special case (l|m|s)fence and the prefetch instructions as they never take a VEX prefix + // special case the fencing and the prefetch instructions as they never take a VEX prefix switch (ins) { case INS_lfence: diff --git a/src/jit/hwintrinsiccodegenxarch.cpp b/src/jit/hwintrinsiccodegenxarch.cpp index 597a72b020c6..42640593e048 100644 --- a/src/jit/hwintrinsiccodegenxarch.cpp +++ b/src/jit/hwintrinsiccodegenxarch.cpp @@ -744,7 +744,6 @@ void CodeGen::genSSE2Intrinsic(GenTreeHWIntrinsic* node) regNumber targetReg = node->gtRegNum; var_types targetType = node->TypeGet(); var_types baseType = node->gtSIMDBaseType; - instruction ins = INS_invalid; regNumber op1Reg = REG_NA; regNumber op2Reg = REG_NA; emitter* emit = getEmitter(); @@ -764,15 +763,161 @@ void CodeGen::genSSE2Intrinsic(GenTreeHWIntrinsic* node) assert(op1 != nullptr); assert(op2 != nullptr); assert(baseType == TYP_DOUBLE); - - ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); - op2Reg = op2->gtRegNum; - ival = Compiler::ivalOfHWIntrinsic(intrinsicID); + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + op2Reg = op2->gtRegNum; + ival = Compiler::ivalOfHWIntrinsic(intrinsicID); + assert(ival != -1); emit->emitIns_SIMD_R_R_R_I(ins, emitTypeSize(TYP_SIMD16), targetReg, op1Reg, op2Reg, ival); break; } + case NI_SSE2_CompareEqualOrderedScalar: + case NI_SSE2_CompareEqualUnorderedScalar: + { + assert(baseType == TYP_DOUBLE); + op2Reg = op2->gtRegNum; + regNumber tmpReg = node->GetSingleTempReg(); + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + + emit->emitIns_R_R(ins, emitTypeSize(TYP_SIMD16), op1Reg, op2Reg); + emit->emitIns_R(INS_setpo, EA_1BYTE, targetReg); + emit->emitIns_R(INS_sete, EA_1BYTE, tmpReg); + emit->emitIns_R_R(INS_and, EA_1BYTE, tmpReg, targetReg); + emit->emitIns_R(INS_setne, EA_1BYTE, targetReg); + emit->emitIns_R_R(INS_movzx, EA_1BYTE, targetReg, targetReg); + break; + } + + case NI_SSE2_CompareGreaterThanOrderedScalar: + case NI_SSE2_CompareGreaterThanUnorderedScalar: + { + assert(baseType == TYP_DOUBLE); + op2Reg = op2->gtRegNum; + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + + emit->emitIns_R_R(ins, emitTypeSize(TYP_SIMD16), op1Reg, op2Reg); + emit->emitIns_R(INS_seta, EA_1BYTE, targetReg); + emit->emitIns_R_R(INS_movzx, EA_1BYTE, targetReg, targetReg); + break; + } + + case NI_SSE2_CompareGreaterThanOrEqualOrderedScalar: + case NI_SSE2_CompareGreaterThanOrEqualUnorderedScalar: + { + assert(baseType == TYP_DOUBLE); + op2Reg = op2->gtRegNum; + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + + emit->emitIns_R_R(ins, emitTypeSize(TYP_SIMD16), op1Reg, op2Reg); + emit->emitIns_R(INS_setae, EA_1BYTE, targetReg); + emit->emitIns_R_R(INS_movzx, EA_1BYTE, targetReg, targetReg); + break; + } + + case NI_SSE2_CompareLessThanOrderedScalar: + case NI_SSE2_CompareLessThanUnorderedScalar: + { + assert(baseType == TYP_DOUBLE); + op2Reg = op2->gtRegNum; + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + + emit->emitIns_R_R(ins, emitTypeSize(TYP_SIMD16), op2Reg, op1Reg); + emit->emitIns_R(INS_seta, EA_1BYTE, targetReg); + emit->emitIns_R_R(INS_movzx, EA_1BYTE, targetReg, targetReg); + break; + } + + case NI_SSE2_CompareLessThanOrEqualOrderedScalar: + case NI_SSE2_CompareLessThanOrEqualUnorderedScalar: + { + assert(baseType == TYP_DOUBLE); + op2Reg = op2->gtRegNum; + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + + emit->emitIns_R_R(ins, emitTypeSize(TYP_SIMD16), op2Reg, op1Reg); + emit->emitIns_R(INS_setae, EA_1BYTE, targetReg); + emit->emitIns_R_R(INS_movzx, EA_1BYTE, targetReg, targetReg); + break; + } + + case NI_SSE2_CompareNotEqualOrderedScalar: + case NI_SSE2_CompareNotEqualUnorderedScalar: + { + assert(baseType == TYP_DOUBLE); + op2Reg = op2->gtRegNum; + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + regNumber tmpReg = node->GetSingleTempReg(); + + emit->emitIns_R_R(ins, emitTypeSize(TYP_SIMD16), op1Reg, op2Reg); + emit->emitIns_R(INS_setpe, EA_1BYTE, targetReg); + emit->emitIns_R(INS_setne, EA_1BYTE, tmpReg); + emit->emitIns_R_R(INS_or, EA_1BYTE, tmpReg, targetReg); + emit->emitIns_R(INS_setne, EA_1BYTE, targetReg); + emit->emitIns_R_R(INS_movzx, EA_1BYTE, targetReg, targetReg); + break; + } + + case NI_SSE2_ConvertScalarToVector128Double: + case NI_SSE2_ConvertScalarToVector128Single: + { + assert(baseType == TYP_INT || baseType == TYP_LONG || baseType == TYP_FLOAT || baseType == TYP_DOUBLE); + assert(op1 != nullptr); + assert(op2 != nullptr); + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + genHWIntrinsic_R_R_RM(node, ins); + break; + } + + case NI_SSE2_ConvertScalarToVector128Int64: + case NI_SSE2_ConvertScalarToVector128UInt64: + { + assert(baseType == TYP_LONG || baseType == TYP_ULONG); + assert(op1 != nullptr); + assert(op2 == nullptr); + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + // TODO-XArch-CQ -> use of type size of TYP_SIMD16 leads to + // instruction register encoding errors for SSE legacy encoding + emit->emitIns_R_R(ins, emitTypeSize(baseType), targetReg, op1Reg); + break; + } + + case NI_SSE2_ConvertToDouble: + { + assert(op2 == nullptr); + if (op1Reg != targetReg) + { + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + emit->emitIns_R_R(ins, emitTypeSize(targetType), targetReg, op1Reg); + } + break; + } + + case NI_SSE2_ConvertToInt32: + case NI_SSE2_ConvertToInt64: + case NI_SSE2_ConvertToUInt32: + case NI_SSE2_ConvertToUInt64: + { + assert(op2 == nullptr); + assert(baseType == TYP_DOUBLE || baseType == TYP_FLOAT || baseType == TYP_INT || baseType == TYP_UINT || + baseType == TYP_LONG || baseType == TYP_ULONG); + if (op1Reg != targetReg) + { + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + if (baseType == TYP_DOUBLE || baseType == TYP_FLOAT) + { + emit->emitIns_R_R(ins, emitTypeSize(targetType), targetReg, op1Reg); + } + else + { + // TODO-XArch-Bug https://github.com/dotnet/coreclr/issues/16329 + // using hardcoded instruction as workaround for inexact type conversions + emit->emitIns_R_R(INS_mov_xmm2i, emitActualTypeSize(baseType), op1Reg, targetReg); + } + } + break; + } + case NI_SSE2_LoadFence: { assert(baseType == TYP_VOID); @@ -781,6 +926,7 @@ void CodeGen::genSSE2Intrinsic(GenTreeHWIntrinsic* node) emit->emitIns(INS_lfence); break; } + case NI_SSE2_MemoryFence: { assert(baseType == TYP_VOID); @@ -795,7 +941,7 @@ void CodeGen::genSSE2Intrinsic(GenTreeHWIntrinsic* node) assert(op2 == nullptr); assert(baseType == TYP_BYTE || baseType == TYP_UBYTE || baseType == TYP_DOUBLE); - ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); emit->emitIns_R_R(ins, emitTypeSize(TYP_INT), targetReg, op1Reg); break; } @@ -807,7 +953,7 @@ void CodeGen::genSSE2Intrinsic(GenTreeHWIntrinsic* node) assert(op1 == nullptr); assert(op2 == nullptr); - ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); + instruction ins = Compiler::insOfHWIntrinsic(intrinsicID, baseType); emit->emitIns_SIMD_R_R_R(ins, emitTypeSize(TYP_SIMD16), targetReg, targetReg, targetReg); break; } diff --git a/src/jit/hwintrinsiclistxarch.h b/src/jit/hwintrinsiclistxarch.h index 7ffbcef9c8b3..9cb33dd04991 100644 --- a/src/jit/hwintrinsiclistxarch.h +++ b/src/jit/hwintrinsiclistxarch.h @@ -129,44 +129,88 @@ HARDWARE_INTRINSIC(SSE_Xor, "Xor", HARDWARE_INTRINSIC(SSE2_IsSupported, "get_IsSupported", SSE2, -1, 0, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_IsSupportedProperty, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_Add, "Add", SSE2, -1, 16, 2, {INS_paddb, INS_paddb, INS_paddw, INS_paddw, INS_paddd, INS_paddd, INS_paddq, INS_paddq, INS_invalid, INS_addpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) HARDWARE_INTRINSIC(SSE2_AddSaturate, "AddSaturate", SSE2, -1, 16, 2, {INS_paddsb, INS_paddusb, INS_paddsw, INS_paddusw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative) +HARDWARE_INTRINSIC(SSE2_AddScalar, "AddScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_addsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_And, "And", SSE2, -1, 16, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_invalid, INS_andpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) HARDWARE_INTRINSIC(SSE2_AndNot, "AndNot", SSE2, -1, 16, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_Average, "Average", SSE2, -1, 16, 2, {INS_invalid, INS_pavgb, INS_invalid, INS_pavgw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative) HARDWARE_INTRINSIC(SSE2_CompareEqual, "CompareEqual", SSE2, 0, 16, 2, {INS_pcmpeqb, INS_pcmpeqb, INS_pcmpeqw, INS_pcmpeqw, INS_pcmpeqd, INS_pcmpeqd, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) +HARDWARE_INTRINSIC(SSE2_CompareEqualOrderedScalar, "CompareEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) +HARDWARE_INTRINSIC(SSE2_CompareEqualScalar, "CompareEqualScalar", SSE2, 0, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_CompareEqualUnorderedScalar, "CompareEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_CompareGreaterThan, "CompareGreaterThan", SSE2, 6, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrderedScalar, "CompareGreaterThanOrderedScalar", SSE2, -1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) +HARDWARE_INTRINSIC(SSE2_CompareGreaterThanScalar, "CompareGreaterThanScalar", SSE2, 6, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_CompareGreaterThanUnorderedScalar, "CompareGreaterThanUnorderedScalar", SSE2, -1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqual, "CompareGreaterThanOrEqual", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqualOrderedScalar, "CompareGreaterThanOrEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) +HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqualScalar, "CompareGreaterThanOrEqualScalar", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_CompareGreaterThanOrEqualUnorderedScalar, "CompareGreaterThanOrEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_CompareLessThan, "CompareLessThan", SSE2, 1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareLessThanOrderedScalar, "CompareLessThanOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) +HARDWARE_INTRINSIC(SSE2_CompareLessThanScalar, "CompareLessThanScalar", SSE2, 1, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromArg|HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_CompareLessThanUnorderedScalar, "CompareLessThanUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqual, "CompareLessThanOrEqual", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqualOrderedScalar, "CompareLessThanOrEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) +HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqualScalar, "CompareLessThanOrEqualScalar", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_CompareLessThanOrEqualUnorderedScalar, "CompareLessThanOrEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_CompareNotEqual, "CompareNotEqual", SSE2, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) +HARDWARE_INTRINSIC(SSE2_CompareNotEqualOrderedScalar, "CompareNotEqualOrderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_comisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) +HARDWARE_INTRINSIC(SSE2_CompareNotEqualScalar, "CompareNotEqualScalar", SSE2, 4, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_CompareNotEqualUnorderedScalar, "CompareNotEqualUnorderedScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ucomisd}, HW_Category_SIMDScalar, HW_Flag_MultiIns|HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThan, "CompareNotGreaterThan", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThanScalar, "CompareNotGreaterThanScalar", SSE2, 2, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThanOrEqual, "CompareNotGreaterThanOrEqual", SSE2, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareNotGreaterThanOrEqualScalar, "CompareNotGreaterThanOrEqualScalar", SSE2, 1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_CompareNotLessThan, "CompareNotLessThan", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareNotLessThanScalar, "CompareNotLessThanScalar", SSE2, 5, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_CompareNotLessThanOrEqual, "CompareNotLessThanOrEqual", SSE2, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareNotLessThanOrEqualScalar, "CompareNotLessThanOrEqualScalar", SSE2, 6, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_CompareOrdered, "CompareOrdered", SSE2, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareOrderedScalar, "CompareOrderedScalar", SSE2, 7, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_CompareUnordered, "CompareUnordered", SSE2, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_CompareUnorderedScalar, "CompareUnorderedScalar", SSE2, 3, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmpsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) +HARDWARE_INTRINSIC(SSE2_ConvertToDouble, "ConvertToDouble", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movsd}, HW_Category_Helper, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_ConvertToInt32, "ConvertToInt32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtsd2si}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_ConvertToInt32WithTruncation, "ConvertToInt32WithTruncation", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttsd2si}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromArg) +HARDWARE_INTRINSIC(SSE2_ConvertToInt64, "ConvertToInt64", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_cvtsd2si}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_ConvertToInt64WithTruncation, "ConvertToInt64WithTruncation", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttsd2si}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromArg) +HARDWARE_INTRINSIC(SSE2_ConvertToUInt32, "ConvertToUInt32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_ConvertToUInt64, "ConvertToUInt64", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_ConvertToVector128Double, "ConvertToVector128Double", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtdq2pd, INS_invalid, INS_invalid, INS_invalid, INS_cvtps2pd, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) +HARDWARE_INTRINSIC(SSE2_ConvertScalarToVector128Double, "ConvertScalarToVector128Double", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtsi2sd, INS_invalid, INS_cvtsi2sd, INS_invalid, INS_cvtss2sd, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_ConvertToVector128Int32, "ConvertToVector128Int32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtps2dq, INS_cvtpd2dq}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) +HARDWARE_INTRINSIC(SSE2_ConvertScalarToVector128Int32, "ConvertScalarToVector128Int32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_i2xmm, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_ConvertToVector128Int32WithTruncation, "ConvertToVector128Int32WithTruncation", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttps2dq, INS_cvttpd2dq}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) +HARDWARE_INTRINSIC(SSE2_ConvertScalarToVector128Int64, "ConvertScalarToVector128Int64", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_i2xmm, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_ConvertToVector128Single, "ConvertToVector128Single", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtdq2ps, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtpd2ps}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) +HARDWARE_INTRINSIC(SSE2_ConvertScalarToVector128Single, "ConvertScalarToVector128Single", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtsd2ss}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_ConvertScalarToVector128UInt32, "ConvertScalarToVector128UInt32", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_i2xmm, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_ConvertScalarToVector128UInt64, "ConvertScalarToVector128UInt64", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_i2xmm, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_Divide, "Divide", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_divpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_DivideScalar, "DivideScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_divsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_LoadAlignedVector128, "LoadAlignedVector128", SSE2, -1, 16, 1, {INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_invalid, INS_movapd}, HW_Category_MemoryLoad, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_LoadFence, "LoadFence", SSE2, -1, 0, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_LoadScalarVector128, "LoadScalarVector128", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movd, INS_movd, INS_movq, INS_movq, INS_invalid, INS_movsdsse2}, HW_Category_MemoryLoad, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_LoadVector128, "LoadVector128", SSE2, -1, 16, 1, {INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_invalid, INS_movupd}, HW_Category_MemoryLoad, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_Max, "Max", SSE2, -1, 16, 2, {INS_invalid, INS_pmaxub, INS_pmaxsw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_maxpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) HARDWARE_INTRINSIC(SSE2_MemoryFence, "MemoryFence", SSE2, -1, 0, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_MaxScalar, "MaxScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_maxsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_Min, "Min", SSE2, -1, 16, 2, {INS_invalid, INS_pminub, INS_pminsw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_minpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) +HARDWARE_INTRINSIC(SSE2_MinScalar, "MinScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_minsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_MoveMask, "MoveMask", SSE2, -1, 16, 1, {INS_pmovmskb, INS_pmovmskb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movmskpd}, HW_Category_Special, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_MoveScalar, "MoveScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movsdsse2}, HW_Category_SIMDScalar, HW_Flag_NoContainment) HARDWARE_INTRINSIC(SSE2_Multiply, "Multiply", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pmuludq, INS_invalid, INS_invalid, INS_invalid, INS_mulpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_BaseTypeFromArg) HARDWARE_INTRINSIC(SSE2_MultiplyHigh, "MultiplyHigh", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_pmulhw, INS_pmulhuw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative) HARDWARE_INTRINSIC(SSE2_MultiplyHorizontalAdd, "MultiplyHorizontalAdd", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_pmaddwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_BaseTypeFromArg) HARDWARE_INTRINSIC(SSE2_MultiplyLow, "MultiplyLow", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_pmullw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative) +HARDWARE_INTRINSIC(SSE2_MultiplyScalar, "MultiplyScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_Or, "Or", SSE2, -1, 16, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_invalid, INS_orpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) HARDWARE_INTRINSIC(SSE2_PackSignedSaturate, "PackSignedSaturate", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_packsswb, INS_invalid, INS_packssdw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) HARDWARE_INTRINSIC(SSE2_PackUnsignedSaturate, "PackUnsignedSaturate", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_packuswb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) HARDWARE_INTRINSIC(SSE2_SetZeroVector128, "SetZeroVector128", SSE2, -1, 16, 0, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_xorpd}, HW_Category_Helper, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_SumAbsoluteDifferences, "SumAbsoluteDifferences", SSE2, -1, 16, 2, {INS_invalid, INS_psadbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromArg) HARDWARE_INTRINSIC(SSE2_Sqrt, "Sqrt", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqrtpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_SqrtScalar, "SqrtScalar", SSE2, -1, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqrtsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_Store, "Store", SSE2, -1, 16, 2, {INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_movdqu, INS_invalid, INS_movupd}, HW_Category_MemoryStore, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_StoreAligned, "StoreAligned", SSE2, -1, 16, 2, {INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_invalid, INS_movapd}, HW_Category_MemoryStore, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_StoreAlignedNonTemporal, "StoreAlignedNonTemporal", SSE2, -1, 16, 2, {INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_invalid, INS_movntpd}, HW_Category_MemoryStore, HW_Flag_NoFlag) @@ -175,6 +219,7 @@ HARDWARE_INTRINSIC(SSE2_StoreLow, "StoreLow", HARDWARE_INTRINSIC(SSE2_StoreHigh, "StoreHigh", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movhpd}, HW_Category_MemoryStore, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_Subtract, "Subtract", SSE2, -1, 16, 2, {INS_psubb, INS_psubb, INS_psubw, INS_psubw, INS_psubd, INS_psubd, INS_psubq, INS_psubq, INS_invalid, INS_subpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_SubtractSaturate, "SubtractSaturate", SSE2, -1, 16, 2, {INS_psubsb, INS_psubusb, INS_psubsw, INS_psubusw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) +HARDWARE_INTRINSIC(SSE2_SubtractScalar, "SubtractScalar", SSE2, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_subsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE2_UnpackHigh, "UnpackHigh", SSE2, -1, 16, 2, {INS_punpckhbw, INS_punpckhbw, INS_punpckhwd, INS_punpckhwd, INS_punpckhdq, INS_punpckhdq, INS_punpckhqdq,INS_punpckhqdq,INS_invalid, INS_unpckhpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_UnpackLow, "UnpackLow", SSE2, -1, 16, 2, {INS_punpcklbw, INS_punpcklbw, INS_punpcklwd, INS_punpcklwd, INS_punpckldq, INS_punpckldq, INS_punpcklqdq,INS_punpcklqdq,INS_invalid, INS_unpcklpd}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2_Xor, "Xor", SSE2, -1, 16, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_xorpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative) diff --git a/src/jit/hwintrinsicxarch.cpp b/src/jit/hwintrinsicxarch.cpp index 0fc225160817..383c2c1d6da0 100644 --- a/src/jit/hwintrinsicxarch.cpp +++ b/src/jit/hwintrinsicxarch.cpp @@ -736,11 +736,17 @@ GenTree* Compiler::impSSE2Intrinsic(NamedIntrinsic intrinsic, var_types baseType = TYP_UNKNOWN; var_types retType = TYP_UNKNOWN; + // The fencing intrinsics don't take any operands and simdSize is 0 assert((simdSize == 16) || (simdSize == 0)); + CORINFO_ARG_LIST_HANDLE argList = sig->args; + CORINFO_CLASS_HANDLE argClass; + var_types argType = TYP_UNKNOWN; + switch (intrinsic) { case NI_SSE2_CompareLessThan: + { assert(sig->numArgs == 2); op2 = impSIMDPopStack(TYP_SIMD16); op1 = impSIMDPopStack(TYP_SIMD16); @@ -755,6 +761,89 @@ GenTree* Compiler::impSSE2Intrinsic(NamedIntrinsic intrinsic, gtNewSimdHWIntrinsicNode(TYP_SIMD16, op2, op1, NI_SSE2_CompareGreaterThan, baseType, simdSize); } break; + } + + case NI_SSE2_ConvertScalarToVector128Double: + { + assert(sig->numArgs == 2); + assert(getBaseTypeOfSIMDType(sig->retTypeSigClass) == TYP_DOUBLE); + + argList = info.compCompHnd->getArgNext(sig->args); + CorInfoType corType = + strip(info.compCompHnd->getArgType(sig, argList, &argClass)); // type of the second argument + + baseType = JITtype2varType(corType); + +#ifdef _TARGET_X86_ + if (varTypeIsLong(JITtype2varType(corType))) + { + return impUnsupportedHWIntrinsic(CORINFO_HELP_THROW_PLATFORM_NOT_SUPPORTED, method, sig, mustExpand); + } +#endif // _TARGET_X86_ + + if (baseType == TYP_STRUCT) + { + baseType = TYP_FLOAT; // it is the only type passed as Vector + op2 = impSIMDPopStack(TYP_SIMD16); + } + else + { + op2 = impPopStack().val; + } + + op1 = impSIMDPopStack(TYP_SIMD16); + retNode = gtNewSimdHWIntrinsicNode(TYP_SIMD16, op1, op2, intrinsic, baseType, simdSize); + + break; + } + + case NI_SSE2_ConvertScalarToVector128Int64: + case NI_SSE2_ConvertScalarToVector128UInt64: + { + assert(sig->numArgs == 1); + baseType = getBaseTypeOfSIMDType(sig->retTypeSigClass); + assert(baseType == TYP_LONG || baseType == TYP_ULONG); + +#ifdef _TARGET_X86_ + return impUnsupportedHWIntrinsic(CORINFO_HELP_THROW_PLATFORM_NOT_SUPPORTED, method, sig, mustExpand); +#endif // _TARGET_X86_ + + op1 = impPopStack().val; + retNode = gtNewSimdHWIntrinsicNode(TYP_SIMD16, op1, intrinsic, baseType, simdSize); + break; + } + + case NI_SSE2_ConvertScalarToVector128Single: + { + assert(sig->numArgs == 2); + assert(getBaseTypeOfSIMDType(sig->retTypeSigClass) == TYP_FLOAT); + + op2 = impSIMDPopStack(TYP_SIMD16); + op1 = impSIMDPopStack(TYP_SIMD16); + retNode = gtNewSimdHWIntrinsicNode(TYP_SIMD16, op1, op2, intrinsic, TYP_DOUBLE, simdSize); + break; + } + + case NI_SSE2_ConvertToInt32: + case NI_SSE2_ConvertToInt64: + { + assert(sig->numArgs == 1); + op1 = impSIMDPopStack(TYP_SIMD16); + retType = JITtype2varType(sig->retType); + baseType = getBaseTypeOfSIMDType(info.compCompHnd->getArgClass(sig, sig->args)); + retNode = gtNewSimdHWIntrinsicNode(retType, op1, intrinsic, baseType, simdSize); + break; + } + + case NI_SSE2_ConvertToUInt32: + case NI_SSE2_ConvertToUInt64: + { + assert(sig->numArgs == 1); + op1 = impSIMDPopStack(TYP_SIMD16); + baseType = JITtype2varType(sig->retType); + retNode = gtNewSimdHWIntrinsicNode(baseType, op1, intrinsic, baseType, simdSize); + break; + } case NI_SSE2_LoadFence: case NI_SSE2_MemoryFence: @@ -768,6 +857,7 @@ GenTree* Compiler::impSSE2Intrinsic(NamedIntrinsic intrinsic, } case NI_SSE2_MoveMask: + { assert(sig->numArgs == 1); retType = JITtype2varType(sig->retType); assert(retType == TYP_INT); @@ -775,6 +865,7 @@ GenTree* Compiler::impSSE2Intrinsic(NamedIntrinsic intrinsic, baseType = getBaseTypeOfSIMDType(info.compCompHnd->getArgClass(sig, sig->args)); retNode = gtNewSimdHWIntrinsicNode(retType, op1, intrinsic, baseType, simdSize); break; + } default: JITDUMP("Not implemented hardware intrinsic"); diff --git a/src/jit/lsraxarch.cpp b/src/jit/lsraxarch.cpp index e4095739c462..63db1b0a31c5 100644 --- a/src/jit/lsraxarch.cpp +++ b/src/jit/lsraxarch.cpp @@ -2286,6 +2286,10 @@ void LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) case NI_SSE_CompareEqualUnorderedScalar: case NI_SSE_CompareNotEqualOrderedScalar: case NI_SSE_CompareNotEqualUnorderedScalar: + case NI_SSE2_CompareEqualOrderedScalar: + case NI_SSE2_CompareEqualUnorderedScalar: + case NI_SSE2_CompareNotEqualOrderedScalar: + case NI_SSE2_CompareNotEqualUnorderedScalar: info->internalIntCount = 1; info->setInternalCandidates(this, RBM_BYTE_REGS); break; @@ -2317,6 +2321,7 @@ void LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) case NI_SSE_ConvertToSingle: case NI_SSE_StaticCast: + case NI_SSE2_ConvertToDouble: assert(info->srcCount == 1); assert(info->dstCount == 1); useList.Last()->info.isTgtPref = true; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/TestTableSse2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/TestTableSse2.cs index 8233c1660855..e3fc3e8b8f4d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/TestTableSse2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/TestTableSse2.cs @@ -4,11 +4,11 @@ // using System; -using System.Globalization; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; using System.Runtime.Intrinsics.X86; +using System.Text; namespace IntelHardwareIntrinsicTest { @@ -36,6 +36,9 @@ public delegate bool CheckMethodSix( ValueTuple> z, ref U a1, ref U a2, ref U a3, ref U a4, ref U a5, ref U a6, ref U a7, ref U a8); + public delegate bool CheckMethodEight( + Span x, Span y, Span z, Span a); + public delegate bool CheckMethodEightOne( Span x, Span y, U z, ref U a); @@ -106,6 +109,12 @@ public void SetOutArray(Vector128 value, int index = -1) Unsafe.Write((byte*)OutArrayPtr + (index * _stepSize), value); } + public void SetOutArray(bool value1, Vector128 value2, int index = -1) + { + index = index < 0 ? _index : index; + Unsafe.Write((byte*)OutArrayPtr + (index * _stepSize), value2); + } + public (Vector128, Vector128, Vector128) this[int index] { get @@ -1040,7 +1049,8 @@ public void Dispose() public unsafe struct TestTableImmSse2 : IDisposable where T : struct where U : struct where V : struct { private const int _stepSize = 16; - private int _tSize; + private static int s_tSize; + private static int s_ElementCount; private GCHandle _inHandle1; private GCHandle _inHandle2; @@ -1100,8 +1110,9 @@ public static TestTableImmSse2 Create(int lengthInVectors, double tSize public TestTableImmSse2(int lengthInVectors, double tSizeMultiplier = 1.0, bool initialize = true) { - _tSize = Marshal.SizeOf(); - int length = _stepSize / _tSize * lengthInVectors; + s_tSize = Marshal.SizeOf(); + s_ElementCount = _stepSize / s_tSize; + int length = s_ElementCount * lengthInVectors; inArray1 = new T[length]; inArray2 = new T[lengthInVectors]; immArray = new V[lengthInVectors]; @@ -1147,7 +1158,7 @@ public void Initialize(InitMode mode = InitMode.Undefined) } else { - random.NextBytes(new Span(((byte*)InArray1Ptr), inArray1.Length * _tSize)); + random.NextBytes(new Span(((byte*)InArray1Ptr), inArray1.Length * s_tSize)); } } else if (mode == InitMode.NumberFirstVectors) @@ -1237,7 +1248,7 @@ public bool CheckResultImm(CheckMethodEightImm check) bool result = true; for (int i = 0; i < inArray1.Length; i++) { - int elNo = _stepSize / _tSize; + int elNo = _stepSize / s_tSize; if (!check( new Span(inArray1, Index * elNo, elNo), inArray2[i], immArray[i], @@ -1260,6 +1271,257 @@ public void Dispose() } } + public unsafe struct TestTableScalarSse2 : IDisposable where T : struct where U : struct + { + private const int _stepSize = 16; + private static int s_tSize; + public static int s_ElementCount; + + private GCHandle _inHandle1; + private GCHandle _inHandle2; + private GCHandle _outHandle; + private GCHandle _checkHandle; + + private int _index; + + public T[] inArray1; + public T[] inArray2; + public U[] outArray; + public U[] checkArray; + + public void* InArray1Ptr => _inHandle1.AddrOfPinnedObject().ToPointer(); + public void* InArray2Ptr => _inHandle2.AddrOfPinnedObject().ToPointer(); + public void* OutArrayPtr => _outHandle.AddrOfPinnedObject().ToPointer(); + public void* CheckArrayPtr => _checkHandle.AddrOfPinnedObject().ToPointer(); + + public Vector128 Vector1 => Unsafe.Read>((byte*)InArray1Ptr + (_index * _stepSize)); + public Vector128 Vector2 => Unsafe.Read>((byte*)InArray2Ptr + (_index * _stepSize)); + + public int Index { get => _index; set => _index = value; } + + public void SetIndex(int index) + { + _index = index; + } + + public void SetOutArray(U value, int index = -1) + { + index = index < 0 ? _index : index; + outArray[_index] = value; + } + + public void SetOutArray(Vector128 value, int index = -1) + { + index = index < 0 ? _index : index; + Unsafe.Write((byte*)OutArrayPtr + (_index * _stepSize), value); + } + + public (Vector128, Vector128) this[int index] + { + get + { + _index = index; + return (Vector1, Vector2); + } + } + + public ValueTuple, Memory, Memory, Memory> GetMemoryDataPoint(int index) + { + return (new Memory(inArray1, index, s_ElementCount), new Memory(inArray2, index, s_ElementCount), + new Memory(outArray, index, s_ElementCount), new Memory(checkArray, index, s_ElementCount)); + } + + public ValueTuple, Memory, U, U> GetMemoryValueDataPoint(int index) + { + return (new Memory(inArray1, index, s_ElementCount), new Memory(inArray2, index, s_ElementCount), + outArray[index/s_ElementCount], checkArray[index/s_ElementCount]); + } + + public static TestTableScalarSse2 Create(int lengthInVectors, double tSizeMultiplier = 1.0) + { + return new TestTableScalarSse2(lengthInVectors, tSizeMultiplier); + } + + public TestTableScalarSse2(int lengthInVectors, double tSizeMultiplier = 1.0, bool initialize = true) + { + s_tSize = Marshal.SizeOf(); + s_ElementCount = _stepSize / s_tSize; + int length = s_ElementCount * lengthInVectors; + inArray1 = new T[length]; + inArray2 = new T[length]; + outArray = new U[(int)(length / tSizeMultiplier)]; + checkArray = new U[(int)(length / tSizeMultiplier)]; + _index = 0; + _inHandle1 = GCHandle.Alloc(inArray1, GCHandleType.Pinned); + _inHandle2 = GCHandle.Alloc(inArray2, GCHandleType.Pinned); + _outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + _checkHandle = GCHandle.Alloc(checkArray, GCHandleType.Pinned); + if (initialize) + { + Initialize(); + } + } + + public void Initialize() + { + Initialize(InitMode.Undefined); + } + + public void Initialize(InitMode mode = InitMode.Undefined) + { + if (mode == InitMode.Undefined) + { + Random random = new Random(unchecked((int)(DateTime.UtcNow.Ticks & 0x00000000ffffffffl))); + if (inArray1 is double[]) + { + var array1 = inArray1 as double[]; + var array2 = inArray2 as double[]; + for (int i = 0; i < array1.Length; i++) + { + array1[i] = random.NextDouble() * random.Next(); + array2[i] = random.NextDouble() * random.Next(); + } + } + else if (inArray1 is float[]) + { + var arrayFloat1 = inArray1 as float[]; + var arrayFloat2 = inArray2 as float[]; + for (int i = 0; i < arrayFloat1.Length; i++) + { + arrayFloat1[i] = (float)(random.NextDouble() * random.Next(ushort.MaxValue)); + arrayFloat2[i] = (float)(random.NextDouble() * random.Next(ushort.MaxValue)); + } + } + else + { + random.NextBytes(new Span(((byte*)InArray1Ptr), inArray1.Length * s_tSize)); + random.NextBytes(new Span(((byte*)InArray2Ptr), inArray2.Length * s_tSize)); + } + } + else if (mode == InitMode.NumberFirstVectors) + { + InitializeWithVectorNumbering(); + } + } + + private void InitializeWithVectorNumbering() + { + Type baseType = typeof(T); + if (inArray1 is double[] doubleArray1) + { + for (double i = 0.0, j = 10000.0; i < doubleArray1.Length; i++, j++) + { + doubleArray1[(int)i] = i; + } + } + else if (inArray1 is float[] floatArray1) + { + for (float i = 0.0f, j = 10000.0f; i < floatArray1.Length; i++, j++) + { + floatArray1[(int)i] = i; + } + } + else if (inArray1 is byte[] byteArray1) + { + for (byte i = 0, j = 100; i < byteArray1.Length; i++, j++) + { + byteArray1[i] = i; + } + } + else if (inArray1 is sbyte[] sbyteArray1) + { + for (sbyte i = 0, j = 100; i < sbyteArray1.Length; i++, j++) + { + sbyteArray1[i] = i; + } + } + else if (inArray1 is short[] shortArray1) + { + for (short i = 0, j = 10000; i < shortArray1.Length; i++, j++) + { + shortArray1[i] = i; + } + + } + else if (inArray1 is ushort[] ushortArray1) + { + for (ushort i = 0, j = 10000; i < ushortArray1.Length; i++, j++) + { + ushortArray1[i] = i; + } + } + else if (inArray1 is int[] intArray1) + { + for (int i = 0, j = 10000; i < intArray1.Length; i++, j++) + { + intArray1[i] = i; + } + } + else if (inArray1 is uint[] uintArray1) + { + for (uint i = 0, j = 10000; i < uintArray1.Length; i++, j++) + { + uintArray1[i] = i; + } + } + else if (inArray1 is long[] longArray1) + { + for (long i = 0, j = 10000; i < longArray1.Length; i++, j++) + { + longArray1[i] = i; + } + } + else if (inArray1 is ulong[] ulongArray1) + { + for (uint i = 0, j = 10000; i < ulongArray1.Length; i++, j++) + { + ulongArray1[i] = i; + } + } + } + + public bool CheckResult(CheckMethodEight check) + { + bool result = true; + for (int i = 0; i < inArray1.Length - 1; i += s_ElementCount) + { + if (!check( + new Span(inArray1, i, s_ElementCount), + new Span(inArray2, i, s_ElementCount), + new Span(outArray, i, s_ElementCount), + new Span(checkArray, i, s_ElementCount))) + { + result = false; + } + } + return result; + } + + public bool CheckResult(CheckMethodEightOne check) + { + bool result = true; + for (int i = 0, j =0; i < inArray1.Length - 1; i += s_ElementCount, j++) + { + if (!check( + new Span(inArray1, i, s_ElementCount), + new Span(inArray2, i, s_ElementCount), + outArray[j], ref checkArray[j])) + { + result = false; + } + } + return result; + } + + public void Dispose() + { + _inHandle1.Free(); + _inHandle2.Free(); + _outHandle.Free(); + _checkHandle.Free(); + } + } + public enum SpecialCheck { Undefined = 0, @@ -1282,6 +1544,19 @@ private static void PrintErrorHeaderTuv(string functionName, string testFu Console.WriteLine($"{ typeof(Sse2)}.{functionName} test tuples:"); } + private static string PrintMemory(Memory x) + { + var xSpan = x.Span; + var builder = new StringBuilder().Append("("); + for (int i = 0; i < x.Length; i++) + { + builder.Append(xSpan[i]); + if (i + 1 < x.Length) + builder.Append(", "); + } + return builder.Append(")").ToString(); + } + private static void PrintError(TestTableSse2 testTable, string functionName = "", string testFuncString = "", CheckMethod check = null) where T : struct { @@ -1391,6 +1666,30 @@ private static void PrintError(TestTableSse2 testTable, string funct Console.WriteLine(); } + private static void PrintError(TestTableScalarSse2 testTable, string functionName = "", string testFuncString = "", + CheckMethodEight check = null) where T : struct where U : struct + { + PrintErrorHeaderTu(functionName, testFuncString); + for (int i = 0; i < testTable.inArray1.Length - 1; i += TestTableScalarSse2.s_ElementCount) + { + var item = testTable.GetMemoryDataPoint(i); + Console.Write($"( x{PrintMemory(item.Item1)}, y{PrintMemory(item.Item2)}, z{PrintMemory(item.Item3)}, a{PrintMemory(item.Item4)})"); + } + Console.WriteLine(); + } + + private static void PrintError(TestTableScalarSse2 testTable, string functionName = "", string testFuncString = "", + CheckMethodEightOne check = null) where T : struct where U : struct + { + PrintErrorHeaderTu(functionName, testFuncString); + for (int i = 0; i < testTable.inArray1.Length - 1; i += TestTableScalarSse2.s_ElementCount) + { + var item = testTable.GetMemoryValueDataPoint(i); + Console.Write($"( x{PrintMemory(item.Item1)}, y{PrintMemory(item.Item2)}, z({item.Item3}), a({item.Item4}))"); + } + Console.WriteLine(); + } + private static void PrintError(TestTableSse2 testTable, string functionName = "", string testFuncString = "", CheckMethodEightOne check = null) where T : struct where U : struct { From f8fc2fb00455d4b03462446cedf6eda7a83ec38e Mon Sep 17 00:00:00 2001 From: Jacek Blaszczynski Date: Tue, 6 Feb 2018 21:24:59 +0100 Subject: [PATCH 2/2] Add Sse2 scalar hardware intrinsics tests --- .../HardwareIntrinsics/X86/Sse2/AddScalar.cs | 56 +++++++++ .../X86/Sse2/AddScalar_r.csproj | 38 ++++++ .../X86/Sse2/AddScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareEqualOrderedScalar.cs | 54 ++++++++ .../Sse2/CompareEqualOrderedScalar_r.csproj | 38 ++++++ .../Sse2/CompareEqualOrderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareEqualScalar.cs | 56 +++++++++ .../X86/Sse2/CompareEqualScalar_r.csproj | 38 ++++++ .../X86/Sse2/CompareEqualScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareEqualUnorderedScalar.cs | 54 ++++++++ .../Sse2/CompareEqualUnorderedScalar_r.csproj | 38 ++++++ .../CompareEqualUnorderedScalar_ro.csproj | 37 ++++++ .../CompareGreaterThanOrEqualOrderedScalar.cs | 55 +++++++++ ...reGreaterThanOrEqualOrderedScalar_r.csproj | 38 ++++++ ...eGreaterThanOrEqualOrderedScalar_ro.csproj | 37 ++++++ .../Sse2/CompareGreaterThanOrEqualScalar.cs | 57 +++++++++ .../CompareGreaterThanOrEqualScalar_r.csproj | 38 ++++++ .../CompareGreaterThanOrEqualScalar_ro.csproj | 38 ++++++ ...ompareGreaterThanOrEqualUnorderedScalar.cs | 55 +++++++++ ...GreaterThanOrEqualUnorderedScalar_r.csproj | 38 ++++++ ...reaterThanOrEqualUnorderedScalar_ro.csproj | 38 ++++++ .../Sse2/CompareGreaterThanOrderedScalar.cs | 55 +++++++++ .../CompareGreaterThanOrderedScalar_r.csproj | 38 ++++++ .../CompareGreaterThanOrderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareGreaterThanScalar.cs | 57 +++++++++ .../Sse2/CompareGreaterThanScalar_r.csproj | 38 ++++++ .../Sse2/CompareGreaterThanScalar_ro.csproj | 37 ++++++ .../Sse2/CompareGreaterThanUnorderedScalar.cs | 55 +++++++++ ...CompareGreaterThanUnorderedScalar_r.csproj | 38 ++++++ ...ompareGreaterThanUnorderedScalar_ro.csproj | 37 ++++++ .../CompareLessThanOrEqualOrderedScalar.cs | 55 +++++++++ ...mpareLessThanOrEqualOrderedScalar_r.csproj | 38 ++++++ ...pareLessThanOrEqualOrderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareLessThanOrEqualScalar.cs | 57 +++++++++ .../CompareLessThanOrEqualScalar_r.csproj | 38 ++++++ .../CompareLessThanOrEqualScalar_ro.csproj | 37 ++++++ .../CompareLessThanOrEqualUnorderedScalar.cs | 55 +++++++++ ...areLessThanOrEqualUnorderedScalar_r.csproj | 38 ++++++ ...reLessThanOrEqualUnorderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareLessThanOrderedScalar.cs | 56 +++++++++ .../CompareLessThanOrderedScalar_r.csproj | 38 ++++++ .../CompareLessThanOrderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareLessThanScalar.cs | 58 +++++++++ .../X86/Sse2/CompareLessThanScalar_r.csproj | 38 ++++++ .../X86/Sse2/CompareLessThanScalar_ro.csproj | 37 ++++++ .../Sse2/CompareLessThanUnorderedScalar.cs | 56 +++++++++ .../CompareLessThanUnorderedScalar_r.csproj | 38 ++++++ .../CompareLessThanUnorderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareNotEqualOrderedScalar.cs | 55 +++++++++ .../CompareNotEqualOrderedScalar_r.csproj | 38 ++++++ .../CompareNotEqualOrderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareNotEqualScalar.cs | 57 +++++++++ .../X86/Sse2/CompareNotEqualScalar_r.csproj | 38 ++++++ .../X86/Sse2/CompareNotEqualScalar_ro.csproj | 37 ++++++ .../Sse2/CompareNotEqualUnorderedScalar.cs | 55 +++++++++ .../CompareNotEqualUnorderedScalar_r.csproj | 38 ++++++ .../CompareNotEqualUnorderedScalar_ro.csproj | 37 ++++++ .../CompareNotGreaterThanOrEqualScalar.cs | 57 +++++++++ ...ompareNotGreaterThanOrEqualScalar_r.csproj | 38 ++++++ ...mpareNotGreaterThanOrEqualScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareNotGreaterThanScalar.cs | 57 +++++++++ .../Sse2/CompareNotGreaterThanScalar_r.csproj | 38 ++++++ .../CompareNotGreaterThanScalar_ro.csproj | 37 ++++++ .../Sse2/CompareNotLessThanOrEqualScalar.cs | 57 +++++++++ .../CompareNotLessThanOrEqualScalar_r.csproj | 38 ++++++ .../CompareNotLessThanOrEqualScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareNotLessThanScalar.cs | 57 +++++++++ .../Sse2/CompareNotLessThanScalar_r.csproj | 38 ++++++ .../Sse2/CompareNotLessThanScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareOrderedScalar.cs | 65 ++++++++++ .../X86/Sse2/CompareOrderedScalar_r.csproj | 38 ++++++ .../X86/Sse2/CompareOrderedScalar_ro.csproj | 37 ++++++ .../X86/Sse2/CompareUnorderedScalar.cs | 65 ++++++++++ .../X86/Sse2/CompareUnorderedScalar_r.csproj | 38 ++++++ .../X86/Sse2/CompareUnorderedScalar_ro.csproj | 37 ++++++ .../Sse2/ConvertScalarToVector128Double.cs | 116 ++++++++++++++++++ .../ConvertScalarToVector128Double_r.csproj | 37 ++++++ .../ConvertScalarToVector128Double_ro.csproj | 36 ++++++ .../X86/Sse2/ConvertScalarToVector128Int32.cs | 79 ++++++++++++ .../ConvertScalarToVector128Int32_r.csproj | 37 ++++++ .../ConvertScalarToVector128Int32_ro.csproj | 36 ++++++ .../X86/Sse2/ConvertScalarToVector128Int64.cs | 93 ++++++++++++++ .../ConvertScalarToVector128Int64_r.csproj | 37 ++++++ .../ConvertScalarToVector128Int64_ro.csproj | 36 ++++++ .../Sse2/ConvertScalarToVector128Single.cs | 81 ++++++++++++ .../ConvertScalarToVector128Single_r.csproj | 37 ++++++ .../ConvertScalarToVector128Single_ro.csproj | 36 ++++++ .../Sse2/ConvertScalarToVector128UInt32.cs | 79 ++++++++++++ .../ConvertScalarToVector128UInt32_r.csproj | 37 ++++++ .../ConvertScalarToVector128UInt32_ro.csproj | 36 ++++++ .../Sse2/ConvertScalarToVector128UInt64.cs | 93 ++++++++++++++ .../ConvertScalarToVector128UInt64_r.csproj | 37 ++++++ .../ConvertScalarToVector128UInt64_ro.csproj | 36 ++++++ .../X86/Sse2/ConvertToDouble.cs | 55 +++++++++ .../X86/Sse2/ConvertToDouble_r.csproj | 38 ++++++ .../X86/Sse2/ConvertToDouble_ro.csproj | 37 ++++++ .../X86/Sse2/ConvertToInt32.cs | 75 +++++++++++ .../X86/Sse2/ConvertToInt32WithTruncation.cs | 55 +++++++++ .../ConvertToInt32WithTruncation_r.csproj | 38 ++++++ .../ConvertToInt32WithTruncation_ro.csproj | 37 ++++++ .../X86/Sse2/ConvertToInt32_r.csproj | 38 ++++++ .../X86/Sse2/ConvertToInt32_ro.csproj | 37 ++++++ .../X86/Sse2/ConvertToInt64.cs | 113 +++++++++++++++++ .../X86/Sse2/ConvertToInt64WithTruncation.cs | 76 ++++++++++++ .../ConvertToInt64WithTruncation_r.csproj | 38 ++++++ .../ConvertToInt64WithTruncation_ro.csproj | 37 ++++++ .../X86/Sse2/ConvertToInt64_r.csproj | 38 ++++++ .../X86/Sse2/ConvertToInt64_ro.csproj | 37 ++++++ .../X86/Sse2/ConvertToUInt32.cs | 55 +++++++++ .../X86/Sse2/ConvertToUInt32_r.csproj | 38 ++++++ .../X86/Sse2/ConvertToUInt32_ro.csproj | 37 ++++++ .../X86/Sse2/ConvertToUInt64.cs | 76 ++++++++++++ .../X86/Sse2/ConvertToUInt64_r.csproj | 38 ++++++ .../X86/Sse2/ConvertToUInt64_ro.csproj | 37 ++++++ .../X86/Sse2/DivideScalar.cs | 56 +++++++++ .../X86/Sse2/DivideScalar_r.csproj | 38 ++++++ .../X86/Sse2/DivideScalar_ro.csproj | 37 ++++++ .../HardwareIntrinsics/X86/Sse2/MaxScalar.cs | 56 +++++++++ .../X86/Sse2/MaxScalar_r.csproj | 38 ++++++ .../X86/Sse2/MaxScalar_ro.csproj | 37 ++++++ .../HardwareIntrinsics/X86/Sse2/MinScalar.cs | 56 +++++++++ .../X86/Sse2/MinScalar_r.csproj | 38 ++++++ .../X86/Sse2/MinScalar_ro.csproj | 37 ++++++ .../HardwareIntrinsics/X86/Sse2/MoveMask.cs | 91 ++++++++++++++ .../X86/Sse2/MoveMask_r.csproj | 36 ++++++ .../X86/Sse2/MoveMask_ro.csproj | 36 ++++++ .../HardwareIntrinsics/X86/Sse2/MoveScalar.cs | 56 +++++++++ .../X86/Sse2/MoveScalar_r.csproj | 37 ++++++ .../X86/Sse2/MoveScalar_ro.csproj | 37 ++++++ .../X86/Sse2/MultiplyScalar.cs | 55 +++++++++ .../X86/Sse2/MultiplyScalar_r.csproj | 38 ++++++ .../X86/Sse2/MultiplyScalar_ro.csproj | 37 ++++++ .../HardwareIntrinsics/X86/Sse2/SqrtScalar.cs | 56 +++++++++ .../X86/Sse2/SqrtScalar_r.csproj | 38 ++++++ .../X86/Sse2/SqrtScalar_ro.csproj | 37 ++++++ .../X86/Sse2/SubtractScalar.cs | 56 +++++++++ .../X86/Sse2/SubtractScalar_r.csproj | 38 ++++++ .../X86/Sse2/SubtractScalar_ro.csproj | 37 ++++++ 138 files changed, 6380 insertions(+) create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_ro.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.cs create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_r.csproj create mode 100644 tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_ro.csproj diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.cs new file mode 100644 index 000000000000..d6fb163f80ad --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.AddScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.AddScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] + y[0]; + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => AddScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_r.csproj new file mode 100644 index 000000000000..ef63cf34118a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {B09B2F36-803A-4435-BCFA-0E83F963840F} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_ro.csproj new file mode 100644 index 000000000000..e45d56a6a49d --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {28A6B11C-68B9-45AF-A42C-C5886AAF6748} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.cs new file mode 100644 index 000000000000..e5a9ec3998e4 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar.cs @@ -0,0 +1,54 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareEqualOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareEqualOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] == y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = x == y ? -1l : 0) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_r.csproj new file mode 100644 index 000000000000..8600be7f5341 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {EB82DD03-0CB7-41E2-8879-63C128833B6E} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_ro.csproj new file mode 100644 index 000000000000..9bf8c1b635f2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {81E414C4-4281-4C1F-BC30-EACDCD551D1D} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.cs new file mode 100644 index 000000000000..a2b1a33bdb28 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareEqualScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareEqualScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] == y[0] ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = x == y ? -1l : 0) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_r.csproj new file mode 100644 index 000000000000..27931e989bf5 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {03F13B5B-6FB8-453D-B947-67CAAFA084A4} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_ro.csproj new file mode 100644 index 000000000000..79c2541c4807 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {B5152634-64C2-49B7-B049-73728855F514} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.cs new file mode 100644 index 000000000000..a1dff35ea94b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar.cs @@ -0,0 +1,54 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareEqualUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareEqualUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] == y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareEqualUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_r.csproj new file mode 100644 index 000000000000..88c270a36e80 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {0C1E06B8-4DD8-471D-914E-A464EB3F5FB0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..f2247b446790 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqualUnorderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {5E49EB53-2BD9-469E-8125-3878DB8DB8B1} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.cs new file mode 100644 index 000000000000..e913b844427b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareGreaterThanOrEqualOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareGreaterThanOrEqualOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] >= y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareGreaterThanOrEqualOrderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_r.csproj new file mode 100644 index 000000000000..439b201306ba --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {C55BCD67-C516-4B41-B2CB-28B55192B868} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_ro.csproj new file mode 100644 index 000000000000..a51130e78f04 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {A9EBC815-0839-4047-8602-7AB7AFB9C876} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.cs new file mode 100644 index 000000000000..b94ac3d3deeb --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareGreaterThanOrEqualScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareGreaterThanOrEqualScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] >= y[0] ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareGreaterThanOrEqualScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_r.csproj new file mode 100644 index 000000000000..b82c782827ad --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {F69D5695-D22E-41D8-B030-43CFF17B95ED} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_ro.csproj new file mode 100644 index 000000000000..7e904f2ffdf3 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualScalar_ro.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {87F2B90D-85D3-4304-99D3-355F109BE961} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.cs new file mode 100644 index 000000000000..16f8df7edb9c --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareGreaterThanOrEqualUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareGreaterThanOrEqualUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] >= y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareGreaterThanOrEqualUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_r.csproj new file mode 100644 index 000000000000..83eaaadd930a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {D865492C-FD82-4454-BE55-FDA217C69FC2} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..cd2ae9ffca6e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqualUnorderedScalar_ro.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {3584397A-13D4-4F6D-8E11-F01E9561338E} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.cs new file mode 100644 index 000000000000..ae9f9614324c --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareGreaterThanOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareGreaterThanOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] > y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareGreaterThanOrderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_r.csproj new file mode 100644 index 000000000000..1f47a7d78fa2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {C28A4AAF-7F4E-4FC2-B7E8-AB856A453C8F} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_ro.csproj new file mode 100644 index 000000000000..249332308849 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {083F679A-B810-4523-892B-B86CC2089A05} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.cs new file mode 100644 index 000000000000..5cfbec464c92 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareGreaterThanScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareGreaterThanScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] > y[0] ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareGreaterThanScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_r.csproj new file mode 100644 index 000000000000..b9bc9b77978c --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {35415AB4-E885-4E32-A735-CBDA1AE8783E} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_ro.csproj new file mode 100644 index 000000000000..c05f9b06f6d7 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {6E3A0CC9-42E5-4CA4-8BC7-719C22CD57A7} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.cs new file mode 100644 index 000000000000..913f00dbed0a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareGreaterThanUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareGreaterThanUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] > y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareGreaterThanUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_r.csproj new file mode 100644 index 000000000000..73bc3f5237b0 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {0CABBFB3-3404-4E3D-B3A1-C4D4CFD40C03} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..55e62e8afa78 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanUnorderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {8C267FA4-FED6-493B-8FD7-DAA0E31A9934} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.cs new file mode 100644 index 000000000000..bb82ac1b09a4 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareLessThanOrEqualOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareLessThanOrEqualOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] <= y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareLessThanOrEqualOrderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_r.csproj new file mode 100644 index 000000000000..96788562dab9 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {398DEA1A-16E3-4EE8-8668-54DFB80EB7AB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_ro.csproj new file mode 100644 index 000000000000..94f2b352e277 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {3AC17539-DEBA-4FFB-BE4A-4FCB21C37294} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.cs new file mode 100644 index 000000000000..a7dc17c38539 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareLessThanOrEqualScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareLessThanOrEqualScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] <= y[0] ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareLessThanOrEqualScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_r.csproj new file mode 100644 index 000000000000..3c7c0f3979f8 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {81043FA3-79B2-47C2-B87B-155D02C56129} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_ro.csproj new file mode 100644 index 000000000000..dda7f38b4142 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {D5F2B67E-9F8B-47E1-B817-15A62A807902} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.cs new file mode 100644 index 000000000000..3e16c5eccd21 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareLessThanOrEqualUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareLessThanOrEqualUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] <= y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareLessThanOrEqualUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_r.csproj new file mode 100644 index 000000000000..d63f943804c5 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {BFB0C199-C3B9-4194-80C9-66DAE8F32BED} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..d33e9b52fb62 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqualUnorderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {88243AD7-6A24-41B0-9ED1-C995551F23DA} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.cs new file mode 100644 index 000000000000..d321540dfc69 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareLessThanOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareLessThanOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] < y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareLessThanOrderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_r.csproj new file mode 100644 index 000000000000..ea691fd16675 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {93E4851E-5200-4A1E-AC26-FD8B18476570} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_ro.csproj new file mode 100644 index 000000000000..a480e7157c45 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {EFB18286-69A8-4260-8AD9-94A576984ECB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.cs new file mode 100644 index 000000000000..30d682bed610 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareLessThanScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareLessThanScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] < y[0] ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareLessThanScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_r.csproj new file mode 100644 index 000000000000..9df91b62688e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {4C7EE867-4785-47FC-AFBE-AF4A72651577} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_ro.csproj new file mode 100644 index 000000000000..494f268bf735 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {1C1FEDB0-64E8-405A-922A-67731CE53956} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.cs new file mode 100644 index 000000000000..9455ee171912 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareLessThanUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareLessThanUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = x[0] < y[0] ? true : false; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareLessThanUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_r.csproj new file mode 100644 index 000000000000..99a219feac2d --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {8810F33B-6D6A-43A9-8FBF-0C5BE46046CD} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..87968f958b00 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanUnorderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {2EB27EC3-3440-443F-8CCF-2EC9B900982D} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.cs new file mode 100644 index 000000000000..71f02af38f89 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotEqualOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareNotEqualOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = (x[0] != y[0]); + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareNotEqualOrderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_r.csproj new file mode 100644 index 000000000000..5eb6a2681f6c --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {9E2D750B-1AD6-4CCB-8CEE-856A702714DB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_ro.csproj new file mode 100644 index 000000000000..2b086ac66c2a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {A51475EC-9B61-442A-B8E9-90817E8C5FF3} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.cs new file mode 100644 index 000000000000..7c889f39b75f --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotEqualScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareNotEqualScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] != y[0] ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(x, y, z, ref a) => (a = x != y ? double.NaN : 0) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_r.csproj new file mode 100644 index 000000000000..941285ad07e2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {5E0CE7C0-B254-46AF-A81E-F2EBA971B8A3} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_ro.csproj new file mode 100644 index 000000000000..8e3200065516 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {49727A3A-3AEF-4BDC-A3BB-6FEBC8C106D5} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.cs new file mode 100644 index 000000000000..96e0745ef314 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotEqualUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareNotEqualUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, bool z, ref bool a) => + { + a = (x[0] != y[0]); + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, bool z, ref bool a) => CompareNotEqualUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_r.csproj new file mode 100644 index 000000000000..bf0d8b5adf3e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {FC56E4E9-E46B-4E86-A022-70EAA6A3776E} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..571855c590a0 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqualUnorderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {3E67F586-EB9F-4209-BED1-CDDB2CA032FB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.cs new file mode 100644 index 000000000000..98a00bceb92b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotGreaterThanOrEqualScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareNotGreaterThanOrEqualScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = !(x[0] >= y[0]) ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareNotGreaterThanOrEqualScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_r.csproj new file mode 100644 index 000000000000..0ff1e1968fdb --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {9719321A-FA33-43E6-B01E-102879E77321} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_ro.csproj new file mode 100644 index 000000000000..cde50a8f9edd --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqualScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {93C1DB28-D5A7-493D-8017-9E028D39E025} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.cs new file mode 100644 index 000000000000..0a7778a0ed38 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotGreaterThanScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareNotGreaterThanScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = !(x[0] > y[0]) ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(x, y, z, ref a) => (a = !(x > y) ? double.NaN : 0) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_r.csproj new file mode 100644 index 000000000000..a3cd771b2410 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {CE864D5D-9D54-4000-A5BE-EC7052673CE5} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_ro.csproj new file mode 100644 index 000000000000..70139e61d296 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {8B32892C-136B-4809-A082-F4EEF0FD0A8F} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.cs new file mode 100644 index 000000000000..560db5a441d2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotLessThanOrEqualScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + var result = Sse2.CompareNotLessThanOrEqualScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = !(x[0] <= y[0]) ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(x, y, z, ref a) => (a = !(x <= y) ? double.NaN : 0) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_r.csproj new file mode 100644 index 000000000000..dbdeb6286922 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {608FCA63-FF4F-4A38-9503-9CF51D291BAB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_ro.csproj new file mode 100644 index 000000000000..ccd016301519 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqualScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {D61F7DC7-97A3-4A5A-8A49-B80195B7EBFA} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.cs new file mode 100644 index 000000000000..b53619d59d8f --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareNotLessThanScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareNotLessThanScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = !(x[0] < y[0]) ? BitConverter.Int64BitsToDouble(-1) : 0; + a[1] = x[1]; + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(x, y, z, ref a) => (a = !(x <= y) ? double.NaN : 0) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_r.csproj new file mode 100644 index 000000000000..76331fc20199 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {BF772C6E-6EA2-4649-9618-D3DB0AE49F41} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_ro.csproj new file mode 100644 index 000000000000..69e96a08cf92 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {44063F5C-8943-4FC0-AEDF-45ED4A744CA9} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.cs new file mode 100644 index 000000000000..1349bdd19396 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar.cs @@ -0,0 +1,65 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareOrderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareOrderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + if (!double.IsNaN(x[0]) && !double.IsNaN(y[0])) + { + a[0] = BitConverter.Int64BitsToDouble(-1); + a[1] = x[1]; + } + else + { + a[0] = 0; + a[1] = x[1]; + } + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareOrderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_r.csproj new file mode 100644 index 000000000000..263b1ec4a75b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {2099478C-8A85-4032-8F86-402DA54F8FA2} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_ro.csproj new file mode 100644 index 000000000000..783860a1c0ac --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {AA7AFEBE-8C40-4A22-8A1E-5FC39EDD9A51} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.cs new file mode 100644 index 000000000000..23a9282f3ac2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar.cs @@ -0,0 +1,65 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.CompareUnorderedScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.CompareUnorderedScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + if (double.IsNaN(x[0]) || double.IsNaN(y[0])) + { + a[0] = BitConverter.Int64BitsToDouble(-1); + a[1] = x[1]; + } + else + { + a[0] = 0; + a[1] = x[1]; + } + return BitConverter.DoubleToInt64Bits(a[0]) == BitConverter.DoubleToInt64Bits(z[0]) && + BitConverter.DoubleToInt64Bits(a[1]) == BitConverter.DoubleToInt64Bits(z[1]); + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => CompareUnorderedScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_r.csproj new file mode 100644 index 000000000000..03ba54b2a424 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {15931119-A410-40C5-9FCC-D7A714C68512} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_ro.csproj new file mode 100644 index 000000000000..2f3974dacd3f --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnorderedScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {66739F14-FEA4-4993-B0E7-3E9B0D824FED} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double.cs new file mode 100644 index 000000000000..9721f9c09476 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double.cs @@ -0,0 +1,116 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse2.IsSupported) + { + using (TestTable doubleTable = new TestTable(new double[2] { 1, -5 }, new double[2])) + { + var vf1 = Unsafe.Read>(doubleTable.inArrayPtr); + var vf2 = Sse2.ConvertScalarToVector128Double(vf1, 5); + Unsafe.Write(doubleTable.outArrayPtr, vf2); + + if (!doubleTable.CheckResult((x, y) => (y[0] == 5) && (y[1] == x[1]))) + { + Console.WriteLine("SSE2 ConvertScalarToVector128Double failed on int:"); + foreach (var item in doubleTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + + using (TestTable doubleTable = new TestTable(new double[2] { 1, -5 }, new double[2])) + { + var vf1 = Unsafe.Read>(doubleTable.inArrayPtr); + var vf2 = Sse2.ConvertScalarToVector128Double(vf1, 7); + Unsafe.Write(doubleTable.outArrayPtr, vf2); + + if (!doubleTable.CheckResult((x, y) => (y[0] == 7) && (y[1] == x[1]))) + { + Console.WriteLine("SSE2 ConvertScalarToVector128Double failed on long:"); + foreach (var item in doubleTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + + using (TestTable doubleTable = new TestTable(new double[2] { 1, -5 }, new double[2])) + using (TestTable floatTable = new TestTable(new float[4] { 3, -11, 7, 49 }, new float[4])) + { + var vd0 = Unsafe.Read>(doubleTable.inArrayPtr); + var vf1 = Unsafe.Read>(floatTable.inArrayPtr); + var vf2 = Sse2.ConvertScalarToVector128Double(vd0, vf1); + Unsafe.Write(doubleTable.outArrayPtr, vf2); + + if (!doubleTable.CheckResult((x, y) => (y[0] == 3) && (y[1] == x[1]))) + { + Console.WriteLine("SSE2 ConvertScalarToVector128Double failed on float:"); + foreach (var item in doubleTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + } + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray; + public T[] outArray; + + public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer(); + public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer(); + + GCHandle inHandle; + GCHandle outHandle; + public TestTable(T[] a, T[] b) + { + this.inArray = a; + this.outArray = b; + + inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned); + outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + } + public bool CheckResult(Func check) + { + return check(inArray, outArray); + } + + public void Dispose() + { + inHandle.Free(); + outHandle.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_r.csproj new file mode 100644 index 000000000000..b1a603af05c6 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {1C247877-EBBC-42C2-BC1C-A8A561DA74D5} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_ro.csproj new file mode 100644 index 000000000000..591e122f312a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Double_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {015189FF-AC56-4074-AD13-80E8A2A28075} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32.cs new file mode 100644 index 000000000000..cdfb2870f66b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32.cs @@ -0,0 +1,79 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse2.IsSupported) + { + using (TestTable intTable = new TestTable(new int[4] { 1, -5, 7, 19 }, new int[4])) + { + var vf1 = Unsafe.Read>(intTable.inArrayPtr); + var vf2 = Sse2.ConvertScalarToVector128Int32(5); + Unsafe.Write(intTable.outArrayPtr, vf2); + + if (!intTable.CheckResult((x, y) => (y[0] == 5) + && (y[1] == 0) && (y[2] == 0) && (y[3] == 0))) + { + Console.WriteLine("SSE2 ConvertScalarToVector128Int32 failed on int:"); + foreach (var item in intTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + } + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray; + public T[] outArray; + + public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer(); + public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer(); + + GCHandle inHandle; + GCHandle outHandle; + public TestTable(T[] a, T[] b) + { + this.inArray = a; + this.outArray = b; + + inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned); + outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + } + public bool CheckResult(Func check) + { + return check(inArray, outArray); + } + + public void Dispose() + { + inHandle.Free(); + outHandle.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_r.csproj new file mode 100644 index 000000000000..f7f0147747f2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {E42146CD-285E-43A8-B254-5B252594EAFB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_ro.csproj new file mode 100644 index 000000000000..706671563145 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int32_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {38DA713E-D154-4724-9BA8-5E7A19A160C4} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64.cs new file mode 100644 index 000000000000..eb4c5488ab15 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64.cs @@ -0,0 +1,93 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse2.IsSupported) + { + using (TestTable longTable = new TestTable(new long[2] { 1, -5 }, new long[2])) + { + if (Environment.Is64BitProcess) + { + var vd = Sse2.ConvertScalarToVector128Int64((long)-5); + Unsafe.Write(longTable.outArrayPtr, vd); + + if (!longTable.CheckResult((x, y) => (y[0] == -5) && (y[1] == 0))) + { + Console.WriteLine("SSE2 ConvertScalarToVector128Int32 failed on long:"); + foreach (var item in longTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + else + { + try + { + var vd = Sse2.ConvertScalarToVector128Int64(-5l); + testResult = Fail; + Console.WriteLine($"{nameof(Sse2)}.{nameof(Sse2.ConvertScalarToVector128Int64)} failed: expected PlatformNotSupportedException exception."); + } + catch (PlatformNotSupportedException) + { + + } + } + } + } + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray; + public T[] outArray; + + public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer(); + public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer(); + + GCHandle inHandle; + GCHandle outHandle; + public TestTable(T[] a, T[] b) + { + this.inArray = a; + this.outArray = b; + + inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned); + outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + } + public bool CheckResult(Func check) + { + return check(inArray, outArray); + } + + public void Dispose() + { + inHandle.Free(); + outHandle.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_r.csproj new file mode 100644 index 000000000000..e6262d055028 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {B734C778-AAEE-4A98-970D-19C61FA245AC} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_ro.csproj new file mode 100644 index 000000000000..23e7e5b16543 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Int64_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {553F8403-75AB-4711-BDF8-C20F04B207CD} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single.cs new file mode 100644 index 000000000000..343669b0b7b0 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single.cs @@ -0,0 +1,81 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse2.IsSupported) + { + using (TestTable floatTable = new TestTable(new float[4] { 1, -5, 100, 0 }, new float[4])) + using (TestTable doubleTable = new TestTable(new double[2] { -11, 7 }, new double[2])) + { + var vd0 = Unsafe.Read>(doubleTable.inArrayPtr); + var vf1 = Unsafe.Read>(floatTable.inArrayPtr); + var vf2 = Sse2.ConvertScalarToVector128Single(vf1, vd0); + Unsafe.Write(floatTable.outArrayPtr, vf2); + + if (!floatTable.CheckResult((x, y) => (y[0] == -11) + && (y[1] == x[1]) && (y[2] == x[2]) && (y[3] == x[3]))) + { + Console.WriteLine("SSE ConvertScalarToVector128Single failed on float:"); + foreach (var item in floatTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + } + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray; + public T[] outArray; + + public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer(); + public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer(); + + GCHandle inHandle; + GCHandle outHandle; + public TestTable(T[] a, T[] b) + { + this.inArray = a; + this.outArray = b; + + inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned); + outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + } + public bool CheckResult(Func check) + { + return check(inArray, outArray); + } + + public void Dispose() + { + inHandle.Free(); + outHandle.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_r.csproj new file mode 100644 index 000000000000..0a62d1b9199f --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {3CD4F47E-D859-4E65-AEE0-255A88CB5AD0} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_ro.csproj new file mode 100644 index 000000000000..81e1545d59d5 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128Single_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {29C530A3-9347-4AAB-A067-CDF52A18CA1D} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32.cs new file mode 100644 index 000000000000..4ca158629002 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32.cs @@ -0,0 +1,79 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse.IsSupported) + { + using (TestTable floatTable = new TestTable(new float[4] { 1, -5, 100, 0 }, new float[4])) + { + var vf1 = Unsafe.Read>(floatTable.inArrayPtr); + var vf2 = Sse.ConvertScalarToVector128Single(vf1, 5); + Unsafe.Write(floatTable.outArrayPtr, vf2); + + if (!floatTable.CheckResult((x, y) => (y[0] == 5) + && (y[1] == x[1]) && (y[2] == x[2]) && (y[3] == x[3]))) + { + Console.WriteLine("SSE ConvertScalarToVector128Single failed on float:"); + foreach (var item in floatTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + } + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray; + public T[] outArray; + + public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer(); + public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer(); + + GCHandle inHandle; + GCHandle outHandle; + public TestTable(T[] a, T[] b) + { + this.inArray = a; + this.outArray = b; + + inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned); + outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + } + public bool CheckResult(Func check) + { + return check(inArray, outArray); + } + + public void Dispose() + { + inHandle.Free(); + outHandle.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_r.csproj new file mode 100644 index 000000000000..2a76cd19867a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {1023B51C-E7CF-4956-91C4-DA08CBED4B73} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_ro.csproj new file mode 100644 index 000000000000..8473f681900e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt32_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {5B9D2F20-BFA3-446F-A8F9-27F2E08D895D} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64.cs new file mode 100644 index 000000000000..f75cc86aea03 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64.cs @@ -0,0 +1,93 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse2.IsSupported) + { + using (TestTable ulongTable = new TestTable(new ulong[2], new ulong[2])) + { + if (Environment.Is64BitProcess) + { + var vd = Sse2.ConvertScalarToVector128UInt64((ulong)5); + Unsafe.Write(ulongTable.outArrayPtr, vd); + + if (!ulongTable.CheckResult((x, y) => (y[0] == 5) && (y[1] == 0))) + { + Console.WriteLine("SSE ConvertScalarToVector128Single failed on ulong:"); + foreach (var item in ulongTable.outArray) + { + Console.Write(item + ", "); + } + Console.WriteLine(); + testResult = Fail; + } + } + else + { + try + { + var vd = Sse2.ConvertScalarToVector128UInt64((ulong)5); + testResult = Fail; + Console.WriteLine($"{nameof(Sse2)}.{nameof(Sse2.ConvertScalarToVector128UInt64)} failed: expected PlatformNotSupportedException exception."); + } + catch (PlatformNotSupportedException) + { + + } + } + } + } + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray; + public T[] outArray; + + public void* inArrayPtr => inHandle.AddrOfPinnedObject().ToPointer(); + public void* outArrayPtr => outHandle.AddrOfPinnedObject().ToPointer(); + + GCHandle inHandle; + GCHandle outHandle; + public TestTable(T[] a, T[] b) + { + this.inArray = a; + this.outArray = b; + + inHandle = GCHandle.Alloc(inArray, GCHandleType.Pinned); + outHandle = GCHandle.Alloc(outArray, GCHandleType.Pinned); + } + public bool CheckResult(Func check) + { + return check(inArray, outArray); + } + + public void Dispose() + { + inHandle.Free(); + outHandle.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_r.csproj new file mode 100644 index 000000000000..89f4423003fd --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {037BE502-9140-47B9-B51F-F18717E32E17} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_ro.csproj new file mode 100644 index 000000000000..d174bf79b483 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertScalarToVector128UInt64_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {11507378-A92B-4557-95A0-A0567822BDE7} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble.cs new file mode 100644 index 000000000000..5badcc5c9ce6 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToDouble); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + double result = Sse2.ConvertToDouble(value.Item1); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, double z, ref double a) => + { + a = x[0]; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, double z, ref double a) => ConvertToDouble", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_r.csproj new file mode 100644 index 000000000000..d8ccb82a52e4 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {D87DF85C-7593-4FB9-97B5-A93B25EC80DC} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_ro.csproj new file mode 100644 index 000000000000..020cf93b0a1e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToDouble_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {A66024E0-4878-42B5-AF63-67BDF1DAC96B} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.cs new file mode 100644 index 000000000000..e12f928b91f7 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32.cs @@ -0,0 +1,75 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToInt32); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + using (var intTable = TestTableScalarSse2.Create(testsCount, 4.0)) + { + for (int i = 0; i < testsCount; i++) + { + doubleTable.SetIndex(i); + int result = Sse2.ConvertToInt32(doubleTable.Vector1); + doubleTable.SetOutArray(result); + } + + for (int i = 0; i < testsCount; i++) + { + intTable.SetIndex(i); + int result = Sse2.ConvertToInt32(intTable.Vector1); + intTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, int z, ref int a) => + { + a = (int) Math.Round(x[0], 0); + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, int z, ref int a) => ConvertToInt32", checkDouble); + testResult = Fail; + } + + CheckMethodEightOne checkInt32 = (Span x, Span y, int z, ref int a) => + { + a = x[0]; + return a == z; + }; + + if (!intTable.CheckResult(checkInt32)) + { + PrintError(intTable, methodUnderTestName, "(Span x, Span y, int z, ref int a) => ConvertToInt32", checkInt32); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.cs new file mode 100644 index 000000000000..69e6d6f6911e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToInt32WithTruncation); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + int result = Sse2.ConvertToInt32(value.Item1); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, int z, ref int a) => + { + a = (int) Math.Round(x[0], 0); + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, int z, ref int a) => ConvertToInt32", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_r.csproj new file mode 100644 index 000000000000..c536e788f460 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {CA2D8337-D94E-40E5-8464-F838AA91EE6B} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_ro.csproj new file mode 100644 index 000000000000..1c8b96af4e13 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32WithTruncation_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {B4C44B80-ABAB-4EAE-A6DA-C3A1097F8492} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_r.csproj new file mode 100644 index 000000000000..296bbae37419 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {F143CA17-393D-4356-98C4-6FD20D29B636} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_ro.csproj new file mode 100644 index 000000000000..bee976c570b7 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt32_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {BE046A37-50C1-48D8-96A2-FAD95E43C304} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.cs new file mode 100644 index 000000000000..2a2bc2a129de --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64.cs @@ -0,0 +1,113 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToInt64); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + using (var longTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + if (Environment.Is64BitProcess) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + long result = Sse2.ConvertToInt64(value.Item1); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, long z, ref long a) => + { + a = (long)Math.Round(x[0], 0); + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, long z, ref long a) => ConvertToInt64", checkDouble); + testResult = Fail; + } + + Console.WriteLine("In 64bit branch"); + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = longTable[i]; + long result = Sse2.ConvertToInt64(value.Item1); + longTable.SetOutArray(result); + } + + CheckMethodEightOne checkInt64 = (Span x, Span y, long z, ref long a) => + { + a = x[0]; + return a == z; + }; + + if (!longTable.CheckResult(checkInt64)) + { + PrintError(longTable, methodUnderTestName, "(Span x, Span y, long z, ref long a) => ConvertToInt64", checkInt64); + testResult = Fail; + } + } + else + { + try + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + long result = Sse2.ConvertToInt64(value.Item1); + doubleTable.SetOutArray(result); + } + testResult = Fail; + Console.WriteLine($"{nameof(Sse2)}.{methodUnderTestName} failed for Double: expected PlatformNotSupportedException exception."); + } + catch (PlatformNotSupportedException) + { + + } + + try + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = longTable[i]; + long result = Sse2.ConvertToInt64(value.Item1); + longTable.SetOutArray(result); + } + testResult = Fail; + Console.WriteLine($"{nameof(Sse2)}.{methodUnderTestName} failed for Int64: expected PlatformNotSupportedException exception."); + } + catch(PlatformNotSupportedException) + { + + } + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.cs new file mode 100644 index 000000000000..14b5eb046b0b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation.cs @@ -0,0 +1,76 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToInt64WithTruncation); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + if (Environment.Is64BitProcess) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + long result = Sse2.ConvertToInt64WithTruncation(value.Item1); + doubleTable.SetOutArray(result); + } + + CheckMethodEightOne checkDouble = (Span x, Span y, long z, ref long a) => + { + a = (long)x[0]; + return a == z; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, long z, ref long a) => ConvertToInt64", checkDouble); + testResult = Fail; + } + } + else + { + try + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + long result = Sse2.ConvertToInt64WithTruncation(value.Item1); + doubleTable.SetOutArray(result); + } + testResult = Fail; + Console.WriteLine($"{nameof(Sse2)}.{methodUnderTestName} failed: expected PlatformNotSupportedException exception."); + } + catch (PlatformNotSupportedException) + { + + } + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_r.csproj new file mode 100644 index 000000000000..8e2b4dda2c7b --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {31F6938B-8319-4F6A-9897-2796126CFF11} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_ro.csproj new file mode 100644 index 000000000000..09c16df6c101 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64WithTruncation_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {F6FF61B8-1A9D-4ABB-93C2-F950947C676F} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_r.csproj new file mode 100644 index 000000000000..b7a026806919 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {B70864A8-687D-439F-B8DF-073C93572FC7} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_ro.csproj new file mode 100644 index 000000000000..61df0af3c8f2 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToInt64_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {FCECAD9B-126D-485A-8217-8B6596903F10} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.cs new file mode 100644 index 000000000000..d9e0868bd9ea --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToUInt32); + + if (Sse2.IsSupported) + { + using (var uintTable = TestTableScalarSse2.Create(testsCount, 4.0)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = uintTable[i]; + var result = Sse2.ConvertToUInt32(value.Item1); + uintTable.SetOutArray(result); + } + + CheckMethodEightOne checkUInt32 = (Span x, Span y, uint z, ref uint a) => + { + a = x[0]; + return a == z; + }; + + if (!uintTable.CheckResult(checkUInt32)) + { + PrintError(uintTable, methodUnderTestName, "(Span x, Span y, int z, ref int a) => ConvertToInt32", checkUInt32); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_r.csproj new file mode 100644 index 000000000000..75558db52a9d --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {141F226E-A9E7-4D48-9D9C-54CE2D1B05FC} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_ro.csproj new file mode 100644 index 000000000000..887953c9b471 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt32_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {2BE39F43-D31A-4F11-90EE-CD2E7F13D0A8} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.cs new file mode 100644 index 000000000000..e38c573a952a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64.cs @@ -0,0 +1,76 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.ConvertToUInt64); + + if (Sse2.IsSupported) + { + using (var uintTable = TestTableScalarSse2.Create(testsCount, 2.0)) + { + if (Environment.Is64BitProcess) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = uintTable[i]; + var result = Sse2.ConvertToUInt64(value.Item1); + uintTable.SetOutArray(result); + } + + CheckMethodEightOne checkUInt64 = (Span x, Span y, ulong z, ref ulong a) => + { + a = x[0]; + return a == z; + }; + + if (!uintTable.CheckResult(checkUInt64)) + { + PrintError(uintTable, methodUnderTestName, "(Span x, Span y, int z, ref int a) => ConvertToInt32", checkUInt64); + testResult = Fail; + } + } + else + { + try + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = uintTable[i]; + var result = Sse2.ConvertToUInt64(value.Item1); + uintTable.SetOutArray(result); + } + testResult = Fail; + Console.WriteLine($"{nameof(Sse2)}.{methodUnderTestName} failed: expected PlatformNotSupportedException exception."); + } + catch (PlatformNotSupportedException) + { + + } + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_r.csproj new file mode 100644 index 000000000000..401a362b475c --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {9E8E464A-28A7-419F-BA7E-45372B2A4DB9} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_ro.csproj new file mode 100644 index 000000000000..bff00ea0cd64 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ConvertToUInt64_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {B22FD3C7-AFA3-438E-BF5B-D0CFF313CF42} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.cs new file mode 100644 index 000000000000..b57fd17d51d8 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.DivideScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.DivideScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] / y[0]; + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = x / y) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_r.csproj new file mode 100644 index 000000000000..ef13996c9d79 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {87A3726E-381D-417E-B498-3C4FFB632544} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_ro.csproj new file mode 100644 index 000000000000..746b7254707f --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {8AABA105-3887-4CA6-83F9-3CD59DAAC7E8} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.cs new file mode 100644 index 000000000000..8d11f911e0d0 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.MaxScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.MaxScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = Math.Max(x[0], y[0]); + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = x > y ? x : y) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_r.csproj new file mode 100644 index 000000000000..e08d77e8132e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {E47ED2C4-6A89-43E3-AD1A-8FEDA7D8FA03} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_ro.csproj new file mode 100644 index 000000000000..fd0ec48868d7 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {75455928-80BB-4905-956F-0D53BFC4D804} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.cs new file mode 100644 index 000000000000..5ae64f3bea68 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.MinScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.MinScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = Math.Min(x[0], y[0]); + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = BitwiseOr(x, y)) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_r.csproj new file mode 100644 index 000000000000..2e1488d8d7b0 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {78A91B0F-6535-42D7-B64C-948DF295B6BB} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_ro.csproj new file mode 100644 index 000000000000..4e8543a8c1c1 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {C392B2A4-03ED-4A52-8419-C17085646869} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask.cs new file mode 100644 index 000000000000..770b32517a63 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask.cs @@ -0,0 +1,91 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics; + +namespace IntelHardwareIntrinsicTest +{ + class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + + if (Sse2.IsSupported) + { + using (TestTable doubleTable = new TestTable(new double[2] { 1, -5 })) + { + + var vf1 = Unsafe.Read>(doubleTable.inArray1Ptr); + var res = Sse2.MoveMask(vf1); + + if (res != 0b0010) + { + Console.WriteLine("SSE MoveMask failed on double:"); + Console.WriteLine(res); + testResult = Fail; + } + } + + using (TestTable byteTable = new TestTable(new byte[16] { 255, 2, 0, 80, 0, 7, 0, 1, 2, 7, 80, 0, 123, 127, 5, 255 })) + { + + var vf1 = Unsafe.Read>(byteTable.inArray1Ptr); + var res = Sse2.MoveMask(vf1); + + if (res != 0b1000000000000001) + { + Console.WriteLine("SSE MoveMask failed on byte:"); + Console.WriteLine(res); + testResult = Fail; + } + } + + using (TestTable sbyteTable = new TestTable(new sbyte[16] { -1, 2, 0, 6, 0, 7, 111, 1, 2, 55, 80, 0, 11, 127, 5, -9 })) + { + + var vf1 = Unsafe.Read>(sbyteTable.inArray1Ptr); + var res = Sse2.MoveMask(vf1); + + if (res != 0b1000000000000001) + { + Console.WriteLine("SSE MoveMask failed on sbyte:"); + Console.WriteLine(res); + testResult = Fail; + } + } + } + + + return testResult; + } + + public unsafe struct TestTable : IDisposable where T : struct + { + public T[] inArray1; + public void* inArray1Ptr => inHandle1.AddrOfPinnedObject().ToPointer(); + GCHandle inHandle1; + + public TestTable(T[] a) + { + this.inArray1 = a; + inHandle1 = GCHandle.Alloc(inArray1, GCHandleType.Pinned); + } + + public void Dispose() + { + inHandle1.Free(); + } + } + + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_r.csproj new file mode 100644 index 000000000000..868b0ce2e856 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_r.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {EC7AD883-41EA-4BDC-BFBE-77A78B727D76} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_ro.csproj new file mode 100644 index 000000000000..06ad5dc47f12 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveMask_ro.csproj @@ -0,0 +1,36 @@ + + + + + Debug + AnyCPU + 2.0 + {4D4CC0B8-3894-4F6F-868B-C93A7B722B5C} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar.cs new file mode 100644 index 000000000000..954883fa5e0a --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + private const int Pass = 100; + private const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.MoveScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.MoveScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = y[0]; + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => MoveScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_r.csproj new file mode 100644 index 000000000000..52e3602ddd59 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_r.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {0B80D700-B05A-4D16-BAF9-ED6EDD08B693} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_ro.csproj new file mode 100644 index 000000000000..225a2578cc6e --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MoveScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {12E4FEBD-6650-40E9-8D42-99BCC12FCAB9} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.cs new file mode 100644 index 000000000000..e4f2c7b0d234 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + internal static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.MultiplyScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.MultiplyScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] * y[0]; + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(double x, double y, double z, ref double a) => (a = x * y) == z", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_r.csproj new file mode 100644 index 000000000000..affd316bf584 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {750A2506-0993-4BD6-B350-9D1CDF4736A1} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_ro.csproj new file mode 100644 index 000000000000..74c040d254ed --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {9B509A79-A647-4FA8-A057-0D7935EC3A0A} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar.cs new file mode 100644 index 000000000000..28b5ddbe36c8 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.SqrtScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.SqrtScalar(value.Item1); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = Math.Sqrt(x[0]); + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => SqrtScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_r.csproj new file mode 100644 index 000000000000..89207f6622e1 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {51841B25-F26B-41A4-8C77-C7FE92548A4C} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_ro.csproj new file mode 100644 index 000000000000..68a26aee545c --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SqrtScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {066503AD-D4E3-453D-AE7A-685199416339} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.cs new file mode 100644 index 000000000000..ee4aabdcd1a8 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace IntelHardwareIntrinsicTest +{ + internal static partial class Program + { + const int Pass = 100; + const int Fail = 0; + + static unsafe int Main(string[] args) + { + int testResult = Pass; + int testsCount = 21; + string methodUnderTestName = nameof(Sse2.SubtractScalar); + + if (Sse2.IsSupported) + { + using (var doubleTable = TestTableScalarSse2.Create(testsCount)) + { + for (int i = 0; i < testsCount; i++) + { + (Vector128, Vector128) value = doubleTable[i]; + Vector128 result = Sse2.SubtractScalar(value.Item1, value.Item2); + doubleTable.SetOutArray(result); + } + + CheckMethodEight checkDouble = (Span x, Span y, Span z, Span a) => + { + a[0] = x[0] - y[0]; + a[1] = x[1]; + return a[0] == z[0] && a[1] == z[1]; + }; + + if (!doubleTable.CheckResult(checkDouble)) + { + PrintError(doubleTable, methodUnderTestName, "(Span x, Span y, Span z, Span a) => SubtractScalar", checkDouble); + testResult = Fail; + } + } + } + else + { + Console.WriteLine($"Sse2.IsSupported: {Sse2.IsSupported}, skipped tests of {typeof(Sse2)}.{methodUnderTestName}"); + } + + return testResult; + } + } +} diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_r.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_r.csproj new file mode 100644 index 000000000000..589bd513b415 --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_r.csproj @@ -0,0 +1,38 @@ + + + + + Debug + AnyCPU + 2.0 + {DDE1DDD6-B6BD-42D2-9D49-5BCE2E707442} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_ro.csproj b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_ro.csproj new file mode 100644 index 000000000000..3037bd7198dc --- /dev/null +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar_ro.csproj @@ -0,0 +1,37 @@ + + + + + Debug + AnyCPU + 2.0 + {7B7FCE02-0D75-4BE2-80C0-29F2D410FDF3} + Exe + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + ..\..\ + true + + + + + + + + False + + + + None + True + + + + + + + + + + + + \ No newline at end of file