diff options
29 files changed, 794 insertions, 38 deletions
diff --git a/src/jit/hwintrinsiccodegenxarch.cpp b/src/jit/hwintrinsiccodegenxarch.cpp index 2866e76ae8..7627d125da 100644 --- a/src/jit/hwintrinsiccodegenxarch.cpp +++ b/src/jit/hwintrinsiccodegenxarch.cpp @@ -1764,6 +1764,26 @@ void CodeGen::genSSE41Intrinsic(GenTreeHWIntrinsic* node) switch (intrinsicId) { + case NI_SSE41_ConvertToVector128Int16: + case NI_SSE41_ConvertToVector128Int32: + case NI_SSE41_ConvertToVector128Int64: + { + instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType); + + if (!varTypeIsSIMD(op1->gtType)) + { + // Until we improve the handling of addressing modes in the emitter, we'll create a + // temporary GT_IND to generate code with. + GenTreeIndir load = indirForm(node->TypeGet(), op1); + emit->emitInsLoadInd(ins, emitTypeSize(TYP_SIMD16), node->gtRegNum, &load); + } + else + { + genHWIntrinsic_R_RM(node, ins, emitTypeSize(TYP_SIMD16)); + } + break; + } + case NI_SSE41_TestAllOnes: { op1Reg = op1->gtRegNum; @@ -1955,6 +1975,26 @@ void CodeGen::genAvxOrAvx2Intrinsic(GenTreeHWIntrinsic* node) break; } + case NI_AVX2_ConvertToVector256Int16: + case NI_AVX2_ConvertToVector256Int32: + case NI_AVX2_ConvertToVector256Int64: + { + instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType); + + if (!varTypeIsSIMD(op1->gtType)) + { + // Until we improve the handling of addressing modes in the emitter, we'll create a + // temporary GT_IND to generate code with. + GenTreeIndir load = indirForm(node->TypeGet(), op1); + emit->emitInsLoadInd(ins, emitTypeSize(TYP_SIMD32), node->gtRegNum, &load); + } + else + { + genHWIntrinsic_R_RM(node, ins, emitTypeSize(TYP_SIMD32)); + } + break; + } + case NI_AVX2_GatherVector128: case NI_AVX2_GatherVector256: case NI_AVX2_GatherMaskVector128: diff --git a/src/jit/hwintrinsiclistxarch.h b/src/jit/hwintrinsiclistxarch.h index 41ddfc8dd2..b7de03be20 100644 --- a/src/jit/hwintrinsiclistxarch.h +++ b/src/jit/hwintrinsiclistxarch.h @@ -330,9 +330,9 @@ HARDWARE_INTRINSIC(SSE41_BlendVariable, "BlendVariab HARDWARE_INTRINSIC(SSE41_Ceiling, "Ceiling", SSE41, 10, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_roundps, INS_roundpd}, HW_Category_SimpleSIMD, HW_Flag_NoRMWSemantics) HARDWARE_INTRINSIC(SSE41_CeilingScalar, "CeilingScalar", SSE41, 10, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_roundss, INS_roundsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(SSE41_CompareEqual, "CompareEqual", SSE41, -1, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pcmpeqq, INS_pcmpeqq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative) -HARDWARE_INTRINSIC(SSE41_ConvertToVector128Int16, "ConvertToVector128Int16", SSE41, -1, 16, 1, {INS_pmovsxbw, INS_pmovzxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics) -HARDWARE_INTRINSIC(SSE41_ConvertToVector128Int32, "ConvertToVector128Int32", SSE41, -1, 16, 1, {INS_pmovsxbd, INS_pmovzxbd, INS_pmovsxwd, INS_pmovzxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics) -HARDWARE_INTRINSIC(SSE41_ConvertToVector128Int64, "ConvertToVector128Int64", SSE41, -1, 16, 1, {INS_pmovsxbq, INS_pmovzxbq, INS_pmovsxwq, INS_pmovzxwq, INS_pmovsxdq, INS_pmovzxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics) +HARDWARE_INTRINSIC(SSE41_ConvertToVector128Int16, "ConvertToVector128Int16", SSE41, -1, 16, 1, {INS_pmovsxbw, INS_pmovzxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics) +HARDWARE_INTRINSIC(SSE41_ConvertToVector128Int32, "ConvertToVector128Int32", SSE41, -1, 16, 1, {INS_pmovsxbd, INS_pmovzxbd, INS_pmovsxwd, INS_pmovzxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics) +HARDWARE_INTRINSIC(SSE41_ConvertToVector128Int64, "ConvertToVector128Int64", SSE41, -1, 16, 1, {INS_pmovsxbq, INS_pmovzxbq, INS_pmovsxwq, INS_pmovzxwq, INS_pmovsxdq, INS_pmovzxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics) HARDWARE_INTRINSIC(SSE41_DotProduct, "DotProduct", SSE41, -1, 16, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_dpps, INS_dppd}, HW_Category_IMM, HW_Flag_FullRangeIMM) HARDWARE_INTRINSIC(SSE41_Extract, "Extract", SSE41, -1, 16, 2, {INS_pextrb, INS_pextrb, INS_invalid, INS_invalid, INS_pextrd, INS_pextrd, INS_invalid, INS_invalid, INS_extractps, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_BaseTypeFromFirstArg|HW_Flag_MultiIns|HW_Flag_NoRMWSemantics) HARDWARE_INTRINSIC(SSE41_Floor, "Floor", SSE41, 9, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_roundps, INS_roundpd}, HW_Category_SimpleSIMD, HW_Flag_NoRMWSemantics) @@ -474,9 +474,9 @@ HARDWARE_INTRINSIC(AVX2_CompareGreaterThan, "CompareGrea HARDWARE_INTRINSIC(AVX2_ExtractVector128, "ExtractVector128", AVX2, -1, 32, 2, {INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM) HARDWARE_INTRINSIC(AVX2_ConvertToInt32, "ConvertToInt32", AVX2, -1, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics) HARDWARE_INTRINSIC(AVX2_ConvertToUInt32, "ConvertToUInt32", AVX2, -1, 32, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mov_xmm2i, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMDScalar, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_NoRMWSemantics) -HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int16, "ConvertToVector256Int16", AVX2, -1, 32, 1, {INS_pmovsxbw, INS_pmovzxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg) -HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int32, "ConvertToVector256Int32", AVX2, -1, 32, 1, {INS_pmovsxbd, INS_pmovzxbd, INS_pmovsxwd, INS_pmovzxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg) -HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int64, "ConvertToVector256Int64", AVX2, -1, 32, 1, {INS_pmovsxbq, INS_pmovzxbq, INS_pmovsxwq, INS_pmovzxwq, INS_pmovsxdq, INS_pmovzxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg) +HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int16, "ConvertToVector256Int16", AVX2, -1, 32, 1, {INS_pmovsxbw, INS_pmovzxbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg) +HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int32, "ConvertToVector256Int32", AVX2, -1, 32, 1, {INS_pmovsxbd, INS_pmovzxbd, INS_pmovsxwd, INS_pmovzxwd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg) +HARDWARE_INTRINSIC(AVX2_ConvertToVector256Int64, "ConvertToVector256Int64", AVX2, -1, 32, 1, {INS_pmovsxbq, INS_pmovzxbq, INS_pmovsxwq, INS_pmovzxwq, INS_pmovsxdq, INS_pmovzxdq, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(AVX2_GatherVector128, "GatherVector128", AVX2, -1, 16, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpgatherdd, INS_vpgatherdd, INS_vpgatherdq, INS_vpgatherdq, INS_vgatherdps, INS_vgatherdpd}, HW_Category_IMM, HW_Flag_SpecialCodeGen|HW_Flag_NoContainment) HARDWARE_INTRINSIC(AVX2_GatherVector256, "GatherVector256", AVX2, -1, 32, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpgatherdd, INS_vpgatherdd, INS_vpgatherdq, INS_vpgatherdq, INS_vgatherdps, INS_vgatherdpd}, HW_Category_IMM, HW_Flag_MaybeMemoryLoad|HW_Flag_SpecialCodeGen|HW_Flag_NoContainment) HARDWARE_INTRINSIC(AVX2_GatherMaskVector128, "GatherMaskVector128", AVX2, -1, 16, 5, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpgatherdd, INS_vpgatherdd, INS_vpgatherdq, INS_vpgatherdq, INS_vgatherdps, INS_vgatherdpd}, HW_Category_IMM, HW_Flag_MaybeMemoryLoad|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_NoContainment) diff --git a/src/jit/hwintrinsicxarch.cpp b/src/jit/hwintrinsicxarch.cpp index 4d78fde975..bb224f9a17 100644 --- a/src/jit/hwintrinsicxarch.cpp +++ b/src/jit/hwintrinsicxarch.cpp @@ -807,29 +807,6 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } } - bool isTableDriven = impIsTableDrivenHWIntrinsic(intrinsic, category); - - if (isTableDriven && ((category == HW_Category_MemoryStore) || HWIntrinsicInfo::BaseTypeFromFirstArg(intrinsic) || - HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic))) - { - if (HWIntrinsicInfo::BaseTypeFromFirstArg(intrinsic)) - { - baseType = getBaseTypeOfSIMDType(info.compCompHnd->getArgClass(sig, sig->args)); - } - else - { - assert((category == HW_Category_MemoryStore) || HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic)); - CORINFO_ARG_LIST_HANDLE secondArg = info.compCompHnd->getArgNext(sig->args); - CORINFO_CLASS_HANDLE secondArgClass = info.compCompHnd->getArgClass(sig, secondArg); - baseType = getBaseTypeOfSIMDType(secondArgClass); - - if (baseType == TYP_UNKNOWN) // the second argument is not a vector - { - baseType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, secondArg, &secondArgClass))); - } - } - } - if (HWIntrinsicInfo::IsFloatingPointUsed(intrinsic)) { // Set `compFloatingPointUsed` to cover the scenario where an intrinsic is being on SIMD fields, but @@ -838,8 +815,37 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } // table-driven importer of simple intrinsics - if (isTableDriven) + if (impIsTableDrivenHWIntrinsic(intrinsic, category)) { + if ((category == HW_Category_MemoryStore) || HWIntrinsicInfo::BaseTypeFromFirstArg(intrinsic) || + HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic)) + { + CORINFO_ARG_LIST_HANDLE arg = sig->args; + + if ((category == HW_Category_MemoryStore) || HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic)) + { + arg = info.compCompHnd->getArgNext(arg); + } + + CORINFO_CLASS_HANDLE argClass = info.compCompHnd->getArgClass(sig, arg); + baseType = getBaseTypeAndSizeOfSIMDType(argClass); + + if (baseType == TYP_UNKNOWN) // the argument is not a vector + { + CORINFO_CLASS_HANDLE tmpClass; + CorInfoType corInfoType = strip(info.compCompHnd->getArgType(sig, arg, &tmpClass)); + + if (corInfoType == CORINFO_TYPE_PTR) + { + corInfoType = info.compCompHnd->getChildType(argClass, &tmpClass); + } + + baseType = JITtype2varType(corInfoType); + } + + assert(baseType != TYP_UNKNOWN); + } + unsigned simdSize = HWIntrinsicInfo::lookupSimdSize(this, intrinsic, sig); CORINFO_ARG_LIST_HANDLE argList = sig->args; CORINFO_CLASS_HANDLE argClass; @@ -1737,6 +1743,7 @@ GenTree* Compiler::impSSE42Intrinsic(NamedIntrinsic intrinsic, CORINFO_ARG_LIST_HANDLE argList = sig->args; CORINFO_CLASS_HANDLE argClass; CorInfoType corType; + switch (intrinsic) { case NI_SSE42_Crc32: diff --git a/src/jit/hwintrinsicxarch.h b/src/jit/hwintrinsicxarch.h index 30a4d9bddb..d4469e7a2e 100644 --- a/src/jit/hwintrinsicxarch.h +++ b/src/jit/hwintrinsicxarch.h @@ -178,7 +178,11 @@ struct HWIntrinsicInfo static instruction lookupIns(NamedIntrinsic id, var_types type) { - assert((type >= TYP_BYTE) && (type <= TYP_DOUBLE)); + if ((type < TYP_BYTE) || (type > TYP_DOUBLE)) + { + assert(!"Unexpected type"); + return INS_invalid; + } return lookup(id).ins[type - TYP_BYTE]; } diff --git a/src/jit/lowerxarch.cpp b/src/jit/lowerxarch.cpp index 9a1f223d8f..bcb5bef51f 100644 --- a/src/jit/lowerxarch.cpp +++ b/src/jit/lowerxarch.cpp @@ -2492,15 +2492,32 @@ bool Lowering::IsContainableHWIntrinsicOp(GenTreeHWIntrinsic* containingNode, Ge case HW_Category_SimpleSIMD: { - // These intrinsics only expect 16 or 32-byte nodes for containment - assert((genTypeSize(node->TypeGet()) == 16) || (genTypeSize(node->TypeGet()) == 32)); - assert(supportsSIMDScalarLoads == false); + switch (containingIntrinsicId) + { + case NI_SSE41_ConvertToVector128Int16: + case NI_SSE41_ConvertToVector128Int32: + case NI_SSE41_ConvertToVector128Int64: + case NI_AVX2_ConvertToVector256Int16: + case NI_AVX2_ConvertToVector256Int32: + case NI_AVX2_ConvertToVector256Int64: + { + supportsGeneralLoads = (!node->OperIsHWIntrinsic()); + break; + } - supportsAlignedSIMDLoads = - !comp->canUseVexEncoding() && (containingIntrinsicId != NI_SSE2_ConvertToVector128Double); - supportsUnalignedSIMDLoads = !supportsAlignedSIMDLoads; - supportsGeneralLoads = supportsUnalignedSIMDLoads; + default: + { + // These intrinsics only expect 16 or 32-byte nodes for containment + assert((genTypeSize(node->TypeGet()) == 16) || (genTypeSize(node->TypeGet()) == 32)); + supportsAlignedSIMDLoads = + !comp->canUseVexEncoding() && (containingIntrinsicId != NI_SSE2_ConvertToVector128Double); + supportsUnalignedSIMDLoads = !supportsAlignedSIMDLoads; + supportsGeneralLoads = supportsUnalignedSIMDLoads; + break; + } + } + assert(supportsSIMDScalarLoads == false); break; } @@ -2908,6 +2925,22 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) break; } + case NI_SSE41_ConvertToVector128Int16: + case NI_SSE41_ConvertToVector128Int32: + case NI_SSE41_ConvertToVector128Int64: + case NI_AVX2_ConvertToVector256Int16: + case NI_AVX2_ConvertToVector256Int32: + case NI_AVX2_ConvertToVector256Int64: + { + if (!varTypeIsSIMD(op1->gtType)) + { + GenTree** pAddr = &node->gtOp1; + ContainCheckHWIntrinsicAddr(node, pAddr); + return; + } + break; + } + default: { break; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs index ebaea926c6..2a4800189f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.Byte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int16( + (Byte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int16( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Byte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<Byte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs index 92b47e7eba..21beb9dd3c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int16.SByte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int16( + (SByte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int16( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(SByte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int16>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int16), new Type[] { typeof(Vector128<SByte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs index 172ce8539d..ac163d11a3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Byte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int32( + (Byte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Byte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Byte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs index a197da2439..777b6f244c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.Int16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int32( + (Int16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Int16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<Int16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs index 47af229606..d824f5686f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.SByte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int32( + (SByte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(SByte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<SByte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs index 8020d84a91..dbdb145706 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int32.UInt16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int32( + (UInt16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(UInt16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int32), new Type[] { typeof(Vector128<UInt16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs index 80c10fed28..cc1862d98b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Byte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int64( + (Byte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Byte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Byte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs index 092610d61d..aff546dff9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int64( + (Int16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Int16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Int16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs index f1c16ee090..c93d69b07f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.Int32.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int64( + (Int32*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Int32*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Int32*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<Int32>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs index f3848d55e6..1058faaf20 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.SByte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int64( + (SByte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(SByte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<SByte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs index 63a9e20823..abd6201e1a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int64( + (UInt16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(UInt16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs index 2fd078610b..54ecb60936 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToVector256Int64.UInt32.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Avx.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Avx.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Avx2.ConvertToVector256Int64( + (UInt32*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Avx2.ConvertToVector256Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(UInt32*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(UInt32*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector256<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToVector256Int64), new Type[] { typeof(Vector128<UInt32>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs index 67ee09b11d..d1353b21ef 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.Byte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int16( + (Byte*)_dataTable.inArrayPtr + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int16( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(Byte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int16>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(Vector128<Byte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs index 8f4ea820dd..ccc1010cd4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int16.SByte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int16( + (SByte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int16( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(SByte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int16>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int16), new Type[] { typeof(Vector128<SByte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs index f48f8d48e9..2877d2e767 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Byte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int32( + (Byte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Byte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<Byte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs index ed1d1ee976..403e12f4fb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.Int16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int32( + (Int16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Int16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<Int16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs index 73f87e4e42..a4285ecce5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.SByte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int32( + (SByte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(SByte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<SByte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs index 27976d60b0..c1fcecb708 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int32.UInt16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int32( + (UInt16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int32( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(UInt16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int32>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int32), new Type[] { typeof(Vector128<UInt16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs index 63ea6c7c34..0cdd7768ea 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Byte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int64( + (Byte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Byte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Byte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<Byte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs index fa76d77890..9d1caef482 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int64( + (Int16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Int16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Int16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<Int16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs index 870ad738a3..f19e7838a2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.Int32.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int64( + (Int32*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Int32*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(Int32*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<Int32>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs index ba2859cc68..d8ef38562d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.SByte.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int64( + (SByte*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(SByte*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(SByte*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<SByte>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs index 1ea8e06a20..f81b199dce 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt16.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int64( + (UInt16*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(UInt16*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(UInt16*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<UInt16>) }) diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs index 9e58baad22..18e2233ad4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/ConvertToVector128Int64.UInt32.cs @@ -10,6 +10,7 @@ ******************************************************************************/ using System; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; @@ -28,6 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); + // Validates basic functionality works, using the pointer overload + test.RunBasicScenario_Ptr(); + if (Sse2.IsSupported) { // Validates basic functionality works, using Load @@ -40,6 +44,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); + // Validates calling via reflection works, using the pointer overload + test.RunReflectionScenario_Ptr(); + if (Sse2.IsSupported) { // Validates calling via reflection works, using Load @@ -133,6 +140,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunBasicScenario_Ptr() + { + var result = Sse41.ConvertToVector128Int64( + (UInt32*)(_dataTable.inArrayPtr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunBasicScenario_Load() { var result = Sse41.ConvertToVector128Int64( @@ -164,6 +181,17 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } + public void RunReflectionScenario_Ptr() + { + var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(UInt32*) }) + .Invoke(null, new object[] { + Pointer.Box(_dataTable.inArrayPtr, typeof(UInt32*)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128<Int64>)(result)); + ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); + } + public void RunReflectionScenario_Load() { var result = typeof(Sse41).GetMethod(nameof(Sse41.ConvertToVector128Int64), new Type[] { typeof(Vector128<UInt32>) }) |