diff --git a/src/coreclr/src/jit/hwintrinsic.cpp b/src/coreclr/src/jit/hwintrinsic.cpp index 0ce3ec25b69f5..0a5eb66e9af2c 100644 --- a/src/coreclr/src/jit/hwintrinsic.cpp +++ b/src/coreclr/src/jit/hwintrinsic.cpp @@ -807,7 +807,8 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, sigReader.Read(info.compCompHnd, sig); #ifdef TARGET_ARM64 - if ((intrinsic == NI_AdvSimd_Insert) || (intrinsic == NI_AdvSimd_LoadAndInsertScalar)) + if ((intrinsic == NI_AdvSimd_Insert) || (intrinsic == NI_AdvSimd_InsertScalar) || + (intrinsic == NI_AdvSimd_LoadAndInsertScalar)) { assert(sig->numArgs == 3); immOp = impStackTop(1).val; @@ -1058,7 +1059,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } } } - else if (intrinsic == NI_AdvSimd_Insert) + else if ((intrinsic == NI_AdvSimd_Insert) || (intrinsic == NI_AdvSimd_InsertScalar)) { op2 = addRangeCheckIfNeeded(intrinsic, op2, mustExpand, immLowerBound, immUpperBound); } diff --git a/src/coreclr/src/jit/hwintrinsicarm64.cpp b/src/coreclr/src/jit/hwintrinsicarm64.cpp index b6a7bd8c59dfa..ec6f2f40d2588 100644 --- a/src/coreclr/src/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/src/jit/hwintrinsicarm64.cpp @@ -225,6 +225,7 @@ void HWIntrinsicInfo::lookupImmBounds( case NI_AdvSimd_ExtractVector128: case NI_AdvSimd_ExtractVector64: case NI_AdvSimd_Insert: + case NI_AdvSimd_InsertScalar: case NI_AdvSimd_LoadAndInsertScalar: case NI_AdvSimd_StoreSelectedScalar: case NI_AdvSimd_Arm64_DuplicateSelectedScalarToVector128: diff --git a/src/coreclr/src/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/src/jit/hwintrinsiccodegenarm64.cpp index c2ebd16eecf58..a655248c515a0 100644 --- a/src/coreclr/src/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/src/jit/hwintrinsiccodegenarm64.cpp @@ -644,6 +644,27 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } break; + case NI_AdvSimd_InsertScalar: + { + assert(isRMW); + assert(targetReg != op3Reg); + + if (targetReg != op1Reg) + { + GetEmitter()->emitIns_R_R(INS_mov, emitTypeSize(node), targetReg, op1Reg); + } + + HWIntrinsicImmOpHelper helper(this, intrin.op2, node); + + for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) + { + const int elementIndex = helper.ImmValue(); + + GetEmitter()->emitIns_R_R_I_I(ins, emitSize, targetReg, op3Reg, elementIndex, 0, opt); + } + } + break; + case NI_AdvSimd_Arm64_InsertSelectedScalar: { assert(isRMW); diff --git a/src/coreclr/src/jit/hwintrinsiclistarm64.h b/src/coreclr/src/jit/hwintrinsiclistarm64.h index 194929b4ac1c7..63ca9b21526d0 100644 --- a/src/coreclr/src/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/src/jit/hwintrinsiclistarm64.h @@ -165,6 +165,7 @@ HARDWARE_INTRINSIC(AdvSimd, FusedMultiplySubtractScalar, HARDWARE_INTRINSIC(AdvSimd, FusedMultiplySubtractNegatedScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_fnmsub, INS_fnmsub}, HW_Category_SIMD, HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd, FusedSubtractHalving, -1, 2, {INS_shsub, INS_uhsub, INS_shsub, INS_uhsub, INS_shsub, INS_uhsub, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, Insert, -1, 3, {INS_ins, INS_ins, INS_ins, INS_ins, INS_ins, INS_ins, INS_ins, INS_ins, INS_ins, INS_ins}, HW_Category_SIMD, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_SupportsContainment) +HARDWARE_INTRINSIC(AdvSimd, InsertScalar, 16, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ins, INS_ins, INS_invalid, INS_ins}, HW_Category_SIMD, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd, LeadingSignCount, -1, 1, {INS_cls, INS_invalid, INS_cls, INS_invalid, INS_cls, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, LeadingZeroCount, -1, 1, {INS_clz, INS_clz, INS_clz, INS_clz, INS_clz, INS_clz, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, LoadAndInsertScalar, -1, 3, {INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1}, HW_Category_MemoryLoad, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen) @@ -235,9 +236,9 @@ HARDWARE_INTRINSIC(AdvSimd, ShiftArithmeticRoundedScalar, HARDWARE_INTRINSIC(AdvSimd, ShiftArithmeticSaturate, -1, 2, {INS_sqshl, INS_invalid, INS_sqshl, INS_invalid, INS_sqshl, INS_invalid, INS_sqshl, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, ShiftArithmeticSaturateScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqshl, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftArithmeticScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sshl, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_SIMDScalar) +HARDWARE_INTRINSIC(AdvSimd, ShiftLeftAndInsert, -1, 3, {INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(AdvSimd, ShiftLeftAndInsertScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sli, INS_sli, INS_invalid, INS_invalid}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftLeftLogical, -1, 2, {INS_shl, INS_shl, INS_shl, INS_shl, INS_shl, INS_shl, INS_shl, INS_shl, INS_invalid, INS_invalid}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand) -HARDWARE_INTRINSIC(AdvSimd, ShiftLeftLogicalAndInsert, -1, 3, {INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli, INS_sli}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(AdvSimd, ShiftLeftLogicalAndInsertScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sli, INS_sli, INS_invalid, INS_invalid}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftLeftLogicalSaturate, -1, 2, {INS_sqshl, INS_uqshl, INS_sqshl, INS_uqshl, INS_sqshl, INS_uqshl, INS_sqshl, INS_uqshl, INS_invalid, INS_invalid}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand) HARDWARE_INTRINSIC(AdvSimd, ShiftLeftLogicalSaturateScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqshl, INS_uqshl, INS_invalid, INS_invalid}, HW_Category_ShiftLeftByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftLeftLogicalSaturateUnsigned, -1, 2, {INS_sqshlu, INS_invalid, INS_sqshlu, INS_invalid, INS_sqshlu, INS_invalid, INS_sqshlu, INS_invalid, INS_invalid, INS_invalid}, HW_Category_ShiftLeftByImmediate, HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand) @@ -254,7 +255,7 @@ HARDWARE_INTRINSIC(AdvSimd, ShiftLogicalSaturate, HARDWARE_INTRINSIC(AdvSimd, ShiftLogicalSaturateScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_uqshl, INS_uqshl, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftLogicalScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ushl, INS_ushl, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftRightAndInsert, -1, 3, {INS_sri, INS_sri, INS_sri, INS_sri, INS_sri, INS_sri, INS_sri, INS_sri, INS_sri, INS_sri}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(AdvSimd, ShiftRightLogicalAndInsertScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sri, INS_sri, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar) +HARDWARE_INTRINSIC(AdvSimd, ShiftRightAndInsertScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sri, INS_sri, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd, ShiftRightArithmetic, -1, 2, {INS_sshr, INS_invalid, INS_sshr, INS_invalid, INS_sshr, INS_invalid, INS_sshr, INS_invalid, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand) HARDWARE_INTRINSIC(AdvSimd, ShiftRightArithmeticAdd, -1, 3, {INS_ssra, INS_invalid, INS_ssra, INS_invalid, INS_ssra, INS_invalid, INS_ssra, INS_invalid, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(AdvSimd, ShiftRightArithmeticAddScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_ssra, INS_invalid, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar) diff --git a/src/coreclr/src/jit/lowerarmarch.cpp b/src/coreclr/src/jit/lowerarmarch.cpp index 84c664a7606e9..465f414433325 100644 --- a/src/coreclr/src/jit/lowerarmarch.cpp +++ b/src/coreclr/src/jit/lowerarmarch.cpp @@ -1416,6 +1416,7 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_DuplicateSelectedScalarToVector64: case NI_AdvSimd_DuplicateSelectedScalarToVector128: case NI_AdvSimd_Extract: + case NI_AdvSimd_InsertScalar: case NI_AdvSimd_LoadAndInsertScalar: case NI_AdvSimd_Arm64_DuplicateSelectedScalarToVector128: case NI_Vector64_GetElement: diff --git a/src/coreclr/src/jit/lsraarm64.cpp b/src/coreclr/src/jit/lsraarm64.cpp index df0c7113fa679..47ce26478c647 100644 --- a/src/coreclr/src/jit/lsraarm64.cpp +++ b/src/coreclr/src/jit/lsraarm64.cpp @@ -1025,6 +1025,7 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) case NI_AdvSimd_DuplicateSelectedScalarToVector128: case NI_AdvSimd_Extract: case NI_AdvSimd_Insert: + case NI_AdvSimd_InsertScalar: case NI_AdvSimd_LoadAndInsertScalar: case NI_AdvSimd_Arm64_DuplicateSelectedScalarToVector128: needBranchTargetReg = !intrin.op2->isContainedIntOrIImmed(); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_r.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_r.csproj index 0a45468bcd8ca..f4df25ca3c4d0 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_r.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_r.csproj @@ -60,6 +60,9 @@ + + + @@ -261,9 +264,6 @@ - - - diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_ro.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_ro.csproj index 019d81be05aaa..d81245d161639 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_ro.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part2_ro.csproj @@ -60,6 +60,9 @@ + + + @@ -261,9 +264,6 @@ - - - diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj index 50ab81166e163..82c323ac45cd0 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj @@ -8,6 +8,9 @@ + + + @@ -261,9 +264,6 @@ - - - diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj index a2b675906e68c..c85f9dc01ef7c 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj @@ -8,6 +8,9 @@ True + + + @@ -261,9 +264,6 @@ - - - diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj index 7b0ba98d5d916..95339a266cabf 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj @@ -8,6 +8,9 @@ + + + @@ -23,6 +26,22 @@ + + + + + + + + + + + + + + + + @@ -36,22 +55,6 @@ - - - - - - - - - - - - - - - - @@ -168,6 +171,8 @@ + + @@ -254,16 +259,11 @@ - - - - - diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj index 46fea9701d655..84c99d20f420e 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj @@ -8,6 +8,9 @@ True + + + @@ -23,6 +26,22 @@ + + + + + + + + + + + + + + + + @@ -36,22 +55,6 @@ - - - - - - - - - - - - - - - - @@ -168,6 +171,8 @@ + + @@ -254,16 +259,11 @@ - - - - - diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj index 6cbc5bfbb8c5c..f6f81aa78a5f2 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj @@ -8,6 +8,9 @@ + + + diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj index b2d9439d017de..2bb02d86071c2 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj @@ -8,6 +8,9 @@ True + + + diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.Double.1.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.Double.1.cs new file mode 100644 index 0000000000000..de86d8e8bc8e4 --- /dev/null +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.Double.1.cs @@ -0,0 +1,541 @@ +// 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. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void InsertScalar_Vector128_Double_1() + { + var test = new InsertScalarTest__InsertScalar_Vector128_Double_1(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing a static member works, using pinning and Load + test.RunClsVarScenario_Load(); + } + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing the field of a local class works, using pinning and Load + test.RunClassLclFldScenario_Load(); + } + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing an instance member of a class works, using pinning and Load + test.RunClassFldScenario_Load(); + } + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing the field of a local struct works, using pinning and Load + test.RunStructLclFldScenario_Load(); + } + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class InsertScalarTest__InsertScalar_Vector128_Double_1 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] inArray3; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle inHandle3; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Double[] inArray1, Double[] inArray3, Double[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray3 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray3Ptr), ref Unsafe.As(ref inArray3[0]), (uint)sizeOfinArray3); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + inHandle3.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + public Vector64 _fld3; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertScalarTest__InsertScalar_Vector128_Double_1 testClass) + { + var result = AdvSimd.InsertScalar(_fld1, 1, _fld3); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(InsertScalarTest__InsertScalar_Vector128_Double_1 testClass) + { + fixed (Vector128* pFld1 = &_fld1) + fixed (Vector64* pFld2 = &_fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Double*)pFld1), + 1, + AdvSimd.LoadVector64((Double*)pFld2) + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Double); + private static readonly int Op3ElementCount = Unsafe.SizeOf>() / sizeof(Double); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Double); + private static readonly byte ElementIndex = 1; + + private static Double[] _data1 = new Double[Op1ElementCount]; + private static Double[] _data3 = new Double[Op3ElementCount]; + + private static Vector128 _clsVar1; + private static Vector64 _clsVar3; + + private Vector128 _fld1; + private Vector64 _fld3; + + private DataTable _dataTable; + + static InsertScalarTest__InsertScalar_Vector128_Double_1() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + } + + public InsertScalarTest__InsertScalar_Vector128_Double_1() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetDouble(); } + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetDouble(); } + _dataTable = new DataTable(_data1, _data3, new Double[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.InsertScalar( + Unsafe.Read>(_dataTable.inArray1Ptr), + 1, + Unsafe.Read>(_dataTable.inArray3Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Double*)(_dataTable.inArray1Ptr)), + 1, + AdvSimd.LoadVector64((Double*)(_dataTable.inArray3Ptr)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.InsertScalar), new Type[] { typeof(Vector128), typeof(byte), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + ElementIndex, + Unsafe.Read>(_dataTable.inArray3Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.InsertScalar), new Type[] { typeof(Vector128), typeof(byte), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((Double*)(_dataTable.inArray1Ptr)), + ElementIndex, + AdvSimd.LoadVector64((Double*)(_dataTable.inArray3Ptr)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.InsertScalar( + _clsVar1, + 1, + _clsVar3 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + fixed (Vector64* pClsVar3 = &_clsVar3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Double*)(pClsVar1)), + 1, + AdvSimd.LoadVector64((Double*)(pClsVar3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var op3 = Unsafe.Read>(_dataTable.inArray3Ptr); + var result = AdvSimd.InsertScalar(op1, 1, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((Double*)(_dataTable.inArray1Ptr)); + var op3 = AdvSimd.LoadVector64((Double*)(_dataTable.inArray3Ptr)); + var result = AdvSimd.InsertScalar(op1, 1, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new InsertScalarTest__InsertScalar_Vector128_Double_1(); + var result = AdvSimd.InsertScalar(test._fld1, 1, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new InsertScalarTest__InsertScalar_Vector128_Double_1(); + + fixed (Vector128* pFld1 = &test._fld1) + fixed (Vector64* pFld2 = &test._fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Double*)pFld1), + 1, + AdvSimd.LoadVector64((Double*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.InsertScalar(_fld1, 1, _fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + fixed (Vector64* pFld2 = &_fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Double*)pFld1), + 1, + AdvSimd.LoadVector64((Double*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.InsertScalar(test._fld1, 1, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Double*)(&test._fld1)), + 1, + AdvSimd.LoadVector64((Double*)(&test._fld3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + public void RunStructFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); + + var test = TestStruct.Create(); + test.RunStructFldScenario_Load(this); + } + + public void RunUnsupportedScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, Vector64 op3, void* result, [CallerMemberName] string method = "") + { + Double[] inArray1 = new Double[Op1ElementCount]; + Double[] inArray3 = new Double[Op3ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray3[0]), op3); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "") + { + Double[] inArray1 = new Double[Op1ElementCount]; + Double[] inArray3 = new Double[Op3ElementCount]; + Double[] outArray = new Double[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray3[0]), ref Unsafe.AsRef(op3), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(Double[] firstOp, Double[] thirdOp, Double[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + for (var i = 0; i < RetElementCount; i++) + { + if (BitConverter.DoubleToInt64Bits(Helpers.Insert(firstOp, ElementIndex, thirdOp[0], i)) != BitConverter.DoubleToInt64Bits(result[i])) + { + succeeded = false; + break; + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.InsertScalar)}(Vector128, 1, Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.Int64.1.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.Int64.1.cs new file mode 100644 index 0000000000000..820957ac79fcf --- /dev/null +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.Int64.1.cs @@ -0,0 +1,541 @@ +// 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. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void InsertScalar_Vector128_Int64_1() + { + var test = new InsertScalarTest__InsertScalar_Vector128_Int64_1(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing a static member works, using pinning and Load + test.RunClsVarScenario_Load(); + } + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing the field of a local class works, using pinning and Load + test.RunClassLclFldScenario_Load(); + } + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing an instance member of a class works, using pinning and Load + test.RunClassFldScenario_Load(); + } + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing the field of a local struct works, using pinning and Load + test.RunStructLclFldScenario_Load(); + } + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class InsertScalarTest__InsertScalar_Vector128_Int64_1 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] inArray3; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle inHandle3; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int64[] inArray1, Int64[] inArray3, Int64[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray3 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray3Ptr), ref Unsafe.As(ref inArray3[0]), (uint)sizeOfinArray3); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + inHandle3.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + public Vector64 _fld3; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertScalarTest__InsertScalar_Vector128_Int64_1 testClass) + { + var result = AdvSimd.InsertScalar(_fld1, 1, _fld3); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(InsertScalarTest__InsertScalar_Vector128_Int64_1 testClass) + { + fixed (Vector128* pFld1 = &_fld1) + fixed (Vector64* pFld2 = &_fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Int64*)pFld1), + 1, + AdvSimd.LoadVector64((Int64*)pFld2) + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int64); + private static readonly int Op3ElementCount = Unsafe.SizeOf>() / sizeof(Int64); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int64); + private static readonly byte ElementIndex = 1; + + private static Int64[] _data1 = new Int64[Op1ElementCount]; + private static Int64[] _data3 = new Int64[Op3ElementCount]; + + private static Vector128 _clsVar1; + private static Vector64 _clsVar3; + + private Vector128 _fld1; + private Vector64 _fld3; + + private DataTable _dataTable; + + static InsertScalarTest__InsertScalar_Vector128_Int64_1() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + } + + public InsertScalarTest__InsertScalar_Vector128_Int64_1() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetInt64(); } + _dataTable = new DataTable(_data1, _data3, new Int64[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.InsertScalar( + Unsafe.Read>(_dataTable.inArray1Ptr), + 1, + Unsafe.Read>(_dataTable.inArray3Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), + 1, + AdvSimd.LoadVector64((Int64*)(_dataTable.inArray3Ptr)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.InsertScalar), new Type[] { typeof(Vector128), typeof(byte), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + ElementIndex, + Unsafe.Read>(_dataTable.inArray3Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.InsertScalar), new Type[] { typeof(Vector128), typeof(byte), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), + ElementIndex, + AdvSimd.LoadVector64((Int64*)(_dataTable.inArray3Ptr)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.InsertScalar( + _clsVar1, + 1, + _clsVar3 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + fixed (Vector64* pClsVar3 = &_clsVar3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Int64*)(pClsVar1)), + 1, + AdvSimd.LoadVector64((Int64*)(pClsVar3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var op3 = Unsafe.Read>(_dataTable.inArray3Ptr); + var result = AdvSimd.InsertScalar(op1, 1, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); + var op3 = AdvSimd.LoadVector64((Int64*)(_dataTable.inArray3Ptr)); + var result = AdvSimd.InsertScalar(op1, 1, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new InsertScalarTest__InsertScalar_Vector128_Int64_1(); + var result = AdvSimd.InsertScalar(test._fld1, 1, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new InsertScalarTest__InsertScalar_Vector128_Int64_1(); + + fixed (Vector128* pFld1 = &test._fld1) + fixed (Vector64* pFld2 = &test._fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Int64*)pFld1), + 1, + AdvSimd.LoadVector64((Int64*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.InsertScalar(_fld1, 1, _fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + fixed (Vector64* pFld2 = &_fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Int64*)pFld1), + 1, + AdvSimd.LoadVector64((Int64*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.InsertScalar(test._fld1, 1, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((Int64*)(&test._fld1)), + 1, + AdvSimd.LoadVector64((Int64*)(&test._fld3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + public void RunStructFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); + + var test = TestStruct.Create(); + test.RunStructFldScenario_Load(this); + } + + public void RunUnsupportedScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, Vector64 op3, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Int64[] inArray3 = new Int64[Op3ElementCount]; + Int64[] outArray = new Int64[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray3[0]), op3); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "") + { + Int64[] inArray1 = new Int64[Op1ElementCount]; + Int64[] inArray3 = new Int64[Op3ElementCount]; + Int64[] outArray = new Int64[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray3[0]), ref Unsafe.AsRef(op3), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(Int64[] firstOp, Int64[] thirdOp, Int64[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + for (var i = 0; i < RetElementCount; i++) + { + if (Helpers.Insert(firstOp, ElementIndex, thirdOp[0], i) != result[i]) + { + succeeded = false; + break; + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.InsertScalar)}(Vector128, 1, Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.UInt64.1.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.UInt64.1.cs new file mode 100644 index 0000000000000..686e7939ebc3b --- /dev/null +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/InsertScalar.Vector128.UInt64.1.cs @@ -0,0 +1,541 @@ +// 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. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void InsertScalar_Vector128_UInt64_1() + { + var test = new InsertScalarTest__InsertScalar_Vector128_UInt64_1(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing a static member works, using pinning and Load + test.RunClsVarScenario_Load(); + } + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing the field of a local class works, using pinning and Load + test.RunClassLclFldScenario_Load(); + } + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing an instance member of a class works, using pinning and Load + test.RunClassFldScenario_Load(); + } + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing the field of a local struct works, using pinning and Load + test.RunStructLclFldScenario_Load(); + } + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class InsertScalarTest__InsertScalar_Vector128_UInt64_1 + { + private struct DataTable + { + private byte[] inArray1; + private byte[] inArray3; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle inHandle3; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(UInt64[] inArray1, UInt64[] inArray3, UInt64[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray3 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray3Ptr), ref Unsafe.As(ref inArray3[0]), (uint)sizeOfinArray3); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + inHandle3.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + public Vector64 _fld3; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertScalarTest__InsertScalar_Vector128_UInt64_1 testClass) + { + var result = AdvSimd.InsertScalar(_fld1, 1, _fld3); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(InsertScalarTest__InsertScalar_Vector128_UInt64_1 testClass) + { + fixed (Vector128* pFld1 = &_fld1) + fixed (Vector64* pFld2 = &_fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((UInt64*)pFld1), + 1, + AdvSimd.LoadVector64((UInt64*)pFld2) + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt64); + private static readonly int Op3ElementCount = Unsafe.SizeOf>() / sizeof(UInt64); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt64); + private static readonly byte ElementIndex = 1; + + private static UInt64[] _data1 = new UInt64[Op1ElementCount]; + private static UInt64[] _data3 = new UInt64[Op3ElementCount]; + + private static Vector128 _clsVar1; + private static Vector64 _clsVar3; + + private Vector128 _fld1; + private Vector64 _fld3; + + private DataTable _dataTable; + + static InsertScalarTest__InsertScalar_Vector128_UInt64_1() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + } + + public InsertScalarTest__InsertScalar_Vector128_UInt64_1() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld3), ref Unsafe.As(ref _data3[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = TestLibrary.Generator.GetUInt64(); } + _dataTable = new DataTable(_data1, _data3, new UInt64[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.InsertScalar( + Unsafe.Read>(_dataTable.inArray1Ptr), + 1, + Unsafe.Read>(_dataTable.inArray3Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), + 1, + AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray3Ptr)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.InsertScalar), new Type[] { typeof(Vector128), typeof(byte), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + ElementIndex, + Unsafe.Read>(_dataTable.inArray3Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.InsertScalar), new Type[] { typeof(Vector128), typeof(byte), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), + ElementIndex, + AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray3Ptr)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.InsertScalar( + _clsVar1, + 1, + _clsVar3 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + fixed (Vector64* pClsVar3 = &_clsVar3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((UInt64*)(pClsVar1)), + 1, + AdvSimd.LoadVector64((UInt64*)(pClsVar3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var op3 = Unsafe.Read>(_dataTable.inArray3Ptr); + var result = AdvSimd.InsertScalar(op1, 1, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); + var op3 = AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray3Ptr)); + var result = AdvSimd.InsertScalar(op1, 1, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new InsertScalarTest__InsertScalar_Vector128_UInt64_1(); + var result = AdvSimd.InsertScalar(test._fld1, 1, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new InsertScalarTest__InsertScalar_Vector128_UInt64_1(); + + fixed (Vector128* pFld1 = &test._fld1) + fixed (Vector64* pFld2 = &test._fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((UInt64*)pFld1), + 1, + AdvSimd.LoadVector64((UInt64*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.InsertScalar(_fld1, 1, _fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + fixed (Vector64* pFld2 = &_fld3) + { + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((UInt64*)pFld1), + 1, + AdvSimd.LoadVector64((UInt64*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.InsertScalar(test._fld1, 1, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.InsertScalar( + AdvSimd.LoadVector128((UInt64*)(&test._fld1)), + 1, + AdvSimd.LoadVector64((UInt64*)(&test._fld3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + public void RunStructFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); + + var test = TestStruct.Create(); + test.RunStructFldScenario_Load(this); + } + + public void RunUnsupportedScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, Vector64 op3, void* result, [CallerMemberName] string method = "") + { + UInt64[] inArray1 = new UInt64[Op1ElementCount]; + UInt64[] inArray3 = new UInt64[Op3ElementCount]; + UInt64[] outArray = new UInt64[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray3[0]), op3); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "") + { + UInt64[] inArray1 = new UInt64[Op1ElementCount]; + UInt64[] inArray3 = new UInt64[Op3ElementCount]; + UInt64[] outArray = new UInt64[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray3[0]), ref Unsafe.AsRef(op3), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(UInt64[] firstOp, UInt64[] thirdOp, UInt64[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + for (var i = 0; i < RetElementCount; i++) + { + if (Helpers.Insert(firstOp, ElementIndex, thirdOp[0], i) != result[i]) + { + succeeded = false; + break; + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.InsertScalar)}(Vector128, 1, Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part2.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part2.cs index eaa02ebca6ef5..2da7a8bc75575 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part2.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part2.cs @@ -64,6 +64,9 @@ static Program() ["Insert.Vector128.UInt16.1"] = Insert_Vector128_UInt16_1, ["Insert.Vector128.UInt32.1"] = Insert_Vector128_UInt32_1, ["Insert.Vector128.UInt64.1"] = Insert_Vector128_UInt64_1, + ["InsertScalar.Vector128.Double.1"] = InsertScalar_Vector128_Double_1, + ["InsertScalar.Vector128.Int64.1"] = InsertScalar_Vector128_Int64_1, + ["InsertScalar.Vector128.UInt64.1"] = InsertScalar_Vector128_UInt64_1, ["LeadingSignCount.Vector64.Int16"] = LeadingSignCount_Vector64_Int16, ["LeadingSignCount.Vector64.Int32"] = LeadingSignCount_Vector64_Int32, ["LeadingSignCount.Vector64.SByte"] = LeadingSignCount_Vector64_SByte, @@ -265,9 +268,6 @@ static Program() ["MultiplyBySelectedScalar.Vector128.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalar_Vector128_UInt16_Vector128_UInt16_7, ["MultiplyBySelectedScalar.Vector128.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalar_Vector128_UInt32_Vector64_UInt32_1, ["MultiplyBySelectedScalar.Vector128.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalar_Vector128_UInt32_Vector128_UInt32_3, - ["MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningLower_Vector64_Int16_Vector64_Int16_3, - ["MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningLower_Vector64_Int16_Vector128_Int16_7, - ["MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningLower_Vector64_Int32_Vector64_Int32_1, }; } } diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs index 1cd2a9644fc52..ff968e476f311 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs @@ -12,6 +12,9 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningLower_Vector64_Int16_Vector64_Int16_3, + ["MultiplyBySelectedScalarWideningLower.Vector64.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningLower_Vector64_Int16_Vector128_Int16_7, + ["MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningLower_Vector64_Int32_Vector64_Int32_1, ["MultiplyBySelectedScalarWideningLower.Vector64.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningLower_Vector64_Int32_Vector128_Int32_3, ["MultiplyBySelectedScalarWideningLower.Vector64.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningLower_Vector64_UInt16_Vector64_UInt16_3, ["MultiplyBySelectedScalarWideningLower.Vector64.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningLower_Vector64_UInt16_Vector128_UInt16_7, @@ -265,9 +268,6 @@ static Program() ["ShiftArithmeticRounded.Vector128.Int32"] = ShiftArithmeticRounded_Vector128_Int32, ["ShiftArithmeticRounded.Vector128.Int64"] = ShiftArithmeticRounded_Vector128_Int64, ["ShiftArithmeticRounded.Vector128.SByte"] = ShiftArithmeticRounded_Vector128_SByte, - ["ShiftArithmeticRoundedSaturate.Vector64.Int16"] = ShiftArithmeticRoundedSaturate_Vector64_Int16, - ["ShiftArithmeticRoundedSaturate.Vector64.Int32"] = ShiftArithmeticRoundedSaturate_Vector64_Int32, - ["ShiftArithmeticRoundedSaturate.Vector64.SByte"] = ShiftArithmeticRoundedSaturate_Vector64_SByte, }; } } diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs index 319ffff221d8a..94dde708d798c 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs @@ -12,6 +12,9 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ShiftArithmeticRoundedSaturate.Vector64.Int16"] = ShiftArithmeticRoundedSaturate_Vector64_Int16, + ["ShiftArithmeticRoundedSaturate.Vector64.Int32"] = ShiftArithmeticRoundedSaturate_Vector64_Int32, + ["ShiftArithmeticRoundedSaturate.Vector64.SByte"] = ShiftArithmeticRoundedSaturate_Vector64_SByte, ["ShiftArithmeticRoundedSaturate.Vector128.Int16"] = ShiftArithmeticRoundedSaturate_Vector128_Int16, ["ShiftArithmeticRoundedSaturate.Vector128.Int32"] = ShiftArithmeticRoundedSaturate_Vector128_Int32, ["ShiftArithmeticRoundedSaturate.Vector128.Int64"] = ShiftArithmeticRoundedSaturate_Vector128_Int64, @@ -27,6 +30,22 @@ static Program() ["ShiftArithmeticSaturate.Vector128.SByte"] = ShiftArithmeticSaturate_Vector128_SByte, ["ShiftArithmeticSaturateScalar.Vector64.Int64"] = ShiftArithmeticSaturateScalar_Vector64_Int64, ["ShiftArithmeticScalar.Vector64.Int64"] = ShiftArithmeticScalar_Vector64_Int64, + ["ShiftLeftAndInsert.Vector64.Byte"] = ShiftLeftAndInsert_Vector64_Byte, + ["ShiftLeftAndInsert.Vector64.Int16"] = ShiftLeftAndInsert_Vector64_Int16, + ["ShiftLeftAndInsert.Vector64.Int32"] = ShiftLeftAndInsert_Vector64_Int32, + ["ShiftLeftAndInsert.Vector64.SByte"] = ShiftLeftAndInsert_Vector64_SByte, + ["ShiftLeftAndInsert.Vector64.UInt16"] = ShiftLeftAndInsert_Vector64_UInt16, + ["ShiftLeftAndInsert.Vector64.UInt32"] = ShiftLeftAndInsert_Vector64_UInt32, + ["ShiftLeftAndInsert.Vector128.Byte"] = ShiftLeftAndInsert_Vector128_Byte, + ["ShiftLeftAndInsert.Vector128.Int16"] = ShiftLeftAndInsert_Vector128_Int16, + ["ShiftLeftAndInsert.Vector128.Int32"] = ShiftLeftAndInsert_Vector128_Int32, + ["ShiftLeftAndInsert.Vector128.Int64"] = ShiftLeftAndInsert_Vector128_Int64, + ["ShiftLeftAndInsert.Vector128.SByte"] = ShiftLeftAndInsert_Vector128_SByte, + ["ShiftLeftAndInsert.Vector128.UInt16"] = ShiftLeftAndInsert_Vector128_UInt16, + ["ShiftLeftAndInsert.Vector128.UInt32"] = ShiftLeftAndInsert_Vector128_UInt32, + ["ShiftLeftAndInsert.Vector128.UInt64"] = ShiftLeftAndInsert_Vector128_UInt64, + ["ShiftLeftAndInsertScalar.Vector64.Int64"] = ShiftLeftAndInsertScalar_Vector64_Int64, + ["ShiftLeftAndInsertScalar.Vector64.UInt64"] = ShiftLeftAndInsertScalar_Vector64_UInt64, ["ShiftLeftLogical.Vector64.Byte.1"] = ShiftLeftLogical_Vector64_Byte_1, ["ShiftLeftLogical.Vector64.Int16.1"] = ShiftLeftLogical_Vector64_Int16_1, ["ShiftLeftLogical.Vector64.Int32.1"] = ShiftLeftLogical_Vector64_Int32_1, @@ -40,22 +59,6 @@ static Program() ["ShiftLeftLogical.Vector128.UInt16.1"] = ShiftLeftLogical_Vector128_UInt16_1, ["ShiftLeftLogical.Vector128.UInt32.1"] = ShiftLeftLogical_Vector128_UInt32_1, ["ShiftLeftLogical.Vector128.UInt64.1"] = ShiftLeftLogical_Vector128_UInt64_1, - ["ShiftLeftLogicalAndInsert.Vector64.Byte"] = ShiftLeftLogicalAndInsert_Vector64_Byte, - ["ShiftLeftLogicalAndInsert.Vector64.Int16"] = ShiftLeftLogicalAndInsert_Vector64_Int16, - ["ShiftLeftLogicalAndInsert.Vector64.Int32"] = ShiftLeftLogicalAndInsert_Vector64_Int32, - ["ShiftLeftLogicalAndInsert.Vector64.SByte"] = ShiftLeftLogicalAndInsert_Vector64_SByte, - ["ShiftLeftLogicalAndInsert.Vector64.UInt16"] = ShiftLeftLogicalAndInsert_Vector64_UInt16, - ["ShiftLeftLogicalAndInsert.Vector64.UInt32"] = ShiftLeftLogicalAndInsert_Vector64_UInt32, - ["ShiftLeftLogicalAndInsert.Vector128.Byte"] = ShiftLeftLogicalAndInsert_Vector128_Byte, - ["ShiftLeftLogicalAndInsert.Vector128.Int16"] = ShiftLeftLogicalAndInsert_Vector128_Int16, - ["ShiftLeftLogicalAndInsert.Vector128.Int32"] = ShiftLeftLogicalAndInsert_Vector128_Int32, - ["ShiftLeftLogicalAndInsert.Vector128.Int64"] = ShiftLeftLogicalAndInsert_Vector128_Int64, - ["ShiftLeftLogicalAndInsert.Vector128.SByte"] = ShiftLeftLogicalAndInsert_Vector128_SByte, - ["ShiftLeftLogicalAndInsert.Vector128.UInt16"] = ShiftLeftLogicalAndInsert_Vector128_UInt16, - ["ShiftLeftLogicalAndInsert.Vector128.UInt32"] = ShiftLeftLogicalAndInsert_Vector128_UInt32, - ["ShiftLeftLogicalAndInsert.Vector128.UInt64"] = ShiftLeftLogicalAndInsert_Vector128_UInt64, - ["ShiftLeftLogicalAndInsertScalar.Vector64.Int64"] = ShiftLeftLogicalAndInsertScalar_Vector64_Int64, - ["ShiftLeftLogicalAndInsertScalar.Vector64.UInt64"] = ShiftLeftLogicalAndInsertScalar_Vector64_UInt64, ["ShiftLeftLogicalSaturate.Vector64.Byte.1"] = ShiftLeftLogicalSaturate_Vector64_Byte_1, ["ShiftLeftLogicalSaturate.Vector64.Int16.1"] = ShiftLeftLogicalSaturate_Vector64_Int16_1, ["ShiftLeftLogicalSaturate.Vector64.Int32.1"] = ShiftLeftLogicalSaturate_Vector64_Int32_1, @@ -172,6 +175,8 @@ static Program() ["ShiftRightAndInsert.Vector128.UInt16"] = ShiftRightAndInsert_Vector128_UInt16, ["ShiftRightAndInsert.Vector128.UInt32"] = ShiftRightAndInsert_Vector128_UInt32, ["ShiftRightAndInsert.Vector128.UInt64"] = ShiftRightAndInsert_Vector128_UInt64, + ["ShiftRightAndInsertScalar.Vector64.Int64"] = ShiftRightAndInsertScalar_Vector64_Int64, + ["ShiftRightAndInsertScalar.Vector64.UInt64"] = ShiftRightAndInsertScalar_Vector64_UInt64, ["ShiftRightArithmetic.Vector64.Int16.1"] = ShiftRightArithmetic_Vector64_Int16_1, ["ShiftRightArithmetic.Vector64.Int32.1"] = ShiftRightArithmetic_Vector64_Int32_1, ["ShiftRightArithmetic.Vector64.SByte.1"] = ShiftRightArithmetic_Vector64_SByte_1, @@ -258,16 +263,11 @@ static Program() ["ShiftRightLogicalAdd.Vector128.UInt64.1"] = ShiftRightLogicalAdd_Vector128_UInt64_1, ["ShiftRightLogicalAddScalar.Vector64.Int64.1"] = ShiftRightLogicalAddScalar_Vector64_Int64_1, ["ShiftRightLogicalAddScalar.Vector64.UInt64.1"] = ShiftRightLogicalAddScalar_Vector64_UInt64_1, - ["ShiftRightLogicalAndInsertScalar.Vector64.Int64"] = ShiftRightLogicalAndInsertScalar_Vector64_Int64, - ["ShiftRightLogicalAndInsertScalar.Vector64.UInt64"] = ShiftRightLogicalAndInsertScalar_Vector64_UInt64, ["ShiftRightLogicalNarrowingLower.Vector64.Byte.1"] = ShiftRightLogicalNarrowingLower_Vector64_Byte_1, ["ShiftRightLogicalNarrowingLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingLower_Vector64_Int16_1, ["ShiftRightLogicalNarrowingLower.Vector64.Int32.1"] = ShiftRightLogicalNarrowingLower_Vector64_Int32_1, ["ShiftRightLogicalNarrowingLower.Vector64.SByte.1"] = ShiftRightLogicalNarrowingLower_Vector64_SByte_1, ["ShiftRightLogicalNarrowingLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt16_1, - ["ShiftRightLogicalNarrowingLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt32_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Byte_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int16_1, }; } } diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs index 6ae284b83de61..8dedd51ffb021 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs @@ -12,6 +12,9 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ShiftRightLogicalNarrowingLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt32_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Byte_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int16_1, ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int32_1, ["ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_SByte_1, ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt16_1, diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Byte.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Byte.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Byte.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Byte.cs index 752f5ac35d4f5..fbbb74ca35602 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Byte.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Byte.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_Byte() + private static void ShiftLeftAndInsert_Vector128_Byte() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_Byte() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Byte*)(pFld1)), AdvSimd.LoadVector128((Byte*)(pFld2)), 4 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 4 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Byte*)(_dataTable.inArray2Ptr)), 4 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Byte*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 4 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Byte*)(pClsVar1)), AdvSimd.LoadVector128((Byte*)(pClsVar2)), 4 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Byte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Byte(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Byte*)(pFld1)), AdvSimd.LoadVector128((Byte*)(pFld2)), 4 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Byte*)(pFld1)), AdvSimd.LoadVector128((Byte*)(pFld2)), 4 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Byte*)(&test._fld1)), AdvSimd.LoadVector128((Byte*)(&test._fld2)), 4 @@ -518,7 +518,7 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] result, [Cal for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] result, [Cal if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 4): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 4): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int16.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int16.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int16.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int16.cs index 8715e5270249b..aba5bf018eaf0 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int16.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int16.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_Int16() + private static void ShiftLeftAndInsert_Vector128_Int16() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_Int16() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16 testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int16*)(pFld1)), AdvSimd.LoadVector128((Int16*)(pFld2)), 8 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 8 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)), 8 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 8 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int16*)(pClsVar1)), AdvSimd.LoadVector128((Int16*)(pClsVar2)), 8 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int16(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int16*)(pFld1)), AdvSimd.LoadVector128((Int16*)(pFld2)), 8 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int16*)(pFld1)), AdvSimd.LoadVector128((Int16*)(pFld2)), 8 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int16*)(&test._fld1)), AdvSimd.LoadVector128((Int16*)(&test._fld2)), 8 @@ -518,7 +518,7 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 8): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 8): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int32.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int32.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int32.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int32.cs index 50aa9c8bf5e63..ceaa66ccb401e 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int32.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int32.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_Int32() + private static void ShiftLeftAndInsert_Vector128_Int32() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_Int32() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32 testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int32*)(pFld1)), AdvSimd.LoadVector128((Int32*)(pFld2)), 16 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 16 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)), 16 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 16 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int32*)(pClsVar1)), AdvSimd.LoadVector128((Int32*)(pClsVar2)), 16 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int32(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int32*)(pFld1)), AdvSimd.LoadVector128((Int32*)(pFld2)), 16 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int32*)(pFld1)), AdvSimd.LoadVector128((Int32*)(pFld2)), 16 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int32*)(&test._fld1)), AdvSimd.LoadVector128((Int32*)(&test._fld2)), 16 @@ -518,7 +518,7 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 16): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 16): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int64.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int64.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int64.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int64.cs index 5b25cdb0655b0..680522583e173 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.Int64.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.Int64.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_Int64() + private static void ShiftLeftAndInsert_Vector128_Int64() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_Int64() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 32); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64 testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int64*)(pFld1)), AdvSimd.LoadVector128((Int64*)(pFld2)), 32 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 32 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)), 32 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 32 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int64*)(pClsVar1)), AdvSimd.LoadVector128((Int64*)(pClsVar2)), 32 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 32); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_Int64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_Int64(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int64*)(pFld1)), AdvSimd.LoadVector128((Int64*)(pFld2)), 32 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int64*)(pFld1)), AdvSimd.LoadVector128((Int64*)(pFld2)), 32 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 32); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((Int64*)(&test._fld1)), AdvSimd.LoadVector128((Int64*)(&test._fld2)), 32 @@ -518,7 +518,7 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 32): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 32): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.SByte.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.SByte.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.SByte.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.SByte.cs index 40e2015ad2883..f6b3fe1b95c7e 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.SByte.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.SByte.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_SByte() + private static void ShiftLeftAndInsert_Vector128_SByte() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_SByte() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((SByte*)(pFld1)), AdvSimd.LoadVector128((SByte*)(pFld2)), 4 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 4 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((SByte*)(_dataTable.inArray2Ptr)), 4 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((SByte*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 4 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((SByte*)(pClsVar1)), AdvSimd.LoadVector128((SByte*)(pClsVar2)), 4 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_SByte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_SByte(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((SByte*)(pFld1)), AdvSimd.LoadVector128((SByte*)(pFld2)), 4 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((SByte*)(pFld1)), AdvSimd.LoadVector128((SByte*)(pFld2)), 4 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((SByte*)(&test._fld1)), AdvSimd.LoadVector128((SByte*)(&test._fld2)), 4 @@ -518,7 +518,7 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 4): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 4): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt16.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt16.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt16.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt16.cs index 01b01171cca3d..17ac825ac56ca 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt16.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt16.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_UInt16() + private static void ShiftLeftAndInsert_Vector128_UInt16() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_UInt16() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16 testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt16*)(pFld1)), AdvSimd.LoadVector128((UInt16*)(pFld2)), 8 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 8 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)), 8 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 8 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt16*)(pClsVar1)), AdvSimd.LoadVector128((UInt16*)(pClsVar2)), 8 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt16(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt16*)(pFld1)), AdvSimd.LoadVector128((UInt16*)(pFld2)), 8 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt16*)(pFld1)), AdvSimd.LoadVector128((UInt16*)(pFld2)), 8 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt16*)(&test._fld1)), AdvSimd.LoadVector128((UInt16*)(&test._fld2)), 8 @@ -518,7 +518,7 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] result for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 8): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 8): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt32.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt32.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt32.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt32.cs index f514ff210d111..f641f953d4c4a 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt32.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt32.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_UInt32() + private static void ShiftLeftAndInsert_Vector128_UInt32() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_UInt32() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32 testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt32*)(pFld1)), AdvSimd.LoadVector128((UInt32*)(pFld2)), 16 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 16 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), 16 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 16 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt32*)(pClsVar1)), AdvSimd.LoadVector128((UInt32*)(pClsVar2)), 16 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt32(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt32*)(pFld1)), AdvSimd.LoadVector128((UInt32*)(pFld2)), 16 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt32*)(pFld1)), AdvSimd.LoadVector128((UInt32*)(pFld2)), 16 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt32*)(&test._fld1)), AdvSimd.LoadVector128((UInt32*)(&test._fld2)), 16 @@ -518,7 +518,7 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] result for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 16): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 16): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt64.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt64.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt64.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt64.cs index d33c9ef0cb840..ea22f113fe3bc 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector128.UInt64.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector128.UInt64.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector128_UInt64() + private static void ShiftLeftAndInsert_Vector128_UInt64() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector128_UInt64() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 32); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64 testClass) { fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt64*)(pFld1)), AdvSimd.LoadVector128((UInt64*)(pFld2)), 32 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 32 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)), 32 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 32 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector128* pClsVar1 = &_clsVar1) fixed (Vector128* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt64*)(pClsVar1)), AdvSimd.LoadVector128((UInt64*)(pClsVar2)), 32 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 32); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector128_UInt64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector128_UInt64(); fixed (Vector128* pFld1 = &test._fld1) fixed (Vector128* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt64*)(pFld1)), AdvSimd.LoadVector128((UInt64*)(pFld2)), 32 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector128* pFld1 = &_fld1) fixed (Vector128* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt64*)(pFld1)), AdvSimd.LoadVector128((UInt64*)(pFld2)), 32 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 32); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector128((UInt64*)(&test._fld1)), AdvSimd.LoadVector128((UInt64*)(&test._fld2)), 32 @@ -518,7 +518,7 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] result for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector128, Vector128, 32): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector128, Vector128, 32): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Byte.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Byte.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Byte.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Byte.cs index 4e3b8cc065315..3e72d25db098d 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Byte.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Byte.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector64_Byte() + private static void ShiftLeftAndInsert_Vector64_Byte() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector64_Byte() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Byte*)(pFld1)), AdvSimd.LoadVector64((Byte*)(pFld2)), 4 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 4 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Byte*)(_dataTable.inArray2Ptr)), 4 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Byte*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 4 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Byte*)(pClsVar1)), AdvSimd.LoadVector64((Byte*)(pClsVar2)), 4 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Byte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Byte(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Byte*)(pFld1)), AdvSimd.LoadVector64((Byte*)(pFld2)), 4 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Byte*)(pFld1)), AdvSimd.LoadVector64((Byte*)(pFld2)), 4 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Byte*)(&test._fld1)), AdvSimd.LoadVector64((Byte*)(&test._fld2)), 4 @@ -518,7 +518,7 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] result, [Cal for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Byte[] firstOp, Byte[] secondOp, Byte[] result, [Cal if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector64, Vector64, 4): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector64, Vector64, 4): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Int16.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Int16.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Int16.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Int16.cs index 0d44b3b7a043e..0ef732cae5e3c 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Int16.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Int16.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector64_Int16() + private static void ShiftLeftAndInsert_Vector64_Int16() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector64_Int16() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int16*)(pFld1)), AdvSimd.LoadVector64((Int16*)(pFld2)), 8 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 8 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)), 8 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 8 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int16*)(pClsVar1)), AdvSimd.LoadVector64((Int16*)(pClsVar2)), 8 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int16(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int16*)(pFld1)), AdvSimd.LoadVector64((Int16*)(pFld2)), 8 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int16*)(pFld1)), AdvSimd.LoadVector64((Int16*)(pFld2)), 8 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int16*)(&test._fld1)), AdvSimd.LoadVector64((Int16*)(&test._fld2)), 8 @@ -518,7 +518,7 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Int16[] firstOp, Int16[] secondOp, Int16[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector64, Vector64, 8): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector64, Vector64, 8): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Int32.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Int32.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Int32.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Int32.cs index 18e54faf1f5e4..e31ca629e4a3a 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.Int32.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.Int32.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector64_Int32() + private static void ShiftLeftAndInsert_Vector64_Int32() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector64_Int32() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int32*)(pFld1)), AdvSimd.LoadVector64((Int32*)(pFld2)), 16 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 16 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int32*)(_dataTable.inArray2Ptr)), 16 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int32*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 16 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int32*)(pClsVar1)), AdvSimd.LoadVector64((Int32*)(pClsVar2)), 16 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_Int32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_Int32(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int32*)(pFld1)), AdvSimd.LoadVector64((Int32*)(pFld2)), 16 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int32*)(pFld1)), AdvSimd.LoadVector64((Int32*)(pFld2)), 16 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((Int32*)(&test._fld1)), AdvSimd.LoadVector64((Int32*)(&test._fld2)), 16 @@ -518,7 +518,7 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(Int32[] firstOp, Int32[] secondOp, Int32[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector64, Vector64, 16): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector64, Vector64, 16): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.SByte.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.SByte.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.SByte.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.SByte.cs index 0a1c6f13ed826..c55f2996f3828 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.SByte.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.SByte.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector64_SByte() + private static void ShiftLeftAndInsert_Vector64_SByte() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector64_SByte() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((SByte*)(pFld1)), AdvSimd.LoadVector64((SByte*)(pFld2)), 4 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 4 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((SByte*)(_dataTable.inArray2Ptr)), 4 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((SByte*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 4 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((SByte*)(pClsVar1)), AdvSimd.LoadVector64((SByte*)(pClsVar2)), 4 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 4); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_SByte(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_SByte(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((SByte*)(pFld1)), AdvSimd.LoadVector64((SByte*)(pFld2)), 4 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((SByte*)(pFld1)), AdvSimd.LoadVector64((SByte*)(pFld2)), 4 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 4); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((SByte*)(&test._fld1)), AdvSimd.LoadVector64((SByte*)(&test._fld2)), 4 @@ -518,7 +518,7 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] result, [ for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(SByte[] firstOp, SByte[] secondOp, SByte[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector64, Vector64, 4): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector64, Vector64, 4): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.UInt16.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.UInt16.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.UInt16.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.UInt16.cs index 2ce06c62d9a61..8f663925e285c 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.UInt16.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.UInt16.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector64_UInt16() + private static void ShiftLeftAndInsert_Vector64_UInt16() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector64_UInt16() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt16*)(pFld1)), AdvSimd.LoadVector64((UInt16*)(pFld2)), 8 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 8 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)), 8 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 8 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt16*)(pClsVar1)), AdvSimd.LoadVector64((UInt16*)(pClsVar2)), 8 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 8); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt16(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt16(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt16*)(pFld1)), AdvSimd.LoadVector64((UInt16*)(pFld2)), 8 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt16*)(pFld1)), AdvSimd.LoadVector64((UInt16*)(pFld2)), 8 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 8); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt16*)(&test._fld1)), AdvSimd.LoadVector64((UInt16*)(&test._fld2)), 8 @@ -518,7 +518,7 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] result for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(UInt16[] firstOp, UInt16[] secondOp, UInt16[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector64, Vector64, 8): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector64, Vector64, 8): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.UInt32.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.UInt32.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.UInt32.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.UInt32.cs index a70e7f29ff92d..8857f44c99eed 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsert.Vector64.UInt32.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsert.Vector64.UInt32.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsert_Vector64_UInt32() + private static void ShiftLeftAndInsert_Vector64_UInt32() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsert_Vector64_UInt32() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt32*)(pFld1)), AdvSimd.LoadVector64((UInt32*)(pFld2)), 16 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32() + static ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32() + public ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 16 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray2Ptr)), 16 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsert), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( _clsVar1, _clsVar2, 16 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt32*)(pClsVar1)), AdvSimd.LoadVector64((UInt32*)(pClsVar2)), 16 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(op1, op2, 16); + var result = AdvSimd.ShiftLeftAndInsert(op1, op2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32(); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsert_Vector64_UInt32(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsert_Vector64_UInt32(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt32*)(pFld1)), AdvSimd.LoadVector64((UInt32*)(pFld2)), 16 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsert(_fld1, _fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(_fld1, _fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt32*)(pFld1)), AdvSimd.LoadVector64((UInt32*)(pFld2)), 16 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert(test._fld1, test._fld2, 16); + var result = AdvSimd.ShiftLeftAndInsert(test._fld1, test._fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsert( + var result = AdvSimd.ShiftLeftAndInsert( AdvSimd.LoadVector64((UInt32*)(&test._fld1)), AdvSimd.LoadVector64((UInt32*)(&test._fld2)), 16 @@ -518,7 +518,7 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] result for (var i = 0; i < RetElementCount; i++) { - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) + if (Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]) { succeeded = false; break; @@ -527,7 +527,7 @@ private void ValidateResult(UInt32[] firstOp, UInt32[] secondOp, UInt32[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsert)}(Vector64, Vector64, 16): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsert)}(Vector64, Vector64, 16): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsertScalar.Vector64.Int64.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsertScalar.Vector64.Int64.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsertScalar.Vector64.Int64.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsertScalar.Vector64.Int64.cs index 8de3b258454df..a37ca2e73cf9c 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsertScalar.Vector64.Int64.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsertScalar.Vector64.Int64.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsertScalar_Vector64_Int64() + private static void ShiftLeftAndInsertScalar_Vector64_Int64() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsertScalar_Vector64_Int64() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pFld1)), AdvSimd.LoadVector64((Int64*)(pFld2)), 32 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64() + static ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64() + public ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 32 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)), 32 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( _clsVar1, _clsVar2, 32 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pClsVar1)), AdvSimd.LoadVector64((Int64*)(pClsVar2)), 32 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64(); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var test = new ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64(); + var result = AdvSimd.ShiftLeftAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_Int64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_Int64(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pFld1)), AdvSimd.LoadVector64((Int64*)(pFld2)), 32 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pFld1)), AdvSimd.LoadVector64((Int64*)(pFld2)), 32 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((Int64*)(&test._fld1)), AdvSimd.LoadVector64((Int64*)(&test._fld2)), 32 @@ -516,7 +516,7 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] result, [ { bool succeeded = true; - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[0], secondOp[0], Imm) != result[0]) + if (Helpers.ShiftLeftAndInsert(firstOp[0], secondOp[0], Imm) != result[0]) { succeeded = false; } @@ -534,7 +534,7 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsertScalar.Vector64.UInt64.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsertScalar.Vector64.UInt64.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsertScalar.Vector64.UInt64.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsertScalar.Vector64.UInt64.cs index 72419837a33aa..1b9b1e4f414ab 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftLogicalAndInsertScalar.Vector64.UInt64.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftLeftAndInsertScalar.Vector64.UInt64.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftLeftLogicalAndInsertScalar_Vector64_UInt64() + private static void ShiftLeftAndInsertScalar_Vector64_UInt64() { - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftLeftLogicalAndInsertScalar_Vector64_UInt64() } } - public sealed unsafe class ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64 + public sealed unsafe class ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64 testClass) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pFld1)), AdvSimd.LoadVector64((UInt64*)(pFld2)), 32 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftLeftLogicalAndInsert private DataTable _dataTable; - static ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64() + static ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64() + public ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 32 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)), 32 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftLeftAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( _clsVar1, _clsVar2, 32 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pClsVar1)), AdvSimd.LoadVector64((UInt64*)(pClsVar2)), 32 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64(); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var test = new ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64(); + var result = AdvSimd.ShiftLeftAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftLeftLogicalAndInsertScalar_Vector64_UInt64(); + var test = new ImmBinaryOpTest__ShiftLeftAndInsertScalar_Vector64_UInt64(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pFld1)), AdvSimd.LoadVector64((UInt64*)(pFld2)), 32 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pFld1)), AdvSimd.LoadVector64((UInt64*)(pFld2)), 32 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var result = AdvSimd.ShiftLeftAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftLeftLogicalAndInsertScalar( + var result = AdvSimd.ShiftLeftAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(&test._fld1)), AdvSimd.LoadVector64((UInt64*)(&test._fld2)), 32 @@ -516,7 +516,7 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] result { bool succeeded = true; - if (Helpers.ShiftLeftLogicalAndInsert(firstOp[0], secondOp[0], Imm) != result[0]) + if (Helpers.ShiftLeftAndInsert(firstOp[0], secondOp[0], Imm) != result[0]) { succeeded = false; } @@ -534,7 +534,7 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftLogicalAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftLeftAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAndInsertScalar.Vector64.Int64.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightAndInsertScalar.Vector64.Int64.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAndInsertScalar.Vector64.Int64.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightAndInsertScalar.Vector64.Int64.cs index 50c24e04e464e..3b51967d01dcd 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAndInsertScalar.Vector64.Int64.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightAndInsertScalar.Vector64.Int64.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftRightLogicalAndInsertScalar_Vector64_Int64() + private static void ShiftRightAndInsertScalar_Vector64_Int64() { - var test = new ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64(); + var test = new ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftRightLogicalAndInsertScalar_Vector64_Int64() } } - public sealed unsafe class ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64 + public sealed unsafe class ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64 testClass) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pFld1)), AdvSimd.LoadVector64((Int64*)(pFld2)), 32 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightLogicalAndInser private DataTable _dataTable; - static ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64() + static ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt64(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64() + public ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 32 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)), 32 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( _clsVar1, _clsVar2, 32 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pClsVar1)), AdvSimd.LoadVector64((Int64*)(pClsVar2)), 32 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((Int64*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((Int64*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64(); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var test = new ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64(); + var result = AdvSimd.ShiftRightAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_Int64(); + var test = new ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_Int64(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pFld1)), AdvSimd.LoadVector64((Int64*)(pFld2)), 32 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((Int64*)(pFld1)), AdvSimd.LoadVector64((Int64*)(pFld2)), 32 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((Int64*)(&test._fld1)), AdvSimd.LoadVector64((Int64*)(&test._fld2)), 32 @@ -534,7 +534,7 @@ private void ValidateResult(Int64[] firstOp, Int64[] secondOp, Int64[] result, [ if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightLogicalAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAndInsertScalar.Vector64.UInt64.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightAndInsertScalar.Vector64.UInt64.cs similarity index 90% rename from src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAndInsertScalar.Vector64.UInt64.cs rename to src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightAndInsertScalar.Vector64.UInt64.cs index 74835b4bc0280..411a102dfb709 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightLogicalAndInsertScalar.Vector64.UInt64.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/AdvSimd/ShiftRightAndInsertScalar.Vector64.UInt64.cs @@ -19,9 +19,9 @@ namespace JIT.HardwareIntrinsics.Arm { public static partial class Program { - private static void ShiftRightLogicalAndInsertScalar_Vector64_UInt64() + private static void ShiftRightAndInsertScalar_Vector64_UInt64() { - var test = new ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64(); + var test = new ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64(); if (test.IsSupported) { @@ -110,7 +110,7 @@ private static void ShiftRightLogicalAndInsertScalar_Vector64_UInt64() } } - public sealed unsafe class ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64 + public sealed unsafe class ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64 { private struct DataTable { @@ -182,20 +182,20 @@ public static TestStruct Create() return testStruct; } - public void RunStructFldScenario(ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64 testClass) + public void RunStructFldScenario(ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64 testClass) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64 testClass) + public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64 testClass) { fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pFld1)), AdvSimd.LoadVector64((UInt64*)(pFld2)), 32 @@ -225,7 +225,7 @@ public void RunStructFldScenario_Load(ImmBinaryOpTest__ShiftRightLogicalAndInser private DataTable _dataTable; - static ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64() + static ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64() { for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt64(); } Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); @@ -233,7 +233,7 @@ static ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64() Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar2), ref Unsafe.As(ref _data2[0]), (uint)Unsafe.SizeOf>()); } - public ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64() + public ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64() { Succeeded = true; @@ -255,7 +255,7 @@ public void RunBasicScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), 32 @@ -269,7 +269,7 @@ public void RunBasicScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)), 32 @@ -283,7 +283,7 @@ public void RunReflectionScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -298,7 +298,7 @@ public void RunReflectionScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightLogicalAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.ShiftRightAndInsertScalar), new Type[] { typeof(Vector64), typeof(Vector64), typeof(byte) }) .Invoke(null, new object[] { AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)), AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)), @@ -313,7 +313,7 @@ public void RunClsVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( _clsVar1, _clsVar2, 32 @@ -330,7 +330,7 @@ public void RunClsVarScenario_Load() fixed (Vector64* pClsVar1 = &_clsVar1) fixed (Vector64* pClsVar2 = &_clsVar2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pClsVar1)), AdvSimd.LoadVector64((UInt64*)(pClsVar2)), 32 @@ -347,7 +347,7 @@ public void RunLclVarScenario_UnsafeRead() var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); var op2 = Unsafe.Read>(_dataTable.inArray2Ptr); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -359,7 +359,7 @@ public void RunLclVarScenario_Load() var op1 = AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray1Ptr)); var op2 = AdvSimd.LoadVector64((UInt64*)(_dataTable.inArray2Ptr)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(op1, op2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(op1, op2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(op1, op2, _dataTable.outArrayPtr); @@ -369,8 +369,8 @@ public void RunClassLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - var test = new ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64(); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var test = new ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64(); + var result = AdvSimd.ShiftRightAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -379,12 +379,12 @@ public void RunClassLclFldScenario() public void RunClassLclFldScenario_Load() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - var test = new ImmBinaryOpTest__ShiftRightLogicalAndInsertScalar_Vector64_UInt64(); + var test = new ImmBinaryOpTest__ShiftRightAndInsertScalar_Vector64_UInt64(); fixed (Vector64* pFld1 = &test._fld1) fixed (Vector64* pFld2 = &test._fld2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pFld1)), AdvSimd.LoadVector64((UInt64*)(pFld2)), 32 @@ -399,7 +399,7 @@ public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(_fld1, _fld2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); @@ -412,7 +412,7 @@ public void RunClassFldScenario_Load() fixed (Vector64* pFld1 = &_fld1) fixed (Vector64* pFld2 = &_fld2) { - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(pFld1)), AdvSimd.LoadVector64((UInt64*)(pFld2)), 32 @@ -428,7 +428,7 @@ public void RunStructLclFldScenario() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar(test._fld1, test._fld2, 32); + var result = AdvSimd.ShiftRightAndInsertScalar(test._fld1, test._fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); @@ -439,7 +439,7 @@ public void RunStructLclFldScenario_Load() TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); var test = TestStruct.Create(); - var result = AdvSimd.ShiftRightLogicalAndInsertScalar( + var result = AdvSimd.ShiftRightAndInsertScalar( AdvSimd.LoadVector64((UInt64*)(&test._fld1)), AdvSimd.LoadVector64((UInt64*)(&test._fld2)), 32 @@ -534,7 +534,7 @@ private void ValidateResult(UInt64[] firstOp, UInt64[] secondOp, UInt64[] result if (!succeeded) { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightLogicalAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.ShiftRightAndInsertScalar)}(Vector64, Vector64, 32): {method} failed:"); TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); TestLibrary.TestFramework.LogInformation($" secondOp: ({string.Join(", ", secondOp)})"); TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx index 3afc869a24af8..36e3d58adee33 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx @@ -674,6 +674,9 @@ private static readonly (string templateFileName, Dictionary tem ("InsertTest.template", new Dictionary { ["TestName"] = "Insert_Vector128_UInt16_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Insert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ElementIndex"] = "1", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.Insert(firstOp, ElementIndex, thirdOp, i) != result[i]"}), ("InsertTest.template", new Dictionary { ["TestName"] = "Insert_Vector128_UInt32_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Insert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ElementIndex"] = "1", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.Insert(firstOp, ElementIndex, thirdOp, i) != result[i]"}), ("InsertTest.template", new Dictionary { ["TestName"] = "Insert_Vector128_UInt64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "Insert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ElementIndex"] = "1", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.Insert(firstOp, ElementIndex, thirdOp, i) != result[i]"}), + ("InsertScalarTest.template", new Dictionary { ["TestName"] = "InsertScalar_Vector128_Double_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "InsertScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op3VectorType"] = "Vector64", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["ElementIndex"] = "1", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "BitConverter.DoubleToInt64Bits(Helpers.Insert(firstOp, ElementIndex, thirdOp[0], i)) != BitConverter.DoubleToInt64Bits(result[i])"}), + ("InsertScalarTest.template", new Dictionary { ["TestName"] = "InsertScalar_Vector128_Int64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "InsertScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op3VectorType"] = "Vector64", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["ElementIndex"] = "1", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.Insert(firstOp, ElementIndex, thirdOp[0], i) != result[i]"}), + ("InsertScalarTest.template", new Dictionary { ["TestName"] = "InsertScalar_Vector128_UInt64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "InsertScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op3VectorType"] = "Vector64", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ElementIndex"] = "1", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.Insert(firstOp, ElementIndex, thirdOp[0], i) != result[i]"}), ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "LeadingSignCount_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LeadingSignCount", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.CountLeadingSignBits(firstOp[i]) != result[i]"}), ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "LeadingSignCount_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LeadingSignCount", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.CountLeadingSignBits(firstOp[i]) != result[i]"}), ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "LeadingSignCount_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LeadingSignCount", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "Helpers.CountLeadingSignBits(firstOp[i]) != result[i]"}), @@ -1149,6 +1152,22 @@ private static readonly (string templateFileName, Dictionary tem ("VecBinOpTest.template", new Dictionary { ["TestName"] = "ShiftArithmeticSaturate_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftArithmeticSaturate", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "Helpers.ShiftArithmeticSaturate(left[i], right[i]) != result[i]"}), ("SimpleBinOpTest.template", new Dictionary { ["TestName"] = "ShiftArithmeticSaturateScalar_Vector64_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftArithmeticSaturateScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "Helpers.ShiftArithmeticSaturate(left[0], right[0]) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("SimpleBinOpTest.template", new Dictionary { ["TestName"] = "ShiftArithmeticScalar_Vector64_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftArithmeticScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "Helpers.ShiftArithmetic(left[0], right[0]) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "32", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsert_Vector128_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateIterResult"] = "Helpers.ShiftLeftAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsertScalar_Vector64_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftLeftAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftAndInsertScalar_Vector64_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftLeftAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogical_Vector64_Byte_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogical(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogical_Vector64_Int16_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogical(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogical_Vector64_Int32_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogical(firstOp[i], Imm) != result[i]"}), @@ -1162,22 +1181,6 @@ private static readonly (string templateFileName, Dictionary tem ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogical_Vector128_UInt16_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogical(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogical_Vector128_UInt32_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogical(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogical_Vector128_UInt64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogical(firstOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector64_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector64_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector64_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector64_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector64_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector64_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_Int16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_Int32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "32", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "4", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsert_Vector128_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), - ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsertScalar_Vector64_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalAndInsertScalar_Vector64_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftLeftLogicalAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalSaturate_Vector64_Byte_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalSaturate(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalSaturate_Vector64_Int16_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalSaturate(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftLeftLogicalSaturate_Vector64_Int32_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftLeftLogicalSaturate", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftLeftLogicalSaturate(firstOp[i], Imm) != result[i]"}), @@ -1294,6 +1297,8 @@ private static readonly (string templateFileName, Dictionary tem ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightAndInsert_Vector128_UInt16", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "8", ["ValidateIterResult"] = "Helpers.ShiftRightAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightAndInsert_Vector128_UInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["Imm"] = "16", ["ValidateIterResult"] = "Helpers.ShiftRightAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightAndInsert_Vector128_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightAndInsert", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateIterResult"] = "Helpers.ShiftRightAndInsert(firstOp[i], secondOp[i], Imm) != result[i]"}), + ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightAndInsertScalar_Vector64_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftRightAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightAndInsertScalar_Vector64_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftRightAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftRightArithmetic_Vector64_Int16_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightArithmetic", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightArithmetic(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftRightArithmetic_Vector64_Int32_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightArithmetic", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightArithmetic(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftRightArithmetic_Vector64_SByte_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightArithmetic", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightArithmetic(firstOp[i], Imm) != result[i]"}), @@ -1380,8 +1385,6 @@ private static readonly (string templateFileName, Dictionary tem ("VecImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalAdd_Vector128_UInt64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalAdd", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightLogicalAdd(firstOp[i], secondOp[i], Imm) != result[i]"}), ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalAddScalar_Vector64_Int64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalAddScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "1", ["ValidateFirstResult"] = "Helpers.ShiftRightLogicalAdd(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalAddScalar_Vector64_UInt64_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalAddScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "1", ["ValidateFirstResult"] = "Helpers.ShiftRightLogicalAdd(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalAndInsertScalar_Vector64_Int64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftRightAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ImmBinOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalAndInsertScalar_Vector64_UInt64", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalAndInsertScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["Imm"] = "32", ["ValidateFirstResult"] = "Helpers.ShiftRightAndInsert(firstOp[0], secondOp[0], Imm) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalNarrowingLower_Vector64_Byte_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalNarrowingLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightLogicalNarrowing(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalNarrowingLower_Vector64_Int16_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalNarrowingLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightLogicalNarrowing(firstOp[i], Imm) != result[i]"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "ShiftRightLogicalNarrowingLower_Vector64_Int32_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ShiftRightLogicalNarrowingLower", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["Imm"] = "1", ["ValidateIterResult"] = "Helpers.ShiftRightLogicalNarrowing(firstOp[i], Imm) != result[i]"}), diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs index 626ae084038b7..5a808ac684e8d 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs @@ -5070,6 +5070,14 @@ public static byte TableVectorLookup(int i, byte[] indices, params byte[][] tabl return TableVectorExtension(i, zeros, indices, table); } + public static byte ShiftLeftAndInsert(byte left, byte right, byte shift) + { + byte mask = (byte)~(byte.MaxValue << shift); + byte value = (byte)(right << shift); + byte newval = (byte)(((byte)left & mask) | value); + return newval; + } + public static byte ShiftRightAndInsert(byte left, byte right, byte shift) { byte mask = (byte)~(byte.MaxValue >> shift); @@ -5078,11 +5086,11 @@ public static byte ShiftRightAndInsert(byte left, byte right, byte shift) return newval; } - public static byte ShiftLeftLogicalAndInsert(byte left, byte right, byte shift) + public static short ShiftLeftAndInsert(short left, short right, byte shift) { - byte mask = (byte)~(byte.MaxValue << shift); - byte value = (byte)(right << shift); - byte newval = (byte)(((byte)left & mask) | value); + ushort mask = (ushort)~(ushort.MaxValue << shift); + ushort value = (ushort)(right << shift); + short newval = (short)(((ushort)left & mask) | value); return newval; } @@ -5094,11 +5102,11 @@ public static short ShiftRightAndInsert(short left, short right, byte shift) return newval; } - public static short ShiftLeftLogicalAndInsert(short left, short right, byte shift) + public static int ShiftLeftAndInsert(int left, int right, byte shift) { - ushort mask = (ushort)~(ushort.MaxValue << shift); - ushort value = (ushort)(right << shift); - short newval = (short)(((ushort)left & mask) | value); + uint mask = (uint)~(uint.MaxValue << shift); + uint value = (uint)(right << shift); + int newval = (int)(((uint)left & mask) | value); return newval; } @@ -5110,11 +5118,11 @@ public static int ShiftRightAndInsert(int left, int right, byte shift) return newval; } - public static int ShiftLeftLogicalAndInsert(int left, int right, byte shift) + public static long ShiftLeftAndInsert(long left, long right, byte shift) { - uint mask = (uint)~(uint.MaxValue << shift); - uint value = (uint)(right << shift); - int newval = (int)(((uint)left & mask) | value); + ulong mask = (ulong)~(ulong.MaxValue << shift); + ulong value = (ulong)(right << shift); + long newval = (long)(((ulong)left & mask) | value); return newval; } @@ -5126,11 +5134,11 @@ public static long ShiftRightAndInsert(long left, long right, byte shift) return newval; } - public static long ShiftLeftLogicalAndInsert(long left, long right, byte shift) + public static sbyte ShiftLeftAndInsert(sbyte left, sbyte right, byte shift) { - ulong mask = (ulong)~(ulong.MaxValue << shift); - ulong value = (ulong)(right << shift); - long newval = (long)(((ulong)left & mask) | value); + byte mask = (byte)~(byte.MaxValue << shift); + byte value = (byte)(right << shift); + sbyte newval = (sbyte)(((byte)left & mask) | value); return newval; } @@ -5142,11 +5150,11 @@ public static sbyte ShiftRightAndInsert(sbyte left, sbyte right, byte shift) return newval; } - public static sbyte ShiftLeftLogicalAndInsert(sbyte left, sbyte right, byte shift) + public static ushort ShiftLeftAndInsert(ushort left, ushort right, byte shift) { - byte mask = (byte)~(byte.MaxValue << shift); - byte value = (byte)(right << shift); - sbyte newval = (sbyte)(((byte)left & mask) | value); + ushort mask = (ushort)~(ushort.MaxValue << shift); + ushort value = (ushort)(right << shift); + ushort newval = (ushort)(((ushort)left & mask) | value); return newval; } @@ -5158,11 +5166,11 @@ public static ushort ShiftRightAndInsert(ushort left, ushort right, byte shift) return newval; } - public static ushort ShiftLeftLogicalAndInsert(ushort left, ushort right, byte shift) + public static uint ShiftLeftAndInsert(uint left, uint right, byte shift) { - ushort mask = (ushort)~(ushort.MaxValue << shift); - ushort value = (ushort)(right << shift); - ushort newval = (ushort)(((ushort)left & mask) | value); + uint mask = (uint)~(uint.MaxValue << shift); + uint value = (uint)(right << shift); + uint newval = (uint)(((uint)left & mask) | value); return newval; } @@ -5174,11 +5182,11 @@ public static uint ShiftRightAndInsert(uint left, uint right, byte shift) return newval; } - public static uint ShiftLeftLogicalAndInsert(uint left, uint right, byte shift) + public static ulong ShiftLeftAndInsert(ulong left, ulong right, byte shift) { - uint mask = (uint)~(uint.MaxValue << shift); - uint value = (uint)(right << shift); - uint newval = (uint)(((uint)left & mask) | value); + ulong mask = (ulong)~(ulong.MaxValue << shift); + ulong value = (ulong)(right << shift); + ulong newval = (ulong)(((ulong)left & mask) | value); return newval; } @@ -5190,14 +5198,6 @@ public static ulong ShiftRightAndInsert(ulong left, ulong right, byte shift) return newval; } - public static ulong ShiftLeftLogicalAndInsert(ulong left, ulong right, byte shift) - { - ulong mask = (ulong)~(ulong.MaxValue << shift); - ulong value = (ulong)(right << shift); - ulong newval = (ulong)(((ulong)left & mask) | value); - return newval; - } - public static double Ceiling(double op1) => Math.Ceiling(op1); public static double Floor(double op1) => Math.Floor(op1); diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.tt b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.tt index da006d4016d0b..ccd9bcb691dc5 100644 --- a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.tt +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/Helpers.tt @@ -1358,18 +1358,18 @@ namespace JIT.HardwareIntrinsics.Arm (original: "ulong", unsigned: "ulong") }) { #> - public static <#= typeName.original #> ShiftRightAndInsert(<#= typeName.original #> left, <#= typeName.original #> right, byte shift) + public static <#= typeName.original #> ShiftLeftAndInsert(<#= typeName.original #> left, <#= typeName.original #> right, byte shift) { - <#= typeName.unsigned #> mask = (<#= typeName.unsigned #>)~(<#= typeName.unsigned #>.MaxValue >> shift); - <#= typeName.unsigned #> value = (<#= typeName.unsigned #>)(right >> shift); + <#= typeName.unsigned #> mask = (<#= typeName.unsigned #>)~(<#= typeName.unsigned #>.MaxValue << shift); + <#= typeName.unsigned #> value = (<#= typeName.unsigned #>)(right << shift); <#= typeName.original #> newval = (<#= typeName.original #>)(((<#= typeName.unsigned #>)left & mask) | value); return newval; } - public static <#= typeName.original #> ShiftLeftLogicalAndInsert(<#= typeName.original #> left, <#= typeName.original #> right, byte shift) + public static <#= typeName.original #> ShiftRightAndInsert(<#= typeName.original #> left, <#= typeName.original #> right, byte shift) { - <#= typeName.unsigned #> mask = (<#= typeName.unsigned #>)~(<#= typeName.unsigned #>.MaxValue << shift); - <#= typeName.unsigned #> value = (<#= typeName.unsigned #>)(right << shift); + <#= typeName.unsigned #> mask = (<#= typeName.unsigned #>)~(<#= typeName.unsigned #>.MaxValue >> shift); + <#= typeName.unsigned #> value = (<#= typeName.unsigned #>)(right >> shift); <#= typeName.original #> newval = (<#= typeName.original #>)(((<#= typeName.unsigned #>)left & mask) | value); return newval; } diff --git a/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template new file mode 100644 index 0000000000000..010e6effb37f8 --- /dev/null +++ b/src/coreclr/tests/src/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template @@ -0,0 +1,541 @@ +// 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. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void {TestName}() + { + var test = new InsertScalarTest__{TestName}(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if ({LoadIsa}.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if ({LoadIsa}.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if ({LoadIsa}.IsSupported) + { + // Validates passing a static member works, using pinning and Load + test.RunClsVarScenario_Load(); + } + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + if ({LoadIsa}.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if ({LoadIsa}.IsSupported) + { + // Validates passing the field of a local class works, using pinning and Load + test.RunClassLclFldScenario_Load(); + } + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + if ({LoadIsa}.IsSupported) + { + // Validates passing an instance member of a class works, using pinning and Load + test.RunClassFldScenario_Load(); + } + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + if ({LoadIsa}.IsSupported) + { + // Validates passing the field of a local struct works, using pinning and Load + test.RunStructLclFldScenario_Load(); + } + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + + if ({LoadIsa}.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class InsertScalarTest__{TestName} + { + private struct DataTable + { + private byte[] inArray1; + private byte[] inArray3; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle inHandle3; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable({Op1BaseType}[] inArray1, {Op3BaseType}[] inArray3, {RetBaseType}[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); + int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op3BaseType}>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray3 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray3Ptr), ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), (uint)sizeOfinArray3); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + inHandle3.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op3VectorType}<{Op3BaseType}> _fld3; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref testStruct._fld3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertScalarTest__{TestName} testClass) + { + var result = {Isa}.{Method}(_fld1, {ElementIndex}, _fld3); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(InsertScalarTest__{TestName} testClass) + { + fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) + fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &_fld3) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), + {ElementIndex}, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2) + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = {LargestVectorSize}; + + private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); + private static readonly int Op3ElementCount = Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>() / sizeof({Op3BaseType}); + private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); + private static readonly byte ElementIndex = {ElementIndex}; + + private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; + private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; + + private static {Op1VectorType}<{Op1BaseType}> _clsVar1; + private static {Op3VectorType}<{Op3BaseType}> _clsVar3; + + private {Op1VectorType}<{Op1BaseType}> _fld1; + private {Op3VectorType}<{Op3BaseType}> _fld3; + + private DataTable _dataTable; + + static InsertScalarTest__{TestName}() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>()); + } + + public InsertScalarTest__{TestName}() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref _fld3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + _dataTable = new DataTable(_data1, _data3, new {RetBaseType}[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => {Isa}.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = {Isa}.{Method}( + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), + {ElementIndex}, + Unsafe.Read<{Op3VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), + {ElementIndex}, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte), typeof({Op3VectorType}<{Op3BaseType}>) }) + .Invoke(null, new object[] { + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), + ElementIndex, + Unsafe.Read<{Op3VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr) + }); + + Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte), typeof({Op3VectorType}<{Op3BaseType}>) }) + .Invoke(null, new object[] { + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), + ElementIndex, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)) + }); + + Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = {Isa}.{Method}( + _clsVar1, + {ElementIndex}, + _clsVar3 + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) + fixed ({Op3VectorType}<{Op3BaseType}>* pClsVar3 = &_clsVar3) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), + {ElementIndex}, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(pClsVar3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr); + var op3 = Unsafe.Read<{Op3VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr); + var result = {Isa}.{Method}(op1, {ElementIndex}, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); + var op3 = {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)); + var result = {Isa}.{Method}(op1, {ElementIndex}, op3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, op3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new InsertScalarTest__{TestName}(); + var result = {Isa}.{Method}(test._fld1, {ElementIndex}, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new InsertScalarTest__{TestName}(); + + fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) + fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &test._fld3) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), + {ElementIndex}, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = {Isa}.{Method}(_fld1, {ElementIndex}, _fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) + fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &_fld3) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), + {ElementIndex}, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, {ElementIndex}, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), + {ElementIndex}, + {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(&test._fld3)) + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + + public void RunStructFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); + + var test = TestStruct.Create(); + test.RunStructFldScenario_Load(this); + } + + public void RunUnsupportedScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult({Op1VectorType}<{Op1BaseType}> op1, {Op3VectorType}<{Op3BaseType}> op3, void* result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {Op3BaseType}[] inArray3 = new {Op3BaseType}[Op3ElementCount]; + {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), op1); + Unsafe.WriteUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), op3); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult(void* op1, void* op3, void* result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {Op3BaseType}[] inArray3 = new {Op3BaseType}[Op3ElementCount]; + {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef(op3), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); + + ValidateResult(inArray1, inArray3, outArray, method); + } + + private void ValidateResult({Op1BaseType}[] firstOp, {Op3BaseType}[] thirdOp, {RetBaseType}[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + for (var i = 0; i < RetElementCount; i++) + { + if ({ValidateIterResult}) + { + succeeded = false; + break; + } + } + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {ElementIndex}, {Op3VectorType}<{Op3BaseType}>): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs index 60ed841892f77..806e9ad17990b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs @@ -7105,6 +7105,27 @@ internal Arm64() { } /// public static Vector128 Insert(Vector128 vector, byte index, ulong data) { throw new PlatformNotSupportedException(); } + /// + /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2) + /// A32: VMOV.F64 Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] + /// + public static Vector128 InsertScalar(Vector128 result, byte resultIndex, Vector64 value) { throw new PlatformNotSupportedException(); } + + /// + /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] + /// + public static Vector128 InsertScalar(Vector128 result, byte resultIndex, Vector64 value) { throw new PlatformNotSupportedException(); } + + /// + /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] + /// + public static Vector128 InsertScalar(Vector128 result, byte resultIndex, Vector64 value) { throw new PlatformNotSupportedException(); } + /// /// int16x4_t vcls_s16 (int16x4_t a) /// A32: VCLS.S16 Dd, Dm @@ -10225,230 +10246,6 @@ internal Arm64() { } /// public static Vector64 RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } - /// - /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n - /// - public static Vector64 ShiftLeftLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n - /// - public static Vector64 ShiftLeftLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n - /// - public static Vector64 ShiftRightLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - - /// - /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n - /// - public static Vector64 ShiftRightLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } - /// /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b) /// A32: VSHL.S16 Dd, Dn, Dm @@ -10673,6 +10470,118 @@ internal Arm64() { } /// public static Vector64 ShiftArithmeticScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } + /// + /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n + /// + public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n + /// + public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + /// /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n) /// A32: VSHL.I8 Dd, Dm, #n @@ -11478,6 +11387,118 @@ internal Arm64() { } /// public static Vector64 ShiftLogicalScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } + /// + /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n + /// + public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + + /// + /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n + /// + public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, byte shift) { throw new PlatformNotSupportedException(); } + /// /// int16x4_t vshr_n_s16 (int16x4_t a, const int n) /// A32: VSHR.S16 Dd, Dm, #n diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs index 6b3d27f159571..fcb4fd4b4140d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs @@ -7108,6 +7108,27 @@ internal Arm64() { } /// public static Vector128 Insert(Vector128 vector, byte index, ulong data) => Insert(vector, index, data); + /// + /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2) + /// A32: VMOV.F64 Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] + /// + public static Vector128 InsertScalar(Vector128 result, byte resultIndex, Vector64 value) => InsertScalar(result, resultIndex, value); + + /// + /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] + /// + public static Vector128 InsertScalar(Vector128 result, byte resultIndex, Vector64 value) => InsertScalar(result, resultIndex, value); + + /// + /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] + /// + public static Vector128 InsertScalar(Vector128 result, byte resultIndex, Vector64 value) => InsertScalar(result, resultIndex, value); + /// /// int16x4_t vcls_s16 (int16x4_t a) /// A32: VCLS.S16 Dd, Dm @@ -10228,230 +10249,6 @@ internal Arm64() { } /// public static Vector64 RoundToZeroScalar(Vector64 value) => RoundToZeroScalar(value); - /// - /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftLeftLogicalAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftLeftLogicalAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftLogicalAndInsert(left, right, shift); - - /// - /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n - /// - public static Vector64 ShiftLeftLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsertScalar(left, right, shift); - - /// - /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n - /// - public static Vector64 ShiftLeftLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftLeftLogicalAndInsertScalar(left, right, shift); - - /// - /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n - /// - public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n - /// - public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); - - /// - /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n - /// - public static Vector64 ShiftRightLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftRightLogicalAndInsertScalar(left, right, shift); - - /// - /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n - /// - public static Vector64 ShiftRightLogicalAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftRightLogicalAndInsertScalar(left, right, shift); - /// /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b) /// A32: VSHL.S16 Dd, Dn, Dm @@ -10676,6 +10473,118 @@ internal Arm64() { } /// public static Vector64 ShiftArithmeticScalar(Vector64 value, Vector64 count) => ShiftArithmeticScalar(value, count); + /// + /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftLeftAndInsert(left, right, shift); + + /// + /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n + /// + public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsertScalar(left, right, shift); + + /// + /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n + /// + public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftLeftAndInsertScalar(left, right, shift); + /// /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n) /// A32: VSHL.I8 Dd, Dm, #n @@ -11481,6 +11390,118 @@ internal Arm64() { } /// public static Vector64 ShiftLogicalScalar(Vector64 value, Vector64 count) => ShiftLogicalScalar(value, count); + /// + /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n + /// + public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n + /// + public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, byte shift) => ShiftRightAndInsert(left, right, shift); + + /// + /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n + /// + public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsertScalar(left, right, shift); + + /// + /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n + /// + public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, byte shift) => ShiftRightAndInsertScalar(left, right, shift); + /// /// int16x4_t vshr_n_s16 (int16x4_t a, const int n) /// A32: VSHR.S16 Dd, Dm, #n diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs index 58206b4649b5d..cc1114572a728 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs @@ -1682,9 +1682,9 @@ public static Vector64 GetLower(this Vector128 vector) public static Vector128 WithLower(this Vector128 vector, Vector64 value) where T : struct { - if (AdvSimd.Arm64.IsSupported) + if (AdvSimd.IsSupported) { - return AdvSimd.Arm64.InsertSelectedScalar(vector.AsUInt64(), 0, value.ToVector128Unsafe().AsUInt64(), 0).As(); + return AdvSimd.InsertScalar(vector.AsUInt64(), 0, value.AsUInt64()).As(); } return SoftwareFallback(vector, value); @@ -1724,9 +1724,9 @@ public static Vector64 GetUpper(this Vector128 vector) public static Vector128 WithUpper(this Vector128 vector, Vector64 value) where T : struct { - if (AdvSimd.Arm64.IsSupported) + if (AdvSimd.IsSupported) { - return AdvSimd.Arm64.InsertSelectedScalar(vector.AsUInt64(), 1, value.ToVector128Unsafe().AsUInt64(), 0).As(); + return AdvSimd.InsertScalar(vector.AsUInt64(), 1, value.AsUInt64()).As(); } return SoftwareFallback(vector, value); diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index 1932e232bfde9..412841d340474 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -871,6 +871,9 @@ internal AdvSimd() { } public static System.Runtime.Intrinsics.Vector64 Insert(System.Runtime.Intrinsics.Vector64 vector, byte index, float data) { throw null; } public static System.Runtime.Intrinsics.Vector64 Insert(System.Runtime.Intrinsics.Vector64 vector, byte index, ushort data) { throw null; } public static System.Runtime.Intrinsics.Vector64 Insert(System.Runtime.Intrinsics.Vector64 vector, byte index, uint data) { throw null; } + public static System.Runtime.Intrinsics.Vector128 InsertScalar(System.Runtime.Intrinsics.Vector128 result, byte resultIndex, System.Runtime.Intrinsics.Vector64 value) { throw null; } + public static System.Runtime.Intrinsics.Vector128 InsertScalar(System.Runtime.Intrinsics.Vector128 result, byte resultIndex, System.Runtime.Intrinsics.Vector64 value) { throw null; } + public static System.Runtime.Intrinsics.Vector128 InsertScalar(System.Runtime.Intrinsics.Vector128 result, byte resultIndex, System.Runtime.Intrinsics.Vector64 value) { throw null; } public static System.Runtime.Intrinsics.Vector128 LeadingSignCount(System.Runtime.Intrinsics.Vector128 value) { throw null; } public static System.Runtime.Intrinsics.Vector128 LeadingSignCount(System.Runtime.Intrinsics.Vector128 value) { throw null; } public static System.Runtime.Intrinsics.Vector128 LeadingSignCount(System.Runtime.Intrinsics.Vector128 value) { throw null; } @@ -1346,6 +1349,22 @@ internal AdvSimd() { } public static System.Runtime.Intrinsics.Vector64 ShiftArithmeticSaturate(System.Runtime.Intrinsics.Vector64 value, System.Runtime.Intrinsics.Vector64 count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftArithmeticSaturateScalar(System.Runtime.Intrinsics.Vector64 value, System.Runtime.Intrinsics.Vector64 count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftArithmeticScalar(System.Runtime.Intrinsics.Vector64 value, System.Runtime.Intrinsics.Vector64 count) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector128 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogical(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogical(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogical(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } @@ -1359,22 +1378,6 @@ internal AdvSimd() { } public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogical(System.Runtime.Intrinsics.Vector64 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogical(System.Runtime.Intrinsics.Vector64 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogical(System.Runtime.Intrinsics.Vector64 value, byte count) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector128 left, System.Runtime.Intrinsics.Vector128 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftLeftLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } @@ -1491,6 +1494,8 @@ internal AdvSimd() { } public static System.Runtime.Intrinsics.Vector64 ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } + public static System.Runtime.Intrinsics.Vector64 ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector128 ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } @@ -1577,8 +1582,6 @@ internal AdvSimd() { } public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64 addend, System.Runtime.Intrinsics.Vector64 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64 addend, System.Runtime.Intrinsics.Vector64 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64 addend, System.Runtime.Intrinsics.Vector64 value, byte count) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } - public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalAndInsertScalar(System.Runtime.Intrinsics.Vector64 left, System.Runtime.Intrinsics.Vector64 right, byte shift) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; } public static System.Runtime.Intrinsics.Vector64 ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128 value, byte count) { throw null; }